Bitcoin Core  29.1.0
P2P Digital Currency
script_tests.cpp
Go to the documentation of this file.
1 // Copyright (c) 2011-2022 The Bitcoin Core developers
2 // Distributed under the MIT software license, see the accompanying
3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 
5 #include <test/data/script_tests.json.h>
6 #include <test/data/bip341_wallet_vectors.json.h>
7 
8 #include <common/system.h>
9 #include <core_io.h>
10 #include <key.h>
11 #include <rpc/util.h>
12 #include <script/script.h>
13 #include <script/script_error.h>
14 #include <script/sigcache.h>
15 #include <script/sign.h>
16 #include <script/signingprovider.h>
17 #include <script/solver.h>
18 #include <streams.h>
19 #include <test/util/json.h>
20 #include <test/util/random.h>
21 #include <test/util/setup_common.h>
22 #include <test/util/transaction_utils.h>
23 #include <util/fs.h>
24 #include <util/strencodings.h>
25 
26 #include <cstdint>
27 #include <fstream>
28 #include <string>
29 #include <vector>
30 
31 #include <boost/test/unit_test.hpp>
32 
33 #include <univalue.h>
34 
35 // Uncomment if you want to output updated JSON tests.
36 // #define UPDATE_JSON_TESTS
37 
38 using namespace util::hex_literals;
39 
40 static const unsigned int gFlags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
41 
42 unsigned int ParseScriptFlags(std::string strFlags);
43 std::string FormatScriptFlags(unsigned int flags);
44 
45 struct ScriptErrorDesc
46 {
47  ScriptError_t err;
48  const char *name;
49 };
50 
51 static ScriptErrorDesc script_errors[]={
52  {SCRIPT_ERR_OK, "OK"},
53  {SCRIPT_ERR_UNKNOWN_ERROR, "UNKNOWN_ERROR"},
54  {SCRIPT_ERR_EVAL_FALSE, "EVAL_FALSE"},
55  {SCRIPT_ERR_OP_RETURN, "OP_RETURN"},
56  {SCRIPT_ERR_SCRIPT_SIZE, "SCRIPT_SIZE"},
57  {SCRIPT_ERR_PUSH_SIZE, "PUSH_SIZE"},
58  {SCRIPT_ERR_OP_COUNT, "OP_COUNT"},
59  {SCRIPT_ERR_STACK_SIZE, "STACK_SIZE"},
60  {SCRIPT_ERR_SIG_COUNT, "SIG_COUNT"},
61  {SCRIPT_ERR_PUBKEY_COUNT, "PUBKEY_COUNT"},
62  {SCRIPT_ERR_VERIFY, "VERIFY"},
63  {SCRIPT_ERR_EQUALVERIFY, "EQUALVERIFY"},
64  {SCRIPT_ERR_CHECKMULTISIGVERIFY, "CHECKMULTISIGVERIFY"},
65  {SCRIPT_ERR_CHECKSIGVERIFY, "CHECKSIGVERIFY"},
66  {SCRIPT_ERR_NUMEQUALVERIFY, "NUMEQUALVERIFY"},
67  {SCRIPT_ERR_BAD_OPCODE, "BAD_OPCODE"},
68  {SCRIPT_ERR_DISABLED_OPCODE, "DISABLED_OPCODE"},
69  {SCRIPT_ERR_INVALID_STACK_OPERATION, "INVALID_STACK_OPERATION"},
70  {SCRIPT_ERR_INVALID_ALTSTACK_OPERATION, "INVALID_ALTSTACK_OPERATION"},
71  {SCRIPT_ERR_UNBALANCED_CONDITIONAL, "UNBALANCED_CONDITIONAL"},
72  {SCRIPT_ERR_NEGATIVE_LOCKTIME, "NEGATIVE_LOCKTIME"},
73  {SCRIPT_ERR_UNSATISFIED_LOCKTIME, "UNSATISFIED_LOCKTIME"},
74  {SCRIPT_ERR_SIG_HASHTYPE, "SIG_HASHTYPE"},
75  {SCRIPT_ERR_SIG_DER, "SIG_DER"},
76  {SCRIPT_ERR_MINIMALDATA, "MINIMALDATA"},
77  {SCRIPT_ERR_SIG_PUSHONLY, "SIG_PUSHONLY"},
78  {SCRIPT_ERR_SIG_HIGH_S, "SIG_HIGH_S"},
79  {SCRIPT_ERR_SIG_NULLDUMMY, "SIG_NULLDUMMY"},
80  {SCRIPT_ERR_PUBKEYTYPE, "PUBKEYTYPE"},
81  {SCRIPT_ERR_CLEANSTACK, "CLEANSTACK"},
82  {SCRIPT_ERR_MINIMALIF, "MINIMALIF"},
83  {SCRIPT_ERR_SIG_NULLFAIL, "NULLFAIL"},
84  {SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS, "DISCOURAGE_UPGRADABLE_NOPS"},
85  {SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM, "DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM"},
86  {SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH, "WITNESS_PROGRAM_WRONG_LENGTH"},
87  {SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY, "WITNESS_PROGRAM_WITNESS_EMPTY"},
88  {SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH, "WITNESS_PROGRAM_MISMATCH"},
89  {SCRIPT_ERR_WITNESS_MALLEATED, "WITNESS_MALLEATED"},
90  {SCRIPT_ERR_WITNESS_MALLEATED_P2SH, "WITNESS_MALLEATED_P2SH"},
91  {SCRIPT_ERR_WITNESS_UNEXPECTED, "WITNESS_UNEXPECTED"},
92  {SCRIPT_ERR_WITNESS_PUBKEYTYPE, "WITNESS_PUBKEYTYPE"},
93  {SCRIPT_ERR_OP_CODESEPARATOR, "OP_CODESEPARATOR"},
94  {SCRIPT_ERR_SIG_FINDANDDELETE, "SIG_FINDANDDELETE"},
95 };
96 
97 static std::string FormatScriptError(ScriptError_t err)
98 {
99  for (const auto& se : script_errors)
100  if (se.err == err)
101  return se.name;
102  BOOST_ERROR("Unknown scripterror enumeration value, update script_errors in script_tests.cpp.");
103  return "";
104 }
105 
106 static ScriptError_t ParseScriptError(const std::string& name)
107 {
108  for (const auto& se : script_errors)
109  if (se.name == name)
110  return se.err;
111  BOOST_ERROR("Unknown scripterror \"" << name << "\" in test description");
112  return SCRIPT_ERR_UNKNOWN_ERROR;
113 }
114 
115 struct ScriptTest : BasicTestingSetup {
116 void DoTest(const CScript& scriptPubKey, const CScript& scriptSig, const CScriptWitness& scriptWitness, uint32_t flags, const std::string& message, int scriptError, CAmount nValue = 0)
117 {
118  bool expect = (scriptError == SCRIPT_ERR_OK);
119  if (flags & SCRIPT_VERIFY_CLEANSTACK) {
120  flags |= SCRIPT_VERIFY_P2SH;
121  flags |= SCRIPT_VERIFY_WITNESS;
122  }
123  ScriptError err;
124  const CTransaction txCredit{BuildCreditingTransaction(scriptPubKey, nValue)};
125  CMutableTransaction tx = BuildSpendingTransaction(scriptSig, scriptWitness, txCredit);
126  BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, &scriptWitness, flags, MutableTransactionSignatureChecker(&tx, 0, txCredit.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err) == expect, message);
127  BOOST_CHECK_MESSAGE(err == scriptError, FormatScriptError(err) + " where " + FormatScriptError((ScriptError_t)scriptError) + " expected: " + message);
128 
129  // Verify that removing flags from a passing test or adding flags to a failing test does not change the result.
130  for (int i = 0; i < 16; ++i) {
131  uint32_t extra_flags(m_rng.randbits(16));
132  uint32_t combined_flags{expect ? (flags & ~extra_flags) : (flags | extra_flags)};
133  // Weed out some invalid flag combinations.
134  if (combined_flags & SCRIPT_VERIFY_CLEANSTACK && ~combined_flags & (SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS)) continue;
135  if (combined_flags & SCRIPT_VERIFY_WITNESS && ~combined_flags & SCRIPT_VERIFY_P2SH) continue;
136  BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, &scriptWitness, combined_flags, MutableTransactionSignatureChecker(&tx, 0, txCredit.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err) == expect, message + strprintf(" (with flags %x)", combined_flags));
137  }
138 }
139 }; // struct ScriptTest
140 
141 void static NegateSignatureS(std::vector<unsigned char>& vchSig) {
142  // Parse the signature.
143  std::vector<unsigned char> r, s;
144  r = std::vector<unsigned char>(vchSig.begin() + 4, vchSig.begin() + 4 + vchSig[3]);
145  s = std::vector<unsigned char>(vchSig.begin() + 6 + vchSig[3], vchSig.begin() + 6 + vchSig[3] + vchSig[5 + vchSig[3]]);
146 
147  // Really ugly to implement mod-n negation here, but it would be feature creep to expose such functionality from libsecp256k1.
148  static const unsigned char order[33] = {
149  0x00,
150  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
151  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
152  0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
153  0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x41
154  };
155  while (s.size() < 33) {
156  s.insert(s.begin(), 0x00);
157  }
158  int carry = 0;
159  for (int p = 32; p >= 1; p--) {
160  int n = (int)order[p] - s[p] - carry;
161  s[p] = (n + 256) & 0xFF;
162  carry = (n < 0);
163  }
164  assert(carry == 0);
165  if (s.size() > 1 && s[0] == 0 && s[1] < 0x80) {
166  s.erase(s.begin());
167  }
168 
169  // Reconstruct the signature.
170  vchSig.clear();
171  vchSig.push_back(0x30);
172  vchSig.push_back(4 + r.size() + s.size());
173  vchSig.push_back(0x02);
174  vchSig.push_back(r.size());
175  vchSig.insert(vchSig.end(), r.begin(), r.end());
176  vchSig.push_back(0x02);
177  vchSig.push_back(s.size());
178  vchSig.insert(vchSig.end(), s.begin(), s.end());
179 }
180 
181 namespace
182 {
183 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};
184 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};
185 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};
186 
187 struct KeyData
188 {
189  CKey key0, key0C, key1, key1C, key2, key2C;
190  CPubKey pubkey0, pubkey0C, pubkey0H;
191  CPubKey pubkey1, pubkey1C;
192  CPubKey pubkey2, pubkey2C;
193 
194  KeyData()
195  {
196  key0.Set(vchKey0, vchKey0 + 32, false);
197  key0C.Set(vchKey0, vchKey0 + 32, true);
198  pubkey0 = key0.GetPubKey();
199  pubkey0H = key0.GetPubKey();
200  pubkey0C = key0C.GetPubKey();
201  *const_cast<unsigned char*>(pubkey0H.data()) = 0x06 | (pubkey0H[64] & 1);
202 
203  key1.Set(vchKey1, vchKey1 + 32, false);
204  key1C.Set(vchKey1, vchKey1 + 32, true);
205  pubkey1 = key1.GetPubKey();
206  pubkey1C = key1C.GetPubKey();
207 
208  key2.Set(vchKey2, vchKey2 + 32, false);
209  key2C.Set(vchKey2, vchKey2 + 32, true);
210  pubkey2 = key2.GetPubKey();
211  pubkey2C = key2C.GetPubKey();
212  }
213 };
214 
215 enum class WitnessMode {
216  NONE,
217  PKH,
218  SH
219 };
220 
221 class TestBuilder
222 {
223 private:
225  CScript script;
227  CScript redeemscript;
229  CScript witscript;
230  CScriptWitness scriptWitness;
231  CTransactionRef creditTx;
232  CMutableTransaction spendTx;
233  bool havePush{false};
234  std::vector<unsigned char> push;
235  std::string comment;
236  uint32_t flags;
237  int scriptError{SCRIPT_ERR_OK};
238  CAmount nValue;
239 
240  void DoPush()
241  {
242  if (havePush) {
243  spendTx.vin[0].scriptSig << push;
244  havePush = false;
245  }
246  }
247 
248  void DoPush(const std::vector<unsigned char>& data)
249  {
250  DoPush();
251  push = data;
252  havePush = true;
253  }
254 
255 public:
256  TestBuilder(const CScript& script_, const std::string& comment_, uint32_t flags_, bool P2SH = false, WitnessMode wm = WitnessMode::NONE, int witnessversion = 0, CAmount nValue_ = 0) : script(script_), comment(comment_), flags(flags_), nValue(nValue_)
257  {
258  CScript scriptPubKey = script;
259  if (wm == WitnessMode::PKH) {
260  uint160 hash;
261  CHash160().Write(Span{script}.subspan(1)).Finalize(hash);
262  script = CScript() << OP_DUP << OP_HASH160 << ToByteVector(hash) << OP_EQUALVERIFY << OP_CHECKSIG;
263  scriptPubKey = CScript() << witnessversion << ToByteVector(hash);
264  } else if (wm == WitnessMode::SH) {
265  witscript = scriptPubKey;
266  uint256 hash;
267  CSHA256().Write(witscript.data(), witscript.size()).Finalize(hash.begin());
268  scriptPubKey = CScript() << witnessversion << ToByteVector(hash);
269  }
270  if (P2SH) {
271  redeemscript = scriptPubKey;
272  scriptPubKey = CScript() << OP_HASH160 << ToByteVector(CScriptID(redeemscript)) << OP_EQUAL;
273  }
274  creditTx = MakeTransactionRef(BuildCreditingTransaction(scriptPubKey, nValue));
275  spendTx = BuildSpendingTransaction(CScript(), CScriptWitness(), *creditTx);
276  }
277 
278  TestBuilder& ScriptError(ScriptError_t err)
279  {
280  scriptError = err;
281  return *this;
282  }
283 
284  TestBuilder& Opcode(const opcodetype& _op)
285  {
286  DoPush();
287  spendTx.vin[0].scriptSig << _op;
288  return *this;
289  }
290 
291  TestBuilder& Num(int num)
292  {
293  DoPush();
294  spendTx.vin[0].scriptSig << num;
295  return *this;
296  }
297 
298  TestBuilder& Push(const std::string& hex)
299  {
300  DoPush(ParseHex(hex));
301  return *this;
302  }
303 
304  TestBuilder& Push(const CScript& _script)
305  {
306  DoPush(std::vector<unsigned char>(_script.begin(), _script.end()));
307  return *this;
308  }
309 
310  TestBuilder& PushSig(const CKey& key, int nHashType = SIGHASH_ALL, unsigned int lenR = 32, unsigned int lenS = 32, SigVersion sigversion = SigVersion::BASE, CAmount amount = 0)
311  {
312  uint256 hash = SignatureHash(script, spendTx, 0, nHashType, amount, sigversion);
313  std::vector<unsigned char> vchSig, r, s;
314  uint32_t iter = 0;
315  do {
316  key.Sign(hash, vchSig, false, iter++);
317  if ((lenS == 33) != (vchSig[5 + vchSig[3]] == 33)) {
318  NegateSignatureS(vchSig);
319  }
320  r = std::vector<unsigned char>(vchSig.begin() + 4, vchSig.begin() + 4 + vchSig[3]);
321  s = std::vector<unsigned char>(vchSig.begin() + 6 + vchSig[3], vchSig.begin() + 6 + vchSig[3] + vchSig[5 + vchSig[3]]);
322  } while (lenR != r.size() || lenS != s.size());
323  vchSig.push_back(static_cast<unsigned char>(nHashType));
324  DoPush(vchSig);
325  return *this;
326  }
327 
328  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)
329  {
330  if (amount == -1)
331  amount = nValue;
332  return PushSig(key, nHashType, lenR, lenS, sigversion, amount).AsWit();
333  }
334 
335  TestBuilder& Push(const CPubKey& pubkey)
336  {
337  DoPush(std::vector<unsigned char>(pubkey.begin(), pubkey.end()));
338  return *this;
339  }
340 
341  TestBuilder& PushRedeem()
342  {
343  DoPush(std::vector<unsigned char>(redeemscript.begin(), redeemscript.end()));
344  return *this;
345  }
346 
347  TestBuilder& PushWitRedeem()
348  {
349  DoPush(std::vector<unsigned char>(witscript.begin(), witscript.end()));
350  return AsWit();
351  }
352 
353  TestBuilder& EditPush(unsigned int pos, const std::string& hexin, const std::string& hexout)
354  {
355  assert(havePush);
356  std::vector<unsigned char> datain = ParseHex(hexin);
357  std::vector<unsigned char> dataout = ParseHex(hexout);
358  assert(pos + datain.size() <= push.size());
359  BOOST_CHECK_MESSAGE(std::vector<unsigned char>(push.begin() + pos, push.begin() + pos + datain.size()) == datain, comment);
360  push.erase(push.begin() + pos, push.begin() + pos + datain.size());
361  push.insert(push.begin() + pos, dataout.begin(), dataout.end());
362  return *this;
363  }
364 
365  TestBuilder& DamagePush(unsigned int pos)
366  {
367  assert(havePush);
368  assert(pos < push.size());
369  push[pos] ^= 1;
370  return *this;
371  }
372 
373  TestBuilder& Test(ScriptTest& test)
374  {
375  TestBuilder copy = *this; // Make a copy so we can rollback the push.
376  DoPush();
377  test.DoTest(creditTx->vout[0].scriptPubKey, spendTx.vin[0].scriptSig, scriptWitness, flags, comment, scriptError, nValue);
378  *this = copy;
379  return *this;
380  }
381 
382  TestBuilder& AsWit()
383  {
384  assert(havePush);
385  scriptWitness.stack.push_back(push);
386  havePush = false;
387  return *this;
388  }
389 
390  UniValue GetJSON()
391  {
392  DoPush();
393  UniValue array(UniValue::VARR);
394  if (!scriptWitness.stack.empty()) {
395  UniValue wit(UniValue::VARR);
396  for (unsigned i = 0; i < scriptWitness.stack.size(); i++) {
397  wit.push_back(HexStr(scriptWitness.stack[i]));
398  }
399  wit.push_back(ValueFromAmount(nValue));
400  array.push_back(std::move(wit));
401  }
402  array.push_back(FormatScript(spendTx.vin[0].scriptSig));
403  array.push_back(FormatScript(creditTx->vout[0].scriptPubKey));
404  array.push_back(FormatScriptFlags(flags));
405  array.push_back(FormatScriptError((ScriptError_t)scriptError));
406  array.push_back(comment);
407  return array;
408  }
409 
410  std::string GetComment() const
411  {
412  return comment;
413  }
414 };
415 
416 std::string JSONPrettyPrint(const UniValue& univalue)
417 {
418  std::string ret = univalue.write(4);
419  // Workaround for libunivalue pretty printer, which puts a space between commas and newlines
420  size_t pos = 0;
421  while ((pos = ret.find(" \n", pos)) != std::string::npos) {
422  ret.replace(pos, 2, "\n");
423  pos++;
424  }
425  return ret;
426 }
427 } // namespace
428 
429 BOOST_FIXTURE_TEST_SUITE(script_tests, ScriptTest)
430 
431 BOOST_AUTO_TEST_CASE(script_build)
432 {
433  const KeyData keys;
434 
435  std::vector<TestBuilder> tests;
436 
437  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
438  "P2PK", 0
439  ).PushSig(keys.key0));
440  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
441  "P2PK, bad sig", 0
442  ).PushSig(keys.key0).DamagePush(10).ScriptError(SCRIPT_ERR_EVAL_FALSE));
443 
444  tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1C.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
445  "P2PKH", 0
446  ).PushSig(keys.key1).Push(keys.pubkey1C));
447  tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey2C.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
448  "P2PKH, bad pubkey", 0
449  ).PushSig(keys.key2).Push(keys.pubkey2C).DamagePush(5).ScriptError(SCRIPT_ERR_EQUALVERIFY));
450 
451  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
452  "P2PK anyonecanpay", 0
453  ).PushSig(keys.key1, SIGHASH_ALL | SIGHASH_ANYONECANPAY));
454  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
455  "P2PK anyonecanpay marked with normal hashtype", 0
456  ).PushSig(keys.key1, SIGHASH_ALL | SIGHASH_ANYONECANPAY).EditPush(70, "81", "01").ScriptError(SCRIPT_ERR_EVAL_FALSE));
457 
458  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
459  "P2SH(P2PK)", SCRIPT_VERIFY_P2SH, true
460  ).PushSig(keys.key0).PushRedeem());
461  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
462  "P2SH(P2PK), bad redeemscript", SCRIPT_VERIFY_P2SH, true
463  ).PushSig(keys.key0).PushRedeem().DamagePush(10).ScriptError(SCRIPT_ERR_EVAL_FALSE));
464 
465  tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey0.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
466  "P2SH(P2PKH)", SCRIPT_VERIFY_P2SH, true
467  ).PushSig(keys.key0).Push(keys.pubkey0).PushRedeem());
468  tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
469  "P2SH(P2PKH), bad sig but no VERIFY_P2SH", 0, true
470  ).PushSig(keys.key0).DamagePush(10).PushRedeem());
471  tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
472  "P2SH(P2PKH), bad sig", SCRIPT_VERIFY_P2SH, true
473  ).PushSig(keys.key0).DamagePush(10).PushRedeem().ScriptError(SCRIPT_ERR_EQUALVERIFY));
474 
475  tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
476  "3-of-3", 0
477  ).Num(0).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2));
478  tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
479  "3-of-3, 2 sigs", 0
480  ).Num(0).PushSig(keys.key0).PushSig(keys.key1).Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
481 
482  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
483  "P2SH(2-of-3)", SCRIPT_VERIFY_P2SH, true
484  ).Num(0).PushSig(keys.key1).PushSig(keys.key2).PushRedeem());
485  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
486  "P2SH(2-of-3), 1 sig", SCRIPT_VERIFY_P2SH, true
487  ).Num(0).PushSig(keys.key1).Num(0).PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
488 
489  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
490  "P2PK with too much R padding but no DERSIG", 0
491  ).PushSig(keys.key1, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000"));
492  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
493  "P2PK with too much R padding", SCRIPT_VERIFY_DERSIG
494  ).PushSig(keys.key1, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").ScriptError(SCRIPT_ERR_SIG_DER));
495  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
496  "P2PK with too much S padding but no DERSIG", 0
497  ).PushSig(keys.key1, SIGHASH_ALL).EditPush(1, "44", "45").EditPush(37, "20", "2100"));
498  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
499  "P2PK with too much S padding", SCRIPT_VERIFY_DERSIG
500  ).PushSig(keys.key1, SIGHASH_ALL).EditPush(1, "44", "45").EditPush(37, "20", "2100").ScriptError(SCRIPT_ERR_SIG_DER));
501  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
502  "P2PK with too little R padding but no DERSIG", 0
503  ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220"));
504  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
505  "P2PK with too little R padding", SCRIPT_VERIFY_DERSIG
506  ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
507  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
508  "P2PK NOT with bad sig with too much R padding but no DERSIG", 0
509  ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").DamagePush(10));
510  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
511  "P2PK NOT with bad sig with too much R padding", SCRIPT_VERIFY_DERSIG
512  ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").DamagePush(10).ScriptError(SCRIPT_ERR_SIG_DER));
513  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
514  "P2PK NOT with too much R padding but no DERSIG", 0
515  ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").ScriptError(SCRIPT_ERR_EVAL_FALSE));
516  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
517  "P2PK NOT with too much R padding", SCRIPT_VERIFY_DERSIG
518  ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").ScriptError(SCRIPT_ERR_SIG_DER));
519 
520  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
521  "BIP66 example 1, without DERSIG", 0
522  ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220"));
523  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
524  "BIP66 example 1, with DERSIG", SCRIPT_VERIFY_DERSIG
525  ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
526  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
527  "BIP66 example 2, without DERSIG", 0
528  ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_EVAL_FALSE));
529  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
530  "BIP66 example 2, with DERSIG", SCRIPT_VERIFY_DERSIG
531  ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
532  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
533  "BIP66 example 3, without DERSIG", 0
534  ).Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
535  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
536  "BIP66 example 3, with DERSIG", SCRIPT_VERIFY_DERSIG
537  ).Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
538  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
539  "BIP66 example 4, without DERSIG", 0
540  ).Num(0));
541  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
542  "BIP66 example 4, with DERSIG", SCRIPT_VERIFY_DERSIG
543  ).Num(0));
544  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
545  "BIP66 example 5, without DERSIG", 0
546  ).Num(1).ScriptError(SCRIPT_ERR_EVAL_FALSE));
547  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
548  "BIP66 example 5, with DERSIG", SCRIPT_VERIFY_DERSIG
549  ).Num(1).ScriptError(SCRIPT_ERR_SIG_DER));
550  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
551  "BIP66 example 6, without DERSIG", 0
552  ).Num(1));
553  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
554  "BIP66 example 6, with DERSIG", SCRIPT_VERIFY_DERSIG
555  ).Num(1).ScriptError(SCRIPT_ERR_SIG_DER));
556  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
557  "BIP66 example 7, without DERSIG", 0
558  ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2));
559  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
560  "BIP66 example 7, with DERSIG", SCRIPT_VERIFY_DERSIG
561  ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2).ScriptError(SCRIPT_ERR_SIG_DER));
562  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
563  "BIP66 example 8, without DERSIG", 0
564  ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2).ScriptError(SCRIPT_ERR_EVAL_FALSE));
565  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
566  "BIP66 example 8, with DERSIG", SCRIPT_VERIFY_DERSIG
567  ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2).ScriptError(SCRIPT_ERR_SIG_DER));
568  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
569  "BIP66 example 9, without DERSIG", 0
570  ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_EVAL_FALSE));
571  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
572  "BIP66 example 9, with DERSIG", SCRIPT_VERIFY_DERSIG
573  ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
574  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
575  "BIP66 example 10, without DERSIG", 0
576  ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220"));
577  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
578  "BIP66 example 10, with DERSIG", SCRIPT_VERIFY_DERSIG
579  ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
580  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
581  "BIP66 example 11, without DERSIG", 0
582  ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
583  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
584  "BIP66 example 11, with DERSIG", SCRIPT_VERIFY_DERSIG
585  ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
586  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
587  "BIP66 example 12, without DERSIG", 0
588  ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0));
589  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
590  "BIP66 example 12, with DERSIG", SCRIPT_VERIFY_DERSIG
591  ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0));
592  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
593  "P2PK with multi-byte hashtype, without DERSIG", 0
594  ).PushSig(keys.key2, SIGHASH_ALL).EditPush(70, "01", "0101"));
595  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
596  "P2PK with multi-byte hashtype, with DERSIG", SCRIPT_VERIFY_DERSIG
597  ).PushSig(keys.key2, SIGHASH_ALL).EditPush(70, "01", "0101").ScriptError(SCRIPT_ERR_SIG_DER));
598 
599  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
600  "P2PK with high S but no LOW_S", 0
601  ).PushSig(keys.key2, SIGHASH_ALL, 32, 33));
602  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
603  "P2PK with high S", SCRIPT_VERIFY_LOW_S
604  ).PushSig(keys.key2, SIGHASH_ALL, 32, 33).ScriptError(SCRIPT_ERR_SIG_HIGH_S));
605 
606  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
607  "P2PK with hybrid pubkey but no STRICTENC", 0
608  ).PushSig(keys.key0, SIGHASH_ALL));
609  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
610  "P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC
611  ).PushSig(keys.key0, SIGHASH_ALL).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
612  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
613  "P2PK NOT with hybrid pubkey but no STRICTENC", 0
614  ).PushSig(keys.key0, SIGHASH_ALL).ScriptError(SCRIPT_ERR_EVAL_FALSE));
615  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
616  "P2PK NOT with hybrid pubkey", SCRIPT_VERIFY_STRICTENC
617  ).PushSig(keys.key0, SIGHASH_ALL).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
618  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
619  "P2PK NOT with invalid hybrid pubkey but no STRICTENC", 0
620  ).PushSig(keys.key0, SIGHASH_ALL).DamagePush(10));
621  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
622  "P2PK NOT with invalid hybrid pubkey", SCRIPT_VERIFY_STRICTENC
623  ).PushSig(keys.key0, SIGHASH_ALL).DamagePush(10).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
624  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
625  "1-of-2 with the second 1 hybrid pubkey and no STRICTENC", 0
626  ).Num(0).PushSig(keys.key1, SIGHASH_ALL));
627  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
628  "1-of-2 with the second 1 hybrid pubkey", SCRIPT_VERIFY_STRICTENC
629  ).Num(0).PushSig(keys.key1, SIGHASH_ALL));
630  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0H) << OP_2 << OP_CHECKMULTISIG,
631  "1-of-2 with the first 1 hybrid pubkey", SCRIPT_VERIFY_STRICTENC
632  ).Num(0).PushSig(keys.key1, SIGHASH_ALL).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
633 
634  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
635  "P2PK with undefined hashtype but no STRICTENC", 0
636  ).PushSig(keys.key1, 5));
637  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
638  "P2PK with undefined hashtype", SCRIPT_VERIFY_STRICTENC
639  ).PushSig(keys.key1, 5).ScriptError(SCRIPT_ERR_SIG_HASHTYPE));
640  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
641  "P2PK NOT with invalid sig and undefined hashtype but no STRICTENC", 0
642  ).PushSig(keys.key1, 5).DamagePush(10));
643  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
644  "P2PK NOT with invalid sig and undefined hashtype", SCRIPT_VERIFY_STRICTENC
645  ).PushSig(keys.key1, 5).DamagePush(10).ScriptError(SCRIPT_ERR_SIG_HASHTYPE));
646 
647  tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
648  "3-of-3 with nonzero dummy but no NULLDUMMY", 0
649  ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2));
650  tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
651  "3-of-3 with nonzero dummy", SCRIPT_VERIFY_NULLDUMMY
652  ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2).ScriptError(SCRIPT_ERR_SIG_NULLDUMMY));
653  tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG << OP_NOT,
654  "3-of-3 NOT with invalid sig and nonzero dummy but no NULLDUMMY", 0
655  ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2).DamagePush(10));
656  tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG << OP_NOT,
657  "3-of-3 NOT with invalid sig with nonzero dummy", SCRIPT_VERIFY_NULLDUMMY
658  ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2).DamagePush(10).ScriptError(SCRIPT_ERR_SIG_NULLDUMMY));
659 
660  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
661  "2-of-2 with two identical keys and sigs pushed using OP_DUP but no SIGPUSHONLY", 0
662  ).Num(0).PushSig(keys.key1).Opcode(OP_DUP));
663  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
664  "2-of-2 with two identical keys and sigs pushed using OP_DUP", SCRIPT_VERIFY_SIGPUSHONLY
665  ).Num(0).PushSig(keys.key1).Opcode(OP_DUP).ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
666  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
667  "P2SH(P2PK) with non-push scriptSig but no P2SH or SIGPUSHONLY", 0, true
668  ).PushSig(keys.key2).Opcode(OP_NOP8).PushRedeem());
669  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
670  "P2PK with non-push scriptSig but with P2SH validation", 0
671  ).PushSig(keys.key2).Opcode(OP_NOP8));
672  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
673  "P2SH(P2PK) with non-push scriptSig but no SIGPUSHONLY", SCRIPT_VERIFY_P2SH, true
674  ).PushSig(keys.key2).Opcode(OP_NOP8).PushRedeem().ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
675  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
676  "P2SH(P2PK) with non-push scriptSig but not P2SH", SCRIPT_VERIFY_SIGPUSHONLY, true
677  ).PushSig(keys.key2).Opcode(OP_NOP8).PushRedeem().ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
678  tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
679  "2-of-2 with two identical keys and sigs pushed", SCRIPT_VERIFY_SIGPUSHONLY
680  ).Num(0).PushSig(keys.key1).PushSig(keys.key1));
681  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
682  "P2PK with unnecessary input but no CLEANSTACK", SCRIPT_VERIFY_P2SH
683  ).Num(11).PushSig(keys.key0));
684  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
685  "P2PK with unnecessary input", SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH
686  ).Num(11).PushSig(keys.key0).ScriptError(SCRIPT_ERR_CLEANSTACK));
687  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
688  "P2SH with unnecessary input but no CLEANSTACK", SCRIPT_VERIFY_P2SH, true
689  ).Num(11).PushSig(keys.key0).PushRedeem());
690  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
691  "P2SH with unnecessary input", SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true
692  ).Num(11).PushSig(keys.key0).PushRedeem().ScriptError(SCRIPT_ERR_CLEANSTACK));
693  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
694  "P2SH with CLEANSTACK", SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true
695  ).PushSig(keys.key0).PushRedeem());
696 
697  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
698  "Basic P2WSH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
699  0, 1).PushWitSig(keys.key0).PushWitRedeem());
700  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
701  "Basic P2WPKH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH,
702  0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit());
703  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
704  "Basic P2SH(P2WSH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
705  0, 1).PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
706  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
707  "Basic P2SH(P2WPKH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH,
708  0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().PushRedeem());
709  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
710  "Basic P2WSH with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH
711  ).PushWitSig(keys.key0).PushWitRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
712  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
713  "Basic P2WPKH with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH
714  ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().ScriptError(SCRIPT_ERR_EVAL_FALSE));
715  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
716  "Basic P2SH(P2WSH) with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH
717  ).PushWitSig(keys.key0).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
718  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
719  "Basic P2SH(P2WPKH) with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH
720  ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
721  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
722  "Basic P2WSH with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, false, WitnessMode::SH
723  ).PushWitSig(keys.key0).PushWitRedeem());
724  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
725  "Basic P2WPKH with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH
726  ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit());
727  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
728  "Basic P2SH(P2WSH) with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, true, WitnessMode::SH
729  ).PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
730  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
731  "Basic P2SH(P2WPKH) with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH
732  ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().PushRedeem());
733  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
734  "Basic P2WSH with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
735  0, 0).PushWitSig(keys.key0, 1).PushWitRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
736  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
737  "Basic P2WPKH with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH,
738  0, 0).PushWitSig(keys.key0, 1).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_EVAL_FALSE));
739  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
740  "Basic P2SH(P2WSH) with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
741  0, 0).PushWitSig(keys.key0, 1).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
742  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
743  "Basic P2SH(P2WPKH) with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH,
744  0, 0).PushWitSig(keys.key0, 1).Push(keys.pubkey0).AsWit().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
745 
746  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
747  "P2WPKH with future witness version", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH |
748  SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM, false, WitnessMode::PKH, 1
749  ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM));
750  {
751  CScript witscript = CScript() << ToByteVector(keys.pubkey0);
752  uint256 hash;
753  CSHA256().Write(witscript.data(), witscript.size()).Finalize(hash.begin());
754  std::vector<unsigned char> hashBytes = ToByteVector(hash);
755  hashBytes.pop_back();
756  tests.push_back(TestBuilder(CScript() << OP_0 << hashBytes,
757  "P2WPKH with wrong witness program length", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false
758  ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH));
759  }
760  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
761  "P2WSH with empty witness", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH
762  ).ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY));
763  {
764  CScript witscript = CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG;
765  tests.push_back(TestBuilder(witscript,
766  "P2WSH with witness program mismatch", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH
767  ).PushWitSig(keys.key0).Push(witscript).DamagePush(0).AsWit().ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH));
768  }
769  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
770  "P2WPKH with witness program mismatch", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH
771  ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().Push("0").AsWit().ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH));
772  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
773  "P2WPKH with non-empty scriptSig", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH
774  ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().Num(11).ScriptError(SCRIPT_ERR_WITNESS_MALLEATED));
775  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
776  "P2SH(P2WPKH) with superfluous push in scriptSig", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH
777  ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().Num(11).PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_MALLEATED_P2SH));
778  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
779  "P2PK with witness", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH
780  ).PushSig(keys.key0).Push("0").AsWit().ScriptError(SCRIPT_ERR_WITNESS_UNEXPECTED));
781 
782  // Compressed keys should pass SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
783  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
784  "Basic P2WSH with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
785  0, 1).PushWitSig(keys.key0C).PushWitRedeem());
786  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C),
787  "Basic P2WPKH with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::PKH,
788  0, 1).PushWitSig(keys.key0C).Push(keys.pubkey0C).AsWit());
789  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
790  "Basic P2SH(P2WSH) with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
791  0, 1).PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
792  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C),
793  "Basic P2SH(P2WPKH) with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::PKH,
794  0, 1).PushWitSig(keys.key0C).Push(keys.pubkey0C).AsWit().PushRedeem());
795 
796  // Testing uncompressed key in witness with SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
797  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
798  "Basic P2WSH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
799  0, 1).PushWitSig(keys.key0).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
800  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
801  "Basic P2WPKH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::PKH,
802  0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
803  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
804  "Basic P2SH(P2WSH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
805  0, 1).PushWitSig(keys.key0).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
806  tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
807  "Basic P2SH(P2WPKH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::PKH,
808  0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
809 
810  // P2WSH 1-of-2 multisig with compressed keys
811  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
812  "P2WSH CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
813  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
814  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
815  "P2SH(P2WSH) CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
816  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
817  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
818  "P2WSH CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
819  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem());
820  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
821  "P2SH(P2WSH) CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
822  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().PushRedeem());
823 
824  // P2WSH 1-of-2 multisig with first key uncompressed
825  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
826  "P2WSH CHECKMULTISIG with first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
827  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem());
828  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
829  "P2SH(P2WSH) CHECKMULTISIG first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
830  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
831  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
832  "P2WSH CHECKMULTISIG with first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
833  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
834  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
835  "P2SH(P2WSH) CHECKMULTISIG with first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
836  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
837  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
838  "P2WSH CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
839  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem());
840  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
841  "P2SH(P2WSH) CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
842  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().PushRedeem());
843  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
844  "P2WSH CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
845  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
846  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
847  "P2SH(P2WSH) CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
848  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
849  // P2WSH 1-of-2 multisig with second key uncompressed
850  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
851  "P2WSH CHECKMULTISIG with second key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
852  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
853  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
854  "P2SH(P2WSH) CHECKMULTISIG second key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
855  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
856  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
857  "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, WitnessMode::SH,
858  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
859  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
860  "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, WitnessMode::SH,
861  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
862  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
863  "P2WSH CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
864  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem());
865  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
866  "P2SH(P2WSH) CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
867  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem().PushRedeem());
868  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
869  "P2WSH CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
870  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
871  tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
872  "P2SH(P2WSH) CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
873  0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
874 
875  std::set<std::string> tests_set;
876 
877  {
878  UniValue json_tests = read_json(json_tests::script_tests);
879 
880  for (unsigned int idx = 0; idx < json_tests.size(); idx++) {
881  const UniValue& tv = json_tests[idx];
882  tests_set.insert(JSONPrettyPrint(tv.get_array()));
883  }
884  }
885 
886 #ifdef UPDATE_JSON_TESTS
887  std::string strGen;
888 #endif
889  for (TestBuilder& test : tests) {
890  test.Test(*this);
891  std::string str = JSONPrettyPrint(test.GetJSON());
892 #ifdef UPDATE_JSON_TESTS
893  strGen += str + ",\n";
894 #else
895  if (tests_set.count(str) == 0) {
896  BOOST_CHECK_MESSAGE(false, "Missing auto script_valid test: " + test.GetComment());
897  }
898 #endif
899  }
900 
901 #ifdef UPDATE_JSON_TESTS
902  FILE* file = fsbridge::fopen("script_tests.json.gen", "w");
903  fputs(strGen.c_str(), file);
904  fclose(file);
905 #endif
906 }
907 
908 BOOST_AUTO_TEST_CASE(script_json_test)
909 {
910  // Read tests from test/data/script_tests.json
911  // Format is an array of arrays
912  // Inner arrays are [ ["wit"..., nValue]?, "scriptSig", "scriptPubKey", "flags", "expected_scripterror" ]
913  // ... where scriptSig and scriptPubKey are stringified
914  // scripts.
915  // If a witness is given, then the last value in the array should be the
916  // amount (nValue) to use in the crediting tx
917  UniValue tests = read_json(json_tests::script_tests);
918 
919  for (unsigned int idx = 0; idx < tests.size(); idx++) {
920  const UniValue& test = tests[idx];
921  std::string strTest = test.write();
922  CScriptWitness witness;
923  CAmount nValue = 0;
924  unsigned int pos = 0;
925  if (test.size() > 0 && test[pos].isArray()) {
926  unsigned int i=0;
927  for (i = 0; i < test[pos].size()-1; i++) {
928  witness.stack.push_back(ParseHex(test[pos][i].get_str()));
929  }
930  nValue = AmountFromValue(test[pos][i]);
931  pos++;
932  }
933  if (test.size() < 4 + pos) // Allow size > 3; extra stuff ignored (useful for comments)
934  {
935  if (test.size() != 1) {
936  BOOST_ERROR("Bad test: " << strTest);
937  }
938  continue;
939  }
940  std::string scriptSigString = test[pos++].get_str();
941  CScript scriptSig = ParseScript(scriptSigString);
942  std::string scriptPubKeyString = test[pos++].get_str();
943  CScript scriptPubKey = ParseScript(scriptPubKeyString);
944  unsigned int scriptflags = ParseScriptFlags(test[pos++].get_str());
945  int scriptError = ParseScriptError(test[pos++].get_str());
946 
947  DoTest(scriptPubKey, scriptSig, witness, scriptflags, strTest, scriptError, nValue);
948  }
949 }
950 
951 BOOST_AUTO_TEST_CASE(script_PushData)
952 {
953  // Check that PUSHDATA1, PUSHDATA2, and PUSHDATA4 create the same value on
954  // the stack as the 1-75 opcodes do.
955  static const unsigned char direct[] = { 1, 0x5a };
956  static const unsigned char pushdata1[] = { OP_PUSHDATA1, 1, 0x5a };
957  static const unsigned char pushdata2[] = { OP_PUSHDATA2, 1, 0, 0x5a };
958  static const unsigned char pushdata4[] = { OP_PUSHDATA4, 1, 0, 0, 0, 0x5a };
959 
960  ScriptError err;
961  std::vector<std::vector<unsigned char> > directStack;
962  BOOST_CHECK(EvalScript(directStack, CScript(direct, direct + sizeof(direct)), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
963  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
964 
965  std::vector<std::vector<unsigned char> > pushdata1Stack;
966  BOOST_CHECK(EvalScript(pushdata1Stack, CScript(pushdata1, pushdata1 + sizeof(pushdata1)), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
967  BOOST_CHECK(pushdata1Stack == directStack);
968  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
969 
970  std::vector<std::vector<unsigned char> > pushdata2Stack;
971  BOOST_CHECK(EvalScript(pushdata2Stack, CScript(pushdata2, pushdata2 + sizeof(pushdata2)), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
972  BOOST_CHECK(pushdata2Stack == directStack);
973  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
974 
975  std::vector<std::vector<unsigned char> > pushdata4Stack;
976  BOOST_CHECK(EvalScript(pushdata4Stack, CScript(pushdata4, pushdata4 + sizeof(pushdata4)), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
977  BOOST_CHECK(pushdata4Stack == directStack);
978  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
979 
980  const std::vector<unsigned char> pushdata1_trunc{OP_PUSHDATA1, 1};
981  const std::vector<unsigned char> pushdata2_trunc{OP_PUSHDATA2, 1, 0};
982  const std::vector<unsigned char> pushdata4_trunc{OP_PUSHDATA4, 1, 0, 0, 0};
983 
984  std::vector<std::vector<unsigned char>> stack_ignore;
985  BOOST_CHECK(!EvalScript(stack_ignore, CScript(pushdata1_trunc.begin(), pushdata1_trunc.end()), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
986  BOOST_CHECK_EQUAL(err, SCRIPT_ERR_BAD_OPCODE);
987  BOOST_CHECK(!EvalScript(stack_ignore, CScript(pushdata2_trunc.begin(), pushdata2_trunc.end()), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
988  BOOST_CHECK_EQUAL(err, SCRIPT_ERR_BAD_OPCODE);
989  BOOST_CHECK(!EvalScript(stack_ignore, CScript(pushdata4_trunc.begin(), pushdata4_trunc.end()), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
990  BOOST_CHECK_EQUAL(err, SCRIPT_ERR_BAD_OPCODE);
991 }
992 
993 BOOST_AUTO_TEST_CASE(script_cltv_truncated)
994 {
995  const auto script_cltv_trunc = CScript() << OP_CHECKLOCKTIMEVERIFY;
996 
997  std::vector<std::vector<unsigned char>> stack_ignore;
998  ScriptError err;
999  BOOST_CHECK(!EvalScript(stack_ignore, script_cltv_trunc, SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, BaseSignatureChecker(), SigVersion::BASE, &err));
1000  BOOST_CHECK_EQUAL(err, SCRIPT_ERR_INVALID_STACK_OPERATION);
1001 }
1002 
1003 static CScript
1004 sign_multisig(const CScript& scriptPubKey, const std::vector<CKey>& keys, const CTransaction& transaction)
1005 {
1006  uint256 hash = SignatureHash(scriptPubKey, transaction, 0, SIGHASH_ALL, 0, SigVersion::BASE);
1007 
1008  CScript result;
1009  //
1010  // NOTE: CHECKMULTISIG has an unfortunate bug; it requires
1011  // one extra item on the stack, before the signatures.
1012  // Putting OP_0 on the stack is the workaround;
1013  // fixing the bug would mean splitting the block chain (old
1014  // clients would not accept new CHECKMULTISIG transactions,
1015  // and vice-versa)
1016  //
1017  result << OP_0;
1018  for (const CKey &key : keys)
1019  {
1020  std::vector<unsigned char> vchSig;
1021  BOOST_CHECK(key.Sign(hash, vchSig));
1022  vchSig.push_back((unsigned char)SIGHASH_ALL);
1023  result << vchSig;
1024  }
1025  return result;
1026 }
1027 static CScript
1028 sign_multisig(const CScript& scriptPubKey, const CKey& key, const CTransaction& transaction)
1029 {
1030  std::vector<CKey> keys;
1031  keys.push_back(key);
1032  return sign_multisig(scriptPubKey, keys, transaction);
1033 }
1034 
1035 BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG12)
1036 {
1037  ScriptError err;
1038  CKey key1 = GenerateRandomKey();
1039  CKey key2 = GenerateRandomKey(/*compressed=*/false);
1040  CKey key3 = GenerateRandomKey();
1041 
1042  CScript scriptPubKey12;
1043  scriptPubKey12 << OP_1 << ToByteVector(key1.GetPubKey()) << ToByteVector(key2.GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
1044 
1045  const CTransaction txFrom12{BuildCreditingTransaction(scriptPubKey12)};
1046  CMutableTransaction txTo12 = BuildSpendingTransaction(CScript(), CScriptWitness(), txFrom12);
1047 
1048  CScript goodsig1 = sign_multisig(scriptPubKey12, key1, CTransaction(txTo12));
1049  BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1050  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1051  txTo12.vout[0].nValue = 2;
1052  BOOST_CHECK(!VerifyScript(goodsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1053  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1054 
1055  CScript goodsig2 = sign_multisig(scriptPubKey12, key2, CTransaction(txTo12));
1056  BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1057  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1058 
1059  CScript badsig1 = sign_multisig(scriptPubKey12, key3, CTransaction(txTo12));
1060  BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1061  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1062 }
1063 
1064 BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23)
1065 {
1066  ScriptError err;
1067  CKey key1 = GenerateRandomKey();
1068  CKey key2 = GenerateRandomKey(/*compressed=*/false);
1069  CKey key3 = GenerateRandomKey();
1070  CKey key4 = GenerateRandomKey(/*compressed=*/false);
1071 
1072  CScript scriptPubKey23;
1073  scriptPubKey23 << OP_2 << ToByteVector(key1.GetPubKey()) << ToByteVector(key2.GetPubKey()) << ToByteVector(key3.GetPubKey()) << OP_3 << OP_CHECKMULTISIG;
1074 
1075  const CTransaction txFrom23{BuildCreditingTransaction(scriptPubKey23)};
1076  CMutableTransaction txTo23 = BuildSpendingTransaction(CScript(), CScriptWitness(), txFrom23);
1077 
1078  std::vector<CKey> keys;
1079  keys.push_back(key1); keys.push_back(key2);
1080  CScript goodsig1 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1081  BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1082  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1083 
1084  keys.clear();
1085  keys.push_back(key1); keys.push_back(key3);
1086  CScript goodsig2 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1087  BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1088  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1089 
1090  keys.clear();
1091  keys.push_back(key2); keys.push_back(key3);
1092  CScript goodsig3 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1093  BOOST_CHECK(VerifyScript(goodsig3, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1094  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1095 
1096  keys.clear();
1097  keys.push_back(key2); keys.push_back(key2); // Can't reuse sig
1098  CScript badsig1 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1099  BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1100  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1101 
1102  keys.clear();
1103  keys.push_back(key2); keys.push_back(key1); // sigs must be in correct order
1104  CScript badsig2 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1105  BOOST_CHECK(!VerifyScript(badsig2, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1106  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1107 
1108  keys.clear();
1109  keys.push_back(key3); keys.push_back(key2); // sigs must be in correct order
1110  CScript badsig3 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1111  BOOST_CHECK(!VerifyScript(badsig3, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1112  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1113 
1114  keys.clear();
1115  keys.push_back(key4); keys.push_back(key2); // sigs must match pubkeys
1116  CScript badsig4 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1117  BOOST_CHECK(!VerifyScript(badsig4, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1118  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1119 
1120  keys.clear();
1121  keys.push_back(key1); keys.push_back(key4); // sigs must match pubkeys
1122  CScript badsig5 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1123  BOOST_CHECK(!VerifyScript(badsig5, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1124  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
1125 
1126  keys.clear(); // Must have signatures
1127  CScript badsig6 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
1128  BOOST_CHECK(!VerifyScript(badsig6, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err));
1129  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_INVALID_STACK_OPERATION, ScriptErrorString(err));
1130 }
1131 
1132 /* Wrapper around ProduceSignature to combine two scriptsigs */
1133 SignatureData CombineSignatures(const CTxOut& txout, const CMutableTransaction& tx, const SignatureData& scriptSig1, const SignatureData& scriptSig2)
1134 {
1135  SignatureData data;
1136  data.MergeSignatureData(scriptSig1);
1137  data.MergeSignatureData(scriptSig2);
1138  ProduceSignature(DUMMY_SIGNING_PROVIDER, MutableTransactionSignatureCreator(tx, 0, txout.nValue, SIGHASH_DEFAULT), txout.scriptPubKey, data);
1139  return data;
1140 }
1141 
1142 BOOST_AUTO_TEST_CASE(script_combineSigs)
1143 {
1144  // Test the ProduceSignature's ability to combine signatures function
1145  FillableSigningProvider keystore;
1146  std::vector<CKey> keys;
1147  std::vector<CPubKey> pubkeys;
1148  for (int i = 0; i < 3; i++)
1149  {
1150  CKey key = GenerateRandomKey(/*compressed=*/i%2 == 1);
1151  keys.push_back(key);
1152  pubkeys.push_back(key.GetPubKey());
1153  BOOST_CHECK(keystore.AddKey(key));
1154  }
1155 
1156  CMutableTransaction txFrom = BuildCreditingTransaction(GetScriptForDestination(PKHash(keys[0].GetPubKey())));
1157  CMutableTransaction txTo = BuildSpendingTransaction(CScript(), CScriptWitness(), CTransaction(txFrom));
1158  CScript& scriptPubKey = txFrom.vout[0].scriptPubKey;
1159  SignatureData scriptSig;
1160 
1161  SignatureData empty;
1162  SignatureData combined = CombineSignatures(txFrom.vout[0], txTo, empty, empty);
1163  BOOST_CHECK(combined.scriptSig.empty());
1164 
1165  // Single signature case:
1166  SignatureData dummy;
1167  BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy)); // changes scriptSig
1168  scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1169  combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
1170  BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1171  combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
1172  BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1173  SignatureData scriptSigCopy = scriptSig;
1174  // Signing again will give a different, valid signature:
1175  SignatureData dummy_b;
1176  BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy_b));
1177  scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1178  combined = CombineSignatures(txFrom.vout[0], txTo, scriptSigCopy, scriptSig);
1179  BOOST_CHECK(combined.scriptSig == scriptSigCopy.scriptSig || combined.scriptSig == scriptSig.scriptSig);
1180 
1181  // P2SH, single-signature case:
1182  CScript pkSingle; pkSingle << ToByteVector(keys[0].GetPubKey()) << OP_CHECKSIG;
1183  BOOST_CHECK(keystore.AddCScript(pkSingle));
1184  scriptPubKey = GetScriptForDestination(ScriptHash(pkSingle));
1185  SignatureData dummy_c;
1186  BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy_c));
1187  scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1188  combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
1189  BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1190  combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
1191  BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1192  scriptSigCopy = scriptSig;
1193  SignatureData dummy_d;
1194  BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy_d));
1195  scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1196  combined = CombineSignatures(txFrom.vout[0], txTo, scriptSigCopy, scriptSig);
1197  BOOST_CHECK(combined.scriptSig == scriptSigCopy.scriptSig || combined.scriptSig == scriptSig.scriptSig);
1198 
1199  // Hardest case: Multisig 2-of-3
1200  scriptPubKey = GetScriptForMultisig(2, pubkeys);
1201  BOOST_CHECK(keystore.AddCScript(scriptPubKey));
1202  SignatureData dummy_e;
1203  BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, dummy_e));
1204  scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
1205  combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
1206  BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1207  combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
1208  BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
1209 
1210  // A couple of partially-signed versions:
1211  std::vector<unsigned char> sig1;
1212  uint256 hash1 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_ALL, 0, SigVersion::BASE);
1213  BOOST_CHECK(keys[0].Sign(hash1, sig1));
1214  sig1.push_back(SIGHASH_ALL);
1215  std::vector<unsigned char> sig2;
1216  uint256 hash2 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_NONE, 0, SigVersion::BASE);
1217  BOOST_CHECK(keys[1].Sign(hash2, sig2));
1218  sig2.push_back(SIGHASH_NONE);
1219  std::vector<unsigned char> sig3;
1220  uint256 hash3 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_SINGLE, 0, SigVersion::BASE);
1221  BOOST_CHECK(keys[2].Sign(hash3, sig3));
1222  sig3.push_back(SIGHASH_SINGLE);
1223 
1224  // Not fussy about order (or even existence) of placeholders or signatures:
1225  CScript partial1a = CScript() << OP_0 << sig1 << OP_0;
1226  CScript partial1b = CScript() << OP_0 << OP_0 << sig1;
1227  CScript partial2a = CScript() << OP_0 << sig2;
1228  CScript partial2b = CScript() << sig2 << OP_0;
1229  CScript partial3a = CScript() << sig3;
1230  CScript partial3b = CScript() << OP_0 << OP_0 << sig3;
1231  CScript partial3c = CScript() << OP_0 << sig3 << OP_0;
1232  CScript complete12 = CScript() << OP_0 << sig1 << sig2;
1233  CScript complete13 = CScript() << OP_0 << sig1 << sig3;
1234  CScript complete23 = CScript() << OP_0 << sig2 << sig3;
1235  SignatureData partial1_sigs;
1236  partial1_sigs.signatures.emplace(keys[0].GetPubKey().GetID(), SigPair(keys[0].GetPubKey(), sig1));
1237  SignatureData partial2_sigs;
1238  partial2_sigs.signatures.emplace(keys[1].GetPubKey().GetID(), SigPair(keys[1].GetPubKey(), sig2));
1239  SignatureData partial3_sigs;
1240  partial3_sigs.signatures.emplace(keys[2].GetPubKey().GetID(), SigPair(keys[2].GetPubKey(), sig3));
1241 
1242  combined = CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial1_sigs);
1243  BOOST_CHECK(combined.scriptSig == partial1a);
1244  combined = CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial2_sigs);
1245  BOOST_CHECK(combined.scriptSig == complete12);
1246  combined = CombineSignatures(txFrom.vout[0], txTo, partial2_sigs, partial1_sigs);
1247  BOOST_CHECK(combined.scriptSig == complete12);
1248  combined = CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial2_sigs);
1249  BOOST_CHECK(combined.scriptSig == complete12);
1250  combined = CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial1_sigs);
1251  BOOST_CHECK(combined.scriptSig == complete13);
1252  combined = CombineSignatures(txFrom.vout[0], txTo, partial2_sigs, partial3_sigs);
1253  BOOST_CHECK(combined.scriptSig == complete23);
1254  combined = CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial2_sigs);
1255  BOOST_CHECK(combined.scriptSig == complete23);
1256  combined = CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial3_sigs);
1257  BOOST_CHECK(combined.scriptSig == partial3c);
1258 }
1259 
1263 BOOST_AUTO_TEST_CASE(sign_invalid_miniscript)
1264 {
1265  FillableSigningProvider keystore;
1266  SignatureData sig_data;
1267  CMutableTransaction prev, curr;
1268 
1269  // Create a Taproot output which contains a leaf in which a non-32 bytes push is used where a public key is expected
1270  // by the Miniscript parser. This offending Script was found by the RPC fuzzer.
1271  const auto invalid_pubkey{"173d36c8c9c9c9ffffffffffff0200000000021e1e37373721361818181818181e1e1e1e19000000000000000000b19292929292926b006c9b9b9292"_hex_u8};
1272  TaprootBuilder builder;
1273  builder.Add(0, {invalid_pubkey}, 0xc0);
1274  builder.Finalize(XOnlyPubKey::NUMS_H);
1275  prev.vout.emplace_back(0, GetScriptForDestination(builder.GetOutput()));
1276  curr.vin.emplace_back(COutPoint{prev.GetHash(), 0});
1277  sig_data.tr_spenddata = builder.GetSpendData();
1278 
1279  // SignSignature can fail but it shouldn't raise an exception (nor crash).
1280  BOOST_CHECK(!SignSignature(keystore, CTransaction(prev), curr, 0, SIGHASH_ALL, sig_data));
1281 }
1282 
1283 /* P2A input should be considered signed. */
1284 BOOST_AUTO_TEST_CASE(sign_paytoanchor)
1285 {
1286  FillableSigningProvider keystore;
1287  SignatureData sig_data;
1288  CMutableTransaction prev, curr;
1289  prev.vout.emplace_back(0, GetScriptForDestination(PayToAnchor{}));
1290 
1291  curr.vin.emplace_back(COutPoint{prev.GetHash(), 0});
1292 
1293  BOOST_CHECK(SignSignature(keystore, CTransaction(prev), curr, 0, SIGHASH_ALL, sig_data));
1294 }
1295 
1296 BOOST_AUTO_TEST_CASE(script_standard_push)
1297 {
1298  ScriptError err;
1299  for (int i=0; i<67000; i++) {
1300  CScript script;
1301  script << i;
1302  BOOST_CHECK_MESSAGE(script.IsPushOnly(), "Number " << i << " is not pure push.");
1303  BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1, nullptr, SCRIPT_VERIFY_MINIMALDATA, BaseSignatureChecker(), &err), "Number " << i << " push is not minimal data.");
1304  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1305  }
1306 
1307  for (unsigned int i=0; i<=MAX_SCRIPT_ELEMENT_SIZE; i++) {
1308  std::vector<unsigned char> data(i, '\111');
1309  CScript script;
1310  script << data;
1311  BOOST_CHECK_MESSAGE(script.IsPushOnly(), "Length " << i << " is not pure push.");
1312  BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1, nullptr, SCRIPT_VERIFY_MINIMALDATA, BaseSignatureChecker(), &err), "Length " << i << " push is not minimal data.");
1313  BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
1314  }
1315 }
1316 
1317 BOOST_AUTO_TEST_CASE(script_IsPushOnly_on_invalid_scripts)
1318 {
1319  // IsPushOnly returns false when given a script containing only pushes that
1320  // are invalid due to truncation. IsPushOnly() is consensus critical
1321  // because P2SH evaluation uses it, although this specific behavior should
1322  // not be consensus critical as the P2SH evaluation would fail first due to
1323  // the invalid push. Still, it doesn't hurt to test it explicitly.
1324  static const unsigned char direct[] = { 1 };
1325  BOOST_CHECK(!CScript(direct, direct+sizeof(direct)).IsPushOnly());
1326 }
1327 
1328 BOOST_AUTO_TEST_CASE(script_GetScriptAsm)
1329 {
1330  BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_NOP2, true));
1331  BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY, true));
1332  BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_NOP2));
1333  BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY));
1334 
1335  std::string derSig("304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c5090");
1336  std::string pubKey("03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2");
1337  std::vector<unsigned char> vchPubKey = ToByteVector(ParseHex(pubKey));
1338 
1339  BOOST_CHECK_EQUAL(derSig + "00 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "00")) << vchPubKey, true));
1340  BOOST_CHECK_EQUAL(derSig + "80 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "80")) << vchPubKey, true));
1341  BOOST_CHECK_EQUAL(derSig + "[ALL] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "01")) << vchPubKey, true));
1342  BOOST_CHECK_EQUAL(derSig + "[NONE] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "02")) << vchPubKey, true));
1343  BOOST_CHECK_EQUAL(derSig + "[SINGLE] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "03")) << vchPubKey, true));
1344  BOOST_CHECK_EQUAL(derSig + "[ALL|ANYONECANPAY] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "81")) << vchPubKey, true));
1345  BOOST_CHECK_EQUAL(derSig + "[NONE|ANYONECANPAY] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "82")) << vchPubKey, true));
1346  BOOST_CHECK_EQUAL(derSig + "[SINGLE|ANYONECANPAY] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "83")) << vchPubKey, true));
1347 
1348  BOOST_CHECK_EQUAL(derSig + "00 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "00")) << vchPubKey));
1349  BOOST_CHECK_EQUAL(derSig + "80 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "80")) << vchPubKey));
1350  BOOST_CHECK_EQUAL(derSig + "01 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "01")) << vchPubKey));
1351  BOOST_CHECK_EQUAL(derSig + "02 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "02")) << vchPubKey));
1352  BOOST_CHECK_EQUAL(derSig + "03 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "03")) << vchPubKey));
1353  BOOST_CHECK_EQUAL(derSig + "81 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "81")) << vchPubKey));
1354  BOOST_CHECK_EQUAL(derSig + "82 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "82")) << vchPubKey));
1355  BOOST_CHECK_EQUAL(derSig + "83 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "83")) << vchPubKey));
1356 }
1357 
1358 template <typename T>
1359 CScript ToScript(const T& byte_container)
1360 {
1361  auto span{MakeUCharSpan(byte_container)};
1362  return {span.begin(), span.end()};
1363 }
1364 
1365 static CScript ScriptFromHex(const std::string& str)
1366 {
1367  return ToScript(*Assert(TryParseHex(str)));
1368 }
1369 
1370 BOOST_AUTO_TEST_CASE(script_byte_array_u8_vector_equivalence)
1371 {
1372  const CScript scriptPubKey1 = CScript() << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"_hex_v_u8 << OP_CHECKSIG;
1373  const CScript scriptPubKey2 = CScript() << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"_hex << OP_CHECKSIG;
1374  BOOST_CHECK(scriptPubKey1 == scriptPubKey2);
1375 }
1376 
1377 BOOST_AUTO_TEST_CASE(script_FindAndDelete)
1378 {
1379  // Exercise the FindAndDelete functionality
1380  CScript s;
1381  CScript d;
1382  CScript expect;
1383 
1384  s = CScript() << OP_1 << OP_2;
1385  d = CScript(); // delete nothing should be a no-op
1386  expect = s;
1387  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
1388  BOOST_CHECK(s == expect);
1389 
1390  s = CScript() << OP_1 << OP_2 << OP_3;
1391  d = CScript() << OP_2;
1392  expect = CScript() << OP_1 << OP_3;
1393  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1394  BOOST_CHECK(s == expect);
1395 
1396  s = CScript() << OP_3 << OP_1 << OP_3 << OP_3 << OP_4 << OP_3;
1397  d = CScript() << OP_3;
1398  expect = CScript() << OP_1 << OP_4;
1399  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 4);
1400  BOOST_CHECK(s == expect);
1401 
1402  s = ToScript("0302ff03"_hex); // PUSH 0x02ff03 onto stack
1403  d = ToScript("0302ff03"_hex);
1404  expect = CScript();
1405  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1406  BOOST_CHECK(s == expect);
1407 
1408  s = ToScript("0302ff030302ff03"_hex); // PUSH 0x02ff03 PUSH 0x02ff03
1409  d = ToScript("0302ff03"_hex);
1410  expect = CScript();
1411  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
1412  BOOST_CHECK(s == expect);
1413 
1414  s = ToScript("0302ff030302ff03"_hex);
1415  d = ToScript("02"_hex);
1416  expect = s; // FindAndDelete matches entire opcodes
1417  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
1418  BOOST_CHECK(s == expect);
1419 
1420  s = ToScript("0302ff030302ff03"_hex);
1421  d = ToScript("ff"_hex);
1422  expect = s;
1423  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
1424  BOOST_CHECK(s == expect);
1425 
1426  // This is an odd edge case: strip of the push-three-bytes
1427  // prefix, leaving 02ff03 which is push-two-bytes:
1428  s = ToScript("0302ff030302ff03"_hex);
1429  d = ToScript("03"_hex);
1430  expect = CScript() << "ff03"_hex << "ff03"_hex;
1431  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
1432  BOOST_CHECK(s == expect);
1433 
1434  // Byte sequence that spans multiple opcodes:
1435  s = ToScript("02feed5169"_hex); // PUSH(0xfeed) OP_1 OP_VERIFY
1436  d = ToScript("feed51"_hex);
1437  expect = s;
1438  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0); // doesn't match 'inside' opcodes
1439  BOOST_CHECK(s == expect);
1440 
1441  s = ToScript("02feed5169"_hex); // PUSH(0xfeed) OP_1 OP_VERIFY
1442  d = ToScript("02feed51"_hex);
1443  expect = ToScript("69"_hex);
1444  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1445  BOOST_CHECK(s == expect);
1446 
1447  s = ToScript("516902feed5169"_hex);
1448  d = ToScript("feed51"_hex);
1449  expect = s;
1450  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
1451  BOOST_CHECK(s == expect);
1452 
1453  s = ToScript("516902feed5169"_hex);
1454  d = ToScript("02feed51"_hex);
1455  expect = ToScript("516969"_hex);
1456  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1457  BOOST_CHECK(s == expect);
1458 
1459  s = CScript() << OP_0 << OP_0 << OP_1 << OP_1;
1460  d = CScript() << OP_0 << OP_1;
1461  expect = CScript() << OP_0 << OP_1; // FindAndDelete is single-pass
1462  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1463  BOOST_CHECK(s == expect);
1464 
1465  s = CScript() << OP_0 << OP_0 << OP_1 << OP_0 << OP_1 << OP_1;
1466  d = CScript() << OP_0 << OP_1;
1467  expect = CScript() << OP_0 << OP_1; // FindAndDelete is single-pass
1468  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
1469  BOOST_CHECK(s == expect);
1470 
1471  // Another weird edge case:
1472  // End with invalid push (not enough data)...
1473  s = ToScript("0003feed"_hex);
1474  d = ToScript("03feed"_hex); // ... can remove the invalid push
1475  expect = ToScript("00"_hex);
1476  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1477  BOOST_CHECK(s == expect);
1478 
1479  s = ToScript("0003feed"_hex);
1480  d = ToScript("00"_hex);
1481  expect = ToScript("03feed"_hex);
1482  BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1483  BOOST_CHECK(s == expect);
1484 }
1485 
1486 BOOST_AUTO_TEST_CASE(script_HasValidOps)
1487 {
1488  // Exercise the HasValidOps functionality
1489  CScript script;
1490  script = ToScript("76a9141234567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac"_hex); // Normal script
1491  BOOST_CHECK(script.HasValidOps());
1492  script = ToScript("76a914ff34567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac"_hex);
1493  BOOST_CHECK(script.HasValidOps());
1494  script = ToScript("ff88ac"_hex); // Script with OP_INVALIDOPCODE explicit
1495  BOOST_CHECK(!script.HasValidOps());
1496  script = ToScript("88acc0"_hex); // Script with undefined opcode
1497  BOOST_CHECK(!script.HasValidOps());
1498 }
1499 
1500 static CMutableTransaction TxFromHex(const std::string& str)
1501 {
1502  CMutableTransaction tx;
1503  SpanReader{ParseHex(str)} >> TX_NO_WITNESS(tx);
1504  return tx;
1505 }
1506 
1507 static std::vector<CTxOut> TxOutsFromJSON(const UniValue& univalue)
1508 {
1509  assert(univalue.isArray());
1510  std::vector<CTxOut> prevouts;
1511  for (size_t i = 0; i < univalue.size(); ++i) {
1512  CTxOut txout;
1513  SpanReader{ParseHex(univalue[i].get_str())} >> txout;
1514  prevouts.push_back(std::move(txout));
1515  }
1516  return prevouts;
1517 }
1518 
1519 static CScriptWitness ScriptWitnessFromJSON(const UniValue& univalue)
1520 {
1521  assert(univalue.isArray());
1522  CScriptWitness scriptwitness;
1523  for (size_t i = 0; i < univalue.size(); ++i) {
1524  auto bytes = ParseHex(univalue[i].get_str());
1525  scriptwitness.stack.push_back(std::move(bytes));
1526  }
1527  return scriptwitness;
1528 }
1529 
1530 static std::vector<unsigned int> AllConsensusFlags()
1531 {
1532  std::vector<unsigned int> ret;
1533 
1534  for (unsigned int i = 0; i < 128; ++i) {
1535  unsigned int flag = 0;
1536  if (i & 1) flag |= SCRIPT_VERIFY_P2SH;
1537  if (i & 2) flag |= SCRIPT_VERIFY_DERSIG;
1538  if (i & 4) flag |= SCRIPT_VERIFY_NULLDUMMY;
1539  if (i & 8) flag |= SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY;
1540  if (i & 16) flag |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY;
1541  if (i & 32) flag |= SCRIPT_VERIFY_WITNESS;
1542  if (i & 64) flag |= SCRIPT_VERIFY_TAPROOT;
1543 
1544  // SCRIPT_VERIFY_WITNESS requires SCRIPT_VERIFY_P2SH
1545  if (flag & SCRIPT_VERIFY_WITNESS && !(flag & SCRIPT_VERIFY_P2SH)) continue;
1546  // SCRIPT_VERIFY_TAPROOT requires SCRIPT_VERIFY_WITNESS
1547  if (flag & SCRIPT_VERIFY_TAPROOT && !(flag & SCRIPT_VERIFY_WITNESS)) continue;
1548 
1549  ret.push_back(flag);
1550  }
1551 
1552  return ret;
1553 }
1554 
1556 static const std::vector<unsigned int> ALL_CONSENSUS_FLAGS = AllConsensusFlags();
1557 
1558 static void AssetTest(const UniValue& test, SignatureCache& signature_cache)
1559 {
1560  BOOST_CHECK(test.isObject());
1561 
1562  CMutableTransaction mtx = TxFromHex(test["tx"].get_str());
1563  const std::vector<CTxOut> prevouts = TxOutsFromJSON(test["prevouts"]);
1564  BOOST_CHECK(prevouts.size() == mtx.vin.size());
1565  size_t idx = test["index"].getInt<int64_t>();
1566  uint32_t test_flags{ParseScriptFlags(test["flags"].get_str())};
1567  bool fin = test.exists("final") && test["final"].get_bool();
1568 
1569  if (test.exists("success")) {
1570  mtx.vin[idx].scriptSig = ScriptFromHex(test["success"]["scriptSig"].get_str());
1571  mtx.vin[idx].scriptWitness = ScriptWitnessFromJSON(test["success"]["witness"]);
1572  CTransaction tx(mtx);
1573  PrecomputedTransactionData txdata;
1574  txdata.Init(tx, std::vector<CTxOut>(prevouts));
1575  CachingTransactionSignatureChecker txcheck(&tx, idx, prevouts[idx].nValue, true, signature_cache, txdata);
1576 
1577  for (const auto flags : ALL_CONSENSUS_FLAGS) {
1578  // "final": true tests are valid for all flags. Others are only valid with flags that are
1579  // a subset of test_flags.
1580  if (fin || ((flags & test_flags) == flags)) {
1581  bool ret = VerifyScript(tx.vin[idx].scriptSig, prevouts[idx].scriptPubKey, &tx.vin[idx].scriptWitness, flags, txcheck, nullptr);
1582  BOOST_CHECK(ret);
1583  }
1584  }
1585  }
1586 
1587  if (test.exists("failure")) {
1588  mtx.vin[idx].scriptSig = ScriptFromHex(test["failure"]["scriptSig"].get_str());
1589  mtx.vin[idx].scriptWitness = ScriptWitnessFromJSON(test["failure"]["witness"]);
1590  CTransaction tx(mtx);
1591  PrecomputedTransactionData txdata;
1592  txdata.Init(tx, std::vector<CTxOut>(prevouts));
1593  CachingTransactionSignatureChecker txcheck(&tx, idx, prevouts[idx].nValue, true, signature_cache, txdata);
1594 
1595  for (const auto flags : ALL_CONSENSUS_FLAGS) {
1596  // If a test is supposed to fail with test_flags, it should also fail with any superset thereof.
1597  if ((flags & test_flags) == test_flags) {
1598  bool ret = VerifyScript(tx.vin[idx].scriptSig, prevouts[idx].scriptPubKey, &tx.vin[idx].scriptWitness, flags, txcheck, nullptr);
1599  BOOST_CHECK(!ret);
1600  }
1601  }
1602  }
1603 }
1604 
1605 BOOST_AUTO_TEST_CASE(script_assets_test)
1606 {
1607  // See src/test/fuzz/script_assets_test_minimizer.cpp for information on how to generate
1608  // the script_assets_test.json file used by this test.
1609  SignatureCache signature_cache{DEFAULT_SIGNATURE_CACHE_BYTES};
1610 
1611  const char* dir = std::getenv("DIR_UNIT_TEST_DATA");
1612  BOOST_WARN_MESSAGE(dir != nullptr, "Variable DIR_UNIT_TEST_DATA unset, skipping script_assets_test");
1613  if (dir == nullptr) return;
1614  auto path = fs::path(dir) / "script_assets_test.json";
1615  bool exists = fs::exists(path);
1616  BOOST_WARN_MESSAGE(exists, "File $DIR_UNIT_TEST_DATA/script_assets_test.json not found, skipping script_assets_test");
1617  if (!exists) return;
1618  std::ifstream file{path};
1619  BOOST_CHECK(file.is_open());
1620  file.seekg(0, std::ios::end);
1621  size_t length = file.tellg();
1622  file.seekg(0, std::ios::beg);
1623  std::string data(length, '\0');
1624  file.read(data.data(), data.size());
1625  UniValue tests = read_json(data);
1626  BOOST_CHECK(tests.isArray());
1627  BOOST_CHECK(tests.size() > 0);
1628 
1629  for (size_t i = 0; i < tests.size(); i++) {
1630  AssetTest(tests[i], signature_cache);
1631  }
1632  file.close();
1633 }
1634 
1635 BOOST_AUTO_TEST_CASE(bip341_keypath_test_vectors)
1636 {
1637  UniValue tests;
1638  tests.read(json_tests::bip341_wallet_vectors);
1639 
1640  const auto& vectors = tests["keyPathSpending"];
1641 
1642  for (const auto& vec : vectors.getValues()) {
1643  auto txhex = ParseHex(vec["given"]["rawUnsignedTx"].get_str());
1644  CMutableTransaction tx;
1645  SpanReader{txhex} >> TX_WITH_WITNESS(tx);
1646  std::vector<CTxOut> utxos;
1647  for (const auto& utxo_spent : vec["given"]["utxosSpent"].getValues()) {
1648  auto script_bytes = ParseHex(utxo_spent["scriptPubKey"].get_str());
1649  CScript script{script_bytes.begin(), script_bytes.end()};
1650  CAmount amount{utxo_spent["amountSats"].getInt<int>()};
1651  utxos.emplace_back(amount, script);
1652  }
1653 
1654  PrecomputedTransactionData txdata;
1655  txdata.Init(tx, std::vector<CTxOut>{utxos}, true);
1656 
1657  BOOST_CHECK(txdata.m_bip341_taproot_ready);
1658  BOOST_CHECK_EQUAL(HexStr(txdata.m_spent_amounts_single_hash), vec["intermediary"]["hashAmounts"].get_str());
1659  BOOST_CHECK_EQUAL(HexStr(txdata.m_outputs_single_hash), vec["intermediary"]["hashOutputs"].get_str());
1660  BOOST_CHECK_EQUAL(HexStr(txdata.m_prevouts_single_hash), vec["intermediary"]["hashPrevouts"].get_str());
1661  BOOST_CHECK_EQUAL(HexStr(txdata.m_spent_scripts_single_hash), vec["intermediary"]["hashScriptPubkeys"].get_str());
1662  BOOST_CHECK_EQUAL(HexStr(txdata.m_sequences_single_hash), vec["intermediary"]["hashSequences"].get_str());
1663 
1664  for (const auto& input : vec["inputSpending"].getValues()) {
1665  int txinpos = input["given"]["txinIndex"].getInt<int>();
1666  int hashtype = input["given"]["hashType"].getInt<int>();
1667 
1668  // Load key.
1669  auto privkey = ParseHex(input["given"]["internalPrivkey"].get_str());
1670  CKey key;
1671  key.Set(privkey.begin(), privkey.end(), true);
1672 
1673  // Load Merkle root.
1674  uint256 merkle_root;
1675  if (!input["given"]["merkleRoot"].isNull()) {
1676  merkle_root = uint256{ParseHex(input["given"]["merkleRoot"].get_str())};
1677  }
1678 
1679  // Compute and verify (internal) public key.
1680  XOnlyPubKey pubkey{key.GetPubKey()};
1681  BOOST_CHECK_EQUAL(HexStr(pubkey), input["intermediary"]["internalPubkey"].get_str());
1682 
1683  // Sign and verify signature.
1684  FlatSigningProvider provider;
1685  provider.keys[key.GetPubKey().GetID()] = key;
1686  MutableTransactionSignatureCreator creator(tx, txinpos, utxos[txinpos].nValue, &txdata, hashtype);
1687  std::vector<unsigned char> signature;
1688  BOOST_CHECK(creator.CreateSchnorrSig(provider, signature, pubkey, nullptr, &merkle_root, SigVersion::TAPROOT));
1689  BOOST_CHECK_EQUAL(HexStr(signature), input["expected"]["witness"][0].get_str());
1690 
1691  // We can't observe the tweak used inside the signing logic, so verify by recomputing it.
1692  BOOST_CHECK_EQUAL(HexStr(pubkey.ComputeTapTweakHash(merkle_root.IsNull() ? nullptr : &merkle_root)), input["intermediary"]["tweak"].get_str());
1693 
1694  // We can't observe the sighash used inside the signing logic, so verify by recomputing it.
1695  ScriptExecutionData sed;
1696  sed.m_annex_init = true;
1697  sed.m_annex_present = false;
1698  uint256 sighash;
1699  BOOST_CHECK(SignatureHashSchnorr(sighash, sed, tx, txinpos, hashtype, SigVersion::TAPROOT, txdata, MissingDataBehavior::FAIL));
1700  BOOST_CHECK_EQUAL(HexStr(sighash), input["intermediary"]["sigHash"].get_str());
1701 
1702  // To verify the sigmsg, hash the expected sigmsg, and compare it with the (expected) sighash.
1703  BOOST_CHECK_EQUAL(HexStr((HashWriter{HASHER_TAPSIGHASH} << std::span<const uint8_t>{ParseHex(input["intermediary"]["sigMsg"].get_str())}).GetSHA256()), input["intermediary"]["sigHash"].get_str());
1704  }
1705  }
1706 }
1707 
1708 BOOST_AUTO_TEST_CASE(compute_tapbranch)
1709 {
1710  constexpr uint256 hash1{"8ad69ec7cf41c2a4001fd1f738bf1e505ce2277acdcaa63fe4765192497f47a7"};
1711  constexpr uint256 hash2{"f224a923cd0021ab202ab139cc56802ddb92dcfc172b9212261a539df79a112a"};
1712  constexpr uint256 result{"a64c5b7b943315f9b805d7a7296bedfcfd08919270a1f7a1466e98f8693d8cd9"};
1713  BOOST_CHECK_EQUAL(ComputeTapbranchHash(hash1, hash2), result);
1714 }
1715 
1716 BOOST_AUTO_TEST_CASE(compute_tapleaf)
1717 {
1718  constexpr uint8_t script[6] = {'f','o','o','b','a','r'};
1719  constexpr uint256 tlc0{"edbc10c272a1215dcdcc11d605b9027b5ad6ed97cd45521203f136767b5b9c06"};
1720  constexpr uint256 tlc2{"8b5c4f90ae6bf76e259dbef5d8a59df06359c391b59263741b25eca76451b27a"};
1721 
1722  BOOST_CHECK_EQUAL(ComputeTapleafHash(0xc0, Span(script)), tlc0);
1723  BOOST_CHECK_EQUAL(ComputeTapleafHash(0xc2, Span(script)), tlc2);
1724 }
1725 
1726 BOOST_AUTO_TEST_SUITE_END()
CTransactionRef
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:423
CTxOut::nValue
CAmount nValue
Definition: transaction.h:152
BuildCreditingTransaction
CMutableTransaction BuildCreditingTransaction(const CScript &scriptPubKey, int nValue)
Definition: transaction_utils.cpp:10
SCRIPT_ERR_STACK_SIZE
Definition: script_error.h:22
SigVersion::WITNESS_V0
Witness v0 (P2WPKH and P2WSH); see BIP 141.
CSHA256::Write
CSHA256 & Write(const unsigned char *data, size_t len)
Definition: sha256.cpp:701
SCRIPT_ERR_SIG_PUSHONLY
Definition: script_error.h:48
GetScriptForMultisig
CScript GetScriptForMultisig(int nRequired, const std::vector< CPubKey > &keys)
Generate a multisig script.
Definition: solver.cpp:218
UniValue::isObject
bool isObject() const
Definition: univalue.h:86
SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH
Definition: script_error.h:64
ret
int ret
Definition: bitcoin-cli.cpp:1358
SignatureCache
Valid signature cache, to avoid doing expensive ECDSA signature checking twice for every transaction ...
Definition: sigcache.h:38
transaction_utils.h
SCRIPT_ERR_CLEANSTACK
Definition: script_error.h:52
core_io.h
SigVersion::TAPROOT
Witness v1 with 32-byte program, not BIP16 P2SH-wrapped, key path spending; see BIP 341...
FormatScript
std::string FormatScript(const CScript &script)
Definition: core_write.cpp:39
SCRIPT_ERR_VERIFY
Definition: script_error.h:27
SignatureHashSchnorr
bool SignatureHashSchnorr(uint256 &hash_out, ScriptExecutionData &execdata, const T &tx_to, uint32_t in_pos, uint8_t hash_type, SigVersion sigversion, const PrecomputedTransactionData &cache, MissingDataBehavior mdb)
Definition: interpreter.cpp:1478
ParseHex
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
Definition: strencodings.h:68
SCRIPT_ERR_INVALID_STACK_OPERATION
Definition: script_error.h:36
assert
assert(!tx.IsCoinBase())
fsbridge::fopen
FILE * fopen(const fs::path &p, const char *mode)
Definition: fs.cpp:26
ScriptError
enum ScriptError_t ScriptError
CTxOut::scriptPubKey
CScript scriptPubKey
Definition: transaction.h:153
SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS
Definition: script_error.h:57
UniValue::get_bool
bool get_bool() const
Definition: univalue_get.cpp:60
SCRIPT_ERR_UNKNOWN_ERROR
Definition: script_error.h:14
SCRIPT_ERR_SIG_NULLFAIL
Definition: script_error.h:54
SCRIPT_ERR_SIG_COUNT
Definition: script_error.h:23
OP_DUP
Definition: script.h:125
strprintf
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1172
SIGHASH_DEFAULT
Taproot only; implied when sighash byte is missing, and equivalent to SIGHASH_ALL.
Definition: interpreter.h:35
CKey::GetPubKey
CPubKey GetPubKey() const
Compute the public key from a private key.
Definition: key.cpp:182
test_vectors_musig2_generate.data
data
Definition: test_vectors_musig2_generate.py:98
VerifyScript
bool VerifyScript(const CScript &scriptSig, const CScript &scriptPubKey, const CScriptWitness *witness, unsigned int flags, const BaseSignatureChecker &checker, ScriptError *serror)
Definition: interpreter.cpp:1958
SignatureData::scriptSig
CScript scriptSig
The scriptSig of an input. Contains complete signatures or the traditional partial signatures format...
Definition: sign.h:71
SCRIPT_ERR_SIG_HIGH_S
Definition: script_error.h:49
CMutableTransaction::vin
std::vector< CTxIn > vin
Definition: transaction.h:379
FlatSigningProvider::keys
std::map< CKeyID, CKey > keys
Definition: signingprovider.h:214
FillableSigningProvider::AddCScript
virtual bool AddCScript(const CScript &redeemScript)
Definition: signingprovider.cpp:163
SCRIPT_ERR_NUMEQUALVERIFY
Definition: script_error.h:31
SCRIPT_ERR_OP_CODESEPARATOR
Definition: script_error.h:82
expect
#define expect(bit)
Definition: univalue_read.cpp:259
TxFromHex
static CMutableTransaction TxFromHex(const std::string &str)
Definition: script_tests.cpp:1500
CScriptWitness::stack
std::vector< std::vector< unsigned char > > stack
Definition: script.h:588
ScriptErrorDesc::err
ScriptError_t err
Definition: script_tests.cpp:47
BuildSpendingTransaction
CMutableTransaction BuildSpendingTransaction(const CScript &scriptSig, const CScriptWitness &scriptWitness, const CTransaction &txCredit)
Definition: transaction_utils.cpp:26
SCRIPT_ERR_UNSATISFIED_LOCKTIME
Definition: script_error.h:42
XOnlyPubKey::NUMS_H
static const XOnlyPubKey NUMS_H
Nothing Up My Sleeve point H Used as an internal key for provably disabling the key path spend see BI...
Definition: pubkey.h:239
UniValue::get_str
const std::string & get_str() const
Definition: univalue_get.cpp:66
UniValue::get_array
const UniValue & get_array() const
Definition: univalue_get.cpp:87
SigVersion::BASE
Bare scripts and BIP16 P2SH-wrapped redeemscripts.
SCRIPT_ERR_SCRIPT_SIZE
Definition: script_error.h:19
read_json
UniValue read_json(std::string_view jsondata)
Definition: json.cpp:12
ParseScriptFlags
unsigned int ParseScriptFlags(std::string strFlags)
Definition: transaction_tests.cpp:76
OP_0
Definition: script.h:76
MutableTransactionSignatureCreator
A signature creator for transactions.
Definition: sign.h:39
SCRIPT_ERR_DISABLED_OPCODE
Definition: script_error.h:35
UniValue::getInt
Int getInt() const
Definition: univalue.h:138
SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
Definition: script_error.h:58
SCRIPT_ERR_WITNESS_MALLEATED
Definition: script_error.h:67
SCRIPT_ERR_SIG_HASHTYPE
Definition: script_error.h:45
HASHER_TAPSIGHASH
const HashWriter HASHER_TAPSIGHASH
Hasher with tag "TapSighash" pre-fed to it.
Definition: interpreter.cpp:1461
CPubKey::GetID
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Definition: pubkey.h:164
miniscript::Opcode
std::pair< opcodetype, std::vector< unsigned char > > Opcode
Definition: miniscript.h:189
CPubKey::begin
const unsigned char * begin() const
Definition: pubkey.h:114
CTransaction::vin
const std::vector< CTxIn > vin
Definition: transaction.h:306
SCRIPT_ERR_OP_COUNT
Definition: script_error.h:21
prevector::data
value_type * data()
Definition: prevector.h:533
BasicTestingSetup
Basic testing setup.
Definition: setup_common.h:64
base_blob::begin
constexpr unsigned char * begin()
Definition: uint256.h:115
gFlags
static const unsigned int gFlags
Definition: script_tests.cpp:40
SpanReader
Minimal stream for reading from an existing byte array by Span.
Definition: streams.h:100
OP_1
Definition: script.h:83
GenerateRandomKey
CKey GenerateRandomKey(bool compressed) noexcept
Definition: key.cpp:352
CombineSignatures
SignatureData CombineSignatures(const CTxOut &txout, const CMutableTransaction &tx, const SignatureData &scriptSig1, const SignatureData &scriptSig2)
Definition: script_tests.cpp:1133
tests
constexpr std::array tests
Definition: unitester.cpp:100
CAmount
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
NegateSignatureS
static void NegateSignatureS(std::vector< unsigned char > &vchSig)
Definition: script_tests.cpp:141
ScriptFromHex
static CScript ScriptFromHex(const std::string &str)
Definition: script_tests.cpp:1365
CKey::Sign
bool Sign(const uint256 &hash, std::vector< unsigned char > &vchSig, bool grind=true, uint32_t test_case=0) const
Create a DER-serialized signature.
Definition: key.cpp:208
ScriptExecutionData::m_annex_init
bool m_annex_init
Whether m_annex_present and (when needed) m_annex_hash are initialized.
Definition: interpreter.h:211
prevector::end
iterator end()
Definition: prevector.h:304
ScriptWitnessFromJSON
static CScriptWitness ScriptWitnessFromJSON(const UniValue &univalue)
Definition: script_tests.cpp:1519
prevector::push_back
void push_back(const T &value)
Definition: prevector.h:444
SCRIPT_ERR_OK
Definition: script_error.h:13
MissingDataBehavior::ASSERT_FAIL
Abort execution through assertion failure (for consensus code)
PrecomputedTransactionData::Init
void Init(const T &tx, std::vector< CTxOut > &&spent_outputs, bool force=false)
Initialize this PrecomputedTransactionData with transaction data.
Definition: interpreter.cpp:1398
ScriptToAsmStr
std::string ScriptToAsmStr(const CScript &script, const bool fAttemptSighashDecode=false)
Create the assembly string representation of a CScript object.
Definition: core_write.cpp:98
AmountFromValue
static CAmount AmountFromValue(const UniValue &value)
Definition: bitcoin-tx.cpp:561
CPubKey::end
const unsigned char * end() const
Definition: pubkey.h:115
SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH
Definition: script_error.h:66
BOOST_FIXTURE_TEST_SUITE
BOOST_FIXTURE_TEST_SUITE(cuckoocache_tests, BasicTestingSetup)
Test Suite for CuckooCache.
SCRIPT_ERR_CHECKSIGVERIFY
Definition: script_error.h:30
ParseScriptError
static ScriptError_t ParseScriptError(const std::string &name)
Definition: script_tests.cpp:106
name
const char * name
Definition: rest.cpp:49
UniValue::exists
bool exists(const std::string &key) const
Definition: univalue.h:77
DUMMY_SIGNING_PROVIDER
const SigningProvider & DUMMY_SIGNING_PROVIDER
Definition: signingprovider.cpp:12
HashWriter
A writer stream (for serialization) that computes a 256-bit hash.
Definition: hash.h:100
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
setup_common.h
TaprootBuilder::Finalize
TaprootBuilder & Finalize(const XOnlyPubKey &internal_key)
Finalize the construction.
Definition: signingprovider.cpp:394
SCRIPT_ERR_WITNESS_PUBKEYTYPE
Definition: script_error.h:70
CPubKey
An encapsulated public key.
Definition: pubkey.h:33
FillableSigningProvider
Fillable signing provider that keeps keys in an address->secret map.
Definition: signingprovider.h:229
ScriptErrorString
std::string ScriptErrorString(const ScriptError serror)
Definition: script_error.cpp:10
ScriptError_t
ScriptError_t
Definition: script_error.h:11
SigPair
std::pair< CPubKey, std::vector< unsigned char > > SigPair
Definition: sign.h:63
opcodetype
opcodetype
Script opcodes.
Definition: script.h:73
TaprootBuilder::GetOutput
WitnessV1Taproot GetOutput()
Compute scriptPubKey (after Finalize()).
Definition: signingprovider.cpp:405
SCRIPT_ERR_PUBKEY_COUNT
Definition: script_error.h:24
SCRIPT_ERR_EVAL_FALSE
Definition: script_error.h:15
SCRIPT_ERR_PUBKEYTYPE
Definition: script_error.h:51
SCRIPT_ERR_BAD_OPCODE
Definition: script_error.h:34
UniValue::write
std::string write(unsigned int prettyIndent=0, unsigned int indentLevel=0) const
Definition: univalue_write.cpp:31
SCRIPT_ERR_MINIMALDATA
Definition: script_error.h:47
MissingDataBehavior::FAIL
Just act as if the signature was invalid.
SCRIPT_ERR_WITNESS_MALLEATED_P2SH
Definition: script_error.h:68
script_error.h
SCRIPT_ERR_EQUALVERIFY
Definition: script_error.h:28
AssetTest
static void AssetTest(const UniValue &test, SignatureCache &signature_cache)
Definition: script_tests.cpp:1558
CTxOut
An output of a transaction.
Definition: transaction.h:149
util::hex_literals
""_hex is a compile-time user-defined literal returning a std::array<std::byte>, equivalent to ParseH...
Definition: strencodings.h:427
MutableTransactionSignatureChecker
GenericTransactionSignatureChecker< CMutableTransaction > MutableTransactionSignatureChecker
Definition: interpreter.h:307
SCRIPT_ERR_OP_RETURN
Definition: script_error.h:16
CMutableTransaction::GetHash
Txid GetHash() const
Compute the hash of this CMutableTransaction.
Definition: transaction.cpp:69
SCRIPT_ERR_SIG_FINDANDDELETE
Definition: script_error.h:83
COutPoint
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:28
PrecomputedTransactionData::m_bip341_taproot_ready
bool m_bip341_taproot_ready
Whether the 5 fields above are initialized.
Definition: interpreter.h:163
CMutableTransaction::vout
std::vector< CTxOut > vout
Definition: transaction.h:380
base_blob::IsNull
constexpr bool IsNull() const
Definition: uint256.h:48
CKey::Set
void Set(const T pbegin, const T pend, bool fCompressedIn)
Initialize using begin and end iterators to byte data.
Definition: key.h:103
Num
A type to represent integers in the type system.
Definition: lintrans.h:13
SignSignature
bool SignSignature(const SigningProvider &provider, const CScript &fromPubKey, CMutableTransaction &txTo, unsigned int nIn, const CAmount &amount, int nHashType, SignatureData &sig_data)
Produce a satisfying script (scriptSig or witness).
Definition: transaction_utils.cpp:94
ComputeTapleafHash
uint256 ComputeTapleafHash(uint8_t leaf_version, Span< const unsigned char > script)
Compute the BIP341 tapleaf hash from leaf version & script.
Definition: interpreter.cpp:1828
SCRIPT_ERR_INVALID_ALTSTACK_OPERATION
Definition: script_error.h:37
GetScriptForDestination
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
Definition: addresstype.cpp:166
MakeTransactionRef
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:424
TaprootBuilder::GetSpendData
TaprootSpendData GetSpendData() const
Compute spending data (after Finalize()).
Definition: signingprovider.cpp:407
TaprootBuilder
Utility class to construct Taproot outputs from internal key and script tree.
Definition: signingprovider.h:45
flags
int flags
Definition: bitcoin-tx.cpp:536
script_errors
static ScriptErrorDesc script_errors[]
Definition: script_tests.cpp:51
ToByteVector
std::vector< unsigned char > ToByteVector(const T &in)
Definition: script.h:67
SCRIPT_ERR_NEGATIVE_LOCKTIME
Definition: script_error.h:41
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(script_build)
Definition: script_tests.cpp:431
uint256
256-bit opaque blob.
Definition: uint256.h:201
WitnessMode
WitnessMode
Definition: script_tests.cpp:215
SCRIPT_ERR_CHECKMULTISIGVERIFY
Definition: script_error.h:29
mp::result
auto result
Definition: common-types.h:74
SCRIPT_ERR_SIG_DER
Definition: script_error.h:46
DataFromTransaction
SignatureData DataFromTransaction(const CMutableTransaction &tx, unsigned int nIn, const CTxOut &txout)
Extract signature data from a transaction input, and insert it.
Definition: sign.cpp:610
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
ToScript
CScript ToScript(const T &byte_container)
Definition: script_tests.cpp:1359
CScript
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:414
GetPubKey
static bool GetPubKey(const SigningProvider &provider, const SignatureData &sigdata, const CKeyID &address, CPubKey &pubkey)
Definition: sign.cpp:109
MutableTransactionSignatureCreator::CreateSchnorrSig
bool CreateSchnorrSig(const SigningProvider &provider, std::vector< unsigned char > &sig, const XOnlyPubKey &pubkey, const uint256 *leaf_hash, const uint256 *merkle_root, SigVersion sigversion) const override
Definition: sign.cpp:62
SCRIPT_ERR_PUSH_SIZE
Definition: script_error.h:20
prevector::empty
bool empty() const
Definition: prevector.h:298
TaprootBuilder::Add
TaprootBuilder & Add(int depth, Span< const unsigned char > script, int leaf_version, bool track=true)
Add a new script at a certain depth in the tree.
Definition: signingprovider.cpp:371
OP_3
Definition: script.h:86
TxOutsFromJSON
static std::vector< CTxOut > TxOutsFromJSON(const UniValue &univalue)
Definition: script_tests.cpp:1507
MAX_SCRIPT_ELEMENT_SIZE
static const unsigned int MAX_SCRIPT_ELEMENT_SIZE
Definition: script.h:28
SignatureHash
uint256 SignatureHash(const CScript &scriptCode, const T &txTo, unsigned int nIn, int32_t nHashType, const CAmount &amount, SigVersion sigversion, const PrecomputedTransactionData *cache)
Definition: interpreter.cpp:1568
SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY
Definition: script_error.h:65
ScriptErrorDesc::name
const char * name
Definition: script_tests.cpp:48
HexStr
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition: hex_base.cpp:29
ValueFromAmount
UniValue ValueFromAmount(const CAmount amount)
Definition: core_write.cpp:26
SCRIPT_ERR_WITNESS_UNEXPECTED
Definition: script_error.h:69
ComputeTapbranchHash
uint256 ComputeTapbranchHash(Span< const unsigned char > a, Span< const unsigned char > b)
Compute the BIP341 tapbranch hash from two branches.
Definition: interpreter.cpp:1833
MakeUCharSpan
constexpr auto MakeUCharSpan(V &&v) -> decltype(UCharSpanCast(Span
Like the Span constructor, but for (const) unsigned char member types only.
Definition: span.h:296
AllConsensusFlags
static std::vector< unsigned int > AllConsensusFlags()
Definition: script_tests.cpp:1530
uint160
160-bit opaque blob.
Definition: uint256.h:189
ProduceSignature
bool ProduceSignature(const SigningProvider &provider, const BaseSignatureCreator &creator, const CScript &fromPubKey, SignatureData &sigdata)
Produce a script signature using a generic signature creator.
Definition: sign.cpp:502
prevector::begin
iterator begin()
Definition: prevector.h:302
FormatScriptFlags
std::string FormatScriptFlags(unsigned int flags)
Definition: transaction_tests.cpp:101
ALL_CONSENSUS_FLAGS
static const std::vector< unsigned int > ALL_CONSENSUS_FLAGS
Precomputed list of all valid combinations of consensus-relevant script validation flags...
Definition: script_tests.cpp:1556
test_vectors_musig2_generate.s
tuple s
Definition: test_vectors_musig2_generate.py:72
CScriptID
A reference to a CScript: the Hash160 of its serialization.
Definition: script.h:601
CMutableTransaction
A mutable version of CTransaction.
Definition: transaction.h:377
prevector::size
size_type size() const
Definition: prevector.h:294
OP_2
Definition: script.h:85
DEFAULT_SIGNATURE_CACHE_BYTES
static constexpr size_t DEFAULT_SIGNATURE_CACHE_BYTES
Definition: sigcache.h:29
SCRIPT_ERR_SIG_NULLDUMMY
Definition: script_error.h:50
FormatScriptError
static std::string FormatScriptError(ScriptError_t err)
Definition: script_tests.cpp:97
TryParseHex
std::optional< std::vector< Byte > > TryParseHex(std::string_view str)
Parse the hex string into bytes (uint8_t or std::byte).
Definition: strencodings.cpp:50
UniValue::size
size_t size() const
Definition: univalue.h:71
CPubKey::data
const unsigned char * data() const
Definition: pubkey.h:113
CKey
An encapsulated private key.
Definition: key.h:34
Span
A Span is an object that can refer to a contiguous sequence of objects.
Definition: span.h:97
ScriptTest::DoTest
void DoTest(const CScript &scriptPubKey, const CScript &scriptSig, const CScriptWitness &scriptWitness, uint32_t flags, const std::string &message, int scriptError, CAmount nValue=0)
Definition: script_tests.cpp:116
CTransaction
The basic transaction that is broadcasted on the network and contained in blocks. ...
Definition: transaction.h:295
CHash160
A hasher class for Bitcoin&#39;s 160-bit hash (SHA-256 + RIPEMD-160).
Definition: hash.h:49
SCRIPT_ERR_MINIMALIF
Definition: script_error.h:53
fs::exists
static bool exists(const path &p)
Definition: fs.h:89
CSHA256
A hasher class for SHA-256.
Definition: sha256.h:13
ParseScript
CScript ParseScript(const std::string &s)
Definition: core_read.cpp:63
EvalScript
bool EvalScript(std::vector< std::vector< unsigned char > > &stack, const CScript &script, unsigned int flags, const BaseSignatureChecker &checker, SigVersion sigversion, ScriptExecutionData &execdata, ScriptError *serror)
Definition: interpreter.cpp:406
FindAndDelete
int FindAndDelete(CScript &script, const CScript &b)
Definition: interpreter.cpp:228
Span
Span(T *, EndOrSize) -> Span< T >
fs::path
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
Definition: fs.h:32
CHash160::Write
CHash160 & Write(Span< const unsigned char > input)
Definition: hash.h:62
OP_NOT
Definition: script.h:158
UniValue::isArray
bool isArray() const
Definition: univalue.h:85
SCRIPT_ERR_UNBALANCED_CONDITIONAL
Definition: script_error.h:38
FillableSigningProvider::AddKey
virtual bool AddKey(const CKey &key)
Definition: signingprovider.h:290
Assert
#define Assert(val)
Identity function.
Definition: check.h:85
SignatureData::signatures
std::map< CKeyID, SigPair > signatures
BIP 174 style partial signatures for the input. May contain all signatures necessary for producing a ...
Definition: sign.h:77
OP_4
Definition: script.h:87
TX_WITH_WITNESS
static constexpr TransactionSerParams TX_WITH_WITNESS
Definition: transaction.h:195
TX_NO_WITNESS
static constexpr TransactionSerParams TX_NO_WITNESS
Definition: transaction.h:196
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:17
sign_multisig
static CScript sign_multisig(const CScript &scriptPubKey, const std::vector< CKey > &keys, const CTransaction &transaction)
Definition: script_tests.cpp:1004
SigVersion
SigVersion
Definition: interpreter.h:190
SignatureData::tr_spenddata
TaprootSpendData tr_spenddata
Taproot spending data.
Definition: sign.h:75
Generated on Wed Sep 3 2025 12:00:00 for Bitcoin Core by   doxygen 1.8.14