Bitcoin Core  31.0.0
P2P Digital Currency
script_standard_tests.cpp
Go to the documentation of this file.
1 // Copyright (c) 2017-present 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/bip341_wallet_vectors.json.h>
6 
7 #include <addresstype.h>
8 #include <key.h>
9 #include <key_io.h>
10 #include <script/script.h>
11 #include <script/signingprovider.h>
12 #include <script/solver.h>
13 #include <test/util/common.h>
14 #include <test/util/setup_common.h>
15 #include <util/strencodings.h>
16 
17 #include <boost/test/unit_test.hpp>
18 
19 #include <univalue.h>
20 
21 using namespace util::hex_literals;
22 
23 BOOST_FIXTURE_TEST_SUITE(script_standard_tests, BasicTestingSetup)
24 
25 BOOST_AUTO_TEST_CASE(dest_default_is_no_dest)
26 {
27  CTxDestination dest;
28  BOOST_CHECK(!IsValidDestination(dest));
29 }
30 
31 BOOST_AUTO_TEST_CASE(script_standard_Solver_success)
32 {
33  CKey keys[3];
34  CPubKey pubkeys[3];
35  for (int i = 0; i < 3; i++) {
36  keys[i].MakeNewKey(true);
37  pubkeys[i] = keys[i].GetPubKey();
38  }
39 
40  CScript s;
41  std::vector<std::vector<unsigned char> > solutions;
42 
43  // TxoutType::PUBKEY
44  s.clear();
45  s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
46  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::PUBKEY);
47  BOOST_CHECK_EQUAL(solutions.size(), 1U);
48  BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0]));
49 
50  // TxoutType::PUBKEYHASH
51  s.clear();
52  s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
53  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::PUBKEYHASH);
54  BOOST_CHECK_EQUAL(solutions.size(), 1U);
55  BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
56 
57  // TxoutType::SCRIPTHASH
58  CScript redeemScript(s); // initialize with leftover P2PKH script
59  s.clear();
60  s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
61  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::SCRIPTHASH);
62  BOOST_CHECK_EQUAL(solutions.size(), 1U);
63  BOOST_CHECK(solutions[0] == ToByteVector(CScriptID(redeemScript)));
64 
65  // TxoutType::MULTISIG
66  s.clear();
67  s << OP_1 <<
68  ToByteVector(pubkeys[0]) <<
69  ToByteVector(pubkeys[1]) <<
70  OP_2 << OP_CHECKMULTISIG;
71  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::MULTISIG);
72  BOOST_CHECK_EQUAL(solutions.size(), 4U);
73  BOOST_CHECK(solutions[0] == std::vector<unsigned char>({1}));
74  BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
75  BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
76  BOOST_CHECK(solutions[3] == std::vector<unsigned char>({2}));
77 
78  s.clear();
79  s << OP_2 <<
80  ToByteVector(pubkeys[0]) <<
81  ToByteVector(pubkeys[1]) <<
82  ToByteVector(pubkeys[2]) <<
83  OP_3 << OP_CHECKMULTISIG;
84  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::MULTISIG);
85  BOOST_CHECK_EQUAL(solutions.size(), 5U);
86  BOOST_CHECK(solutions[0] == std::vector<unsigned char>({2}));
87  BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
88  BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
89  BOOST_CHECK(solutions[3] == ToByteVector(pubkeys[2]));
90  BOOST_CHECK(solutions[4] == std::vector<unsigned char>({3}));
91 
92  // TxoutType::NULL_DATA
93  s.clear();
94  s << OP_RETURN <<
95  std::vector<unsigned char>({0}) <<
96  std::vector<unsigned char>({75}) <<
97  std::vector<unsigned char>({255});
98  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NULL_DATA);
99  BOOST_CHECK_EQUAL(solutions.size(), 0U);
100 
101  // TxoutType::WITNESS_V0_KEYHASH
102  s.clear();
103  s << OP_0 << ToByteVector(pubkeys[0].GetID());
104  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V0_KEYHASH);
105  BOOST_CHECK_EQUAL(solutions.size(), 1U);
106  BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
107 
108  // TxoutType::WITNESS_V0_SCRIPTHASH
109  uint256 scriptHash;
110  CSHA256().Write(redeemScript.data(), redeemScript.size())
111  .Finalize(scriptHash.begin());
112 
113  s.clear();
114  s << OP_0 << ToByteVector(scriptHash);
115  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V0_SCRIPTHASH);
116  BOOST_CHECK_EQUAL(solutions.size(), 1U);
117  BOOST_CHECK(solutions[0] == ToByteVector(scriptHash));
118 
119  // TxoutType::WITNESS_V1_TAPROOT
120  s.clear();
121  s << OP_1 << ToByteVector(uint256::ZERO);
122  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V1_TAPROOT);
123  BOOST_CHECK_EQUAL(solutions.size(), 1U);
124  BOOST_CHECK(solutions[0] == ToByteVector(uint256::ZERO));
125 
126  // TxoutType::WITNESS_UNKNOWN
127  s.clear();
128  s << OP_16 << ToByteVector(uint256::ONE);
129  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);
130  BOOST_CHECK_EQUAL(solutions.size(), 2U);
131  BOOST_CHECK(solutions[0] == std::vector<unsigned char>{16});
132  BOOST_CHECK(solutions[1] == ToByteVector(uint256::ONE));
133 
134  // TxoutType::ANCHOR
135  s.clear();
136  s << OP_1 << ANCHOR_BYTES;
137  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::ANCHOR);
138  BOOST_CHECK(solutions.empty());
139 
140  // Sanity-check IsPayToAnchor
141  int version{-1};
142  std::vector<unsigned char> witness_program;
143  BOOST_CHECK(s.IsPayToAnchor());
144  BOOST_CHECK(s.IsWitnessProgram(version, witness_program));
145  BOOST_CHECK(CScript::IsPayToAnchor(version, witness_program));
146 
147  // TxoutType::NONSTANDARD
148  s.clear();
149  s << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
150  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
151 }
152 
153 BOOST_AUTO_TEST_CASE(script_standard_Solver_failure)
154 {
155  CKey key = GenerateRandomKey();
156  CPubKey pubkey = key.GetPubKey();
157 
158  CScript s;
159  std::vector<std::vector<unsigned char> > solutions;
160 
161  // TxoutType::PUBKEY with incorrectly sized pubkey
162  s.clear();
163  s << std::vector<unsigned char>(30, 0x01) << OP_CHECKSIG;
164  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
165 
166  // TxoutType::PUBKEYHASH with incorrectly sized key hash
167  s.clear();
168  s << OP_DUP << OP_HASH160 << ToByteVector(pubkey) << OP_EQUALVERIFY << OP_CHECKSIG;
169  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
170 
171  // TxoutType::SCRIPTHASH with incorrectly sized script hash
172  s.clear();
173  s << OP_HASH160 << std::vector<unsigned char>(21, 0x01) << OP_EQUAL;
174  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
175 
176  // TxoutType::MULTISIG 0/2
177  s.clear();
178  s << OP_0 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
179  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
180 
181  // TxoutType::MULTISIG 2/1
182  s.clear();
183  s << OP_2 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
184  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
185 
186  // TxoutType::MULTISIG n = 2 with 1 pubkey
187  s.clear();
188  s << OP_1 << ToByteVector(pubkey) << OP_2 << OP_CHECKMULTISIG;
189  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
190 
191  // TxoutType::MULTISIG n = 1 with 0 pubkeys
192  s.clear();
193  s << OP_1 << OP_1 << OP_CHECKMULTISIG;
194  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
195 
196  // TxoutType::NULL_DATA with other opcodes
197  s.clear();
198  s << OP_RETURN << std::vector<unsigned char>({75}) << OP_ADD;
199  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
200 
201  // TxoutType::WITNESS_V0_{KEY,SCRIPT}HASH with incorrect program size (-> consensus-invalid, i.e. non-standard)
202  s.clear();
203  s << OP_0 << std::vector<unsigned char>(19, 0x01);
204  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
205 
206  // TxoutType::WITNESS_V1_TAPROOT with incorrect program size (-> undefined, but still policy-valid)
207  s.clear();
208  s << OP_1 << std::vector<unsigned char>(31, 0x01);
209  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);
210  s.clear();
211  s << OP_1 << std::vector<unsigned char>(33, 0x01);
212  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);
213 
214  // TxoutType::ANCHOR but wrong witness version
215  s.clear();
216  s << OP_2 << ANCHOR_BYTES;
217  BOOST_CHECK(!s.IsPayToAnchor());
218  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);
219 
220  // TxoutType::ANCHOR but wrong 2-byte data push
221  s.clear();
222  s << OP_1 << std::vector<unsigned char>{0xff, 0xff};
223  BOOST_CHECK(!s.IsPayToAnchor());
224  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);
225 }
226 
227 BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
228 {
229  CKey key = GenerateRandomKey();
230  CPubKey pubkey = key.GetPubKey();
231 
232  CScript s;
233  CTxDestination address;
234 
235  // TxoutType::PUBKEY
236  s.clear();
237  s << ToByteVector(pubkey) << OP_CHECKSIG;
238  BOOST_CHECK(!ExtractDestination(s, address));
239  BOOST_CHECK(std::get<PubKeyDestination>(address) == PubKeyDestination(pubkey));
240 
241  // TxoutType::PUBKEYHASH
242  s.clear();
243  s << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
244  BOOST_CHECK(ExtractDestination(s, address));
245  BOOST_CHECK(std::get<PKHash>(address) == PKHash(pubkey));
246 
247  // TxoutType::SCRIPTHASH
248  CScript redeemScript(s); // initialize with leftover P2PKH script
249  s.clear();
250  s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
251  BOOST_CHECK(ExtractDestination(s, address));
252  BOOST_CHECK(std::get<ScriptHash>(address) == ScriptHash(redeemScript));
253 
254  // TxoutType::MULTISIG
255  s.clear();
256  s << OP_1 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
257  BOOST_CHECK(!ExtractDestination(s, address));
258 
259  // TxoutType::NULL_DATA
260  s.clear();
261  s << OP_RETURN << std::vector<unsigned char>({75});
262  BOOST_CHECK(!ExtractDestination(s, address));
263 
264  // TxoutType::WITNESS_V0_KEYHASH
265  s.clear();
266  s << OP_0 << ToByteVector(pubkey.GetID());
267  BOOST_CHECK(ExtractDestination(s, address));
268  WitnessV0KeyHash keyhash;
269  CHash160().Write(pubkey).Finalize(keyhash);
270  BOOST_CHECK(std::get<WitnessV0KeyHash>(address) == keyhash);
271 
272  // TxoutType::WITNESS_V0_SCRIPTHASH
273  s.clear();
274  WitnessV0ScriptHash scripthash;
275  CSHA256().Write(redeemScript.data(), redeemScript.size()).Finalize(scripthash.begin());
276  s << OP_0 << ToByteVector(scripthash);
277  BOOST_CHECK(ExtractDestination(s, address));
278  BOOST_CHECK(std::get<WitnessV0ScriptHash>(address) == scripthash);
279 
280  // TxoutType::WITNESS_V1_TAPROOT
281  s.clear();
282  auto xpk = XOnlyPubKey(pubkey);
283  s << OP_1 << ToByteVector(xpk);
284  BOOST_CHECK(ExtractDestination(s, address));
285  BOOST_CHECK(std::get<WitnessV1Taproot>(address) == WitnessV1Taproot(xpk));
286 
287  // TxoutType::ANCHOR
288  s.clear();
289  s << OP_1 << ANCHOR_BYTES;
290  BOOST_CHECK(ExtractDestination(s, address));
291  BOOST_CHECK(std::get<PayToAnchor>(address) == PayToAnchor());
292 
293  // TxoutType::WITNESS_UNKNOWN with unknown version
294  // -> segwit version 1 with an undefined program size (33 bytes in this test case)
295  s.clear();
296  s << OP_1 << ToByteVector(pubkey);
297  BOOST_CHECK(ExtractDestination(s, address));
298  WitnessUnknown unk_v1{1, ToByteVector(pubkey)};
299  BOOST_CHECK(std::get<WitnessUnknown>(address) == unk_v1);
300  s.clear();
301  // -> segwit versions 2+ are not specified yet
302  s << OP_2 << ToByteVector(xpk);
303  BOOST_CHECK(ExtractDestination(s, address));
304  WitnessUnknown unk_v2{2, ToByteVector(xpk)};
305  BOOST_CHECK(std::get<WitnessUnknown>(address) == unk_v2);
306 }
307 
308 BOOST_AUTO_TEST_CASE(script_standard_GetScriptFor_)
309 {
310  CKey keys[3];
311  CPubKey pubkeys[3];
312  for (int i = 0; i < 3; i++) {
313  keys[i].MakeNewKey(true);
314  pubkeys[i] = keys[i].GetPubKey();
315  }
316 
317  CScript expected, result;
318 
319  // PKHash
320  expected.clear();
321  expected << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
322  result = GetScriptForDestination(PKHash(pubkeys[0]));
323  BOOST_CHECK(result == expected);
324 
325  // CScriptID
326  CScript redeemScript(result);
327  expected.clear();
328  expected << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
329  result = GetScriptForDestination(ScriptHash(redeemScript));
330  BOOST_CHECK(result == expected);
331 
332  // CNoDestination
333  expected.clear();
334  result = GetScriptForDestination(CNoDestination());
335  BOOST_CHECK(result == expected);
336 
337  // GetScriptForRawPubKey
338  expected.clear();
339  expected << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
340  result = GetScriptForRawPubKey(pubkeys[0]);
341  BOOST_CHECK(result == expected);
342 
343  // GetScriptForMultisig
344  expected.clear();
345  expected << OP_2 <<
346  ToByteVector(pubkeys[0]) <<
347  ToByteVector(pubkeys[1]) <<
348  ToByteVector(pubkeys[2]) <<
349  OP_3 << OP_CHECKMULTISIG;
350  result = GetScriptForMultisig(2, std::vector<CPubKey>(pubkeys, pubkeys + 3));
351  BOOST_CHECK(result == expected);
352 
353  // WitnessV0KeyHash
354  expected.clear();
355  expected << OP_0 << ToByteVector(pubkeys[0].GetID());
356  result = GetScriptForDestination(WitnessV0KeyHash(Hash160(ToByteVector(pubkeys[0]))));
357  BOOST_CHECK(result == expected);
358  result = GetScriptForDestination(WitnessV0KeyHash(pubkeys[0].GetID()));
359  BOOST_CHECK(result == expected);
360 
361  // WitnessV0ScriptHash (multisig)
362  CScript witnessScript;
363  witnessScript << OP_1 << ToByteVector(pubkeys[0]) << OP_1 << OP_CHECKMULTISIG;
364 
365  uint256 scriptHash;
366  CSHA256().Write(witnessScript.data(), witnessScript.size())
367  .Finalize(scriptHash.begin());
368 
369  expected.clear();
370  expected << OP_0 << ToByteVector(scriptHash);
371  result = GetScriptForDestination(WitnessV0ScriptHash(witnessScript));
372  BOOST_CHECK(result == expected);
373 
374  // WitnessV1Taproot
375  auto xpk = XOnlyPubKey(pubkeys[0]);
376  expected.clear();
377  expected << OP_1 << ToByteVector(xpk);
378  result = GetScriptForDestination(WitnessV1Taproot(xpk));
379  BOOST_CHECK(result == expected);
380 
381  // PayToAnchor
382  expected.clear();
383  expected << OP_1 << ANCHOR_BYTES;
384  result = GetScriptForDestination(PayToAnchor());
385  BOOST_CHECK(result == expected);
386 }
387 
388 BOOST_AUTO_TEST_CASE(script_standard_taproot_builder)
389 {
390  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({}), true);
391  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0}), true);
392  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1}), false);
393  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2}), false);
394  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0}), false);
395  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1}), false);
396  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2}), false);
397  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0}), false);
398  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1}), true);
399  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2}), false);
400  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0}), false);
401  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1}), false);
402  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2}), false);
403  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0,0}), false);
404  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0,1}), false);
405  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0,2}), false);
406  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1,0}), false);
407  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1,1}), false);
408  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1,2}), false);
409  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2,0}), false);
410  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2,1}), false);
411  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2,2}), false);
412  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0,0}), false);
413  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0,1}), false);
414  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0,2}), false);
415  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1,0}), false);
416  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1,1}), false);
417  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1,2}), false);
418  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2,0}), false);
419  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2,1}), false);
420  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2,2}), true);
421  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0,0}), false);
422  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0,1}), false);
423  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0,2}), false);
424  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1,0}), false);
425  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1,1}), false);
426  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1,2}), false);
427  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,0}), false);
428  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,1}), true);
429  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,2}), false);
430  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,2,3,4,5,6,7,8,9,10,11,12,14,14,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,31,31,31,31,31,31,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,128}), true);
431  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({128,128,127,126,125,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,109,108,107,106,105,104,103,102,101,100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1}), true);
432  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({129,129,128,127,126,125,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,109,108,107,106,105,104,103,102,101,100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1}), false);
433 
434  XOnlyPubKey key_inner{"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"_hex_u8};
435  XOnlyPubKey key_1{"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5"_hex_u8};
436  XOnlyPubKey key_2{"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9"_hex_u8};
437  CScript script_1 = CScript() << ToByteVector(key_1) << OP_CHECKSIG;
438  CScript script_2 = CScript() << ToByteVector(key_2) << OP_CHECKSIG;
439  constexpr uint256 hash_3{"31fe7061656bea2a36aa60a2f7ef940578049273746935d296426dc0afd86b68"};
440 
441  TaprootBuilder builder;
442  BOOST_CHECK(builder.IsValid() && builder.IsComplete());
443  builder.Add(2, script_2, 0xc0);
444  BOOST_CHECK(builder.IsValid() && !builder.IsComplete());
445  builder.AddOmitted(2, hash_3);
446  BOOST_CHECK(builder.IsValid() && !builder.IsComplete());
447  builder.Add(1, script_1, 0xc0);
448  BOOST_CHECK(builder.IsValid() && builder.IsComplete());
449  builder.Finalize(key_inner);
450  BOOST_CHECK(builder.IsValid() && builder.IsComplete());
451  BOOST_CHECK_EQUAL(EncodeDestination(builder.GetOutput()), "bc1pj6gaw944fy0xpmzzu45ugqde4rz7mqj5kj0tg8kmr5f0pjq8vnaqgynnge");
452 }
453 
454 BOOST_AUTO_TEST_CASE(bip341_spk_test_vectors)
455 {
456  using control_set = decltype(TaprootSpendData::scripts)::mapped_type;
457 
458  UniValue tests;
459  tests.read(json_tests::bip341_wallet_vectors);
460 
461  const auto& vectors = tests["scriptPubKey"];
462 
463  for (const auto& vec : vectors.getValues()) {
464  TaprootBuilder spktest;
465  std::map<std::pair<std::vector<unsigned char>, int>, int> scriptposes;
466  std::function<void (const UniValue&, int)> parse_tree = [&](const UniValue& node, int depth) {
467  if (node.isNull()) return;
468  if (node.isObject()) {
469  auto script = ParseHex(node["script"].get_str());
470  int idx = node["id"].getInt<int>();
471  int leaf_version = node["leafVersion"].getInt<int>();
472  scriptposes[{script, leaf_version}] = idx;
473  spktest.Add(depth, script, leaf_version);
474  } else {
475  parse_tree(node[0], depth + 1);
476  parse_tree(node[1], depth + 1);
477  }
478  };
479  parse_tree(vec["given"]["scriptTree"], 0);
480  spktest.Finalize(XOnlyPubKey(ParseHex(vec["given"]["internalPubkey"].get_str())));
481  BOOST_CHECK_EQUAL(HexStr(GetScriptForDestination(spktest.GetOutput())), vec["expected"]["scriptPubKey"].get_str());
482  BOOST_CHECK_EQUAL(EncodeDestination(spktest.GetOutput()), vec["expected"]["bip350Address"].get_str());
483  auto spend_data = spktest.GetSpendData();
484  BOOST_CHECK_EQUAL(vec["intermediary"]["merkleRoot"].isNull(), spend_data.merkle_root.IsNull());
485  if (!spend_data.merkle_root.IsNull()) {
486  BOOST_CHECK_EQUAL(vec["intermediary"]["merkleRoot"].get_str(), HexStr(spend_data.merkle_root));
487  }
488  BOOST_CHECK_EQUAL(spend_data.scripts.size(), scriptposes.size());
489  for (const auto& scriptpos : scriptposes) {
490  BOOST_CHECK(spend_data.scripts[scriptpos.first] == control_set{ParseHex(vec["expected"]["scriptPathControlBlocks"][scriptpos.second].get_str())});
491  }
492  }
493 }
494 
495 BOOST_AUTO_TEST_SUITE_END()
CSHA256::Write
CSHA256 & Write(const unsigned char *data, size_t len)
Definition: sha256.cpp:699
GetScriptForMultisig
CScript GetScriptForMultisig(int nRequired, const std::vector< CPubKey > &keys)
Generate a multisig script.
Definition: solver.cpp:218
BaseHash::begin
unsigned char * begin()
Definition: hash_type.h:18
uint256::ONE
static const uint256 ONE
Definition: uint256.h:204
ParseHex
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
Definition: strencodings.h:69
CHash160::Write
CHash160 & Write(std::span< const unsigned char > input)
Definition: hash.h:62
IsValidDestination
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination corresponds to one with an address.
Definition: addresstype.cpp:171
OP_DUP
Definition: script.h:125
CKey::GetPubKey
CPubKey GetPubKey() const
Compute the public key from a private key.
Definition: key.cpp:183
Solver
TxoutType Solver(const CScript &scriptPubKey, std::vector< std::vector< unsigned char >> &vSolutionsRet)
Parse a scriptPubKey and identify script type for standard scripts.
Definition: solver.cpp:141
OP_ADD
Definition: script.h:161
TaprootBuilder::AddOmitted
TaprootBuilder & AddOmitted(int depth, const uint256 &hash)
Like Add(), but for a Merkle node with a given hash to the tree.
Definition: signingprovider.cpp:446
ANCHOR_BYTES
static const std::vector< unsigned char > ANCHOR_BYTES
Witness program for Pay-to-Anchor output script type.
Definition: addresstype.h:121
OP_0
Definition: script.h:76
CPubKey::GetID
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Definition: pubkey.h:160
prevector::data
value_type * data()
Definition: prevector.h:477
BasicTestingSetup
Basic testing setup.
Definition: setup_common.h:64
base_blob::begin
constexpr unsigned char * begin()
Definition: uint256.h:100
OP_1
Definition: script.h:83
GenerateRandomKey
CKey GenerateRandomKey(bool compressed) noexcept
Definition: key.cpp:475
tests
constexpr std::array tests
Definition: unitester.cpp:101
OP_11
Definition: script.h:94
TxoutType::ANCHOR
anyone can spend script
key_io.h
TaprootSpendData::scripts
std::map< std::pair< std::vector< unsigned char >, int >, std::set< std::vector< unsigned char >, ShortestVectorFirstComparator > > scripts
Map from (script, leaf_version) to (sets of) control blocks.
Definition: signingprovider.h:43
ExtractDestination
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a scriptPubKey for the destination.
Definition: addresstype.cpp:49
BOOST_FIXTURE_TEST_SUITE
BOOST_FIXTURE_TEST_SUITE(cuckoocache_tests, BasicTestingSetup)
Test Suite for CuckooCache.
WitnessUnknown
CTxDestination subtype to encode any future Witness version.
Definition: addresstype.h:95
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
setup_common.h
TaprootBuilder::Finalize
TaprootBuilder & Finalize(const XOnlyPubKey &internal_key)
Finalize the construction.
Definition: signingprovider.cpp:456
CPubKey
An encapsulated public key.
Definition: pubkey.h:33
uint256::ZERO
static const uint256 ZERO
Definition: uint256.h:203
TaprootBuilder::GetOutput
WitnessV1Taproot GetOutput()
Compute scriptPubKey (after Finalize()).
Definition: signingprovider.cpp:467
CKey::MakeNewKey
void MakeNewKey(bool fCompressed)
Generate a new private key using a cryptographic PRNG.
Definition: key.cpp:162
util::hex_literals
""_hex is a compile-time user-defined literal returning a std::array<std::byte>, equivalent to ParseH...
Definition: strencodings.h:400
GetScriptForDestination
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
Definition: addresstype.cpp:166
CScript::IsPayToAnchor
bool IsPayToAnchor() const
Definition: script.cpp:207
TaprootBuilder::GetSpendData
TaprootSpendData GetSpendData() const
Compute spending data (after Finalize()).
Definition: signingprovider.cpp:469
node
Definition: messages.h:21
TaprootBuilder
Utility class to construct Taproot outputs from internal key and script tree.
Definition: signingprovider.h:49
Hash160
uint160 Hash160(const T1 &in1)
Compute the 160-bit hash an object.
Definition: hash.h:92
ToByteVector
std::vector< unsigned char > ToByteVector(const T &in)
Definition: script.h:67
CHash160::Finalize
void Finalize(std::span< unsigned char > output)
Definition: hash.h:55
uint256
256-bit opaque blob.
Definition: uint256.h:195
TaprootBuilder::Add
TaprootBuilder & Add(int depth, std::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:433
TaprootBuilder::ValidDepths
static bool ValidDepths(const std::vector< int > &depths)
Check if a list of depths is legal (will lead to IsComplete()).
Definition: signingprovider.cpp:410
mp::result
auto result
Definition: common-types.h:74
OP_9
Definition: script.h:92
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:17
CScript
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:404
CTxDestination
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
Definition: addresstype.h:143
OP_3
Definition: script.h:86
test_vectors_musig2_generate.s
tuple s
Definition: test_vectors_musig2_generate.py:72
CScriptID
A reference to a CScript: the Hash160 of its serialization.
Definition: script.h:593
EncodeDestination
std::string EncodeDestination(const CTxDestination &dest)
Definition: key_io.cpp:294
GetScriptForRawPubKey
CScript GetScriptForRawPubKey(const CPubKey &pubKey)
Generate a P2PK script for the given pubkey.
Definition: solver.cpp:213
prevector::size
size_type size() const
Definition: prevector.h:247
OP_2
Definition: script.h:85
TaprootBuilder::IsComplete
bool IsComplete() const
Return whether there were either no leaves, or the leaves form a Huffman tree.
Definition: signingprovider.h:132
OP_16
Definition: script.h:99
CKey
An encapsulated private key.
Definition: key.h:35
CHash160
A hasher class for Bitcoin&#39;s 160-bit hash (SHA-256 + RIPEMD-160).
Definition: hash.h:49
TaprootBuilder::IsValid
bool IsValid() const
Return true if so far all input was valid.
Definition: signingprovider.h:130
CSHA256
A hasher class for SHA-256.
Definition: sha256.h:13
TxoutType::WITNESS_UNKNOWN
Only for Witness versions not already defined above.
CScript::clear
void clear()
Definition: script.h:568
HexStr
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition: hex_base.cpp:30
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(dest_default_is_no_dest)
Definition: script_standard_tests.cpp:25
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:16
TxoutType::NULL_DATA
unspendable OP_RETURN script that carries data
Generated on Thu Apr 16 2026 12:00:00 for Bitcoin Core by   doxygen 1.8.14