Branch data     Line data    Source code

       1                 :            : // Copyright (c) 2017-2022 The Bitcoin Core developers
       2                 :            : // Distributed under the MIT software license, see the accompanying
       3                 :          0 : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4                 :            : 
       5                 :            : #include <test/data/bip341_wallet_vectors.json.h>
       6                 :            : 
       7                 :            : #include <key.h>
       8                 :            : #include <key_io.h>
       9                 :            : #include <script/script.h>
      10                 :            : #include <script/signingprovider.h>
      11                 :            : #include <script/solver.h>
      12                 :            : #include <test/util/setup_common.h>
      13                 :            : #include <util/strencodings.h>
      14                 :            : 
      15                 :            : #include <boost/test/unit_test.hpp>
      16                 :            : 
      17                 :            : #include <univalue.h>
      18                 :            : 
      19                 :            : 
      20                 :          0 : BOOST_FIXTURE_TEST_SUITE(script_standard_tests, BasicTestingSetup)
      21                 :            : 
      22                 :          0 : BOOST_AUTO_TEST_CASE(dest_default_is_no_dest)
      23                 :            : {
      24                 :          0 :     CTxDestination dest;
      25                 :          0 :     BOOST_CHECK(!IsValidDestination(dest));
      26                 :          0 : }
      27                 :            : 
      28                 :          0 : BOOST_AUTO_TEST_CASE(script_standard_Solver_success)
      29                 :            : {
      30                 :          0 :     CKey keys[3];
      31                 :          0 :     CPubKey pubkeys[3];
      32                 :          0 :     for (int i = 0; i < 3; i++) {
      33                 :          0 :         keys[i].MakeNewKey(true);
      34                 :          0 :         pubkeys[i] = keys[i].GetPubKey();
      35                 :          0 :     }
      36                 :            : 
      37                 :          0 :     CScript s;
      38                 :          0 :     std::vector<std::vector<unsigned char> > solutions;
      39                 :            : 
      40                 :            :     // TxoutType::PUBKEY
      41                 :          0 :     s.clear();
      42                 :          0 :     s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
      43                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::PUBKEY);
      44                 :          0 :     BOOST_CHECK_EQUAL(solutions.size(), 1U);
      45                 :          0 :     BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0]));
      46                 :            : 
      47                 :            :     // TxoutType::PUBKEYHASH
      48                 :          0 :     s.clear();
      49                 :          0 :     s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
      50                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::PUBKEYHASH);
      51                 :          0 :     BOOST_CHECK_EQUAL(solutions.size(), 1U);
      52                 :          0 :     BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
      53                 :            : 
      54                 :            :     // TxoutType::SCRIPTHASH
      55                 :          0 :     CScript redeemScript(s); // initialize with leftover P2PKH script
      56                 :          0 :     s.clear();
      57                 :          0 :     s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
      58                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::SCRIPTHASH);
      59                 :          0 :     BOOST_CHECK_EQUAL(solutions.size(), 1U);
      60                 :          0 :     BOOST_CHECK(solutions[0] == ToByteVector(CScriptID(redeemScript)));
      61                 :            : 
      62                 :            :     // TxoutType::MULTISIG
      63                 :          0 :     s.clear();
      64                 :          0 :     s << OP_1 <<
      65                 :          0 :         ToByteVector(pubkeys[0]) <<
      66                 :          0 :         ToByteVector(pubkeys[1]) <<
      67                 :          0 :         OP_2 << OP_CHECKMULTISIG;
      68                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::MULTISIG);
      69                 :          0 :     BOOST_CHECK_EQUAL(solutions.size(), 4U);
      70                 :          0 :     BOOST_CHECK(solutions[0] == std::vector<unsigned char>({1}));
      71                 :          0 :     BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
      72                 :          0 :     BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
      73                 :          0 :     BOOST_CHECK(solutions[3] == std::vector<unsigned char>({2}));
      74                 :          0 : 
      75                 :          0 :     s.clear();
      76                 :          0 :     s << OP_2 <<
      77                 :          0 :         ToByteVector(pubkeys[0]) <<
      78                 :          0 :         ToByteVector(pubkeys[1]) <<
      79                 :          0 :         ToByteVector(pubkeys[2]) <<
      80                 :          0 :         OP_3 << OP_CHECKMULTISIG;
      81                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::MULTISIG);
      82                 :          0 :     BOOST_CHECK_EQUAL(solutions.size(), 5U);
      83                 :          0 :     BOOST_CHECK(solutions[0] == std::vector<unsigned char>({2}));
      84                 :          0 :     BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
      85                 :          0 :     BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
      86                 :          0 :     BOOST_CHECK(solutions[3] == ToByteVector(pubkeys[2]));
      87                 :          0 :     BOOST_CHECK(solutions[4] == std::vector<unsigned char>({3}));
      88                 :            : 
      89                 :            :     // TxoutType::NULL_DATA
      90                 :          0 :     s.clear();
      91                 :          0 :     s << OP_RETURN <<
      92                 :          0 :         std::vector<unsigned char>({0}) <<
      93                 :          0 :         std::vector<unsigned char>({75}) <<
      94                 :          0 :         std::vector<unsigned char>({255});
      95                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NULL_DATA);
      96                 :          0 :     BOOST_CHECK_EQUAL(solutions.size(), 0U);
      97                 :            : 
      98                 :            :     // TxoutType::WITNESS_V0_KEYHASH
      99                 :          0 :     s.clear();
     100                 :          0 :     s << OP_0 << ToByteVector(pubkeys[0].GetID());
     101                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V0_KEYHASH);
     102                 :          0 :     BOOST_CHECK_EQUAL(solutions.size(), 1U);
     103                 :          0 :     BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
     104                 :            : 
     105                 :            :     // TxoutType::WITNESS_V0_SCRIPTHASH
     106                 :          0 :     uint256 scriptHash;
     107                 :          0 :     CSHA256().Write(redeemScript.data(), redeemScript.size())
     108                 :          0 :         .Finalize(scriptHash.begin());
     109                 :            : 
     110                 :          0 :     s.clear();
     111                 :          0 :     s << OP_0 << ToByteVector(scriptHash);
     112                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V0_SCRIPTHASH);
     113                 :          0 :     BOOST_CHECK_EQUAL(solutions.size(), 1U);
     114                 :          0 :     BOOST_CHECK(solutions[0] == ToByteVector(scriptHash));
     115                 :            : 
     116                 :            :     // TxoutType::WITNESS_V1_TAPROOT
     117                 :          0 :     s.clear();
     118                 :          0 :     s << OP_1 << ToByteVector(uint256::ZERO);
     119                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_V1_TAPROOT);
     120                 :          0 :     BOOST_CHECK_EQUAL(solutions.size(), 1U);
     121                 :          0 :     BOOST_CHECK(solutions[0] == ToByteVector(uint256::ZERO));
     122                 :            : 
     123                 :            :     // TxoutType::WITNESS_UNKNOWN
     124                 :          0 :     s.clear();
     125                 :          0 :     s << OP_16 << ToByteVector(uint256::ONE);
     126                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::WITNESS_UNKNOWN);
     127                 :          0 :     BOOST_CHECK_EQUAL(solutions.size(), 2U);
     128                 :          0 :     BOOST_CHECK(solutions[0] == std::vector<unsigned char>{16});
     129                 :          0 :     BOOST_CHECK(solutions[1] == ToByteVector(uint256::ONE));
     130                 :            : 
     131                 :            :     // TxoutType::NONSTANDARD
     132                 :          0 :     s.clear();
     133                 :          0 :     s << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
     134                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
     135                 :          0 : }
     136                 :            : 
     137                 :          0 : BOOST_AUTO_TEST_CASE(script_standard_Solver_failure)
     138                 :            : {
     139                 :          0 :     CKey key;
     140                 :          0 :     CPubKey pubkey;
     141                 :          0 :     key.MakeNewKey(true);
     142                 :          0 :     pubkey = key.GetPubKey();
     143                 :            : 
     144                 :          0 :     CScript s;
     145                 :          0 :     std::vector<std::vector<unsigned char> > solutions;
     146                 :            : 
     147                 :            :     // TxoutType::PUBKEY with incorrectly sized pubkey
     148                 :          0 :     s.clear();
     149                 :          0 :     s << std::vector<unsigned char>(30, 0x01) << OP_CHECKSIG;
     150                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
     151                 :            : 
     152                 :            :     // TxoutType::PUBKEYHASH with incorrectly sized key hash
     153                 :          0 :     s.clear();
     154                 :          0 :     s << OP_DUP << OP_HASH160 << ToByteVector(pubkey) << OP_EQUALVERIFY << OP_CHECKSIG;
     155                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
     156                 :            : 
     157                 :            :     // TxoutType::SCRIPTHASH with incorrectly sized script hash
     158                 :          0 :     s.clear();
     159                 :          0 :     s << OP_HASH160 << std::vector<unsigned char>(21, 0x01) << OP_EQUAL;
     160                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
     161                 :            : 
     162                 :            :     // TxoutType::MULTISIG 0/2
     163                 :          0 :     s.clear();
     164                 :          0 :     s << OP_0 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
     165                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
     166                 :            : 
     167                 :            :     // TxoutType::MULTISIG 2/1
     168                 :          0 :     s.clear();
     169                 :          0 :     s << OP_2 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
     170                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
     171                 :            : 
     172                 :            :     // TxoutType::MULTISIG n = 2 with 1 pubkey
     173                 :          0 :     s.clear();
     174                 :          0 :     s << OP_1 << ToByteVector(pubkey) << OP_2 << OP_CHECKMULTISIG;
     175                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
     176                 :            : 
     177                 :            :     // TxoutType::MULTISIG n = 1 with 0 pubkeys
     178                 :          0 :     s.clear();
     179                 :          0 :     s << OP_1 << OP_1 << OP_CHECKMULTISIG;
     180                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
     181                 :            : 
     182                 :            :     // TxoutType::NULL_DATA with other opcodes
     183                 :          0 :     s.clear();
     184                 :          0 :     s << OP_RETURN << std::vector<unsigned char>({75}) << OP_ADD;
     185                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
     186                 :            : 
     187                 :            :     // TxoutType::WITNESS_UNKNOWN with incorrect program size
     188                 :          0 :     s.clear();
     189                 :          0 :     s << OP_0 << std::vector<unsigned char>(19, 0x01);
     190                 :          0 :     BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
     191                 :          0 : }
     192                 :            : 
     193                 :          0 : BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
     194                 :            : {
     195                 :          0 :     CKey key;
     196                 :          0 :     CPubKey pubkey;
     197                 :          0 :     key.MakeNewKey(true);
     198                 :          0 :     pubkey = key.GetPubKey();
     199                 :            : 
     200                 :          0 :     CScript s;
     201                 :          0 :     CTxDestination address;
     202                 :            : 
     203                 :            :     // TxoutType::PUBKEY
     204                 :          0 :     s.clear();
     205                 :          0 :     s << ToByteVector(pubkey) << OP_CHECKSIG;
     206                 :          0 :     BOOST_CHECK(!ExtractDestination(s, address));
     207                 :          0 :     BOOST_CHECK(std::get<PubKeyDestination>(address) == PubKeyDestination(pubkey));
     208                 :            : 
     209                 :            :     // TxoutType::PUBKEYHASH
     210                 :          0 :     s.clear();
     211                 :          0 :     s << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
     212                 :          0 :     BOOST_CHECK(ExtractDestination(s, address));
     213                 :          0 :     BOOST_CHECK(std::get<PKHash>(address) == PKHash(pubkey));
     214                 :            : 
     215                 :            :     // TxoutType::SCRIPTHASH
     216                 :          0 :     CScript redeemScript(s); // initialize with leftover P2PKH script
     217                 :          0 :     s.clear();
     218                 :          0 :     s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     219                 :          0 :     BOOST_CHECK(ExtractDestination(s, address));
     220                 :          0 :     BOOST_CHECK(std::get<ScriptHash>(address) == ScriptHash(redeemScript));
     221                 :            : 
     222                 :            :     // TxoutType::MULTISIG
     223                 :          0 :     s.clear();
     224                 :          0 :     s << OP_1 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
     225                 :          0 :     BOOST_CHECK(!ExtractDestination(s, address));
     226                 :            : 
     227                 :          0 :     // TxoutType::NULL_DATA
     228                 :          0 :     s.clear();
     229                 :          0 :     s << OP_RETURN << std::vector<unsigned char>({75});
     230                 :          0 :     BOOST_CHECK(!ExtractDestination(s, address));
     231                 :            : 
     232                 :            :     // TxoutType::WITNESS_V0_KEYHASH
     233                 :          0 :     s.clear();
     234                 :          0 :     s << OP_0 << ToByteVector(pubkey.GetID());
     235                 :          0 :     BOOST_CHECK(ExtractDestination(s, address));
     236                 :          0 :     WitnessV0KeyHash keyhash;
     237                 :          0 :     CHash160().Write(pubkey).Finalize(keyhash);
     238                 :          0 :     BOOST_CHECK(std::get<WitnessV0KeyHash>(address) == keyhash);
     239                 :            : 
     240                 :            :     // TxoutType::WITNESS_V0_SCRIPTHASH
     241                 :          0 :     s.clear();
     242                 :          0 :     WitnessV0ScriptHash scripthash;
     243                 :          0 :     CSHA256().Write(redeemScript.data(), redeemScript.size()).Finalize(scripthash.begin());
     244                 :          0 :     s << OP_0 << ToByteVector(scripthash);
     245                 :          0 :     BOOST_CHECK(ExtractDestination(s, address));
     246                 :          0 :     BOOST_CHECK(std::get<WitnessV0ScriptHash>(address) == scripthash);
     247                 :            : 
     248                 :            :     // TxoutType::WITNESS_UNKNOWN with unknown version
     249                 :          0 :     s.clear();
     250                 :          0 :     s << OP_1 << ToByteVector(pubkey);
     251                 :          0 :     BOOST_CHECK(ExtractDestination(s, address));
     252                 :          0 :     WitnessUnknown unk{1, ToByteVector(pubkey)};
     253                 :          0 :     BOOST_CHECK(std::get<WitnessUnknown>(address) == unk);
     254                 :          0 : }
     255                 :            : 
     256                 :          0 : BOOST_AUTO_TEST_CASE(script_standard_GetScriptFor_)
     257                 :            : {
     258                 :          0 :     CKey keys[3];
     259                 :          0 :     CPubKey pubkeys[3];
     260                 :          0 :     for (int i = 0; i < 3; i++) {
     261                 :          0 :         keys[i].MakeNewKey(true);
     262                 :          0 :         pubkeys[i] = keys[i].GetPubKey();
     263                 :          0 :     }
     264                 :            : 
     265                 :          0 :     CScript expected, result;
     266                 :            : 
     267                 :            :     // PKHash
     268                 :          0 :     expected.clear();
     269                 :          0 :     expected << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
     270                 :          0 :     result = GetScriptForDestination(PKHash(pubkeys[0]));
     271                 :          0 :     BOOST_CHECK(result == expected);
     272                 :            : 
     273                 :            :     // CScriptID
     274                 :          0 :     CScript redeemScript(result);
     275                 :          0 :     expected.clear();
     276                 :          0 :     expected << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     277                 :          0 :     result = GetScriptForDestination(ScriptHash(redeemScript));
     278                 :          0 :     BOOST_CHECK(result == expected);
     279                 :            : 
     280                 :            :     // CNoDestination
     281                 :          0 :     expected.clear();
     282                 :          0 :     result = GetScriptForDestination(CNoDestination());
     283                 :          0 :     BOOST_CHECK(result == expected);
     284                 :            : 
     285                 :            :     // GetScriptForRawPubKey
     286                 :          0 :     expected.clear();
     287                 :          0 :     expected << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
     288                 :          0 :     result = GetScriptForRawPubKey(pubkeys[0]);
     289                 :          0 :     BOOST_CHECK(result == expected);
     290                 :            : 
     291                 :            :     // GetScriptForMultisig
     292                 :          0 :     expected.clear();
     293                 :          0 :     expected << OP_2 <<
     294                 :          0 :         ToByteVector(pubkeys[0]) <<
     295                 :          0 :         ToByteVector(pubkeys[1]) <<
     296                 :          0 :         ToByteVector(pubkeys[2]) <<
     297                 :          0 :         OP_3 << OP_CHECKMULTISIG;
     298                 :          0 :     result = GetScriptForMultisig(2, std::vector<CPubKey>(pubkeys, pubkeys + 3));
     299                 :          0 :     BOOST_CHECK(result == expected);
     300                 :            : 
     301                 :            :     // WitnessV0KeyHash
     302                 :          0 :     expected.clear();
     303                 :          0 :     expected << OP_0 << ToByteVector(pubkeys[0].GetID());
     304                 :          0 :     result = GetScriptForDestination(WitnessV0KeyHash(Hash160(ToByteVector(pubkeys[0]))));
     305                 :          0 :     BOOST_CHECK(result == expected);
     306                 :          0 :     result = GetScriptForDestination(WitnessV0KeyHash(pubkeys[0].GetID()));
     307                 :          0 :     BOOST_CHECK(result == expected);
     308                 :            : 
     309                 :            :     // WitnessV0ScriptHash (multisig)
     310                 :          0 :     CScript witnessScript;
     311                 :          0 :     witnessScript << OP_1 << ToByteVector(pubkeys[0]) << OP_1 << OP_CHECKMULTISIG;
     312                 :            : 
     313                 :          0 :     uint256 scriptHash;
     314                 :          0 :     CSHA256().Write(witnessScript.data(), witnessScript.size())
     315                 :          0 :         .Finalize(scriptHash.begin());
     316                 :            : 
     317                 :          0 :     expected.clear();
     318                 :          0 :     expected << OP_0 << ToByteVector(scriptHash);
     319                 :          0 :     result = GetScriptForDestination(WitnessV0ScriptHash(witnessScript));
     320                 :          0 :     BOOST_CHECK(result == expected);
     321                 :          0 : }
     322                 :            : 
     323                 :          0 : BOOST_AUTO_TEST_CASE(script_standard_taproot_builder)
     324                 :            : {
     325                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({}), true);
     326                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0}), true);
     327                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1}), false);
     328                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2}), false);
     329                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0}), false);
     330                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1}), false);
     331                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2}), false);
     332                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0}), false);
     333                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1}), true);
     334                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2}), false);
     335                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0}), false);
     336                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1}), false);
     337                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2}), false);
     338                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0,0}), false);
     339                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0,1}), false);
     340                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,0,2}), false);
     341                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1,0}), false);
     342                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1,1}), false);
     343                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,1,2}), false);
     344                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2,0}), false);
     345                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2,1}), false);
     346                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({0,2,2}), false);
     347                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0,0}), false);
     348                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0,1}), false);
     349                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,0,2}), false);
     350                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1,0}), false);
     351                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1,1}), false);
     352                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,1,2}), false);
     353                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2,0}), false);
     354                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2,1}), false);
     355                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({1,2,2}), true);
     356                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0,0}), false);
     357                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0,1}), false);
     358                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,0,2}), false);
     359                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1,0}), false);
     360                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1,1}), false);
     361                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,1,2}), false);
     362                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,0}), false);
     363                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,1}), true);
     364                 :          0 :     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,2}), false);
     365                 :          0 :     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);
     366                 :          0 :     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);
     367                 :          0 :     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);
     368                 :            : 
     369                 :          0 :     XOnlyPubKey key_inner{ParseHex("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798")};
     370                 :          0 :     XOnlyPubKey key_1{ParseHex("c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5")};
     371                 :          0 :     XOnlyPubKey key_2{ParseHex("f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9")};
     372                 :          0 :     CScript script_1 = CScript() << ToByteVector(key_1) << OP_CHECKSIG;
     373                 :          0 :     CScript script_2 = CScript() << ToByteVector(key_2) << OP_CHECKSIG;
     374                 :          0 :     uint256 hash_3 = uint256S("31fe7061656bea2a36aa60a2f7ef940578049273746935d296426dc0afd86b68");
     375                 :            : 
     376                 :          0 :     TaprootBuilder builder;
     377                 :          0 :     BOOST_CHECK(builder.IsValid() && builder.IsComplete());
     378                 :          0 :     builder.Add(2, script_2, 0xc0);
     379                 :          0 :     BOOST_CHECK(builder.IsValid() && !builder.IsComplete());
     380                 :          0 :     builder.AddOmitted(2, hash_3);
     381                 :          0 :     BOOST_CHECK(builder.IsValid() && !builder.IsComplete());
     382                 :          0 :     builder.Add(1, script_1, 0xc0);
     383                 :          0 :     BOOST_CHECK(builder.IsValid() && builder.IsComplete());
     384                 :          0 :     builder.Finalize(key_inner);
     385                 :          0 :     BOOST_CHECK(builder.IsValid() && builder.IsComplete());
     386                 :          0 :     BOOST_CHECK_EQUAL(EncodeDestination(builder.GetOutput()), "bc1pj6gaw944fy0xpmzzu45ugqde4rz7mqj5kj0tg8kmr5f0pjq8vnaqgynnge");
     387                 :          0 : }
     388                 :            : 
     389                 :          0 : BOOST_AUTO_TEST_CASE(bip341_spk_test_vectors)
     390                 :            : {
     391                 :            :     using control_set = decltype(TaprootSpendData::scripts)::mapped_type;
     392                 :            : 
     393                 :          0 :     UniValue tests;
     394                 :          0 :     tests.read(json_tests::bip341_wallet_vectors);
     395                 :            : 
     396                 :          0 :     const auto& vectors = tests["scriptPubKey"];
     397                 :            : 
     398                 :          0 :     for (const auto& vec : vectors.getValues()) {
     399                 :          0 :         TaprootBuilder spktest;
     400                 :          0 :         std::map<std::pair<std::vector<unsigned char>, int>, int> scriptposes;
     401                 :          0 :         std::function<void (const UniValue&, int)> parse_tree = [&](const UniValue& node, int depth) {
     402                 :          0 :             if (node.isNull()) return;
     403                 :          0 :             if (node.isObject()) {
     404                 :          0 :                 auto script = ParseHex(node["script"].get_str());
     405                 :          0 :                 int idx = node["id"].getInt<int>();
     406                 :          0 :                 int leaf_version = node["leafVersion"].getInt<int>();
     407                 :          0 :                 scriptposes[{script, leaf_version}] = idx;
     408                 :          0 :                 spktest.Add(depth, script, leaf_version);
     409                 :          0 :             } else {
     410                 :          0 :                 parse_tree(node[0], depth + 1);
     411                 :          0 :                 parse_tree(node[1], depth + 1);
     412                 :            :             }
     413                 :          0 :         };
     414                 :          0 :         parse_tree(vec["given"]["scriptTree"], 0);
     415                 :          0 :         spktest.Finalize(XOnlyPubKey(ParseHex(vec["given"]["internalPubkey"].get_str())));
     416                 :          0 :         BOOST_CHECK_EQUAL(HexStr(GetScriptForDestination(spktest.GetOutput())), vec["expected"]["scriptPubKey"].get_str());
     417                 :          0 :         BOOST_CHECK_EQUAL(EncodeDestination(spktest.GetOutput()), vec["expected"]["bip350Address"].get_str());
     418                 :          0 :         auto spend_data = spktest.GetSpendData();
     419                 :          0 :         BOOST_CHECK_EQUAL(vec["intermediary"]["merkleRoot"].isNull(), spend_data.merkle_root.IsNull());
     420                 :          0 :         if (!spend_data.merkle_root.IsNull()) {
     421                 :          0 :             BOOST_CHECK_EQUAL(vec["intermediary"]["merkleRoot"].get_str(), HexStr(spend_data.merkle_root));
     422                 :          0 :         }
     423                 :          0 :         BOOST_CHECK_EQUAL(spend_data.scripts.size(), scriptposes.size());
     424                 :          0 :         for (const auto& scriptpos : scriptposes) {
     425                 :          0 :             BOOST_CHECK(spend_data.scripts[scriptpos.first] == control_set{ParseHex(vec["expected"]["scriptPathControlBlocks"][scriptpos.second].get_str())});
     426                 :            :         }
     427                 :          0 :     }
     428                 :          0 : }
     429                 :            : 
     430                 :          0 : BOOST_AUTO_TEST_SUITE_END()