Bitcoin Core 28.99.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
38using namespace util::hex_literals;
39
40static const unsigned int gFlags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
41
42unsigned int ParseScriptFlags(std::string strFlags);
43std::string FormatScriptFlags(unsigned int flags);
44
45struct ScriptErrorDesc
46{
47 ScriptError_t err;
48 const char *name;
49};
50
51static 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
97static 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
106static 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
115struct ScriptTest : BasicTestingSetup {
116void 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
141void 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
181namespace
182{
183const 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};
184const 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};
185const 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
187struct 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
215enum class WitnessMode {
216 NONE,
217 PKH,
218 SH
219};
220
221class TestBuilder
222{
223private:
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
255public:
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
416std::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
429BOOST_FIXTURE_TEST_SUITE(script_tests, ScriptTest)
430
431BOOST_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
908BOOST_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
951BOOST_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
993BOOST_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
1003static CScript
1004sign_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}
1027static CScript
1028sign_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
1035BOOST_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
1064BOOST_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 */
1133SignatureData 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
1142BOOST_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
1263BOOST_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. */
1284BOOST_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
1296BOOST_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
1317BOOST_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
1328BOOST_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
1358template <typename T>
1359CScript ToScript(const T& byte_container)
1360{
1361 auto span{MakeUCharSpan(byte_container)};
1362 return {span.begin(), span.end()};
1363}
1364
1365static CScript ScriptFromHex(const std::string& str)
1366{
1367 return ToScript(*Assert(TryParseHex(str)));
1368}
1369
1370BOOST_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
1377BOOST_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
1486BOOST_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
1500static CMutableTransaction TxFromHex(const std::string& str)
1501{
1502 CMutableTransaction tx;
1503 SpanReader{ParseHex(str)} >> TX_NO_WITNESS(tx);
1504 return tx;
1505}
1506
1507static 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
1519static 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
1530static 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
1556static const std::vector<unsigned int> ALL_CONSENSUS_FLAGS = AllConsensusFlags();
1557
1558static 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
1605BOOST_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
1635BOOST_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} << Span{ParseHex(input["intermediary"]["sigMsg"].get_str())}).GetSHA256()), input["intermediary"]["sigHash"].get_str());
1704 }
1705
1706 }
1707}
1708
1709BOOST_AUTO_TEST_CASE(compute_tapbranch)
1710{
1711 constexpr uint256 hash1{"8ad69ec7cf41c2a4001fd1f738bf1e505ce2277acdcaa63fe4765192497f47a7"};
1712 constexpr uint256 hash2{"f224a923cd0021ab202ab139cc56802ddb92dcfc172b9212261a539df79a112a"};
1713 constexpr uint256 result{"a64c5b7b943315f9b805d7a7296bedfcfd08919270a1f7a1466e98f8693d8cd9"};
1714 BOOST_CHECK_EQUAL(ComputeTapbranchHash(hash1, hash2), result);
1715}
1716
1717BOOST_AUTO_TEST_CASE(compute_tapleaf)
1718{
1719 constexpr uint8_t script[6] = {'f','o','o','b','a','r'};
1720 constexpr uint256 tlc0{"edbc10c272a1215dcdcc11d605b9027b5ad6ed97cd45521203f136767b5b9c06"};
1721 constexpr uint256 tlc2{"8b5c4f90ae6bf76e259dbef5d8a59df06359c391b59263741b25eca76451b27a"};
1722
1723 BOOST_CHECK_EQUAL(ComputeTapleafHash(0xc0, Span(script)), tlc0);
1724 BOOST_CHECK_EQUAL(ComputeTapleafHash(0xc2, Span(script)), tlc2);
1725}
1726
1727BOOST_AUTO_TEST_SUITE_END()
GetScriptForDestination
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
Definition: addresstype.cpp:166
CAmount
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
ret
int ret
Definition: bitcoin-cli.cpp:1354
AmountFromValue
static CAmount AmountFromValue(const UniValue &value)
Definition: bitcoin-tx.cpp:561
flags
int flags
Definition: bitcoin-tx.cpp:536
Assert
#define Assert(val)
Identity function.
Definition: check.h:85
CHash160
A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160).
Definition: hash.h:49
CHash160::Finalize
void Finalize(Span< unsigned char > output)
Definition: hash.h:55
CHash160::Write
CHash160 & Write(Span< const unsigned char > input)
Definition: hash.h:62
CKey
An encapsulated private key.
Definition: key.h:35
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
CKey::GetPubKey
CPubKey GetPubKey() const
Compute the public key from a private key.
Definition: key.cpp:182
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
COutPoint
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:29
CPubKey
An encapsulated public key.
Definition: pubkey.h:34
CPubKey::data
const unsigned char * data() const
Definition: pubkey.h:113
CPubKey::GetID
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Definition: pubkey.h:164
CPubKey::end
const unsigned char * end() const
Definition: pubkey.h:115
CPubKey::begin
const unsigned char * begin() const
Definition: pubkey.h:114
CSHA256
A hasher class for SHA-256.
Definition: sha256.h:14
CSHA256::Finalize
void Finalize(unsigned char hash[OUTPUT_SIZE])
Definition: sha256.cpp:727
CSHA256::Write
CSHA256 & Write(const unsigned char *data, size_t len)
Definition: sha256.cpp:701
CScript
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:415
CScriptID
A reference to a CScript: the Hash160 of its serialization.
Definition: script.h:602
CTransaction
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:296
CTransaction::vin
const std::vector< CTxIn > vin
Definition: transaction.h:306
CTxOut
An output of a transaction.
Definition: transaction.h:150
CTxOut::scriptPubKey
CScript scriptPubKey
Definition: transaction.h:153
CTxOut::nValue
CAmount nValue
Definition: transaction.h:152
FillableSigningProvider
Fillable signing provider that keeps keys in an address->secret map.
Definition: signingprovider.h:227
FillableSigningProvider::AddCScript
virtual bool AddCScript(const CScript &redeemScript)
Definition: signingprovider.cpp:158
FillableSigningProvider::AddKey
virtual bool AddKey(const CKey &key)
Definition: signingprovider.h:287
HashWriter
A writer stream (for serialization) that computes a 256-bit hash.
Definition: hash.h:101
MutableTransactionSignatureCreator
A signature creator for transactions.
Definition: sign.h:40
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
RandomMixin::randbits
uint64_t randbits(int bits) noexcept
Generate a random (bits)-bit integer.
Definition: random.h:204
SignatureCache
Valid signature cache, to avoid doing expensive ECDSA signature checking twice for every transaction ...
Definition: sigcache.h:39
Span
A Span is an object that can refer to a contiguous sequence of objects.
Definition: span.h:98
SpanReader
Minimal stream for reading from an existing byte array by Span.
Definition: streams.h:101
TaprootBuilder
Utility class to construct Taproot outputs from internal key and script tree.
Definition: signingprovider.h:46
TaprootBuilder::GetOutput
WitnessV1Taproot GetOutput()
Compute scriptPubKey (after Finalize()).
Definition: signingprovider.cpp:400
TaprootBuilder::GetSpendData
TaprootSpendData GetSpendData() const
Compute spending data (after Finalize()).
Definition: signingprovider.cpp:402
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:366
TaprootBuilder::Finalize
TaprootBuilder & Finalize(const XOnlyPubKey &internal_key)
Finalize the construction.
Definition: signingprovider.cpp:389
UniValue::get_str
const std::string & get_str() const
Definition: univalue_get.cpp:66
UniValue::isArray
bool isArray() const
Definition: univalue.h:85
UniValue::VARR
@ VARR
Definition: univalue.h:24
UniValue::write
std::string write(unsigned int prettyIndent=0, unsigned int indentLevel=0) const
Definition: univalue_write.cpp:31
UniValue::size
size_t size() const
Definition: univalue.h:71
UniValue::read
bool read(std::string_view raw)
Definition: univalue_read.cpp:263
UniValue::getInt
Int getInt() const
Definition: univalue.h:138
UniValue::get_array
const UniValue & get_array() const
Definition: univalue_get.cpp:87
UniValue::exists
bool exists(const std::string &key) const
Definition: univalue.h:77
UniValue::get_bool
bool get_bool() const
Definition: univalue_get.cpp:60
UniValue::isObject
bool isObject() const
Definition: univalue.h:86
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
base_blob::IsNull
constexpr bool IsNull() const
Definition: uint256.h:48
base_blob::begin
constexpr unsigned char * begin()
Definition: uint256.h:104
fs::path
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
Definition: fs.h:33
prevector::empty
bool empty() const
Definition: prevector.h:298
prevector::size
size_type size() const
Definition: prevector.h:294
prevector::data
value_type * data()
Definition: prevector.h:533
prevector::begin
iterator begin()
Definition: prevector.h:302
prevector::end
iterator end()
Definition: prevector.h:304
prevector::push_back
void push_back(const T &value)
Definition: prevector.h:444
uint160
160-bit opaque blob.
Definition: uint256.h:178
uint256
256-bit opaque blob.
Definition: uint256.h:190
core_io.h
ParseScript
CScript ParseScript(const std::string &s)
Definition: core_read.cpp:63
FormatScript
std::string FormatScript(const CScript &script)
Definition: core_write.cpp:39
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
ValueFromAmount
UniValue ValueFromAmount(const CAmount amount)
Definition: core_write.cpp:26
BOOST_FIXTURE_TEST_SUITE
BOOST_FIXTURE_TEST_SUITE(cuckoocache_tests, BasicTestingSetup)
Test Suite for CuckooCache.
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
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
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
FindAndDelete
int FindAndDelete(CScript &script, const CScript &b)
Definition: interpreter.cpp:228
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
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
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
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
VerifyScript
bool VerifyScript(const CScript &scriptSig, const CScript &scriptPubKey, const CScriptWitness *witness, unsigned int flags, const BaseSignatureChecker &checker, ScriptError *serror)
Definition: interpreter.cpp:1958
HASHER_TAPSIGHASH
const HashWriter HASHER_TAPSIGHASH
Hasher with tag "TapSighash" pre-fed to it.
Definition: interpreter.cpp:1461
SigVersion
SigVersion
Definition: interpreter.h:191
SigVersion::TAPROOT
@ TAPROOT
Witness v1 with 32-byte program, not BIP16 P2SH-wrapped, key path spending; see BIP 341.
SigVersion::BASE
@ BASE
Bare scripts and BIP16 P2SH-wrapped redeemscripts.
SigVersion::WITNESS_V0
@ WITNESS_V0
Witness v0 (P2WPKH and P2WSH); see BIP 141.
MutableTransactionSignatureChecker
GenericTransactionSignatureChecker< CMutableTransaction > MutableTransactionSignatureChecker
Definition: interpreter.h:307
SCRIPT_VERIFY_NULLDUMMY
@ SCRIPT_VERIFY_NULLDUMMY
Definition: interpreter.h:64
SCRIPT_VERIFY_P2SH
@ SCRIPT_VERIFY_P2SH
Definition: interpreter.h:49
SCRIPT_VERIFY_SIGPUSHONLY
@ SCRIPT_VERIFY_SIGPUSHONLY
Definition: interpreter.h:67
SCRIPT_VERIFY_WITNESS
@ SCRIPT_VERIFY_WITNESS
Definition: interpreter.h:108
SCRIPT_VERIFY_LOW_S
@ SCRIPT_VERIFY_LOW_S
Definition: interpreter.h:61
SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY
@ SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY
Definition: interpreter.h:99
SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
@ SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
Definition: interpreter.h:126
SCRIPT_VERIFY_TAPROOT
@ SCRIPT_VERIFY_TAPROOT
Definition: interpreter.h:134
SCRIPT_VERIFY_STRICTENC
@ SCRIPT_VERIFY_STRICTENC
Definition: interpreter.h:54
SCRIPT_VERIFY_DERSIG
@ SCRIPT_VERIFY_DERSIG
Definition: interpreter.h:57
SCRIPT_VERIFY_CLEANSTACK
@ SCRIPT_VERIFY_CLEANSTACK
Definition: interpreter.h:94
SCRIPT_VERIFY_MINIMALDATA
@ SCRIPT_VERIFY_MINIMALDATA
Definition: interpreter.h:73
SCRIPT_VERIFY_CHECKSEQUENCEVERIFY
@ SCRIPT_VERIFY_CHECKSEQUENCEVERIFY
Definition: interpreter.h:104
SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
@ SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
Definition: interpreter.h:112
SIGHASH_ANYONECANPAY
@ SIGHASH_ANYONECANPAY
Definition: interpreter.h:33
SIGHASH_DEFAULT
@ SIGHASH_DEFAULT
Taproot only; implied when sighash byte is missing, and equivalent to SIGHASH_ALL.
Definition: interpreter.h:35
SIGHASH_ALL
@ SIGHASH_ALL
Definition: interpreter.h:30
SIGHASH_NONE
@ SIGHASH_NONE
Definition: interpreter.h:31
SIGHASH_SINGLE
@ SIGHASH_SINGLE
Definition: interpreter.h:32
MissingDataBehavior::ASSERT_FAIL
@ ASSERT_FAIL
Abort execution through assertion failure (for consensus code)
MissingDataBehavior::FAIL
@ FAIL
Just act as if the signature was invalid.
read_json
UniValue read_json(std::string_view jsondata)
Definition: json.cpp:12
GenerateRandomKey
CKey GenerateRandomKey(bool compressed) noexcept
Definition: key.cpp:352
BCLog::NONE
@ NONE
Definition: logging.h:42
fs::exists
static bool exists(const path &p)
Definition: fs.h:89
fsbridge::fopen
FILE * fopen(const fs::path &p, const char *mode)
Definition: fs.cpp:26
miniscript::Opcode
std::pair< opcodetype, std::vector< unsigned char > > Opcode
Definition: miniscript.h:189
test_vectors_musig2_generate.s
tuple s
Definition: test_vectors_musig2_generate.py:72
test_vectors_musig2_generate.data
data
Definition: test_vectors_musig2_generate.py:98
util::hex_literals
""_hex is a compile-time user-defined literal returning a std::array<std::byte>, equivalent to ParseH...
Definition: strencodings.h:427
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:17
TX_NO_WITNESS
static constexpr TransactionSerParams TX_NO_WITNESS
Definition: transaction.h:196
TX_WITH_WITNESS
static constexpr TransactionSerParams TX_WITH_WITNESS
Definition: transaction.h:195
MakeTransactionRef
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:424
CTransactionRef
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:423
name
const char * name
Definition: rest.cpp:49
MAX_SCRIPT_ELEMENT_SIZE
static const unsigned int MAX_SCRIPT_ELEMENT_SIZE
Definition: script.h:28
opcodetype
opcodetype
Script opcodes.
Definition: script.h:74
OP_2
@ OP_2
Definition: script.h:85
OP_PUSHDATA4
@ OP_PUSHDATA4
Definition: script.h:80
OP_CHECKMULTISIG
@ OP_CHECKMULTISIG
Definition: script.h:192
OP_CHECKSIG
@ OP_CHECKSIG
Definition: script.h:190
OP_CHECKLOCKTIMEVERIFY
@ OP_CHECKLOCKTIMEVERIFY
Definition: script.h:197
OP_NOT
@ OP_NOT
Definition: script.h:158
OP_EQUAL
@ OP_EQUAL
Definition: script.h:146
OP_4
@ OP_4
Definition: script.h:87
OP_DUP
@ OP_DUP
Definition: script.h:125
OP_NOP2
@ OP_NOP2
Definition: script.h:198
OP_NOP8
@ OP_NOP8
Definition: script.h:205
OP_HASH160
@ OP_HASH160
Definition: script.h:187
OP_1
@ OP_1
Definition: script.h:83
OP_PUSHDATA1
@ OP_PUSHDATA1
Definition: script.h:78
OP_3
@ OP_3
Definition: script.h:86
OP_PUSHDATA2
@ OP_PUSHDATA2
Definition: script.h:79
OP_0
@ OP_0
Definition: script.h:76
OP_EQUALVERIFY
@ OP_EQUALVERIFY
Definition: script.h:147
ToByteVector
std::vector< unsigned char > ToByteVector(const T &in)
Definition: script.h:67
ScriptErrorString
std::string ScriptErrorString(const ScriptError serror)
Definition: script_error.cpp:10
script_error.h
ScriptError
enum ScriptError_t ScriptError
ScriptError_t
ScriptError_t
Definition: script_error.h:12
SCRIPT_ERR_OP_CODESEPARATOR
@ SCRIPT_ERR_OP_CODESEPARATOR
Definition: script_error.h:82
SCRIPT_ERR_SIG_PUSHONLY
@ SCRIPT_ERR_SIG_PUSHONLY
Definition: script_error.h:48
SCRIPT_ERR_OP_COUNT
@ SCRIPT_ERR_OP_COUNT
Definition: script_error.h:21
SCRIPT_ERR_EVAL_FALSE
@ SCRIPT_ERR_EVAL_FALSE
Definition: script_error.h:15
SCRIPT_ERR_NUMEQUALVERIFY
@ SCRIPT_ERR_NUMEQUALVERIFY
Definition: script_error.h:31
SCRIPT_ERR_VERIFY
@ SCRIPT_ERR_VERIFY
Definition: script_error.h:27
SCRIPT_ERR_DISABLED_OPCODE
@ SCRIPT_ERR_DISABLED_OPCODE
Definition: script_error.h:35
SCRIPT_ERR_INVALID_ALTSTACK_OPERATION
@ SCRIPT_ERR_INVALID_ALTSTACK_OPERATION
Definition: script_error.h:37
SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
@ SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
Definition: script_error.h:58
SCRIPT_ERR_SCRIPT_SIZE
@ SCRIPT_ERR_SCRIPT_SIZE
Definition: script_error.h:19
SCRIPT_ERR_UNKNOWN_ERROR
@ SCRIPT_ERR_UNKNOWN_ERROR
Definition: script_error.h:14
SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH
@ SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH
Definition: script_error.h:64
SCRIPT_ERR_SIG_HASHTYPE
@ SCRIPT_ERR_SIG_HASHTYPE
Definition: script_error.h:45
SCRIPT_ERR_MINIMALDATA
@ SCRIPT_ERR_MINIMALDATA
Definition: script_error.h:47
SCRIPT_ERR_CHECKSIGVERIFY
@ SCRIPT_ERR_CHECKSIGVERIFY
Definition: script_error.h:30
SCRIPT_ERR_STACK_SIZE
@ SCRIPT_ERR_STACK_SIZE
Definition: script_error.h:22
SCRIPT_ERR_WITNESS_MALLEATED_P2SH
@ SCRIPT_ERR_WITNESS_MALLEATED_P2SH
Definition: script_error.h:68
SCRIPT_ERR_WITNESS_MALLEATED
@ SCRIPT_ERR_WITNESS_MALLEATED
Definition: script_error.h:67
SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS
@ SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS
Definition: script_error.h:57
SCRIPT_ERR_EQUALVERIFY
@ SCRIPT_ERR_EQUALVERIFY
Definition: script_error.h:28
SCRIPT_ERR_INVALID_STACK_OPERATION
@ SCRIPT_ERR_INVALID_STACK_OPERATION
Definition: script_error.h:36
SCRIPT_ERR_SIG_COUNT
@ SCRIPT_ERR_SIG_COUNT
Definition: script_error.h:23
SCRIPT_ERR_SIG_HIGH_S
@ SCRIPT_ERR_SIG_HIGH_S
Definition: script_error.h:49
SCRIPT_ERR_SIG_DER
@ SCRIPT_ERR_SIG_DER
Definition: script_error.h:46
SCRIPT_ERR_WITNESS_UNEXPECTED
@ SCRIPT_ERR_WITNESS_UNEXPECTED
Definition: script_error.h:69
SCRIPT_ERR_NEGATIVE_LOCKTIME
@ SCRIPT_ERR_NEGATIVE_LOCKTIME
Definition: script_error.h:41
SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH
@ SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH
Definition: script_error.h:66
SCRIPT_ERR_OP_RETURN
@ SCRIPT_ERR_OP_RETURN
Definition: script_error.h:16
SCRIPT_ERR_PUSH_SIZE
@ SCRIPT_ERR_PUSH_SIZE
Definition: script_error.h:20
SCRIPT_ERR_SIG_NULLFAIL
@ SCRIPT_ERR_SIG_NULLFAIL
Definition: script_error.h:54
SCRIPT_ERR_OK
@ SCRIPT_ERR_OK
Definition: script_error.h:13
SCRIPT_ERR_SIG_NULLDUMMY
@ SCRIPT_ERR_SIG_NULLDUMMY
Definition: script_error.h:50
SCRIPT_ERR_PUBKEYTYPE
@ SCRIPT_ERR_PUBKEYTYPE
Definition: script_error.h:51
SCRIPT_ERR_CHECKMULTISIGVERIFY
@ SCRIPT_ERR_CHECKMULTISIGVERIFY
Definition: script_error.h:29
SCRIPT_ERR_UNSATISFIED_LOCKTIME
@ SCRIPT_ERR_UNSATISFIED_LOCKTIME
Definition: script_error.h:42
SCRIPT_ERR_WITNESS_PUBKEYTYPE
@ SCRIPT_ERR_WITNESS_PUBKEYTYPE
Definition: script_error.h:70
SCRIPT_ERR_SIG_FINDANDDELETE
@ SCRIPT_ERR_SIG_FINDANDDELETE
Definition: script_error.h:83
SCRIPT_ERR_BAD_OPCODE
@ SCRIPT_ERR_BAD_OPCODE
Definition: script_error.h:34
SCRIPT_ERR_PUBKEY_COUNT
@ SCRIPT_ERR_PUBKEY_COUNT
Definition: script_error.h:24
SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY
@ SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY
Definition: script_error.h:65
SCRIPT_ERR_CLEANSTACK
@ SCRIPT_ERR_CLEANSTACK
Definition: script_error.h:52
SCRIPT_ERR_UNBALANCED_CONDITIONAL
@ SCRIPT_ERR_UNBALANCED_CONDITIONAL
Definition: script_error.h:38
SCRIPT_ERR_MINIMALIF
@ SCRIPT_ERR_MINIMALIF
Definition: script_error.h:53
FormatScriptError
static std::string FormatScriptError(ScriptError_t err)
Definition: script_tests.cpp:97
NegateSignatureS
static void NegateSignatureS(std::vector< unsigned char > &vchSig)
Definition: script_tests.cpp:141
ParseScriptError
static ScriptError_t ParseScriptError(const std::string &name)
Definition: script_tests.cpp:106
ScriptFromHex
static CScript ScriptFromHex(const std::string &str)
Definition: script_tests.cpp:1365
CombineSignatures
SignatureData CombineSignatures(const CTxOut &txout, const CMutableTransaction &tx, const SignatureData &scriptSig1, const SignatureData &scriptSig2)
Definition: script_tests.cpp:1133
script_errors
static ScriptErrorDesc script_errors[]
Definition: script_tests.cpp:51
TxFromHex
static CMutableTransaction TxFromHex(const std::string &str)
Definition: script_tests.cpp:1500
ToScript
CScript ToScript(const T &byte_container)
Definition: script_tests.cpp:1359
sign_multisig
static CScript sign_multisig(const CScript &scriptPubKey, const std::vector< CKey > &keys, const CTransaction &transaction)
Definition: script_tests.cpp:1004
ParseScriptFlags
unsigned int ParseScriptFlags(std::string strFlags)
Definition: transaction_tests.cpp:75
AllConsensusFlags
static std::vector< unsigned int > AllConsensusFlags()
Definition: script_tests.cpp:1530
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(script_build)
Definition: script_tests.cpp:431
FormatScriptFlags
std::string FormatScriptFlags(unsigned int flags)
Definition: transaction_tests.cpp:100
gFlags
static const unsigned int gFlags
Definition: script_tests.cpp:40
TxOutsFromJSON
static std::vector< CTxOut > TxOutsFromJSON(const UniValue &univalue)
Definition: script_tests.cpp:1507
AssetTest
static void AssetTest(const UniValue &test, SignatureCache &signature_cache)
Definition: script_tests.cpp:1558
ScriptWitnessFromJSON
static CScriptWitness ScriptWitnessFromJSON(const UniValue &univalue)
Definition: script_tests.cpp:1519
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
setup_common.h
DEFAULT_SIGNATURE_CACHE_BYTES
static constexpr size_t DEFAULT_SIGNATURE_CACHE_BYTES
Definition: sigcache.h:29
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
GetPubKey
static bool GetPubKey(const SigningProvider &provider, const SignatureData &sigdata, const CKeyID &address, CPubKey &pubkey)
Definition: sign.cpp:109
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
SigPair
std::pair< CPubKey, std::vector< unsigned char > > SigPair
Definition: sign.h:63
DUMMY_SIGNING_PROVIDER
const SigningProvider & DUMMY_SIGNING_PROVIDER
Definition: signingprovider.cpp:12
GetScriptForMultisig
CScript GetScriptForMultisig(int nRequired, const std::vector< CPubKey > &keys)
Generate a multisig script.
Definition: solver.cpp:218
MakeUCharSpan
constexpr auto MakeUCharSpan(V &&v) -> decltype(UCharSpanCast(Span{std::forward< V >(v)}))
Like the Span constructor, but for (const) unsigned char member types only.
Definition: span.h:297
Span
Span(T *, EndOrSize) -> Span< T >
ParseHex
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
Definition: strencodings.h:68
BasicTestingSetup
Basic testing setup.
Definition: setup_common.h:63
BasicTestingSetup::m_rng
FastRandomContext m_rng
Definition: setup_common.h:67
CMutableTransaction
A mutable version of CTransaction.
Definition: transaction.h:378
CMutableTransaction::vout
std::vector< CTxOut > vout
Definition: transaction.h:380
CMutableTransaction::GetHash
Txid GetHash() const
Compute the hash of this CMutableTransaction.
Definition: transaction.cpp:69
CMutableTransaction::vin
std::vector< CTxIn > vin
Definition: transaction.h:379
CScriptWitness::stack
std::vector< std::vector< unsigned char > > stack
Definition: script.h:588
FlatSigningProvider::keys
std::map< CKeyID, CKey > keys
Definition: signingprovider.h:212
Num
A type to represent integers in the type system.
Definition: lintrans.h:13
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
PrecomputedTransactionData::m_bip341_taproot_ready
bool m_bip341_taproot_ready
Whether the 5 fields above are initialized.
Definition: interpreter.h:163
ScriptErrorDesc::err
ScriptError_t err
Definition: script_tests.cpp:47
ScriptErrorDesc::name
const char * name
Definition: script_tests.cpp:48
ScriptExecutionData::m_annex_present
bool m_annex_present
Whether an annex is present.
Definition: interpreter.h:213
ScriptExecutionData::m_annex_init
bool m_annex_init
Whether m_annex_present and (when needed) m_annex_hash are initialized.
Definition: interpreter.h:211
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
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
SignatureData::tr_spenddata
TaprootSpendData tr_spenddata
Taproot spending data.
Definition: sign.h:75
SignatureData::scriptSig
CScript scriptSig
The scriptSig of an input. Contains complete signatures or the traditional partial signatures format.
Definition: sign.h:71
strprintf
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1165
BuildSpendingTransaction
CMutableTransaction BuildSpendingTransaction(const CScript &scriptSig, const CScriptWitness &scriptWitness, const CTransaction &txCredit)
Definition: transaction_utils.cpp:26
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
BuildCreditingTransaction
CMutableTransaction BuildCreditingTransaction(const CScript &scriptPubKey, int nValue)
Definition: transaction_utils.cpp:10
transaction_utils.h
expect
#define expect(bit)
Definition: univalue_read.cpp:259
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
assert
assert(!tx.IsCoinBase())
Generated on Wed Dec 18 2024 20:00:14 for Bitcoin Core by doxygen 1.9.4