script_standard_tests.cpp
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()