text: // Copyright (c) 2011-2016 The Bitcoin Core developers
  // Copyright (c) 2017 The Marlin Core developers
  // Distributed under the MIT software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #include "data/script_tests.json.h"
  
  #include "core_io.h"
  #include "key.h"
  #include "keystore.h"
  #include "script/script.h"
  #include "script/script_error.h"
  #include "script/sign.h"
  #include "util.h"
  #include "utilstrencodings.h"
  #include "test/test_marlin.h"
  #include "rpc/server.h"
  
  #if defined(HAVE_CONSENSUS_LIB)
  #include "script/marlinconsensus.h"
  #endif
  
  #include <fstream>
  #include <stdint.h>
  #include <string>
  #include <vector>
  
  #include <boost/test/unit_test.hpp>
  
  #include <univalue.h>
  
  // Uncomment if you want to output updated JSON tests.
  // #define UPDATE_JSON_TESTS
  
  static const unsigned int gFlags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
  
  unsigned int ParseScriptFlags(std::string strFlags);
  
  std::string FormatScriptFlags(unsigned int flags);
  
  UniValue
  read_json(const std::string &jsondata)
  {
      UniValue v;
  
      if (!v.read(jsondata) || !v.isArray())
      {
          BOOST_ERROR("Parse error.");
          return UniValue(UniValue::VARR);
      }
      return v.get_array();
  }
  
  struct ScriptErrorDesc
  {
      ScriptError_t err;
      const char *name;
  };
  
  static ScriptErrorDesc script_errors[] = {
          {SCRIPT_ERR_OK,                                    "OK"},
          {SCRIPT_ERR_UNKNOWN_ERROR,                         "UNKNOWN_ERROR"},
          {SCRIPT_ERR_EVAL_FALSE,                            "EVAL_FALSE"},
          {SCRIPT_ERR_OP_RETURN,                             "OP_RETURN"},
          {SCRIPT_ERR_SCRIPT_SIZE,                           "SCRIPT_SIZE"},
          {SCRIPT_ERR_PUSH_SIZE,                             "PUSH_SIZE"},
          {SCRIPT_ERR_OP_COUNT,                              "OP_COUNT"},
          {SCRIPT_ERR_STACK_SIZE,                            "STACK_SIZE"},
          {SCRIPT_ERR_SIG_COUNT,                             "SIG_COUNT"},
          {SCRIPT_ERR_PUBKEY_COUNT,                          "PUBKEY_COUNT"},
          {SCRIPT_ERR_VERIFY,                                "VERIFY"},
          {SCRIPT_ERR_EQUALVERIFY,                           "EQUALVERIFY"},
          {SCRIPT_ERR_CHECKMULTISIGVERIFY,                   "CHECKMULTISIGVERIFY"},
          {SCRIPT_ERR_CHECKSIGVERIFY,                        "CHECKSIGVERIFY"},
          {SCRIPT_ERR_NUMEQUALVERIFY,                        "NUMEQUALVERIFY"},
          {SCRIPT_ERR_BAD_OPCODE,                            "BAD_OPCODE"},
          {SCRIPT_ERR_DISABLED_OPCODE,                       "DISABLED_OPCODE"},
          {SCRIPT_ERR_INVALID_STACK_OPERATION,               "INVALID_STACK_OPERATION"},
          {SCRIPT_ERR_INVALID_ALTSTACK_OPERATION,            "INVALID_ALTSTACK_OPERATION"},
          {SCRIPT_ERR_UNBALANCED_CONDITIONAL,                "UNBALANCED_CONDITIONAL"},
          {SCRIPT_ERR_NEGATIVE_LOCKTIME,                     "NEGATIVE_LOCKTIME"},
          {SCRIPT_ERR_UNSATISFIED_LOCKTIME,                  "UNSATISFIED_LOCKTIME"},
          {SCRIPT_ERR_SIG_HASHTYPE,                          "SIG_HASHTYPE"},
          {SCRIPT_ERR_SIG_DER,                               "SIG_DER"},
          {SCRIPT_ERR_MINIMALDATA,                           "MINIMALDATA"},
          {SCRIPT_ERR_SIG_PUSHONLY,                          "SIG_PUSHONLY"},
          {SCRIPT_ERR_SIG_HIGH_S,                            "SIG_HIGH_S"},
          {SCRIPT_ERR_SIG_NULLDUMMY,                         "SIG_NULLDUMMY"},
          {SCRIPT_ERR_PUBKEYTYPE,                            "PUBKEYTYPE"},
          {SCRIPT_ERR_CLEANSTACK,                            "CLEANSTACK"},
          {SCRIPT_ERR_MINIMALIF,                             "MINIMALIF"},
          {SCRIPT_ERR_SIG_NULLFAIL,                          "NULLFAIL"},
          {SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS,            "DISCOURAGE_UPGRADABLE_NOPS"},
          {SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM, "DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM"},
          {SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH,          "WITNESS_PROGRAM_WRONG_LENGTH"},
          {SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY,         "WITNESS_PROGRAM_WITNESS_EMPTY"},
          {SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH,              "WITNESS_PROGRAM_MISMATCH"},
          {SCRIPT_ERR_WITNESS_MALLEATED,                     "WITNESS_MALLEATED"},
          {SCRIPT_ERR_WITNESS_MALLEATED_P2SH,                "WITNESS_MALLEATED_P2SH"},
          {SCRIPT_ERR_WITNESS_UNEXPECTED,                    "WITNESS_UNEXPECTED"},
          {SCRIPT_ERR_WITNESS_PUBKEYTYPE,                    "WITNESS_PUBKEYTYPE"},
  };
  
  const char *FormatScriptError(ScriptError_t err)
  {
      for (unsigned int i = 0; i < ARRAYLEN(script_errors); ++i)
          if (script_errors[i].err == err)
              return script_errors[i].name;
      BOOST_ERROR("Unknown scripterror enumeration value, update script_errors in script_tests.cpp.");
      return "";
  }
  
  ScriptError_t ParseScriptError(const std::string &name)
  {
      for (unsigned int i = 0; i < ARRAYLEN(script_errors); ++i)
          if (script_errors[i].name == name)
              return script_errors[i].err;
      BOOST_ERROR("Unknown scripterror \"" << name << "\" in test description");
      return SCRIPT_ERR_UNKNOWN_ERROR;
  }
  
  BOOST_FIXTURE_TEST_SUITE(script_tests, BasicTestingSetup)
  
      CMutableTransaction BuildCreditingTransaction(const CScript &scriptPubKey, int nValue = 0)
      {
          CMutableTransaction txCredit;
          txCredit.nVersion = 1;
          txCredit.nLockTime = 0;
          txCredit.vin.resize(1);
          txCredit.vout.resize(1);
          txCredit.vin[0].prevout.SetNull();
          txCredit.vin[0].scriptSig = CScript() << CScriptNum(0) << CScriptNum(0);
          txCredit.vin[0].nSequence = CTxIn::SEQUENCE_FINAL;
          txCredit.vout[0].scriptPubKey = scriptPubKey;
          txCredit.vout[0].nValue = nValue;
  
          return txCredit;
      }
  
      CMutableTransaction BuildSpendingTransaction(const CScript &scriptSig, const CScriptWitness &scriptWitness, const CMutableTransaction &txCredit)
      {
          CMutableTransaction txSpend;
          txSpend.nVersion = 1;
          txSpend.nLockTime = 0;
          txSpend.vin.resize(1);
          txSpend.vout.resize(1);
          txSpend.vin[0].scriptWitness = scriptWitness;
          txSpend.vin[0].prevout.hash = txCredit.GetHash();
          txSpend.vin[0].prevout.n = 0;
          txSpend.vin[0].scriptSig = scriptSig;
          txSpend.vin[0].nSequence = CTxIn::SEQUENCE_FINAL;
          txSpend.vout[0].scriptPubKey = CScript();
          txSpend.vout[0].nValue = txCredit.vout[0].nValue;
  
          return txSpend;
      }
  
      void DoTest(const CScript &scriptPubKey, const CScript &scriptSig, const CScriptWitness &scriptWitness, int flags, const std::string &message, int scriptError, CAmount nValue = 0)
      {
          bool expect = (scriptError == SCRIPT_ERR_OK);
          if (flags & SCRIPT_VERIFY_CLEANSTACK)
          {
              flags |= SCRIPT_VERIFY_P2SH;
              flags |= SCRIPT_VERIFY_WITNESS;
          }
          ScriptError err;
          CMutableTransaction txCredit = BuildCreditingTransaction(scriptPubKey, nValue);
          CMutableTransaction tx = BuildSpendingTransaction(scriptSig, scriptWitness, txCredit);
          CMutableTransaction tx2 = tx;
          BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, &scriptWitness, flags, MutableTransactionSignatureChecker(&tx, 0, txCredit.vout[0].nValue), &err) == expect, message);
          BOOST_CHECK_MESSAGE(err == scriptError, std::string(FormatScriptError(err)) + " where " + std::string(FormatScriptError((ScriptError_t) scriptError)) + " expected: " + message);
  #if defined(HAVE_CONSENSUS_LIB)
          CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
          stream << tx2;
          int libconsensus_flags = flags & marlinconsensus_SCRIPT_FLAGS_VERIFY_ALL;
          if (libconsensus_flags == flags) {
              if (flags & marlinconsensus_SCRIPT_FLAGS_VERIFY_WITNESS) {
                  BOOST_CHECK_MESSAGE(marlinconsensus_verify_script_with_amount(scriptPubKey.data(), scriptPubKey.size(), txCredit.vout[0].nValue, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, nullptr) == expect, message);
              } else {
                  BOOST_CHECK_MESSAGE(marlinconsensus_verify_script_with_amount(scriptPubKey.data(), scriptPubKey.size(), 0, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, nullptr) == expect, message);
                  BOOST_CHECK_MESSAGE(marlinconsensus_verify_script(scriptPubKey.data(), scriptPubKey.size(), (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, nullptr) == expect,message);
              }
          }
  #endif
      }
  
      void static NegateSignatureS(std::vector<unsigned char> &vchSig)
      {
          // Parse the signature.
          std::vector<unsigned char> r, s;
          r = std::vector<unsigned char>(vchSig.begin() + 4, vchSig.begin() + 4 + vchSig[3]);
          s = std::vector<unsigned char>(vchSig.begin() + 6 + vchSig[3], vchSig.begin() + 6 + vchSig[3] + vchSig[5 + vchSig[3]]);
  
          // Really ugly to implement mod-n negation here, but it would be feature creep to expose such functionality from libsecp256k1.
          static const unsigned char order[33] = {
                  0x00,
                  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
                  0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
                  0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x41
          };
          while (s.size() < 33)
          {
              s.insert(s.begin(), 0x00);
          }
          int carry = 0;
          for (int p = 32; p >= 1; p--)
          {
              int n = (int) order[p] - s[p] - carry;
              s[p] = (n + 256) & 0xFF;
              carry = (n < 0);
          }
          assert(carry == 0);
          if (s.size() > 1 && s[0] == 0 && s[1] < 0x80)
          {
              s.erase(s.begin());
          }
  
          // Reconstruct the signature.
          vchSig.clear();
          vchSig.push_back(0x30);
          vchSig.push_back(4 + r.size() + s.size());
          vchSig.push_back(0x02);
          vchSig.push_back(r.size());
          vchSig.insert(vchSig.end(), r.begin(), r.end());
          vchSig.push_back(0x02);
          vchSig.push_back(s.size());
          vchSig.insert(vchSig.end(), s.begin(), s.end());
      }
  
      namespace
      {
          const unsigned char vchKey0[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
          const unsigned char vchKey1[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0};
          const unsigned char vchKey2[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0};
  
          struct KeyData
          {
              CKey key0, key0C, key1, key1C, key2, key2C;
              CPubKey pubkey0, pubkey0C, pubkey0H;
              CPubKey pubkey1, pubkey1C;
              CPubKey pubkey2, pubkey2C;
  
              KeyData()
              {
  
                  key0.Set(vchKey0, vchKey0 + 32, false);
                  key0C.Set(vchKey0, vchKey0 + 32, true);
                  pubkey0 = key0.GetPubKey();
                  pubkey0H = key0.GetPubKey();
                  pubkey0C = key0C.GetPubKey();
                  *const_cast<unsigned char *>(&pubkey0H[0]) = 0x06 | (pubkey0H[64] & 1);
  
                  key1.Set(vchKey1, vchKey1 + 32, false);
                  key1C.Set(vchKey1, vchKey1 + 32, true);
                  pubkey1 = key1.GetPubKey();
                  pubkey1C = key1C.GetPubKey();
  
                  key2.Set(vchKey2, vchKey2 + 32, false);
                  key2C.Set(vchKey2, vchKey2 + 32, true);
                  pubkey2 = key2.GetPubKey();
                  pubkey2C = key2C.GetPubKey();
              }
          };
  
          enum WitnessMode
          {
              WITNESS_NONE,
              WITNESS_PKH,
              WITNESS_SH
          };
  
          class TestBuilder
          {
          private:
              //! Actually executed script
              CScript script;
              //! The P2SH redeemscript
              CScript redeemscript;
              //! The Witness embedded script
              CScript witscript;
              CScriptWitness scriptWitness;
              CTransactionRef creditTx;
              CMutableTransaction spendTx;
              bool havePush;
              std::vector<unsigned char> push;
              std::string comment;
              int flags;
              int scriptError;
              CAmount nValue;
  
              void DoPush()
              {
                  if (havePush)
                  {
                      spendTx.vin[0].scriptSig << push;
                      havePush = false;
                  }
              }
  
              void DoPush(const std::vector<unsigned char> &data)
              {
                  DoPush();
                  push = data;
                  havePush = true;
              }
  
          public:
              TestBuilder(const CScript &script_, const std::string &comment_, int flags_, bool P2SH = false, WitnessMode wm = WITNESS_NONE, int witnessversion = 0, CAmount nValue_ = 0)
                      : script(script_), havePush(false), comment(comment_), flags(flags_), scriptError(SCRIPT_ERR_OK), nValue(nValue_)
              {
                  CScript scriptPubKey = script;
                  if (wm == WITNESS_PKH)
                  {
                      uint160 hash;
                      CHash160().Write(&script[1], script.size() - 1).Finalize(hash.begin());
                      script = CScript() << OP_DUP << OP_HASH160 << ToByteVector(hash) << OP_EQUALVERIFY << OP_CHECKSIG;
                      scriptPubKey = CScript() << witnessversion << ToByteVector(hash);
                  } else if (wm == WITNESS_SH)
                  {
                      witscript = scriptPubKey;
                      uint256 hash;
                      CSHA256().Write(&witscript[0], witscript.size()).Finalize(hash.begin());
                      scriptPubKey = CScript() << witnessversion << ToByteVector(hash);
                  }
                  if (P2SH)
                  {
                      redeemscript = scriptPubKey;
                      scriptPubKey = CScript() << OP_HASH160 << ToByteVector(CScriptID(redeemscript)) << OP_EQUAL;
                  }
                  creditTx = MakeTransactionRef(BuildCreditingTransaction(scriptPubKey, nValue));
                  spendTx = BuildSpendingTransaction(CScript(), CScriptWitness(), *creditTx);
              }
  
              TestBuilder &ScriptError(ScriptError_t err)
              {
                  scriptError = err;
                  return *this;
              }
  
              TestBuilder &Add(const CScript &_script)
              {
                  DoPush();
                  spendTx.vin[0].scriptSig += _script;
                  return *this;
              }
  
              TestBuilder &Num(int num)
              {
                  DoPush();
                  spendTx.vin[0].scriptSig << num;
                  return *this;
              }
  
              TestBuilder &Push(const std::string &hex)
              {
                  DoPush(ParseHex(hex));
                  return *this;
              }
  
              TestBuilder &Push(const CScript &_script)
              {
                  DoPush(std::vector<unsigned char>(_script.begin(), _script.end()));
                  return *this;
              }
  
              TestBuilder &PushSig(const CKey &key, int nHashType = SIGHASH_ALL, unsigned int lenR = 32, unsigned int lenS = 32, SigVersion sigversion = SIGVERSION_BASE, CAmount amount = 0)
              {
                  uint256 hash = SignatureHash(script, spendTx, 0, nHashType, amount, sigversion);
                  std::vector<unsigned char> vchSig, r, s;
                  uint32_t iter = 0;
                  do
                  {
                      key.Sign(hash, vchSig, iter++);
                      if ((lenS == 33) != (vchSig[5 + vchSig[3]] == 33))
                      {
                          NegateSignatureS(vchSig);
                      }
                      r = std::vector<unsigned char>(vchSig.begin() + 4, vchSig.begin() + 4 + vchSig[3]);
                      s = std::vector<unsigned char>(vchSig.begin() + 6 + vchSig[3], vchSig.begin() + 6 + vchSig[3] + vchSig[5 + vchSig[3]]);
                  } while (lenR != r.size() || lenS != s.size());
                  vchSig.push_back(static_cast<unsigned char>(nHashType));
                  DoPush(vchSig);
                  return *this;
              }
  
              TestBuilder &PushWitSig(const CKey &key, CAmount amount = -1, int nHashType = SIGHASH_ALL, unsigned int lenR = 32, unsigned int lenS = 32, SigVersion sigversion = SIGVERSION_WITNESS_V0)
              {
                  if (amount == -1)
                      amount = nValue;
                  return PushSig(key, nHashType, lenR, lenS, sigversion, amount).AsWit();
              }
  
              TestBuilder &Push(const CPubKey &pubkey)
              {
                  DoPush(std::vector<unsigned char>(pubkey.begin(), pubkey.end()));
                  return *this;
              }
  
              TestBuilder &PushRedeem()
              {
                  DoPush(std::vector<unsigned char>(redeemscript.begin(), redeemscript.end()));
                  return *this;
              }
  
              TestBuilder &PushWitRedeem()
              {
                  DoPush(std::vector<unsigned char>(witscript.begin(), witscript.end()));
                  return AsWit();
              }
  
              TestBuilder &EditPush(unsigned int pos, const std::string &hexin, const std::string &hexout)
              {
                  assert(havePush);
                  std::vector<unsigned char> datain = ParseHex(hexin);
                  std::vector<unsigned char> dataout = ParseHex(hexout);
                  assert(pos + datain.size() <= push.size());
                  BOOST_CHECK_MESSAGE(std::vector<unsigned char>(push.begin() + pos, push.begin() + pos + datain.size()) == datain, comment);
                  push.erase(push.begin() + pos, push.begin() + pos + datain.size());
                  push.insert(push.begin() + pos, dataout.begin(), dataout.end());
                  return *this;
              }
  
              TestBuilder &DamagePush(unsigned int pos)
              {
                  assert(havePush);
                  assert(pos < push.size());
                  push[pos] ^= 1;
                  return *this;
              }
  
              TestBuilder &Test()
              {
                  TestBuilder copy = *this; // Make a copy so we can rollback the push.
                  DoPush();
                  DoTest(creditTx->vout[0].scriptPubKey, spendTx.vin[0].scriptSig, scriptWitness, flags, comment, scriptError, nValue);
                  *this = copy;
                  return *this;
              }
  
              TestBuilder &AsWit()
              {
                  assert(havePush);
                  scriptWitness.stack.push_back(push);
                  havePush = false;
                  return *this;
              }
  
              UniValue GetJSON()
              {
                  DoPush();
                  UniValue array(UniValue::VARR);
                  if (!scriptWitness.stack.empty())
                  {
                      UniValue wit(UniValue::VARR);
                      for (unsigned i = 0; i < scriptWitness.stack.size(); i++)
                      {
                          wit.push_back(HexStr(scriptWitness.stack[i]));
                      }
                      wit.push_back(ValueFromAmount(nValue));
                      array.push_back(wit);
                  }
                  array.push_back(FormatScript(spendTx.vin[0].scriptSig));
                  array.push_back(FormatScript(creditTx->vout[0].scriptPubKey));
                  array.push_back(FormatScriptFlags(flags));
                  array.push_back(FormatScriptError((ScriptError_t) scriptError));
                  array.push_back(comment);
                  return array;
              }
  
              std::string GetComment() const
              {
                  return comment;
              }
          };
  
          std::string JSONPrettyPrint(const UniValue &univalue)
          {
              std::string ret = univalue.write(4);
              // Workaround for libunivalue pretty printer, which puts a space between commas and newlines
              size_t pos = 0;
              while ((pos = ret.find(" \n", pos)) != std::string::npos)
              {
                  ret.replace(pos, 2, "\n");
                  pos++;
              }
              return ret;
          }
      } // namespace
  
      BOOST_AUTO_TEST_CASE(script_build_test)
      {
          BOOST_TEST_MESSAGE("Running Script Build Test");
  
          const KeyData keys;
  
          std::vector<TestBuilder> tests;
  
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "P2PK", 0
          ).PushSig(keys.key0));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "P2PK, bad sig", 0
          ).PushSig(keys.key0).DamagePush(10).ScriptError(SCRIPT_ERR_EVAL_FALSE));
  
          tests.push_back(TestBuilder(
                  CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1C.GetID()) << OP_EQUALVERIFY
                            << OP_CHECKSIG,
                  "P2PKH", 0
          ).PushSig(keys.key1).Push(keys.pubkey1C));
          tests.push_back(TestBuilder(
                  CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey2C.GetID()) << OP_EQUALVERIFY
                            << OP_CHECKSIG,
                  "P2PKH, bad pubkey", 0
          ).PushSig(keys.key2).Push(keys.pubkey2C).DamagePush(5).ScriptError(SCRIPT_ERR_EQUALVERIFY));
  
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                                      "P2PK anyonecanpay", 0
          ).PushSig(keys.key1, SIGHASH_ALL | SIGHASH_ANYONECANPAY));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                                      "P2PK anyonecanpay marked with normal hashtype", 0
          ).PushSig(keys.key1, SIGHASH_ALL | SIGHASH_ANYONECANPAY).EditPush(70, "81", "01").ScriptError(SCRIPT_ERR_EVAL_FALSE));
  
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
                                      "P2SH(P2PK)", SCRIPT_VERIFY_P2SH, true
          ).PushSig(keys.key0).PushRedeem());
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
                                      "P2SH(P2PK), bad redeemscript", SCRIPT_VERIFY_P2SH, true
          ).PushSig(keys.key0).PushRedeem().DamagePush(10).ScriptError(SCRIPT_ERR_EVAL_FALSE));
  
          tests.push_back(TestBuilder(
                  CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey0.GetID()) << OP_EQUALVERIFY
                            << OP_CHECKSIG,
                  "P2SH(P2PKH)", SCRIPT_VERIFY_P2SH, true
          ).PushSig(keys.key0).Push(keys.pubkey0).PushRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1.GetID()) << OP_EQUALVERIFY
                            << OP_CHECKSIG,
                  "P2SH(P2PKH), bad sig but no VERIFY_P2SH", 0, true
          ).PushSig(keys.key0).DamagePush(10).PushRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1.GetID()) << OP_EQUALVERIFY
                            << OP_CHECKSIG,
                  "P2SH(P2PKH), bad sig", SCRIPT_VERIFY_P2SH, true
          ).PushSig(keys.key0).DamagePush(10).PushRedeem().ScriptError(SCRIPT_ERR_EQUALVERIFY));
  
          tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C)
                                                << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
                                      "3-of-3", 0
          ).Num(0).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2));
          tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C)
                                                << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
                                      "3-of-3, 2 sigs", 0
          ).Num(0).PushSig(keys.key0).PushSig(keys.key1).Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
  
          tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C)
                                                << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
                                      "P2SH(2-of-3)", SCRIPT_VERIFY_P2SH, true
          ).Num(0).PushSig(keys.key1).PushSig(keys.key2).PushRedeem());
          tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C)
                                                << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
                                      "P2SH(2-of-3), 1 sig", SCRIPT_VERIFY_P2SH, true
          ).Num(0).PushSig(keys.key1).Num(0).PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
  
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                                      "P2PK with too much R padding but no DERSIG", 0
          ).PushSig(keys.key1, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000"));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                                      "P2PK with too much R padding", SCRIPT_VERIFY_DERSIG
          ).PushSig(keys.key1, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").ScriptError(SCRIPT_ERR_SIG_DER));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                                      "P2PK with too much S padding but no DERSIG", 0
          ).PushSig(keys.key1, SIGHASH_ALL).EditPush(1, "44", "45").EditPush(37, "20", "2100"));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                                      "P2PK with too much S padding", SCRIPT_VERIFY_DERSIG
          ).PushSig(keys.key1, SIGHASH_ALL).EditPush(1, "44", "45").EditPush(37, "20", "2100").ScriptError(SCRIPT_ERR_SIG_DER));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                                      "P2PK with too little R padding but no DERSIG", 0
          ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220"));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                                      "P2PK with too little R padding", SCRIPT_VERIFY_DERSIG
          ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
                                      "P2PK NOT with bad sig with too much R padding but no DERSIG", 0
          ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").DamagePush(10));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
                                      "P2PK NOT with bad sig with too much R padding", SCRIPT_VERIFY_DERSIG
          ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").DamagePush(10).ScriptError(SCRIPT_ERR_SIG_DER));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
                                      "P2PK NOT with too much R padding but no DERSIG", 0
          ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
                                      "P2PK NOT with too much R padding", SCRIPT_VERIFY_DERSIG
          ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").ScriptError(SCRIPT_ERR_SIG_DER));
  
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                                      "BIP66 example 1, without DERSIG", 0
          ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220"));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                                      "BIP66 example 1, with DERSIG", SCRIPT_VERIFY_DERSIG
          ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
                                      "BIP66 example 2, without DERSIG", 0
          ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
                                      "BIP66 example 2, with DERSIG", SCRIPT_VERIFY_DERSIG
          ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                                      "BIP66 example 3, without DERSIG", 0
          ).Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                                      "BIP66 example 3, with DERSIG", SCRIPT_VERIFY_DERSIG
          ).Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
                                      "BIP66 example 4, without DERSIG", 0
          ).Num(0));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
                                      "BIP66 example 4, with DERSIG", SCRIPT_VERIFY_DERSIG
          ).Num(0));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                                      "BIP66 example 5, without DERSIG", 0
          ).Num(1).ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                                      "BIP66 example 5, with DERSIG", SCRIPT_VERIFY_DERSIG
          ).Num(1).ScriptError(SCRIPT_ERR_SIG_DER));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
                                      "BIP66 example 6, without DERSIG", 0
          ).Num(1));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
                                      "BIP66 example 6, with DERSIG", SCRIPT_VERIFY_DERSIG
          ).Num(1).ScriptError(SCRIPT_ERR_SIG_DER));
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2
                            << OP_CHECKMULTISIG,
                  "BIP66 example 7, without DERSIG", 0
          ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2));
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2
                            << OP_CHECKMULTISIG,
                  "BIP66 example 7, with DERSIG", SCRIPT_VERIFY_DERSIG
          ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2).ScriptError(SCRIPT_ERR_SIG_DER));
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2
                            << OP_CHECKMULTISIG << OP_NOT,
                  "BIP66 example 8, without DERSIG", 0
          ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2).ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2
                            << OP_CHECKMULTISIG << OP_NOT,
                  "BIP66 example 8, with DERSIG", SCRIPT_VERIFY_DERSIG
          ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2).ScriptError(SCRIPT_ERR_SIG_DER));
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2
                            << OP_CHECKMULTISIG,
                  "BIP66 example 9, without DERSIG", 0
          ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2
                            << OP_CHECKMULTISIG,
                  "BIP66 example 9, with DERSIG", SCRIPT_VERIFY_DERSIG
          ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2
                            << OP_CHECKMULTISIG << OP_NOT,
                  "BIP66 example 10, without DERSIG", 0
          ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220"));
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2
                            << OP_CHECKMULTISIG << OP_NOT,
                  "BIP66 example 10, with DERSIG", SCRIPT_VERIFY_DERSIG
          ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2
                            << OP_CHECKMULTISIG,
                  "BIP66 example 11, without DERSIG", 0
          ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2
                            << OP_CHECKMULTISIG,
                  "BIP66 example 11, with DERSIG", SCRIPT_VERIFY_DERSIG
          ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2
                            << OP_CHECKMULTISIG << OP_NOT,
                  "BIP66 example 12, without DERSIG", 0
          ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0));
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2
                            << OP_CHECKMULTISIG << OP_NOT,
                  "BIP66 example 12, with DERSIG", SCRIPT_VERIFY_DERSIG
          ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                                      "P2PK with multi-byte hashtype, without DERSIG", 0
          ).PushSig(keys.key2, SIGHASH_ALL).EditPush(70, "01", "0101"));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                                      "P2PK with multi-byte hashtype, with DERSIG", SCRIPT_VERIFY_DERSIG
          ).PushSig(keys.key2, SIGHASH_ALL).EditPush(70, "01", "0101").ScriptError(SCRIPT_ERR_SIG_DER));
  
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                                      "P2PK with high S but no LOW_S", 0
          ).PushSig(keys.key2, SIGHASH_ALL, 32, 33));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                                      "P2PK with high S", SCRIPT_VERIFY_LOW_S
          ).PushSig(keys.key2, SIGHASH_ALL, 32, 33).ScriptError(SCRIPT_ERR_SIG_HIGH_S));
  
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
                                      "P2PK with hybrid pubkey but no STRICTENC", 0
          ).PushSig(keys.key0, SIGHASH_ALL));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
                                      "P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC
          ).PushSig(keys.key0, SIGHASH_ALL).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
                                      "P2PK NOT with hybrid pubkey but no STRICTENC", 0
          ).PushSig(keys.key0, SIGHASH_ALL).ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
                                      "P2PK NOT with hybrid pubkey", SCRIPT_VERIFY_STRICTENC
          ).PushSig(keys.key0, SIGHASH_ALL).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
                                      "P2PK NOT with invalid hybrid pubkey but no STRICTENC", 0
          ).PushSig(keys.key0, SIGHASH_ALL).DamagePush(10));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
                                      "P2PK NOT with invalid hybrid pubkey", SCRIPT_VERIFY_STRICTENC
          ).PushSig(keys.key0, SIGHASH_ALL).DamagePush(10).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey0H) << ToByteVector(keys.pubkey1C) << OP_2
                            << OP_CHECKMULTISIG,
                  "1-of-2 with the second 1 hybrid pubkey and no STRICTENC", 0
          ).Num(0).PushSig(keys.key1, SIGHASH_ALL));
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey0H) << ToByteVector(keys.pubkey1C) << OP_2
                            << OP_CHECKMULTISIG,
                  "1-of-2 with the second 1 hybrid pubkey", SCRIPT_VERIFY_STRICTENC
          ).Num(0).PushSig(keys.key1, SIGHASH_ALL));
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0H) << OP_2
                            << OP_CHECKMULTISIG,
                  "1-of-2 with the first 1 hybrid pubkey", SCRIPT_VERIFY_STRICTENC
          ).Num(0).PushSig(keys.key1, SIGHASH_ALL).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
  
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                                      "P2PK with undefined hashtype but no STRICTENC", 0
          ).PushSig(keys.key1, 5));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                                      "P2PK with undefined hashtype", SCRIPT_VERIFY_STRICTENC
          ).PushSig(keys.key1, 5).ScriptError(SCRIPT_ERR_SIG_HASHTYPE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
                                      "P2PK NOT with invalid sig and undefined hashtype but no STRICTENC", 0
          ).PushSig(keys.key1, 5).DamagePush(10));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
                                      "P2PK NOT with invalid sig and undefined hashtype", SCRIPT_VERIFY_STRICTENC
          ).PushSig(keys.key1, 5).DamagePush(10).ScriptError(SCRIPT_ERR_SIG_HASHTYPE));
  
          tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C)
                                                << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
                                      "3-of-3 with nonzero dummy but no NULLDUMMY", 0
          ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2));
          tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C)
                                                << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
                                      "3-of-3 with nonzero dummy", SCRIPT_VERIFY_NULLDUMMY
          ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2).ScriptError(SCRIPT_ERR_SIG_NULLDUMMY));
          tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C)
                                                << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG << OP_NOT,
                                      "3-of-3 NOT with invalid sig and nonzero dummy but no NULLDUMMY", 0
          ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2).DamagePush(10));
          tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C)
                                                << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG << OP_NOT,
                                      "3-of-3 NOT with invalid sig with nonzero dummy", SCRIPT_VERIFY_NULLDUMMY
          ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2).DamagePush(10).ScriptError(SCRIPT_ERR_SIG_NULLDUMMY));
  
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C) << OP_2
                            << OP_CHECKMULTISIG,
                  "2-of-2 with two identical keys and sigs pushed using OP_DUP but no SIGPUSHONLY", 0
          ).Num(0).PushSig(keys.key1).Add(CScript() << OP_DUP));
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C) << OP_2
                            << OP_CHECKMULTISIG,
                  "2-of-2 with two identical keys and sigs pushed using OP_DUP", SCRIPT_VERIFY_SIGPUSHONLY
          ).Num(0).PushSig(keys.key1).Add(CScript() << OP_DUP).ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                                      "P2SH(P2PK) with non-push scriptSig but no P2SH or SIGPUSHONLY", 0, true
          ).PushSig(keys.key2).Add(CScript() << OP_NOP8).PushRedeem());
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                                      "P2PK with non-push scriptSig but with P2SH validation", 0
          ).PushSig(keys.key2).Add(CScript() << OP_NOP8));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                                      "P2SH(P2PK) with non-push scriptSig but no SIGPUSHONLY", SCRIPT_VERIFY_P2SH, true
          ).PushSig(keys.key2).Add(CScript() << OP_NOP8).PushRedeem().ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                                      "P2SH(P2PK) with non-push scriptSig but not P2SH", SCRIPT_VERIFY_SIGPUSHONLY, true
          ).PushSig(keys.key2).Add(CScript() << OP_NOP8).PushRedeem().ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
          tests.push_back(TestBuilder(
                  CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C) << OP_2
                            << OP_CHECKMULTISIG,
                  "2-of-2 with two identical keys and sigs pushed", SCRIPT_VERIFY_SIGPUSHONLY
          ).Num(0).PushSig(keys.key1).PushSig(keys.key1));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "P2PK with unnecessary input but no CLEANSTACK", SCRIPT_VERIFY_P2SH
          ).Num(11).PushSig(keys.key0));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "P2PK with unnecessary input", SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH
          ).Num(11).PushSig(keys.key0).ScriptError(SCRIPT_ERR_CLEANSTACK));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "P2SH with unnecessary input but no CLEANSTACK", SCRIPT_VERIFY_P2SH, true
          ).Num(11).PushSig(keys.key0).PushRedeem());
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "P2SH with unnecessary input", SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true
          ).Num(11).PushSig(keys.key0).PushRedeem().ScriptError(SCRIPT_ERR_CLEANSTACK));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "P2SH with CLEANSTACK", SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true
          ).PushSig(keys.key0).PushRedeem());
  
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "Basic P2WSH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_SH,
                                      0, 1).PushWitSig(keys.key0).PushWitRedeem());
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
                                      "Basic P2WPKH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_PKH,
                                      0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit());
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "Basic P2SH(P2WSH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WITNESS_SH,
                                      0, 1).PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
                                      "Basic P2SH(P2WPKH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WITNESS_PKH,
                                      0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().PushRedeem());
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                                      "Basic P2WSH with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_SH
          ).PushWitSig(keys.key0).PushWitRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
                                      "Basic P2WPKH with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_PKH
          ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                                      "Basic P2SH(P2WSH) with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WITNESS_SH
          ).PushWitSig(keys.key0).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
                                      "Basic P2SH(P2WPKH) with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WITNESS_PKH
          ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                                      "Basic P2WSH with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, false, WITNESS_SH
          ).PushWitSig(keys.key0).PushWitRedeem());
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
                                      "Basic P2WPKH with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, false, WITNESS_PKH
          ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit());
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                                      "Basic P2SH(P2WSH) with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, true, WITNESS_SH
          ).PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
                                      "Basic P2SH(P2WPKH) with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, true, WITNESS_PKH
          ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().PushRedeem());
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "Basic P2WSH with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_SH,
                                      0, 0).PushWitSig(keys.key0, 1).PushWitRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
                                      "Basic P2WPKH with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_PKH,
                                      0, 0).PushWitSig(keys.key0, 1).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "Basic P2SH(P2WSH) with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WITNESS_SH,
                                      0, 0).PushWitSig(keys.key0, 1).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
                                      "Basic P2SH(P2WPKH) with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WITNESS_PKH,
                                      0, 0).PushWitSig(keys.key0, 1).Push(keys.pubkey0).AsWit().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
  
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
                                      "P2WPKH with future witness version", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH |
                                                                            SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM, false, WITNESS_PKH, 1
          ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM));
          {
              CScript witscript = CScript() << ToByteVector(keys.pubkey0);
              uint256 hash;
              CSHA256().Write(&witscript[0], witscript.size()).Finalize(hash.begin());
              std::vector<unsigned char> hashBytes = ToByteVector(hash);
              hashBytes.pop_back();
              tests.push_back(TestBuilder(CScript() << OP_0 << hashBytes,
                                          "P2WPKH with wrong witness program length", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false
              ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH));
          }
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "P2WSH with empty witness", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_SH
          ).ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY));
          {
              CScript witscript = CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG;
              tests.push_back(TestBuilder(witscript,
                                          "P2WSH with witness program mismatch", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_SH
              ).PushWitSig(keys.key0).Push(witscript).DamagePush(0).AsWit().ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH));
          }
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
                                      "P2WPKH with witness program mismatch", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_PKH
          ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().Push("0").AsWit().ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
                                      "P2WPKH with non-empty scriptSig", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_PKH
          ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().Num(11).ScriptError(SCRIPT_ERR_WITNESS_MALLEATED));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
                                      "P2SH(P2WPKH) with superfluous push in scriptSig", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WITNESS_PKH
          ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().Num(11).PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_MALLEATED_P2SH));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "P2PK with witness", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH
          ).PushSig(keys.key0).Push("0").AsWit().ScriptError(SCRIPT_ERR_WITNESS_UNEXPECTED));
  
          // Compressed keys should pass SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
                                      "Basic P2WSH with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WITNESS_SH,
                                      0, 1).PushWitSig(keys.key0C).PushWitRedeem());
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C),
                                      "Basic P2WPKH with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WITNESS_PKH,
                                      0, 1).PushWitSig(keys.key0C).Push(keys.pubkey0C).AsWit());
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
                                      "Basic P2SH(P2WSH) with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WITNESS_SH,
                                      0, 1).PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C),
                                      "Basic P2SH(P2WPKH) with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WITNESS_PKH,
                                      0, 1).PushWitSig(keys.key0C).Push(keys.pubkey0C).AsWit().PushRedeem());
  
          // Testing uncompressed key in witness with SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "Basic P2WSH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WITNESS_SH,
                                      0, 1).PushWitSig(keys.key0).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
                                      "Basic P2WPKH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WITNESS_PKH,
                                      0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                                      "Basic P2SH(P2WSH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WITNESS_SH,
                                      0, 1).PushWitSig(keys.key0).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
          tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
                                      "Basic P2SH(P2WPKH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WITNESS_PKH,
                                      0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
  
          // P2WSH 1-of-2 multisig with compressed keys
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2WSH CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2SH(P2WSH) CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2WSH CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2SH(P2WSH) CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().PushRedeem());
  
          // P2WSH 1-of-2 multisig with first key uncompressed
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2WSH CHECKMULTISIG with first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2SH(P2WSH) CHECKMULTISIG first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2WSH CHECKMULTISIG with first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2SH(P2WSH) CHECKMULTISIG with first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2WSH CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2SH(P2WSH) CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().PushRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2WSH CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2SH(P2WSH) CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
          // P2WSH 1-of-2 multisig with second key uncompressed
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2WSH CHECKMULTISIG with second key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2SH(P2WSH) CHECKMULTISIG second key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2WSH CHECKMULTISIG with second key uncompressed and signing with the first key should pass as the uncompressed key is not used", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2SH(P2WSH) CHECKMULTISIG with second key uncompressed and signing with the first key should pass as the uncompressed key is not used", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2WSH CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2SH(P2WSH) CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem().PushRedeem());
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2WSH CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
          tests.push_back(TestBuilder(
                  CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2
                            << OP_CHECKMULTISIG,
                  "P2SH(P2WSH) CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WITNESS_SH,
                  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
  
          std::set<std::string> tests_set;
  
          {
              UniValue json_tests = read_json(std::string(json_tests::script_tests, json_tests::script_tests + sizeof(json_tests::script_tests)));
  
              for (unsigned int idx = 0; idx < json_tests.size(); idx++)
              {
                  const UniValue &tv = json_tests[idx];
                  tests_set.insert(JSONPrettyPrint(tv.get_array()));
              }
          }
  
          std::string strGen;
  
          for (TestBuilder &test : tests)
          {
              test.Test();
              std::string str = JSONPrettyPrint(test.GetJSON());
  #ifndef UPDATE_JSON_TESTS
              if (tests_set.count(str) == 0)
              {
                  BOOST_CHECK_MESSAGE(false, "Missing auto script_valid test: " + test.GetComment());
              }
  #endif
              strGen += str + ",\n";
          }
  
  #ifdef UPDATE_JSON_TESTS
          FILE* file = fopen("script_tests.json.gen", "w");
          fputs(strGen.c_str(), file);
          fclose(file);
  #endif
      }
  
      BOOST_AUTO_TEST_CASE(script_json_test)
      {
          BOOST_TEST_MESSAGE("Running Script JSON Test");
  
          // Read tests from test/data/script_tests.json
          // Format is an array of arrays
          // Inner arrays are [ ["wit"..., nValue]?, "scriptSig", "scriptPubKey", "flags", "expected_scripterror" ]
          // ... where scriptSig and scriptPubKey are stringified
          // scripts.
          // If a witness is given, then the last value in the array should be the
          // amount (nValue) to use in the crediting tx
          UniValue tests = read_json(std::string(json_tests::script_tests, json_tests::script_tests + sizeof(json_tests::script_tests)));
  
          for (unsigned int idx = 0; idx < tests.size(); idx++)
          {
              UniValue test = tests[idx];
              std::string strTest = test.write();
              CScriptWitness witness;
              CAmount nValue = 0;
              unsigned int pos = 0;
              if (test.size() > 0 && test[pos].isArray())
              {
                  unsigned int i = 0;
                  for (i = 0; i < test[pos].size() - 1; i++)
                  {
                      witness.stack.push_back(ParseHex(test[pos][i].get_str()));
                  }
                  nValue = AmountFromValue(test[pos][i]);
                  pos++;
              }
              if (test.size() < 4 + pos) // Allow size > 3; extra stuff ignored (useful for comments)
              {
                  if (test.size() != 1)
                  {
                      BOOST_ERROR("Bad test: " << strTest);
                  }
                  continue;
              }
              std::string scriptSigString = test[pos++].get_str();
              CScript scriptSig = ParseScript(scriptSigString);
              std::string scriptPubKeyString = test[pos++].get_str();
              CScript scriptPubKey = ParseScript(scriptPubKeyString);
              unsigned int scriptflags = ParseScriptFlags(test[pos++].get_str());
              int scriptError = ParseScriptError(test[pos++].get_str());
  
              DoTest(scriptPubKey, scriptSig, witness, scriptflags, strTest, scriptError, nValue);
          }
      }
  
      BOOST_AUTO_TEST_CASE(script_PushData_test)
      {
          BOOST_TEST_MESSAGE("Running Script PushData Test");
  
          // Check that PUSHDATA1, PUSHDATA2, and PUSHDATA4 create the same value on
          // the stack as the 1-75 opcodes do.
          static const unsigned char direct[] = {1, 0x5a};
          static const unsigned char pushdata1[] = {OP_PUSHDATA1, 1, 0x5a};
          static const unsigned char pushdata2[] = {OP_PUSHDATA2, 1, 0, 0x5a};
          static const unsigned char pushdata4[] = {OP_PUSHDATA4, 1, 0, 0, 0, 0x5a};
  
          ScriptError err;
          std::vector<std::vector<unsigned char> > directStack;
          BOOST_CHECK(EvalScript(directStack, CScript(&direct[0], &direct[sizeof(direct)]), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SIGVERSION_BASE, &err));
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
  
          std::vector<std::vector<unsigned char> > pushdata1Stack;
          BOOST_CHECK(EvalScript(pushdata1Stack, CScript(&pushdata1[0], &pushdata1[sizeof(pushdata1)]), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SIGVERSION_BASE, &err));
          BOOST_CHECK(pushdata1Stack == directStack);
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
  
          std::vector<std::vector<unsigned char> > pushdata2Stack;
          BOOST_CHECK(EvalScript(pushdata2Stack, CScript(&pushdata2[0], &pushdata2[sizeof(pushdata2)]), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SIGVERSION_BASE, &err));
          BOOST_CHECK(pushdata2Stack == directStack);
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
  
          std::vector<std::vector<unsigned char> > pushdata4Stack;
          BOOST_CHECK(EvalScript(pushdata4Stack, CScript(&pushdata4[0], &pushdata4[sizeof(pushdata4)]), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SIGVERSION_BASE, &err));
          BOOST_CHECK(pushdata4Stack == directStack);
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
      }
  
      CScript
      sign_multisig(CScript scriptPubKey, std::vector<CKey> keys, CTransaction transaction)
      {
          uint256 hash = SignatureHash(scriptPubKey, transaction, 0, SIGHASH_ALL, 0, SIGVERSION_BASE);
  
          CScript result;
          //
          // NOTE: CHECKMULTISIG has an unfortunate bug; it requires
          // one extra item on the stack, before the signatures.
          // Putting OP_0 on the stack is the workaround;
          // fixing the bug would mean splitting the block chain (old
          // clients would not accept new CHECKMULTISIG transactions,
          // and vice-versa)
          //
          result << OP_0;
          for (const CKey &key : keys)
          {
              std::vector<unsigned char> vchSig;
              BOOST_CHECK(key.Sign(hash, vchSig));
              vchSig.push_back((unsigned char) SIGHASH_ALL);
              result << vchSig;
          }
          return result;
      }
  
      CScript
      sign_multisig(CScript scriptPubKey, const CKey &key, CTransaction transaction)
      {
          std::vector<CKey> keys;
          keys.push_back(key);
          return sign_multisig(scriptPubKey, keys, transaction);
      }
  
      BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG12_test)
      {
          BOOST_TEST_MESSAGE("Running Script CheckMultiSig12 Test");
  
          ScriptError err;
          CKey key1, key2, key3;
          key1.MakeNewKey(true);
          key2.MakeNewKey(false);
          key3.MakeNewKey(true);
  
          CScript scriptPubKey12;
          scriptPubKey12 << OP_1 << ToByteVector(key1.GetPubKey()) << ToByteVector(key2.GetPubKey()) << OP_2
                         << OP_CHECKMULTISIG;
  
          CMutableTransaction txFrom12 = BuildCreditingTransaction(scriptPubKey12);
          CMutableTransaction txTo12 = BuildSpendingTransaction(CScript(), CScriptWitness(), txFrom12);
  
          CScript goodsig1 = sign_multisig(scriptPubKey12, key1, txTo12);
          BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err));
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
          txTo12.vout[0].nValue = 2;
          BOOST_CHECK(!VerifyScript(goodsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err));
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
  
          CScript goodsig2 = sign_multisig(scriptPubKey12, key2, txTo12);
          BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err));
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
  
          CScript badsig1 = sign_multisig(scriptPubKey12, key3, txTo12);
          BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err));
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
      }
  
      BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23_test)
      {
          BOOST_TEST_MESSAGE("Running script CheckMultiSig23 Test");
  
          ScriptError err;
          CKey key1, key2, key3, key4;
          key1.MakeNewKey(true);
          key2.MakeNewKey(false);
          key3.MakeNewKey(true);
          key4.MakeNewKey(false);
  
          CScript scriptPubKey23;
          scriptPubKey23 << OP_2 << ToByteVector(key1.GetPubKey()) << ToByteVector(key2.GetPubKey())
                         << ToByteVector(key3.GetPubKey()) << OP_3 << OP_CHECKMULTISIG;
  
          CMutableTransaction txFrom23 = BuildCreditingTransaction(scriptPubKey23);
          CMutableTransaction txTo23 = BuildSpendingTransaction(CScript(), CScriptWitness(), txFrom23);
  
          std::vector<CKey> keys;
          keys.push_back(key1);
          keys.push_back(key2);
          CScript goodsig1 = sign_multisig(scriptPubKey23, keys, txTo23);
          BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
  
          keys.clear();
          keys.push_back(key1);
          keys.push_back(key3);
          CScript goodsig2 = sign_multisig(scriptPubKey23, keys, txTo23);
          BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
  
          keys.clear();
          keys.push_back(key2);
          keys.push_back(key3);
          CScript goodsig3 = sign_multisig(scriptPubKey23, keys, txTo23);
          BOOST_CHECK(VerifyScript(goodsig3, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
  
          keys.clear();
          keys.push_back(key2);
          keys.push_back(key2); // Can't re-use sig
          CScript badsig1 = sign_multisig(scriptPubKey23, keys, txTo23);
          BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
  
          keys.clear();
          keys.push_back(key2);
          keys.push_back(key1); // sigs must be in correct order
          CScript badsig2 = sign_multisig(scriptPubKey23, keys, txTo23);
          BOOST_CHECK(!VerifyScript(badsig2, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
  
          keys.clear();
          keys.push_back(key3);
          keys.push_back(key2); // sigs must be in correct order
          CScript badsig3 = sign_multisig(scriptPubKey23, keys, txTo23);
          BOOST_CHECK(!VerifyScript(badsig3, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
  
          keys.clear();
          keys.push_back(key4);
          keys.push_back(key2); // sigs must match pubkeys
          CScript badsig4 = sign_multisig(scriptPubKey23, keys, txTo23);
          BOOST_CHECK(!VerifyScript(badsig4, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
  
          keys.clear();
          keys.push_back(key1);
          keys.push_back(key4); // sigs must match pubkeys
          CScript badsig5 = sign_multisig(scriptPubKey23, keys, txTo23);
          BOOST_CHECK(!VerifyScript(badsig5, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
  
          keys.clear(); // Must have signatures
          CScript badsig6 = sign_multisig(scriptPubKey23, keys, txTo23);
          BOOST_CHECK(!VerifyScript(badsig6, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
          BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_INVALID_STACK_OPERATION, ScriptErrorString(err));
      }
  
      BOOST_AUTO_TEST_CASE(script_combineSigs_test)
      {
          BOOST_TEST_MESSAGE("Running Script CombineSigs Test");
  
          // Test the CombineSignatures function
          CAmount amount = 0;
          CBasicKeyStore keystore;
          std::vector<CKey> keys;
          std::vector<CPubKey> pubkeys;
          for (int i = 0; i < 3; i++)
          {
              CKey key;
              key.MakeNewKey(i % 2 == 1);
              keys.push_back(key);
              pubkeys.push_back(key.GetPubKey());
              keystore.AddKey(key);
          }
  
          CMutableTransaction txFrom = BuildCreditingTransaction(GetScriptForDestination(keys[0].GetPubKey().GetID()));
          CMutableTransaction txTo = BuildSpendingTransaction(CScript(), CScriptWitness(), txFrom);
          CScript &scriptPubKey = txFrom.vout[0].scriptPubKey;
          CScript &scriptSig = txTo.vin[0].scriptSig;
  
          SignatureData empty;
          SignatureData combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), empty, empty);
          BOOST_CHECK(combined.scriptSig.empty());
  
          // Single signature case:
          SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL); // changes scriptSig
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(scriptSig), empty);
          BOOST_CHECK(combined.scriptSig == scriptSig);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), empty, SignatureData(scriptSig));
          BOOST_CHECK(combined.scriptSig == scriptSig);
          CScript scriptSigCopy = scriptSig;
          // Signing again will give a different, valid signature:
          SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(scriptSigCopy), SignatureData(scriptSig));
          BOOST_CHECK(combined.scriptSig == scriptSigCopy || combined.scriptSig == scriptSig);
  
          // P2SH, single-signature case:
          CScript pkSingle;
          pkSingle << ToByteVector(keys[0].GetPubKey()) << OP_CHECKSIG;
          keystore.AddCScript(pkSingle);
          scriptPubKey = GetScriptForDestination(CScriptID(pkSingle));
          SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(scriptSig), empty);
          BOOST_CHECK(combined.scriptSig == scriptSig);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), empty, SignatureData(scriptSig));
          BOOST_CHECK(combined.scriptSig == scriptSig);
          scriptSigCopy = scriptSig;
          SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(scriptSigCopy), SignatureData(scriptSig));
          BOOST_CHECK(combined.scriptSig == scriptSigCopy || combined.scriptSig == scriptSig);
          // dummy scriptSigCopy with placeholder, should always choose non-placeholder:
          scriptSigCopy = CScript() << OP_0 << std::vector<unsigned char>(pkSingle.begin(), pkSingle.end());
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(scriptSigCopy), SignatureData(scriptSig));
          BOOST_CHECK(combined.scriptSig == scriptSig);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(scriptSig), SignatureData(scriptSigCopy));
          BOOST_CHECK(combined.scriptSig == scriptSig);
  
          // Hardest case:  Multisig 2-of-3
          scriptPubKey = GetScriptForMultisig(2, pubkeys);
          keystore.AddCScript(scriptPubKey);
          SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(scriptSig), empty);
          BOOST_CHECK(combined.scriptSig == scriptSig);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), empty, SignatureData(scriptSig));
          BOOST_CHECK(combined.scriptSig == scriptSig);
  
          // A couple of partially-signed versions:
          std::vector<unsigned char> sig1;
          uint256 hash1 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_ALL, 0, SIGVERSION_BASE);
          BOOST_CHECK(keys[0].Sign(hash1, sig1));
          sig1.push_back(SIGHASH_ALL);
          std::vector<unsigned char> sig2;
          uint256 hash2 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_NONE, 0, SIGVERSION_BASE);
          BOOST_CHECK(keys[1].Sign(hash2, sig2));
          sig2.push_back(SIGHASH_NONE);
          std::vector<unsigned char> sig3;
          uint256 hash3 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_SINGLE, 0, SIGVERSION_BASE);
          BOOST_CHECK(keys[2].Sign(hash3, sig3));
          sig3.push_back(SIGHASH_SINGLE);
  
          // Not fussy about order (or even existence) of placeholders or signatures:
          CScript partial1a = CScript() << OP_0 << sig1 << OP_0;
          CScript partial1b = CScript() << OP_0 << OP_0 << sig1;
          CScript partial2a = CScript() << OP_0 << sig2;
          CScript partial2b = CScript() << sig2 << OP_0;
          CScript partial3a = CScript() << sig3;
          CScript partial3b = CScript() << OP_0 << OP_0 << sig3;
          CScript partial3c = CScript() << OP_0 << sig3 << OP_0;
          CScript complete12 = CScript() << OP_0 << sig1 << sig2;
          CScript complete13 = CScript() << OP_0 << sig1 << sig3;
          CScript complete23 = CScript() << OP_0 << sig2 << sig3;
  
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial1a), SignatureData(partial1b));
          BOOST_CHECK(combined.scriptSig == partial1a);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial1a), SignatureData(partial2a));
          BOOST_CHECK(combined.scriptSig == complete12);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial2a), SignatureData(partial1a));
          BOOST_CHECK(combined.scriptSig == complete12);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial1b), SignatureData(partial2b));
          BOOST_CHECK(combined.scriptSig == complete12);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial3b), SignatureData(partial1b));
          BOOST_CHECK(combined.scriptSig == complete13);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial2a), SignatureData(partial3a));
          BOOST_CHECK(combined.scriptSig == complete23);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial3b), SignatureData(partial2b));
          BOOST_CHECK(combined.scriptSig == complete23);
          combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial3b), SignatureData(partial3a));
          BOOST_CHECK(combined.scriptSig == partial3c);
      }
  
      BOOST_AUTO_TEST_CASE(script_standard_push_test)
      {
          BOOST_TEST_MESSAGE("Running Script Standard Push Test");
  
          ScriptError err;
          for (int i = 0; i < 67000; i++)
          {
              CScript script;
              script << i;
              BOOST_CHECK_MESSAGE(script.IsPushOnly(), "Number " << i << " is not pure push.");
              BOOST_CHECK_MESSAGE(VerifyScript(script, CScript()
                      << OP_1, nullptr, SCRIPT_VERIFY_MINIMALDATA, BaseSignatureChecker(), &err),
                                  "Number " << i << " push is not minimal data.");
              BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
          }
  
          for (unsigned int i = 0; i <= MAX_SCRIPT_ELEMENT_SIZE; i++)
          {
              std::vector<unsigned char> data(i, '\111');
              CScript script;
              script << data;
              BOOST_CHECK_MESSAGE(script.IsPushOnly(), "Length " << i << " is not pure push.");
              BOOST_CHECK_MESSAGE(VerifyScript(script, CScript()
                      << OP_1, nullptr, SCRIPT_VERIFY_MINIMALDATA, BaseSignatureChecker(), &err),
                                  "Length " << i << " push is not minimal data.");
              BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
          }
      }
  
      BOOST_AUTO_TEST_CASE(script_IsPushOnly_on_invalid_scripts_test)
      {
          BOOST_TEST_MESSAGE("Running Script IsPushOnly On Invalid Scripts Test");
  
          // IsPushOnly returns false when given a script containing only pushes that
          // are invalid due to truncation. IsPushOnly() is consensus critical
          // because P2SH evaluation uses it, although this specific behavior should
          // not be consensus critical as the P2SH evaluation would fail first due to
          // the invalid push. Still, it doesn't hurt to test it explicitly.
          static const unsigned char direct[] = {1};
          BOOST_CHECK(!CScript(direct, direct + sizeof(direct)).IsPushOnly());
      }
  
      BOOST_AUTO_TEST_CASE(script_GetScriptAsm_test)
      {
          BOOST_TEST_MESSAGE("Running Script GetScriptAsm Test");
  
          BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_NOP2, true));
          BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY, true));
          BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_NOP2));
          BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY));
  
          std::string derSig("304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c5090");
          std::string pubKey("03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2");
          std::vector<unsigned char> vchPubKey = ToByteVector(ParseHex(pubKey));
  
          BOOST_CHECK_EQUAL(derSig + "00 " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "00")) << vchPubKey, true));
          BOOST_CHECK_EQUAL(derSig + "80 " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "80")) << vchPubKey, true));
          BOOST_CHECK_EQUAL(derSig + "[ALL] " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "01")) << vchPubKey, true));
          BOOST_CHECK_EQUAL(derSig + "[NONE] " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "02")) << vchPubKey, true));
          BOOST_CHECK_EQUAL(derSig + "[SINGLE] " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "03")) << vchPubKey, true));
          BOOST_CHECK_EQUAL(derSig + "[ALL|ANYONECANPAY] " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "81")) << vchPubKey, true));
          BOOST_CHECK_EQUAL(derSig + "[NONE|ANYONECANPAY] " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "82")) << vchPubKey, true));
          BOOST_CHECK_EQUAL(derSig + "[SINGLE|ANYONECANPAY] " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "83")) << vchPubKey, true));
  
          BOOST_CHECK_EQUAL(derSig + "00 " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "00")) << vchPubKey));
          BOOST_CHECK_EQUAL(derSig + "80 " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "80")) << vchPubKey));
          BOOST_CHECK_EQUAL(derSig + "01 " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "01")) << vchPubKey));
          BOOST_CHECK_EQUAL(derSig + "02 " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "02")) << vchPubKey));
          BOOST_CHECK_EQUAL(derSig + "03 " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "03")) << vchPubKey));
          BOOST_CHECK_EQUAL(derSig + "81 " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "81")) << vchPubKey));
          BOOST_CHECK_EQUAL(derSig + "82 " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "82")) << vchPubKey));
          BOOST_CHECK_EQUAL(derSig + "83 " + pubKey, ScriptToAsmStr(
                  CScript() << ToByteVector(ParseHex(derSig + "83")) << vchPubKey));
      }
  
      static CScript
      ScriptFromHex(const char *hex)
      {
          std::vector<unsigned char> data = ParseHex(hex);
          return CScript(data.begin(), data.end());
      }
  
  
      BOOST_AUTO_TEST_CASE(script_FindAndDelete_test)
      {
          BOOST_TEST_MESSAGE("Running script FindAndDelete Test");
  
          // Exercise the FindAndDelete functionality
          CScript s;
          CScript d;
          CScript expect;
  
          s = CScript() << OP_1 << OP_2;
          d = CScript(); // delete nothing should be a no-op
          expect = s;
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 0);
          BOOST_CHECK(s == expect);
  
          s = CScript() << OP_1 << OP_2 << OP_3;
          d = CScript() << OP_2;
          expect = CScript() << OP_1 << OP_3;
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 1);
          BOOST_CHECK(s == expect);
  
          s = CScript() << OP_3 << OP_1 << OP_3 << OP_3 << OP_4 << OP_3;
          d = CScript() << OP_3;
          expect = CScript() << OP_1 << OP_4;
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 4);
          BOOST_CHECK(s == expect);
  
          s = ScriptFromHex("0302ff03"); // PUSH 0x02ff03 onto stack
          d = ScriptFromHex("0302ff03");
          expect = CScript();
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 1);
          BOOST_CHECK(s == expect);
  
          s = ScriptFromHex("0302ff030302ff03"); // PUSH 0x2ff03 PUSH 0x2ff03
          d = ScriptFromHex("0302ff03");
          expect = CScript();
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 2);
          BOOST_CHECK(s == expect);
  
          s = ScriptFromHex("0302ff030302ff03");
          d = ScriptFromHex("02");
          expect = s; // FindAndDelete matches entire opcodes
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 0);
          BOOST_CHECK(s == expect);
  
          s = ScriptFromHex("0302ff030302ff03");
          d = ScriptFromHex("ff");
          expect = s;
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 0);
          BOOST_CHECK(s == expect);
  
          // This is an odd edge case: strip of the push-three-bytes
          // prefix, leaving 02ff03 which is push-two-bytes:
          s = ScriptFromHex("0302ff030302ff03");
          d = ScriptFromHex("03");
          expect = CScript() << ParseHex("ff03") << ParseHex("ff03");
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 2);
          BOOST_CHECK(s == expect);
  
          // Byte sequence that spans multiple opcodes:
          s = ScriptFromHex("02feed5169"); // PUSH(0xfeed) OP_1 OP_VERIFY
          d = ScriptFromHex("feed51");
          expect = s;
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 0); // doesn't match 'inside' opcodes
          BOOST_CHECK(s == expect);
  
          s = ScriptFromHex("02feed5169"); // PUSH(0xfeed) OP_1 OP_VERIFY
          d = ScriptFromHex("02feed51");
          expect = ScriptFromHex("69");
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 1);
          BOOST_CHECK(s == expect);
  
          s = ScriptFromHex("516902feed5169");
          d = ScriptFromHex("feed51");
          expect = s;
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 0);
          BOOST_CHECK(s == expect);
  
          s = ScriptFromHex("516902feed5169");
          d = ScriptFromHex("02feed51");
          expect = ScriptFromHex("516969");
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 1);
          BOOST_CHECK(s == expect);
  
          s = CScript() << OP_0 << OP_0 << OP_1 << OP_1;
          d = CScript() << OP_0 << OP_1;
          expect = CScript() << OP_0 << OP_1; // FindAndDelete is single-pass
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 1);
          BOOST_CHECK(s == expect);
  
          s = CScript() << OP_0 << OP_0 << OP_1 << OP_0 << OP_1 << OP_1;
          d = CScript() << OP_0 << OP_1;
          expect = CScript() << OP_0 << OP_1; // FindAndDelete is single-pass
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 2);
          BOOST_CHECK(s == expect);
  
          // Another weird edge case:
          // End with invalid push (not enough data)...
          s = ScriptFromHex("0003feed");
          d = ScriptFromHex("03feed"); // ... can remove the invalid push
          expect = ScriptFromHex("00");
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 1);
          BOOST_CHECK(s == expect);
  
          s = ScriptFromHex("0003feed");
          d = ScriptFromHex("00");
          expect = ScriptFromHex("03feed");
          BOOST_CHECK_EQUAL(s.FindAndDelete(d), 1);
          BOOST_CHECK(s == expect);
      }
  
      BOOST_AUTO_TEST_CASE(script_HasValidOps_test)
      {
          BOOST_TEST_MESSAGE("Running Script HasValidOps Test");
  
          // Exercise the HasValidOps functionality
          CScript script;
          script = ScriptFromHex("76a9141234567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac"); // Normal script
          BOOST_CHECK(script.HasValidOps());
          script = ScriptFromHex("76a914ff34567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac");
          BOOST_CHECK(script.HasValidOps());
          script = ScriptFromHex("ff88ac"); // Script with OP_INVALIDOPCODE explicit
          BOOST_CHECK(!script.HasValidOps());
          script = ScriptFromHex("88acc0"); // Script with undefined opcode
          BOOST_CHECK(!script.HasValidOps());
      }
  
      BOOST_AUTO_TEST_CASE(script_can_append_self_test)
      {
          BOOST_TEST_MESSAGE("Running Script Can Append Self Test");
  
          CScript s, d;
  
          s = ScriptFromHex("00");
          s += s;
          d = ScriptFromHex("0000");
          BOOST_CHECK(s == d);
  
          // check doubling a script that's large enough to require reallocation
          static const char hex[] = "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f";
          s = CScript() << ParseHex(hex) << OP_CHECKSIG;
          d = CScript() << ParseHex(hex) << OP_CHECKSIG << ParseHex(hex) << OP_CHECKSIG;
          s += s;
          BOOST_CHECK(s == d);
      }
  
  BOOST_AUTO_TEST_SUITE_END()
  