Inside Bitcoin

1501
1502        psbt = watchonly.sendall([wallet.getnewaddress(), addr])["psbt"]
1503        processed_psbt = self.nodes[0].walletprocesspsbt(psbt)
1504        txid = self.nodes[0].sendrawtransaction(processed_psbt["hex"])
1505        vout = find_vout_for_address(self.nodes[0], txid, addr)
1506
1507        # Make sure tap tree is in psbt
1508        parsed_psbt = PSBT.from_base64(psbt)
1509        assert_greater_than(len(parsed_psbt.o[vout].map[PSBT_OUT_TAP_TREE]), 0)
1510        assert "taproot_tree" in self.nodes[0].decodepsbt(psbt)["outputs"][vout]
1511        parsed_psbt.make_blank()
1512        comb_psbt = self.nodes[0].combinepsbt([psbt, parsed_psbt.to_base64()])
1513        assert_equal(comb_psbt, psbt)
1514
1515        self.log.info("Test that walletprocesspsbt both updates and signs a non-updated psbt containing Taproot inputs")
1516        addr = self.nodes[0].getnewaddress("", "bech32m")
1517        utxo = self.create_outpoints(self.nodes[0], outputs=[{addr: 1}])[0]
1518        psbt = self.nodes[0].createpsbt([utxo], [{self.nodes[0].getnewaddress(): 0.9999}])
1519        signed = self.nodes[0].walletprocesspsbt(psbt)
1520        rawtx = signed["hex"]
1521        self.nodes[0].sendrawtransaction(rawtx)
1522        self.generate(self.nodes[0], 1)
1523
1524        # Make sure tap tree is not in psbt
1525        parsed_psbt = PSBT.from_base64(psbt)
1526        assert PSBT_OUT_TAP_TREE not in parsed_psbt.o[0].map
1527        assert "taproot_tree" not in self.nodes[0].decodepsbt(psbt)["outputs"][0]
1528        parsed_psbt.make_blank()
1529        comb_psbt = self.nodes[0].combinepsbt([psbt, parsed_psbt.to_base64()])
1530        assert_equal(comb_psbt, psbt)
1531
1532        self.log.info("Test walletprocesspsbt raises if an invalid sighashtype is passed")
1533        assert_raises_rpc_error(-8, "'all' is not a valid sighash parameter.", self.nodes[0].walletprocesspsbt, psbt=psbt, sighashtype="all")
1534
1535        self.log.info("Test decoding PSBT with per-input preimage types")
1536        # note that the decodepsbt RPC doesn't check whether preimages and hashes match
1537        hash_ripemd160, preimage_ripemd160 = randbytes(20), randbytes(50)
1538        hash_sha256, preimage_sha256 = randbytes(32), randbytes(50)
1539        hash_hash160, preimage_hash160 = randbytes(20), randbytes(50)
1540        hash_hash256, preimage_hash256 = randbytes(32), randbytes(50)
1541
1542        tx = CTransaction()
1543        tx.vin = [CTxIn(outpoint=COutPoint(hash=int('aa' * 32, 16), n=0), scriptSig=b""),
1544                  CTxIn(outpoint=COutPoint(hash=int('bb' * 32, 16), n=0), scriptSig=b""),
1545                  CTxIn(outpoint=COutPoint(hash=int('cc' * 32, 16), n=0), scriptSig=b""),
1546                  CTxIn(outpoint=COutPoint(hash=int('dd' * 32, 16), n=0), scriptSig=b"")]
1547        tx.vout = [CTxOut(nValue=0, scriptPubKey=b"")]
1548        psbt = PSBT()
1549        psbt.g = PSBTMap({PSBT_GLOBAL_UNSIGNED_TX: tx.serialize()})
1550        psbt.i = [PSBTMap({bytes([PSBT_IN_RIPEMD160]) + hash_ripemd160: preimage_ripemd160}),
1551                  PSBTMap({bytes([PSBT_IN_SHA256]) + hash_sha256: preimage_sha256}),
1552                  PSBTMap({bytes([PSBT_IN_HASH160]) + hash_hash160: preimage_hash160}),
1553                  PSBTMap({bytes([PSBT_IN_HASH256]) + hash_hash256: preimage_hash256})]
1554        psbt.o = [PSBTMap()]
1555        res_inputs = self.nodes[0].decodepsbt(psbt.to_base64())["inputs"]
1556        assert_equal(len(res_inputs), 4)
1557        preimage_keys = ["ripemd160_preimages", "sha256_preimages", "hash160_preimages", "hash256_preimages"]
1558        expected_hashes = [hash_ripemd160, hash_sha256, hash_hash160, hash_hash256]
1559        expected_preimages = [preimage_ripemd160, preimage_sha256, preimage_hash160, preimage_hash256]
1560        for res_input, preimage_key, hash, preimage in zip(res_inputs, preimage_keys, expected_hashes, expected_preimages):
1561            assert preimage_key in res_input
1562            assert_equal(len(res_input[preimage_key]), 1)
1563            assert hash.hex() in res_input[preimage_key]
1564            assert_equal(res_input[preimage_key][hash.hex()], preimage.hex())
1565
1566        self.test_decodepsbt_musig2_input_output_types()
1567
1568        self.test_combinepsbt_preserves_proprietary_fields()
1569        self.test_combinepsbt_global_xpub_origin_conflict()
1570        self.test_combinepsbt_tap_leaf_script_conflict()
1571
1572        self.log.info("Test that combining PSBTs with different transactions fails")
1573        tx = CTransaction()
1574        tx.vin = [CTxIn(outpoint=COutPoint(hash=int('aa' * 32, 16), n=0), scriptSig=b"")]
1575        tx.vout = [CTxOut(nValue=0, scriptPubKey=b"")]
1576        psbt1 = PSBT(g=PSBTMap({PSBT_GLOBAL_UNSIGNED_TX: tx.serialize()}), i=[PSBTMap()], o=[PSBTMap()]).to_base64()
1577        tx.vout[0].nValue += 1  # slightly modify tx
1578        psbt2 = PSBT(g=PSBTMap({PSBT_GLOBAL_UNSIGNED_TX: tx.serialize()}), i=[PSBTMap()], o=[PSBTMap()]).to_base64()
1579        assert_raises_rpc_error(-8, "PSBTs not compatible (different transactions)", self.nodes[0].combinepsbt, [psbt1, psbt2])
1580        assert_equal(self.nodes[0].combinepsbt([psbt1, psbt1]), psbt1)
1581
1582        self.log.info("Test that PSBT inputs are being checked via script execution")
1583        acs_prevout = CTxOut(nValue=0, scriptPubKey=CScript([OP_TRUE]))
1584        tx = CTransaction()
1585        tx.vin = [CTxIn(outpoint=COutPoint(hash=int('dd' * 32, 16), n=0), scriptSig=b"")]
1586        tx.vout = [CTxOut(nValue=0, scriptPubKey=b"")]
1587        psbt = PSBT()
1588        psbt.g = PSBTMap({PSBT_GLOBAL_UNSIGNED_TX: tx.serialize()})
1589        psbt.i = [PSBTMap({bytes([PSBT_IN_WITNESS_UTXO]) : acs_prevout.serialize()})]
1590        psbt.o = [PSBTMap()]
1591        assert_equal(self.nodes[0].finalizepsbt(psbt.to_base64()),
1592            {'hex': '0200000001dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd0000000000000000000100000000000000000000000000', 'complete': True})
1593
1594        self.log.info("Test we don't crash when making a 0-value funded transaction at 0 fee without forcing an input selection")
1595        assert_raises_rpc_error(-4, "Transaction requires one destination of non-zero value, a non-zero feerate, or a pre-selected input", self.nodes[0].walletcreatefundedpsbt, [], [{"data": "deadbeef"}], 0, {"fee_rate": "0"})
1596
1597        self.log.info("Test descriptorprocesspsbt updates and signs a psbt with descriptors")
1598
1599        self.generate(self.nodes[2], 1)
1600
1601        # Disable the wallet for node 2 since `descriptorprocesspsbt` does not use the wallet
1602        self.restart_node(2, extra_args=["-disablewallet"])
1603        self.connect_nodes(0, 2)
1604        self.connect_nodes(1, 2)
1605
1606        key_info = get_generate_key()
1607        key = key_info.privkey
1608        address = key_info.p2wpkh_addr
1609
1610        descriptor = descsum_create(f"wpkh({key})")
1611
1612        utxo = self.create_outpoints(self.nodes[0], outputs=[{address: 1}])[0]
1613        self.sync_all()
1614
1615        self.log.info("Test descriptorprocesspsbt updates PSBT outputs")
1616        for has_input in [False, True]:
1617            output_psbt = self.nodes[2].createpsbt([utxo] if has_input else [], {address: 1})
1618            processed = self.nodes[2].descriptorprocesspsbt(psbt=output_psbt, descriptors=[descriptor], finalize=False)
1619            decoded = self.nodes[2].decodepsbt(processed["psbt"])
1620            assert_equal(len(decoded["inputs"]), int(has_input))
1621            assert_equal(len(decoded["outputs"][0]["bip32_derivs"]), 1)
1622
1623        psbt = self.nodes[2].createpsbt([utxo], {self.nodes[0].getnewaddress(): 0.99999})
1624        decoded = self.nodes[2].decodepsbt(psbt)
1625        test_psbt_input_keys(decoded['inputs'][0], [])
1626
1627        # Test that even if the wrong descriptor is given, `witness_utxo` and `non_witness_utxo`
1628        # are still added to the psbt
1629        alt_descriptor = descsum_create(f"wpkh({get_generate_key().privkey})")
1630        alt_psbt = self.nodes[2].descriptorprocesspsbt(psbt=psbt, descriptors=[alt_descriptor], sighashtype="ALL")["psbt"]
1631        decoded = self.nodes[2].decodepsbt(alt_psbt)
1632        test_psbt_input_keys(decoded['inputs'][0], ['witness_utxo', 'non_witness_utxo'])
1633
1634        # Test that the psbt is not finalized and does not have bip32_derivs unless specified
1635        processed_psbt = self.nodes[2].descriptorprocesspsbt(psbt=psbt, descriptors=[descriptor], sighashtype="ALL", bip32derivs=True, finalize=False)
1636        decoded = self.nodes[2].decodepsbt(processed_psbt['psbt'])
1637        test_psbt_input_keys(decoded['inputs'][0], ['witness_utxo', 'non_witness_utxo', 'partial_signatures', 'bip32_derivs'])
1638
1639        # If psbt not finalized, test that result does not have hex
1640        assert "hex" not in processed_psbt
1641
1642        processed_psbt = self.nodes[2].descriptorprocesspsbt(psbt=psbt, descriptors=[descriptor], sighashtype="ALL", bip32derivs=False, finalize=True)
1643        decoded = self.nodes[2].decodepsbt(processed_psbt['psbt'])
1644        test_psbt_input_keys(decoded['inputs'][0], ['witness_utxo', 'non_witness_utxo', 'final_scriptwitness'])
1645
1646        # Test psbt is complete
1647        assert_equal(processed_psbt['complete'], True)
1648
1649        # Broadcast transaction
1650        self.nodes[2].sendrawtransaction(processed_psbt['hex'])
1651
1652        self.log.info("Test descriptorprocesspsbt raises if an invalid sighashtype is passed")
1653        assert_raises_rpc_error(-8, "'all' is not a valid sighash parameter.", self.nodes[2].descriptorprocesspsbt, psbt=psbt, descriptors=[descriptor], sighashtype="all")
1654
1655        if not self.options.usecli:
1656            self.test_sighash_mismatch()
1657        self.test_sighash_adding()
1658        self.test_decodepsbt_long_sighash_type()
1659        self.test_combinepsbt_sighash_type()
1660        self.test_psbt_named_parameter_handling()
1661        self.test_psbt_roundtrip()
1662        self.test_psbt_version()
1663        self.test_psbt_with_invalid_signature()
1664        self.test_musig2_untrusted_derivation()
1665
1666if __name__ == '__main__':
1667    PSBTTest(__file__).main()
1668