Inside Bitcoin

1501}
1502
1503BOOST_AUTO_TEST_CASE(script_byte_array_u8_vector_equivalence)
1504{
1505    const CScript scriptPubKey1 = CScript() << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"_hex_v_u8 << OP_CHECKSIG;
1506    const CScript scriptPubKey2 = CScript() << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"_hex << OP_CHECKSIG;
1507    BOOST_CHECK(scriptPubKey1 == scriptPubKey2);
1508}
1509
1510BOOST_AUTO_TEST_CASE(script_FindAndDelete)
1511{
1512    // Exercise the FindAndDelete functionality
1513    CScript s;
1514    CScript d;
1515    CScript expect;
1516
1517    s = CScript() << OP_1 << OP_2;
1518    d = CScript(); // delete nothing should be a no-op
1519    expect = s;
1520    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
1521    BOOST_CHECK(s == expect);
1522
1523    s = CScript() << OP_1 << OP_2 << OP_3;
1524    d = CScript() << OP_2;
1525    expect = CScript() << OP_1 << OP_3;
1526    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1527    BOOST_CHECK(s == expect);
1528
1529    s = CScript() << OP_3 << OP_1 << OP_3 << OP_3 << OP_4 << OP_3;
1530    d = CScript() << OP_3;
1531    expect = CScript() << OP_1 << OP_4;
1532    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 4);
1533    BOOST_CHECK(s == expect);
1534
1535    s = ToScript("0302ff03"_hex); // PUSH 0x02ff03 onto stack
1536    d = ToScript("0302ff03"_hex);
1537    expect = CScript();
1538    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1539    BOOST_CHECK(s == expect);
1540
1541    s = ToScript("0302ff030302ff03"_hex); // PUSH 0x02ff03 PUSH 0x02ff03
1542    d = ToScript("0302ff03"_hex);
1543    expect = CScript();
1544    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
1545    BOOST_CHECK(s == expect);
1546
1547    s = ToScript("0302ff030302ff03"_hex);
1548    d = ToScript("02"_hex);
1549    expect = s; // FindAndDelete matches entire opcodes
1550    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
1551    BOOST_CHECK(s == expect);
1552
1553    s = ToScript("0302ff030302ff03"_hex);
1554    d = ToScript("ff"_hex);
1555    expect = s;
1556    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
1557    BOOST_CHECK(s == expect);
1558
1559    // This is an odd edge case: strip of the push-three-bytes
1560    // prefix, leaving 02ff03 which is push-two-bytes:
1561    s = ToScript("0302ff030302ff03"_hex);
1562    d = ToScript("03"_hex);
1563    expect = CScript() << "ff03"_hex << "ff03"_hex;
1564    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
1565    BOOST_CHECK(s == expect);
1566
1567    // Byte sequence that spans multiple opcodes:
1568    s = ToScript("02feed5169"_hex); // PUSH(0xfeed) OP_1 OP_VERIFY
1569    d = ToScript("feed51"_hex);
1570    expect = s;
1571    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0); // doesn't match 'inside' opcodes
1572    BOOST_CHECK(s == expect);
1573
1574    s = ToScript("02feed5169"_hex); // PUSH(0xfeed) OP_1 OP_VERIFY
1575    d = ToScript("02feed51"_hex);
1576    expect = ToScript("69"_hex);
1577    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1578    BOOST_CHECK(s == expect);
1579
1580    s = ToScript("516902feed5169"_hex);
1581    d = ToScript("feed51"_hex);
1582    expect = s;
1583    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
1584    BOOST_CHECK(s == expect);
1585
1586    s = ToScript("516902feed5169"_hex);
1587    d = ToScript("02feed51"_hex);
1588    expect = ToScript("516969"_hex);
1589    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1590    BOOST_CHECK(s == expect);
1591
1592    s = CScript() << OP_0 << OP_0 << OP_1 << OP_1;
1593    d = CScript() << OP_0 << OP_1;
1594    expect = CScript() << OP_0 << OP_1; // FindAndDelete is single-pass
1595    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1596    BOOST_CHECK(s == expect);
1597
1598    s = CScript() << OP_0 << OP_0 << OP_1 << OP_0 << OP_1 << OP_1;
1599    d = CScript() << OP_0 << OP_1;
1600    expect = CScript() << OP_0 << OP_1; // FindAndDelete is single-pass
1601    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
1602    BOOST_CHECK(s == expect);
1603
1604    // Another weird edge case:
1605    // End with invalid push (not enough data)...
1606    s = ToScript("0003feed"_hex);
1607    d = ToScript("03feed"_hex); // ... can remove the invalid push
1608    expect = ToScript("00"_hex);
1609    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1610    BOOST_CHECK(s == expect);
1611
1612    s = ToScript("0003feed"_hex);
1613    d = ToScript("00"_hex);
1614    expect = ToScript("03feed"_hex);
1615    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
1616    BOOST_CHECK(s == expect);
1617}
1618
1619BOOST_AUTO_TEST_CASE(script_HasValidOps)
1620{
1621    // Exercise the HasValidOps functionality
1622    CScript script;
1623    script = ToScript("76a9141234567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac"_hex); // Normal script
1624    BOOST_CHECK(script.HasValidOps());
1625    script = ToScript("76a914ff34567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac"_hex);
1626    BOOST_CHECK(script.HasValidOps());
1627    script = ToScript("ff88ac"_hex); // Script with OP_INVALIDOPCODE explicit
1628    BOOST_CHECK(!script.HasValidOps());
1629    script = ToScript("88acc0"_hex); // Script with undefined opcode
1630    BOOST_CHECK(!script.HasValidOps());
1631}
1632
1633BOOST_AUTO_TEST_CASE(bip341_keypath_test_vectors)
1634{
1635    UniValue tests;
1636    Assert(tests.read(json_tests::bip341_wallet_vectors));
1637
1638    const auto& vectors = tests["keyPathSpending"];
1639
1640    for (const auto& vec : vectors.getValues()) {
1641        auto txhex = ParseHex(vec["given"]["rawUnsignedTx"].get_str());
1642        CMutableTransaction tx;
1643        SpanReader{txhex} >> TX_WITH_WITNESS(tx);
1644        std::vector<CTxOut> utxos;
1645        for (const auto& utxo_spent : vec["given"]["utxosSpent"].getValues()) {
1646            auto script_bytes = ParseHex(utxo_spent["scriptPubKey"].get_str());
1647            CScript script{script_bytes.begin(), script_bytes.end()};
1648            CAmount amount{utxo_spent["amountSats"].getInt<int>()};
1649            utxos.emplace_back(amount, script);
1650        }
1651
1652        PrecomputedTransactionData txdata;
1653        txdata.Init(tx, std::vector<CTxOut>{utxos}, true);
1654
1655        BOOST_CHECK(txdata.m_bip341_taproot_ready);
1656        BOOST_CHECK_EQUAL(HexStr(txdata.m_spent_amounts_single_hash), vec["intermediary"]["hashAmounts"].get_str());
1657        BOOST_CHECK_EQUAL(HexStr(txdata.m_outputs_single_hash), vec["intermediary"]["hashOutputs"].get_str());
1658        BOOST_CHECK_EQUAL(HexStr(txdata.m_prevouts_single_hash), vec["intermediary"]["hashPrevouts"].get_str());
1659        BOOST_CHECK_EQUAL(HexStr(txdata.m_spent_scripts_single_hash), vec["intermediary"]["hashScriptPubkeys"].get_str());
1660        BOOST_CHECK_EQUAL(HexStr(txdata.m_sequences_single_hash), vec["intermediary"]["hashSequences"].get_str());
1661
1662        for (const auto& input : vec["inputSpending"].getValues()) {
1663            int txinpos = input["given"]["txinIndex"].getInt<int>();
1664            int hashtype = input["given"]["hashType"].getInt<int>();
1665
1666            // Load key.
1667            auto privkey = ParseHex(input["given"]["internalPrivkey"].get_str());
1668            CKey key;
1669            key.Set(privkey.begin(), privkey.end(), true);
1670
1671            // Load Merkle root.
1672            uint256 merkle_root;
1673            if (!input["given"]["merkleRoot"].isNull()) {
1674                merkle_root = uint256{ParseHex(input["given"]["merkleRoot"].get_str())};
1675            }
1676
1677            // Compute and verify (internal) public key.
1678            XOnlyPubKey pubkey{key.GetPubKey()};
1679            BOOST_CHECK_EQUAL(HexStr(pubkey), input["intermediary"]["internalPubkey"].get_str());
1680
1681            // Sign and verify signature.
1682            FlatSigningProvider provider;
1683            provider.keys[key.GetPubKey().GetID()] = key;
1684            MutableTransactionSignatureCreator creator(tx, txinpos, utxos[txinpos].nValue, &txdata, {.sighash_type = hashtype});
1685            std::vector<unsigned char> signature;
1686            BOOST_CHECK(creator.CreateSchnorrSig(provider, signature, pubkey, nullptr, &merkle_root, SigVersion::TAPROOT));
1687            BOOST_CHECK_EQUAL(HexStr(signature), input["expected"]["witness"][0].get_str());
1688
1689            // We can't observe the tweak used inside the signing logic, so verify by recomputing it.
1690            BOOST_CHECK_EQUAL(HexStr(pubkey.ComputeTapTweakHash(merkle_root.IsNull() ? nullptr : &merkle_root)), input["intermediary"]["tweak"].get_str());
1691
1692            // We can't observe the sighash used inside the signing logic, so verify by recomputing it.
1693            ScriptExecutionData sed;
1694            sed.m_annex_init = true;
1695            sed.m_annex_present = false;
1696            uint256 sighash;
1697            BOOST_CHECK(SignatureHashSchnorr(sighash, sed, tx, txinpos, hashtype, SigVersion::TAPROOT, txdata, MissingDataBehavior::FAIL));
1698            BOOST_CHECK_EQUAL(HexStr(sighash), input["intermediary"]["sigHash"].get_str());
1699
1700            // To verify the sigmsg, hash the expected sigmsg, and compare it with the (expected) sighash.
1701            BOOST_CHECK_EQUAL(HexStr((HashWriter{HASHER_TAPSIGHASH} << std::span<const uint8_t>{ParseHex(input["intermediary"]["sigMsg"].get_str())}).GetSHA256()), input["intermediary"]["sigHash"].get_str());
1702        }
1703    }
1704}
1705
1706BOOST_AUTO_TEST_CASE(compute_tapbranch)
1707{
1708    constexpr uint256 hash1{"8ad69ec7cf41c2a4001fd1f738bf1e505ce2277acdcaa63fe4765192497f47a7"};
1709    constexpr uint256 hash2{"f224a923cd0021ab202ab139cc56802ddb92dcfc172b9212261a539df79a112a"};
1710    constexpr uint256 result{"a64c5b7b943315f9b805d7a7296bedfcfd08919270a1f7a1466e98f8693d8cd9"};
1711    BOOST_CHECK_EQUAL(ComputeTapbranchHash(hash1, hash2), result);
1712}
1713
1714BOOST_AUTO_TEST_CASE(compute_tapleaf)
1715{
1716    constexpr uint8_t script[6] = {'f','o','o','b','a','r'};
1717    constexpr uint256 tlc0{"edbc10c272a1215dcdcc11d605b9027b5ad6ed97cd45521203f136767b5b9c06"};
1718    constexpr uint256 tlc2{"8b5c4f90ae6bf76e259dbef5d8a59df06359c391b59263741b25eca76451b27a"};
1719
1720    BOOST_CHECK_EQUAL(ComputeTapleafHash(0xc0, std::span(script)), tlc0);
1721    BOOST_CHECK_EQUAL(ComputeTapleafHash(0xc2, std::span(script)), tlc2);
1722}
1723
1724BOOST_AUTO_TEST_CASE(formatscriptflags)
1725{
1726    // quick check that FormatScriptFlags reports any unknown/unexpected bits
1727    BOOST_CHECK_EQUAL(FormatScriptFlags(SCRIPT_VERIFY_P2SH), "P2SH");
1728    BOOST_CHECK_EQUAL(FormatScriptFlags(SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_TAPROOT), "P2SH,TAPROOT");
1729    BOOST_CHECK_EQUAL(FormatScriptFlags(SCRIPT_VERIFY_P2SH | script_verify_flags::from_int(1u<<31)), "P2SH,0x80000000");
1730    BOOST_CHECK_EQUAL(FormatScriptFlags(SCRIPT_VERIFY_TAPROOT | script_verify_flags::from_int(1u<<27)), "TAPROOT,0x08000000");
1731    BOOST_CHECK_EQUAL(FormatScriptFlags(SCRIPT_VERIFY_TAPROOT | script_verify_flags::from_int((1u<<28) | (1ull<<58))), "TAPROOT,0x400000010000000");
1732    BOOST_CHECK_EQUAL(FormatScriptFlags(script_verify_flags::from_int(1u<<26)), "0x04000000");
1733}
1734
1735BOOST_AUTO_TEST_SUITE_END()
1736