Inside Bitcoin

1001                                self.nodes[0].converttopsbt, hexstring=signedtx['hex'], permitsigdata=False, iswitness=True)
1002        # Unless we allow it to convert and strip signatures
1003        self.nodes[0].converttopsbt(hexstring=signedtx['hex'], permitsigdata=True)
1004
1005        # Create outputs to nodes 1 and 2
1006        # (note that we intentionally create two different txs here, as we want
1007        #  to check that each node is missing prevout data for one of the two
1008        #  utxos, see "should only have data for one input" test below)
1009        node1_addr = self.nodes[1].getnewaddress()
1010        node2_addr = self.nodes[2].getnewaddress()
1011        utxo1 = self.create_outpoints(self.nodes[0], outputs=[{node1_addr: 13}])[0]
1012        utxo2 = self.create_outpoints(self.nodes[0], outputs=[{node2_addr: 13}])[0]
1013        self.generate(self.nodes[0], 6)[0]
1014
1015        # Create a psbt spending outputs from nodes 1 and 2
1016        psbt_orig = self.nodes[0].createpsbt([utxo1, utxo2], {self.nodes[0].getnewaddress():25.999})
1017
1018        # Check that the default psbt version is 2
1019        assert_equal(self.nodes[0].decodepsbt(psbt_orig)["psbt_version"], 2)
1020
1021        # Update psbts, should only have data for one input and not the other
1022        psbt1 = self.nodes[1].walletprocesspsbt(psbt_orig, False, "ALL")['psbt']
1023        psbt1_decoded = self.nodes[0].decodepsbt(psbt1)
1024        assert len(psbt1_decoded['inputs'][0].keys()) > 3
1025        assert len(psbt1_decoded['inputs'][1].keys()) == 3
1026        # Check that BIP32 path was added
1027        assert "bip32_derivs" in psbt1_decoded['inputs'][0]
1028        psbt2 = self.nodes[2].walletprocesspsbt(psbt_orig, False, "ALL", False)['psbt']
1029        psbt2_decoded = self.nodes[0].decodepsbt(psbt2)
1030        assert len(psbt2_decoded['inputs'][0].keys()) == 3
1031        assert len(psbt2_decoded['inputs'][1].keys()) > 3
1032        # Check that BIP32 paths were not added
1033        assert "bip32_derivs" not in psbt2_decoded['inputs'][1]
1034
1035        # Sign PSBTs (workaround issue #18039)
1036        psbt1 = self.nodes[1].walletprocesspsbt(psbt_orig)['psbt']
1037        psbt2 = self.nodes[2].walletprocesspsbt(psbt_orig)['psbt']
1038
1039        # Combine, finalize, and send the psbts
1040        combined = self.nodes[0].combinepsbt([psbt1, psbt2])
1041        finalized = self.nodes[0].finalizepsbt(combined)['hex']
1042        self.nodes[0].sendrawtransaction(finalized)
1043        self.generate(self.nodes[0], 6)
1044
1045        # Test additional args in walletcreatepsbt
1046        # Make sure both pre-included and funded inputs
1047        # have the correct sequence numbers based on
1048        # replaceable arg
1049        block_height = self.nodes[0].getblockcount()
1050        unspent = self.nodes[0].listunspent()[0]
1051        psbtx_info = self.nodes[0].walletcreatefundedpsbt([{"txid":unspent["txid"], "vout":unspent["vout"]}], [{self.nodes[2].getnewaddress():unspent["amount"]+1}], block_height+2, {"replaceable": False, "add_inputs": True}, False)
1052        decoded_psbt = self.nodes[0].decodepsbt(psbtx_info["psbt"])
1053        for psbt_in in decoded_psbt["inputs"]:
1054            assert_greater_than(psbt_in["sequence"], MAX_BIP125_RBF_SEQUENCE)
1055            assert "bip32_derivs" not in psbt_in
1056        assert_equal(decoded_psbt["fallback_locktime"], block_height+2)
1057
1058        # Same construction with only locktime set and RBF explicitly enabled
1059        psbtx_info = self.nodes[0].walletcreatefundedpsbt([{"txid":unspent["txid"], "vout":unspent["vout"]}], [{self.nodes[2].getnewaddress():unspent["amount"]+1}], block_height, {"replaceable": True, "add_inputs": True}, True)
1060        decoded_psbt = self.nodes[0].decodepsbt(psbtx_info["psbt"])
1061        for psbt_in in decoded_psbt["inputs"]:
1062            assert_equal(psbt_in["sequence"], MAX_BIP125_RBF_SEQUENCE)
1063            assert "bip32_derivs" in psbt_in
1064        assert_equal(decoded_psbt["fallback_locktime"], block_height)
1065
1066        # Same construction without optional arguments
1067        psbtx_info = self.nodes[0].walletcreatefundedpsbt([], [{self.nodes[2].getnewaddress():unspent["amount"]+1}])
1068        decoded_psbt = self.nodes[0].decodepsbt(psbtx_info["psbt"])
1069        for psbt_in in decoded_psbt["inputs"]:
1070            assert_equal(psbt_in["sequence"], MAX_BIP125_RBF_SEQUENCE)
1071            assert "bip32_derivs" in psbt_in
1072        assert_equal(decoded_psbt["fallback_locktime"], 0)
1073
1074        # Make sure change address wallet does not have P2SH innerscript access to results in success
1075        # when attempting BnB coin selection
1076        self.nodes[0].walletcreatefundedpsbt([], [{self.nodes[2].getnewaddress():unspent["amount"]+1}], block_height+2, {"changeAddress":self.nodes[1].getnewaddress()}, False)
1077
1078        # Make sure the wallet's change type is respected by default
1079        small_output = {self.nodes[0].getnewaddress():0.1}
1080        psbtx_native = self.nodes[0].walletcreatefundedpsbt([], [small_output])
1081        self.assert_change_type(psbtx_native, "witness_v0_keyhash")
1082        psbtx_legacy = self.nodes[1].walletcreatefundedpsbt([], [small_output])
1083        self.assert_change_type(psbtx_legacy, "pubkeyhash")
1084
1085        # Make sure the change type of the wallet can also be overwritten
1086        psbtx_np2wkh = self.nodes[1].walletcreatefundedpsbt([], [small_output], 0, {"change_type":"p2sh-segwit"})
1087        self.assert_change_type(psbtx_np2wkh, "scripthash")
1088
1089        # Make sure the change type cannot be specified if a change address is given
1090        invalid_options = {"change_type":"legacy","changeAddress":self.nodes[0].getnewaddress()}
1091        assert_raises_rpc_error(-8, "both change address and address type options", self.nodes[0].walletcreatefundedpsbt, [], [small_output], 0, invalid_options)
1092
1093        # Regression test for 14473 (mishandling of already-signed witness transaction):
1094        psbtx_info = self.nodes[0].walletcreatefundedpsbt([{"txid":unspent["txid"], "vout":unspent["vout"]}], [{self.nodes[2].getnewaddress():unspent["amount"]+1}], 0, {"add_inputs": True})
1095        complete_psbt = self.nodes[0].walletprocesspsbt(psbtx_info["psbt"])
1096        double_processed_psbt = self.nodes[0].walletprocesspsbt(complete_psbt["psbt"])
1097        assert_equal(complete_psbt, double_processed_psbt)
1098        # We don't care about the decode result, but decoding must succeed.
1099        self.nodes[0].decodepsbt(double_processed_psbt["psbt"])
1100
1101        # Make sure unsafe inputs are included if specified
1102        self.nodes[2].createwallet(wallet_name="unsafe")
1103        wunsafe = self.nodes[2].get_wallet_rpc("unsafe")
1104        self.nodes[0].sendtoaddress(wunsafe.getnewaddress(), 2)
1105        self.sync_mempools()
1106        assert_raises_rpc_error(-4, "Insufficient funds", wunsafe.walletcreatefundedpsbt, [], [{self.nodes[0].getnewaddress(): 1}])
1107        wunsafe.walletcreatefundedpsbt([], [{self.nodes[0].getnewaddress(): 1}], 0, {"include_unsafe": True})
1108
1109        self.log.info("Test that unknown values are just passed through")
1110        unknown_type = b'\xf0'
1111        unknown_key = unknown_type + bytes(range(1, 10))
1112        unknown_value = bytes(range(1, 16))
1113
1114        unknown_psbt = self.create_psbt(inputs={unknown_key: unknown_value}).to_base64()
1115        unknown_out = self.nodes[0].walletprocesspsbt(unknown_psbt)['psbt']
1116        assert_equal(unknown_psbt, unknown_out)
1117
1118        unknown_key2 = unknown_type + bytes(range(1, 9)) + bytes(11)
1119        unknown_psbt2 = self.create_psbt(inputs={unknown_key2: unknown_value}).to_base64()
1120        merged_unknown = self.nodes[0].combinepsbt([unknown_psbt, unknown_psbt2])
1121        merged_unknown_psbt = PSBT.from_base64(merged_unknown)
1122        assert_equal(merged_unknown_psbt.i[0].map[unknown_key], unknown_value)
1123        assert_equal(merged_unknown_psbt.i[0].map[unknown_key2], unknown_value)
1124
1125        # The explicit PSBT_GLOBAL_VERSION=0 encoding is equivalent to omitting the
1126        # version field, and both accepted v0 encodings can be merged.
1127        explicit_v0_psbt = self.create_psbt(inputs={unknown_key2: unknown_value})
1128        explicit_v0_psbt.g.map[PSBT_GLOBAL_VERSION] = (0).to_bytes(4, "little")
1129        merged_v0_versions = self.nodes[0].combinepsbt([unknown_psbt, explicit_v0_psbt.to_base64()])
1130        merged_v0_versions_psbt = PSBT.from_base64(merged_v0_versions)
1131        assert_equal(merged_v0_versions_psbt.i[0].map[unknown_key], unknown_value)
1132        assert_equal(merged_v0_versions_psbt.i[0].map[unknown_key2], unknown_value)
1133
1134        # BIP 174 Test Vectors
1135
1136        # Open the data file
1137        with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'data/rpc_psbt.json')) as f:
1138            d = json.load(f)
1139            invalids = d['invalid']
1140            invalid_with_msgs = d["invalid_with_msg"]
1141            valids = d['valid']
1142            creators = d['creator']
1143            signers = d['signer']
1144            combiners = d['combiner']
1145            finalizers = d['finalizer']
1146            extractors = d['extractor']
1147
1148        # Invalid PSBTs
1149        for invalid in invalids:
1150            assert_raises_rpc_error(-22, "TX decode failed", self.nodes[0].decodepsbt, invalid)
1151        for invalid in invalid_with_msgs:
1152            psbt, msg = invalid
1153            assert_raises_rpc_error(-22, f"TX decode failed {msg}", self.nodes[0].decodepsbt, psbt)
1154
1155        # Valid PSBTs
1156        for valid in valids:
1157            self.nodes[0].decodepsbt(valid)
1158
1159        # Creator Tests
1160        for creator in creators:
1161            created_tx = self.nodes[0].createpsbt(inputs=creator['inputs'], outputs=creator['outputs'], replaceable=False, psbt_version=creator['version'])
1162            assert_equal(created_tx, creator['result'])
1163
1164        # Signer tests
1165        for i, signer in enumerate(signers):
1166            self.nodes[2].createwallet(wallet_name="wallet{}".format(i))
1167            wrpc = self.nodes[2].get_wallet_rpc("wallet{}".format(i))
1168            for key in signer['privkeys']:
1169                wallet_importprivkey(wrpc, key, "now")
1170            signed_tx = wrpc.walletprocesspsbt(signer['psbt'], True, "ALL")['psbt']
1171            assert_equal(signed_tx, signer['result'])
1172
1173        # Combiner test
1174        for combiner in combiners:
1175            combined = self.nodes[2].combinepsbt(combiner['combine'])
1176            assert_equal(combined, combiner['result'])
1177
1178        # Empty combiner test
1179        assert_raises_rpc_error(-8, "Parameter 'txs' cannot be empty", self.nodes[0].combinepsbt, [])
1180
1181        # Finalizer test
1182        for finalizer in finalizers:
1183            finalized = self.nodes[2].finalizepsbt(finalizer['finalize'], False)['psbt']
1184            assert_equal(finalized, finalizer['result'])
1185
1186        # Extractor test
1187        for extractor in extractors:
1188            extracted = self.nodes[2].finalizepsbt(extractor['extract'], True)['hex']
1189            assert_equal(extracted, extractor['result'])
1190
1191        # Unload extra wallets
1192        for i, signer in enumerate(signers):
1193            self.nodes[2].unloadwallet("wallet{}".format(i))
1194
1195        self.test_utxo_conversion()
1196        self.test_psbt_incomplete_after_invalid_modification()
1197
1198        self.test_input_confs_control()
1199
1200        # Test that psbts with p2pkh outputs are created properly
1201        p2pkh = self.nodes[0].getnewaddress(address_type='legacy')
1202        psbt = self.nodes[1].walletcreatefundedpsbt(inputs=[], outputs=[{p2pkh : 1}], bip32derivs=True)
1203        self.nodes[0].decodepsbt(psbt['psbt'])
1204
1205        # Test decoding error: invalid base64
1206        assert_raises_rpc_error(-22, "TX decode failed invalid base64", self.nodes[0].decodepsbt, ";definitely not base64;")
1207
1208        # Send to all types of addresses
1209        addr1 = self.nodes[1].getnewaddress("", "bech32")
1210        addr2 = self.nodes[1].getnewaddress("", "legacy")
1211        addr3 = self.nodes[1].getnewaddress("", "p2sh-segwit")
1212        utxo1, utxo2, utxo3 = self.create_outpoints(self.nodes[1], outputs=[{addr1: 11}, {addr2: 11}, {addr3: 11}])
1213        self.sync_all()
1214
1215        psbt_v2_required_keys = ["previous_txid", "previous_vout", "sequence"]
1216
1217        def test_psbt_input_keys(psbt_input, keys):
1218            """Check that the psbt input has only the expected keys."""
1219            keys.extend(["previous_txid", "previous_vout", "sequence"])
1220            assert_equal(set(keys), set(psbt_input.keys()))
1221
1222        # Create a PSBT. None of the inputs are filled initially
1223        psbt = self.nodes[1].createpsbt([utxo1, utxo2, utxo3], {self.nodes[0].getnewaddress():32.999})
1224        decoded = self.nodes[1].decodepsbt(psbt)
1225        test_psbt_input_keys(decoded['inputs'][0], psbt_v2_required_keys)
1226        test_psbt_input_keys(decoded['inputs'][1], psbt_v2_required_keys)
1227        test_psbt_input_keys(decoded['inputs'][2], psbt_v2_required_keys)
1228
1229        # Update a PSBT with UTXOs from the node
1230        # Bech32 inputs should be filled with witness UTXO. Other inputs should not be filled because they are non-witness
1231        updated = self.nodes[1].utxoupdatepsbt(psbt)
1232        decoded = self.nodes[1].decodepsbt(updated)
1233        test_psbt_input_keys(decoded['inputs'][0], psbt_v2_required_keys + ['witness_utxo', 'non_witness_utxo'])
1234        test_psbt_input_keys(decoded['inputs'][1], psbt_v2_required_keys + ['non_witness_utxo'])
1235        test_psbt_input_keys(decoded['inputs'][2], psbt_v2_required_keys + ['non_witness_utxo'])
1236
1237        # Try again, now while providing descriptors, making P2SH-segwit work, and causing bip32_derivs and redeem_script to be filled in
1238        descs = [self.nodes[1].getaddressinfo(addr)['desc'] for addr in [addr1,addr2,addr3]]
1239        updated = self.nodes[1].utxoupdatepsbt(psbt=psbt, descriptors=descs)
1240        decoded = self.nodes[1].decodepsbt(updated)
1241        test_psbt_input_keys(decoded['inputs'][0], psbt_v2_required_keys + ['witness_utxo', 'non_witness_utxo', 'bip32_derivs'])
1242        test_psbt_input_keys(decoded['inputs'][1], psbt_v2_required_keys + ['non_witness_utxo', 'bip32_derivs'])
1243        test_psbt_input_keys(decoded['inputs'][2], psbt_v2_required_keys + ['non_witness_utxo', 'witness_utxo', 'bip32_derivs', 'redeem_script'])
1244
1245        # Cannot join PSBTv2s
1246        psbt1 = self.nodes[1].createpsbt(inputs=[utxo1], outputs={self.nodes[0].getnewaddress():Decimal('10.999')}, psbt_version=0)
1247        psbt2 = self.nodes[1].createpsbt(inputs=[utxo1], outputs={self.nodes[0].getnewaddress():Decimal('10.999')}, psbt_version=2)
1248        assert_raises_rpc_error(-8, "joinpsbts only operates on version 0 PSBTs", self.nodes[1].joinpsbts, [psbt1, psbt2])
1249
1250        # Two PSBTs with a common input should not be joinable