Bitcoin Core  22.99.0
P2P Digital Currency
script_standard_tests.cpp
Go to the documentation of this file.
1 // Copyright (c) 2017-2020 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 <key.h>
6 #include <key_io.h>
7 #include <script/script.h>
8 #include <script/signingprovider.h>
9 #include <script/standard.h>
10 #include <test/util/setup_common.h>
11 #include <util/strencodings.h>
12 
13 #include <boost/test/unit_test.hpp>
14 
15 
16 BOOST_FIXTURE_TEST_SUITE(script_standard_tests, BasicTestingSetup)
17 
18 BOOST_AUTO_TEST_CASE(dest_default_is_no_dest)
19 {
20  CTxDestination dest;
21  BOOST_CHECK(!IsValidDestination(dest));
22 }
23 
24 BOOST_AUTO_TEST_CASE(script_standard_Solver_success)
25 {
26  CKey keys[3];
27  CPubKey pubkeys[3];
28  for (int i = 0; i < 3; i++) {
29  keys[i].MakeNewKey(true);
30  pubkeys[i] = keys[i].GetPubKey();
31  }
32 
33  CScript s;
34  std::vector<std::vector<unsigned char> > solutions;
35 
36  // TxoutType::PUBKEY
37  s.clear();
38  s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
39  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::PUBKEY);
40  BOOST_CHECK_EQUAL(solutions.size(), 1U);
41  BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0]));
42 
43  // TxoutType::PUBKEYHASH
44  s.clear();
45  s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
46  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::PUBKEYHASH);
47  BOOST_CHECK_EQUAL(solutions.size(), 1U);
48  BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
49 
50  // TxoutType::SCRIPTHASH
51  CScript redeemScript(s); // initialize with leftover P2PKH script
52  s.clear();
53  s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
54  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::SCRIPTHASH);
55  BOOST_CHECK_EQUAL(solutions.size(), 1U);
56  BOOST_CHECK(solutions[0] == ToByteVector(CScriptID(redeemScript)));
57 
58  // TxoutType::MULTISIG
59  s.clear();
60  s << OP_1 <<
61  ToByteVector(pubkeys[0]) <<
62  ToByteVector(pubkeys[1]) <<
63  OP_2 << OP_CHECKMULTISIG;
64  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::MULTISIG);
65  BOOST_CHECK_EQUAL(solutions.size(), 4U);
66  BOOST_CHECK(solutions[0] == std::vector<unsigned char>({1}));
67  BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
68  BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
69  BOOST_CHECK(solutions[3] == std::vector<unsigned char>({2}));
70 
71  s.clear();
72  s << OP_2 <<
73  ToByteVector(pubkeys[0]) <<
74  ToByteVector(pubkeys[1]) <<
75  ToByteVector(pubkeys[2]) <<
76  OP_3 << OP_CHECKMULTISIG;
77  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::MULTISIG);
78  BOOST_CHECK_EQUAL(solutions.size(), 5U);
79  BOOST_CHECK(solutions[0] == std::vector<unsigned char>({2}));
80  BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
81  BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
82  BOOST_CHECK(solutions[3] == ToByteVector(pubkeys[2]));
83  BOOST_CHECK(solutions[4] == std::vector<unsigned char>({3}));
84 
85  // TxoutType::NULL_DATA
86  s.clear();
87  s << OP_RETURN <<
88  std::vector<unsigned char>({0}) <<
89  std::vector<unsigned char>({75}) <<
90  std::vector<unsigned char>({255});
91  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NULL_DATA);
92  BOOST_CHECK_EQUAL(solutions.size(), 0U);
93 
94  // TxoutType::WITNESS_V0_KEYHASH
95  s.clear();
96  s << OP_0 << ToByteVector(pubkeys[0].GetID());
97  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V0_KEYHASH);
98  BOOST_CHECK_EQUAL(solutions.size(), 1U);
99  BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
100 
101  // TxoutType::WITNESS_V0_SCRIPTHASH
102  uint256 scriptHash;
103  CSHA256().Write(redeemScript.data(), redeemScript.size())
104  .Finalize(scriptHash.begin());
105 
106  s.clear();
107  s << OP_0 << ToByteVector(scriptHash);
108  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V0_SCRIPTHASH);
109  BOOST_CHECK_EQUAL(solutions.size(), 1U);
110  BOOST_CHECK(solutions[0] == ToByteVector(scriptHash));
111 
112  // TxoutType::WITNESS_V1_TAPROOT
113  s.clear();
114  s << OP_1 << ToByteVector(uint256::ZERO);
115  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V1_TAPROOT);
116  BOOST_CHECK_EQUAL(solutions.size(), 1U);
117  BOOST_CHECK(solutions[0] == ToByteVector(uint256::ZERO));
118 
119  // TxoutType::WITNESS_UNKNOWN
120  s.clear();
121  s << OP_16 << ToByteVector(uint256::ONE);
122  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);
123  BOOST_CHECK_EQUAL(solutions.size(), 2U);
124  BOOST_CHECK(solutions[0] == std::vector<unsigned char>{16});
125  BOOST_CHECK(solutions[1] == ToByteVector(uint256::ONE));
126 
127  // TxoutType::NONSTANDARD
128  s.clear();
129  s << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
130  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
131 }
132 
133 BOOST_AUTO_TEST_CASE(script_standard_Solver_failure)
134 {
135  CKey key;
136  CPubKey pubkey;
137  key.MakeNewKey(true);
138  pubkey = key.GetPubKey();
139 
140  CScript s;
141  std::vector<std::vector<unsigned char> > solutions;
142 
143  // TxoutType::PUBKEY with incorrectly sized pubkey
144  s.clear();
145  s << std::vector<unsigned char>(30, 0x01) << OP_CHECKSIG;
146  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
147 
148  // TxoutType::PUBKEYHASH with incorrectly sized key hash
149  s.clear();
150  s << OP_DUP << OP_HASH160 << ToByteVector(pubkey) << OP_EQUALVERIFY << OP_CHECKSIG;
151  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
152 
153  // TxoutType::SCRIPTHASH with incorrectly sized script hash
154  s.clear();
155  s << OP_HASH160 << std::vector<unsigned char>(21, 0x01) << OP_EQUAL;
156  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
157 
158  // TxoutType::MULTISIG 0/2
159  s.clear();
160  s << OP_0 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
161  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
162 
163  // TxoutType::MULTISIG 2/1
164  s.clear();
165  s << OP_2 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
166  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
167 
168  // TxoutType::MULTISIG n = 2 with 1 pubkey
169  s.clear();
170  s << OP_1 << ToByteVector(pubkey) << OP_2 << OP_CHECKMULTISIG;
171  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
172 
173  // TxoutType::MULTISIG n = 1 with 0 pubkeys
174  s.clear();
175  s << OP_1 << OP_1 << OP_CHECKMULTISIG;
176  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
177 
178  // TxoutType::NULL_DATA with other opcodes
179  s.clear();
180  s << OP_RETURN << std::vector<unsigned char>({75}) << OP_ADD;
181  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
182 
183  // TxoutType::WITNESS_UNKNOWN with incorrect program size
184  s.clear();
185  s << OP_0 << std::vector<unsigned char>(19, 0x01);
186  BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
187 }
188 
189 BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
190 {
191  CKey key;
192  CPubKey pubkey;
193  key.MakeNewKey(true);
194  pubkey = key.GetPubKey();
195 
196  CScript s;
197  CTxDestination address;
198 
199  // TxoutType::PUBKEY
200  s.clear();
201  s << ToByteVector(pubkey) << OP_CHECKSIG;
202  BOOST_CHECK(ExtractDestination(s, address));
203  BOOST_CHECK(std::get<PKHash>(address) == PKHash(pubkey));
204 
205  // TxoutType::PUBKEYHASH
206  s.clear();
207  s << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
208  BOOST_CHECK(ExtractDestination(s, address));
209  BOOST_CHECK(std::get<PKHash>(address) == PKHash(pubkey));
210 
211  // TxoutType::SCRIPTHASH
212  CScript redeemScript(s); // initialize with leftover P2PKH script
213  s.clear();
214  s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
215  BOOST_CHECK(ExtractDestination(s, address));
216  BOOST_CHECK(std::get<ScriptHash>(address) == ScriptHash(redeemScript));
217 
218  // TxoutType::MULTISIG
219  s.clear();
220  s << OP_1 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
221  BOOST_CHECK(!ExtractDestination(s, address));
222 
223  // TxoutType::NULL_DATA
224  s.clear();
225  s << OP_RETURN << std::vector<unsigned char>({75});
226  BOOST_CHECK(!ExtractDestination(s, address));
227 
228  // TxoutType::WITNESS_V0_KEYHASH
229  s.clear();
230  s << OP_0 << ToByteVector(pubkey.GetID());
231  BOOST_CHECK(ExtractDestination(s, address));
232  WitnessV0KeyHash keyhash;
233  CHash160().Write(pubkey).Finalize(keyhash);
234  BOOST_CHECK(std::get<WitnessV0KeyHash>(address) == keyhash);
235 
236  // TxoutType::WITNESS_V0_SCRIPTHASH
237  s.clear();
238  WitnessV0ScriptHash scripthash;
239  CSHA256().Write(redeemScript.data(), redeemScript.size()).Finalize(scripthash.begin());
240  s << OP_0 << ToByteVector(scripthash);
241  BOOST_CHECK(ExtractDestination(s, address));
242  BOOST_CHECK(std::get<WitnessV0ScriptHash>(address) == scripthash);
243 
244  // TxoutType::WITNESS_UNKNOWN with unknown version
245  s.clear();
246  s << OP_1 << ToByteVector(pubkey);
247  BOOST_CHECK(ExtractDestination(s, address));
248  WitnessUnknown unk;
249  unk.length = 33;
250  unk.version = 1;
251  std::copy(pubkey.begin(), pubkey.end(), unk.program);
252  BOOST_CHECK(std::get<WitnessUnknown>(address) == unk);
253 }
254 
255 BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
256 {
257  CKey keys[3];
258  CPubKey pubkeys[3];
259  for (int i = 0; i < 3; i++) {
260  keys[i].MakeNewKey(true);
261  pubkeys[i] = keys[i].GetPubKey();
262  }
263 
264  CScript s;
265  TxoutType whichType;
266  std::vector<CTxDestination> addresses;
267  int nRequired;
268 
269  // TxoutType::PUBKEY
270  s.clear();
271  s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
272  BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
273  BOOST_CHECK_EQUAL(whichType, TxoutType::PUBKEY);
274  BOOST_CHECK_EQUAL(addresses.size(), 1U);
275  BOOST_CHECK_EQUAL(nRequired, 1);
276  BOOST_CHECK(std::get<PKHash>(addresses[0]) == PKHash(pubkeys[0]));
277 
278  // TxoutType::PUBKEYHASH
279  s.clear();
280  s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
281  BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
282  BOOST_CHECK_EQUAL(whichType, TxoutType::PUBKEYHASH);
283  BOOST_CHECK_EQUAL(addresses.size(), 1U);
284  BOOST_CHECK_EQUAL(nRequired, 1);
285  BOOST_CHECK(std::get<PKHash>(addresses[0]) == PKHash(pubkeys[0]));
286 
287  // TxoutType::SCRIPTHASH
288  CScript redeemScript(s); // initialize with leftover P2PKH script
289  s.clear();
290  s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
291  BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
292  BOOST_CHECK_EQUAL(whichType, TxoutType::SCRIPTHASH);
293  BOOST_CHECK_EQUAL(addresses.size(), 1U);
294  BOOST_CHECK_EQUAL(nRequired, 1);
295  BOOST_CHECK(std::get<ScriptHash>(addresses[0]) == ScriptHash(redeemScript));
296 
297  // TxoutType::MULTISIG
298  s.clear();
299  s << OP_2 <<
300  ToByteVector(pubkeys[0]) <<
301  ToByteVector(pubkeys[1]) <<
302  OP_2 << OP_CHECKMULTISIG;
303  BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
304  BOOST_CHECK_EQUAL(whichType, TxoutType::MULTISIG);
305  BOOST_CHECK_EQUAL(addresses.size(), 2U);
306  BOOST_CHECK_EQUAL(nRequired, 2);
307  BOOST_CHECK(std::get<PKHash>(addresses[0]) == PKHash(pubkeys[0]));
308  BOOST_CHECK(std::get<PKHash>(addresses[1]) == PKHash(pubkeys[1]));
309 
310  // TxoutType::NULL_DATA
311  s.clear();
312  s << OP_RETURN << std::vector<unsigned char>({75});
313  BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
314 }
315 
316 BOOST_AUTO_TEST_CASE(script_standard_GetScriptFor_)
317 {
318  CKey keys[3];
319  CPubKey pubkeys[3];
320  for (int i = 0; i < 3; i++) {
321  keys[i].MakeNewKey(true);
322  pubkeys[i] = keys[i].GetPubKey();
323  }
324 
325  CScript expected, result;
326 
327  // PKHash
328  expected.clear();
329  expected << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
330  result = GetScriptForDestination(PKHash(pubkeys[0]));
331  BOOST_CHECK(result == expected);
332 
333  // CScriptID
334  CScript redeemScript(result);
335  expected.clear();
336  expected << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
337  result = GetScriptForDestination(ScriptHash(redeemScript));
338  BOOST_CHECK(result == expected);
339 
340  // CNoDestination
341  expected.clear();
342  result = GetScriptForDestination(CNoDestination());
343  BOOST_CHECK(result == expected);
344 
345  // GetScriptForRawPubKey
346  expected.clear();
347  expected << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
348  result = GetScriptForRawPubKey(pubkeys[0]);
349  BOOST_CHECK(result == expected);
350 
351  // GetScriptForMultisig
352  expected.clear();
353  expected << OP_2 <<
354  ToByteVector(pubkeys[0]) <<
355  ToByteVector(pubkeys[1]) <<
356  ToByteVector(pubkeys[2]) <<
357  OP_3 << OP_CHECKMULTISIG;
358  result = GetScriptForMultisig(2, std::vector<CPubKey>(pubkeys, pubkeys + 3));
359  BOOST_CHECK(result == expected);
360 
361  // WitnessV0KeyHash
362  expected.clear();
363  expected << OP_0 << ToByteVector(pubkeys[0].GetID());
364  result = GetScriptForDestination(WitnessV0KeyHash(Hash160(ToByteVector(pubkeys[0]))));
365  BOOST_CHECK(result == expected);
366  result = GetScriptForDestination(WitnessV0KeyHash(pubkeys[0].GetID()));
367  BOOST_CHECK(result == expected);
368 
369  // WitnessV0ScriptHash (multisig)
370  CScript witnessScript;
371  witnessScript << OP_1 << ToByteVector(pubkeys[0]) << OP_1 << OP_CHECKMULTISIG;
372 
373  uint256 scriptHash;
374  CSHA256().Write(witnessScript.data(), witnessScript.size())
375  .Finalize(scriptHash.begin());
376 
377  expected.clear();
378  expected << OP_0 << ToByteVector(scriptHash);
379  result = GetScriptForDestination(WitnessV0ScriptHash(witnessScript));
380  BOOST_CHECK(result == expected);
381 }
382 
383 BOOST_AUTO_TEST_CASE(script_standard_taproot_builder)
384 {
385  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({}), true);
386  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0}), true);
387  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1}), false);
388  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2}), false);
389  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0}), false);
390  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1}), false);
391  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2}), false);
392  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0}), false);
393  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1}), true);
394  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2}), false);
395  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0}), false);
396  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1}), false);
397  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2}), false);
398  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0,0}), false);
399  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0,1}), false);
400  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0,2}), false);
401  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1,0}), false);
402  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1,1}), false);
403  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1,2}), false);
404  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2,0}), false);
405  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2,1}), false);
406  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2,2}), false);
407  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0,0}), false);
408  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0,1}), false);
409  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0,2}), false);
410  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1,0}), false);
411  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1,1}), false);
412  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1,2}), false);
413  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2,0}), false);
414  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2,1}), false);
415  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2,2}), true);
416  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0,0}), false);
417  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0,1}), false);
418  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0,2}), false);
419  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1,0}), false);
420  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1,1}), false);
421  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1,2}), false);
422  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,0}), false);
423  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,1}), true);
424  BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,2}), false);
425  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);
426  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);
427  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);
428 
429  XOnlyPubKey key_inner{ParseHex("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798")};
430  XOnlyPubKey key_1{ParseHex("c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5")};
431  XOnlyPubKey key_2{ParseHex("f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9")};
432  CScript script_1 = CScript() << ToByteVector(key_1) << OP_CHECKSIG;
433  CScript script_2 = CScript() << ToByteVector(key_2) << OP_CHECKSIG;
434  uint256 hash_3 = uint256S("31fe7061656bea2a36aa60a2f7ef940578049273746935d296426dc0afd86b68");
435 
436  TaprootBuilder builder;
437  BOOST_CHECK(builder.IsValid() && builder.IsComplete());
438  builder.Add(2, script_2, 0xc0);
439  BOOST_CHECK(builder.IsValid() && !builder.IsComplete());
440  builder.AddOmitted(2, hash_3);
441  BOOST_CHECK(builder.IsValid() && !builder.IsComplete());
442  builder.Add(1, script_1, 0xc0);
443  BOOST_CHECK(builder.IsValid() && builder.IsComplete());
444  builder.Finalize(key_inner);
445  BOOST_CHECK(builder.IsValid() && builder.IsComplete());
446  BOOST_CHECK_EQUAL(EncodeDestination(builder.GetOutput()), "bc1pj6gaw944fy0xpmzzu45ugqde4rz7mqj5kj0tg8kmr5f0pjq8vnaqgynnge");
447 }
448 
449 BOOST_AUTO_TEST_SUITE_END()
ParseHex
std::vector< unsigned char > ParseHex(const char *psz)
Definition: strencodings.cpp:84
WitnessUnknown
CTxDestination subtype to encode any future Witness version.
Definition: standard.h:125
CSHA256::Write
CSHA256 & Write(const unsigned char *data, size_t len)
Definition: sha256.cpp:637
Solver
TxoutType Solver(const CScript &scriptPubKey, std::vector< std::vector< unsigned char >> &vSolutionsRet)
Parse a scriptPubKey and identify script type for standard scripts.
Definition: standard.cpp:144
CKey::MakeNewKey
void MakeNewKey(bool fCompressed)
Generate a new private key using a cryptographic PRNG.
Definition: key.cpp:160
TxoutType
TxoutType
Definition: standard.h:59
key_io.h
setup_common.h
TxoutType::NONSTANDARD
@ NONSTANDARD
TxoutType::WITNESS_UNKNOWN
@ WITNESS_UNKNOWN
Only for Witness versions not already defined above.
GetScriptForDestination
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
Definition: standard.cpp:351
WitnessUnknown::version
unsigned int version
Definition: standard.h:127
OP_ADD
@ OP_ADD
Definition: script.h:154
OP_CHECKMULTISIG
@ OP_CHECKMULTISIG
Definition: script.h:185
BaseHash::begin
unsigned char * begin()
Definition: hash_type.h:18
WitnessUnknown::length
unsigned int length
Definition: standard.h:128
XOnlyPubKey
Definition: pubkey.h:220
OP_3
@ OP_3
Definition: script.h:79
BOOST_FIXTURE_TEST_SUITE
#define BOOST_FIXTURE_TEST_SUITE(a, b)
Definition: object.cpp:14
CScript::clear
void clear()
Definition: script.h:549
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
TxoutType::WITNESS_V1_TAPROOT
@ WITNESS_V1_TAPROOT
WitnessV0KeyHash
Definition: standard.h:109
signingprovider.h
OP_9
@ OP_9
Definition: script.h:85
CPubKey::begin
const unsigned char * begin() const
Definition: pubkey.h:113
OP_1
@ OP_1
Definition: script.h:76
strencodings.h
OP_0
@ OP_0
Definition: script.h:69
TxoutType::WITNESS_V0_SCRIPTHASH
@ WITNESS_V0_SCRIPTHASH
OP_RETURN
@ OP_RETURN
Definition: script.h:104
ToByteVector
std::vector< unsigned char > ToByteVector(const T &in)
Definition: script.h:60
TxoutType::PUBKEY
@ PUBKEY
CTxDestination
std::variant< CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown > CTxDestination
A txout script template with a specific destination.
Definition: standard.h:157
TaprootBuilder::GetOutput
WitnessV1Taproot GetOutput()
Compute scriptPubKey (after Finalize()).
Definition: standard.cpp:503
OP_16
@ OP_16
Definition: script.h:92
IsValidDestination
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination is a CNoDestination.
Definition: standard.cpp:373
GetScriptForRawPubKey
CScript GetScriptForRawPubKey(const CPubKey &pubKey)
Generate a P2PK script for the given pubkey.
Definition: standard.cpp:356
GetScriptForMultisig
CScript GetScriptForMultisig(int nRequired, const std::vector< CPubKey > &keys)
Generate a multisig script.
Definition: standard.cpp:361
CHash160
A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160).
Definition: hash.h:49
OP_EQUAL
@ OP_EQUAL
Definition: script.h:139
CPubKey::end
const unsigned char * end() const
Definition: pubkey.h:114
CHash160::Finalize
void Finalize(Span< unsigned char > output)
Definition: hash.h:55
TaprootBuilder::Add
TaprootBuilder & Add(int depth, const CScript &script, int leaf_version, bool track=true)
Add a new script at a certain depth in the tree.
Definition: standard.cpp:469
standard.h
BasicTestingSetup
Basic testing setup.
Definition: setup_common.h:76
OP_2
@ OP_2
Definition: script.h:78
TxoutType::SCRIPTHASH
@ SCRIPTHASH
uint256::ZERO
static const uint256 ZERO
Definition: uint256.h:129
uint256
256-bit opaque blob.
Definition: uint256.h:124
uint256S
uint256 uint256S(const char *str)
Definition: uint256.h:137
CSHA256::Finalize
void Finalize(unsigned char hash[OUTPUT_SIZE])
Definition: sha256.cpp:663
CKey::GetPubKey
CPubKey GetPubKey() const
Compute the public key from a private key.
Definition: key.cpp:187
CScript
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:405
TaprootBuilder::ValidDepths
static bool ValidDepths(const std::vector< int > &depths)
Check if a list of depths is legal (will lead to IsComplete()).
Definition: standard.cpp:446
TaprootBuilder::IsComplete
bool IsComplete() const
Return whether there were either no leaves, or the leaves form a Huffman tree.
Definition: standard.h:324
script.h
ExtractDestination
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a standard scriptPubKey for the destination address.
Definition: standard.cpp:213
CNoDestination
Definition: standard.h:73
OP_HASH160
@ OP_HASH160
Definition: script.h:180
TxoutType::NULL_DATA
@ NULL_DATA
unspendable OP_RETURN script that carries data
TxoutType::PUBKEYHASH
@ PUBKEYHASH
PKHash
Definition: standard.h:79
key.h
CPubKey
An encapsulated public key.
Definition: pubkey.h:32
CKey
An encapsulated private key.
Definition: key.h:26
Hash160
uint160 Hash160(const T1 &in1)
Compute the 160-bit hash an object.
Definition: hash.h:92
prevector::data
value_type * data()
Definition: prevector.h:528
prevector::size
size_type size() const
Definition: prevector.h:282
CHash160::Write
CHash160 & Write(Span< const unsigned char > input)
Definition: hash.h:62
TxoutType::MULTISIG
@ MULTISIG
CSHA256
A hasher class for SHA-256.
Definition: sha256.h:13
TaprootBuilder::IsValid
bool IsValid() const
Return true if so far all input was valid.
Definition: standard.h:322
OP_EQUALVERIFY
@ OP_EQUALVERIFY
Definition: script.h:140
TaprootBuilder::Finalize
TaprootBuilder & Finalize(const XOnlyPubKey &internal_key)
Finalize the construction.
Definition: standard.cpp:492
TaprootBuilder
Utility class to construct Taproot outputs from internal key and script tree.
Definition: standard.h:241
TxoutType::WITNESS_V0_KEYHASH
@ WITNESS_V0_KEYHASH
WitnessV0ScriptHash
Definition: standard.h:102
CScriptID
A reference to a CScript: the Hash160 of its serialization (see script.h)
Definition: standard.h:25
ExtractDestinations
bool ExtractDestinations(const CScript &scriptPubKey, TxoutType &typeRet, std::vector< CTxDestination > &addressRet, int &nRequiredRet)
Parse a standard scriptPubKey with one or more destination addresses.
Definition: standard.cpp:270
OP_CHECKSIG
@ OP_CHECKSIG
Definition: script.h:183
OP_11
@ OP_11
Definition: script.h:87
TaprootBuilder::AddOmitted
TaprootBuilder & AddOmitted(int depth, const uint256 &hash)
Like Add(), but for a Merkle node with a given hash to the tree.
Definition: standard.cpp:482
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(dest_default_is_no_dest)
Definition: script_standard_tests.cpp:18
ScriptHash
Definition: standard.h:89
base_blob::begin
unsigned char * begin()
Definition: uint256.h:58
OP_DUP
@ OP_DUP
Definition: script.h:118
EncodeDestination
std::string EncodeDestination(const CTxDestination &dest)
Definition: key_io.cpp:256
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:17
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
WitnessUnknown::program
unsigned char program[40]
Definition: standard.h:129
CPubKey::GetID
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Definition: pubkey.h:160
uint256::ONE
static const uint256 ONE
Definition: uint256.h:130
Generated on Sun Sep 26 2021 20:04:30 for Bitcoin Core by   doxygen 1.8.17