Inside Bitcoin

1251        psbt2 = self.nodes[1].createpsbt([utxo1], {self.nodes[0].getnewaddress():Decimal('10.999')}, psbt_version=0)
1252        assert_raises_rpc_error(-8, "exists in multiple PSBTs", self.nodes[1].joinpsbts, [psbt1, psbt2])
1253
1254        # Join two distinct PSBTs
1255        psbt1 = self.nodes[1].createpsbt(inputs=[utxo1, utxo2, utxo3], outputs={self.nodes[0].getnewaddress():32.999}, psbt_version=0)
1256        addr4 = self.nodes[1].getnewaddress("", "p2sh-segwit")
1257        utxo4 = self.create_outpoints(self.nodes[0], outputs=[{addr4: 5}])[0]
1258        self.generate(self.nodes[0], 6)
1259        psbt2 = self.nodes[1].createpsbt([utxo4], {self.nodes[0].getnewaddress():Decimal('4.999')}, psbt_version=0)
1260        psbt2 = self.nodes[1].walletprocesspsbt(psbt2)['psbt']
1261        psbt2_decoded = self.nodes[0].decodepsbt(psbt2)
1262        assert "final_scriptwitness" in psbt2_decoded['inputs'][0] and "final_scriptSig" in psbt2_decoded['inputs'][0]
1263        joined = self.nodes[0].joinpsbts([psbt1, psbt2])
1264        joined_decoded = self.nodes[0].decodepsbt(joined)
1265        assert_equal(len(joined_decoded['inputs']), 4)
1266        assert_equal(len(joined_decoded['outputs']), 2)
1267        assert "final_scriptwitness" not in joined_decoded['inputs'][3]
1268        assert "final_scriptSig" not in joined_decoded['inputs'][3]
1269
1270        # Check that joining shuffles the inputs and outputs
1271        # 10 attempts should be enough to get a shuffled join
1272        shuffled = False
1273        for _ in range(10):
1274            shuffled_joined = self.nodes[0].joinpsbts([psbt1, psbt2])
1275            shuffled |= joined != shuffled_joined
1276            if shuffled:
1277                break
1278        assert shuffled
1279
1280        # Check that joining preserves global xpub and proprietary records
1281        def global_xpub_key(extended_pubkey):
1282            xpub_data, xpub_version = base58_to_byte(extended_pubkey)
1283            return bytes([PSBT_GLOBAL_XPUB]) + bytes([xpub_version]) + xpub_data
1284
1285        xpub1 = "tpubD6NzVbkrYhZ4XgiXtGrdW5XDAPFCL9h7we1vwNCpn8tGbBcgfVYjXyhWo4E1xkh56hjod1RhGjxbaTLV3X4FyWuejifB9jusQ46QzG87VKp"
1286        xpub_key1 = global_xpub_key(xpub1)
1287        xpub_key2 = global_xpub_key("tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B")
1288        xpub_value = b"\x00\x00\x00\x00"  # master key fingerprint with an empty derivation path
1289        global_prop_key = bytes([PSBT_GLOBAL_PROPRIETARY]) + b"\x02\x01\x02\x00"  # identifier "0102", subtype 0
1290        global_prop_value = b"\xde\xad\xbe\xef"
1291
1292        psbt1_obj = PSBT.from_base64(psbt1)
1293        psbt1_obj.g.map[xpub_key1] = xpub_value
1294        psbt1_obj.g.map[global_prop_key] = global_prop_value
1295        psbt2_obj = PSBT.from_base64(psbt2)
1296        psbt2_obj.g.map[xpub_key2] = xpub_value
1297        joined_globals = PSBT.from_base64(self.nodes[0].joinpsbts([psbt1_obj.to_base64(), psbt2_obj.to_base64()]))
1298        assert_equal(joined_globals.g.map[xpub_key1], xpub_value)
1299        assert_equal(joined_globals.g.map[xpub_key2], xpub_value)
1300        assert_equal(joined_globals.g.map[global_prop_key], global_prop_value)
1301
1302        # Same proprietary key in both PSBTs with different values: the first PSBT's value wins
1303        collide_key = bytes([PSBT_GLOBAL_PROPRIETARY]) + b"\x02\x03\x04\x00"
1304        psbt_first_obj = PSBT.from_base64(psbt1)
1305        psbt_first_obj.g.map[collide_key] = b"\x11\x11\x11\x11"
1306        psbt_second_obj = PSBT.from_base64(psbt2)
1307        psbt_second_obj.g.map[collide_key] = b"\x22\x22\x22\x22"
1308        joined_collision = PSBT.from_base64(self.nodes[0].joinpsbts([psbt_first_obj.to_base64(), psbt_second_obj.to_base64()]))
1309        assert_equal(joined_collision.g.map[collide_key], b"\x11\x11\x11\x11")
1310
1311        # Same xpub with conflicting origins: the first PSBT's origin is kept, avoiding duplicate keys
1312        conflict_first_obj = PSBT.from_base64(psbt1)
1313        conflict_first_obj.g.map[xpub_key1] = xpub_value
1314        conflict_second_obj = PSBT.from_base64(psbt2)
1315        conflict_second_obj.g.map[xpub_key1] = b"\x11\x11\x11\x11"
1316        joined_conflict = self.nodes[0].joinpsbts([conflict_first_obj.to_base64(), conflict_second_obj.to_base64()])
1317        assert_equal(self.nodes[0].decodepsbt(joined_conflict)["global_xpubs"], [{"xpub": xpub1, "master_fingerprint": "00000000", "path": "m"}])
1318
1319        # Newly created PSBT needs UTXOs and updating
1320        addr = self.nodes[1].getnewaddress("", "p2sh-segwit")
1321        utxo = self.create_outpoints(self.nodes[0], outputs=[{addr: 7}])[0]
1322        addrinfo = self.nodes[1].getaddressinfo(addr)
1323        self.generate(self.nodes[0], 6)[0]
1324        psbt = self.nodes[1].createpsbt([utxo], {self.nodes[0].getnewaddress("", "p2sh-segwit"):Decimal('6.999')})
1325        analyzed = self.nodes[0].analyzepsbt(psbt)
1326        assert_equal(analyzed['inputs'][0]['has_utxo'], False)
1327        assert_equal(analyzed['inputs'][0]['is_final'], False)
1328        assert_equal(analyzed['inputs'][0]['next'], 'updater')
1329        assert_equal(analyzed['next'], 'updater')
1330
1331        # After update with wallet, only needs signing
1332        updated = self.nodes[1].walletprocesspsbt(psbt, False, 'ALL', True)['psbt']
1333        analyzed = self.nodes[0].analyzepsbt(updated)
1334        assert_equal(analyzed['inputs'][0]['has_utxo'], True)
1335        assert_equal(analyzed['inputs'][0]['is_final'], False)
1336        assert_equal(analyzed['inputs'][0]['next'], 'signer')
1337        assert_equal(analyzed['next'], 'signer')
1338        assert_equal(analyzed['inputs'][0]['missing']['signatures'][0], addrinfo['embedded']['witness_program'])
1339
1340        # Check fee and size things
1341        assert_equal(analyzed['fee'], Decimal('0.001'))
1342        assert_equal(analyzed['estimated_vsize'], 134)
1343        assert_equal(analyzed['estimated_feerate'], Decimal('0.00746268'))
1344
1345        # After signing and finalizing, needs extracting
1346        signed = self.nodes[1].walletprocesspsbt(updated)['psbt']
1347        analyzed = self.nodes[0].analyzepsbt(signed)
1348        assert_equal(analyzed['inputs'][0]['has_utxo'], True)
1349        assert_equal(analyzed['inputs'][0]['is_final'], True)
1350        assert_equal(analyzed['next'], 'extractor')
1351
1352        self.log.info("PSBT spending unspendable outputs should have error message and Creator as next")
1353        analysis = self.nodes[0].analyzepsbt('cHNidP8BAJoCAAAAAljoeiG1ba8MI76OcHBFbDNvfLqlyHV5JPVFiHuyq911AAAAAAD/////g40EJ9DsZQpoqka7CwmK6kQiwHGyyng1Kgd5WdB86h0BAAAAAP////8CcKrwCAAAAAAWAEHYXCtx0AYLCcmIauuBXlCZHdoSTQDh9QUAAAAAFv8/wADXYP/7//////8JxOh0LR2HAI8AAAAAAAEBIADC6wsAAAAAF2oUt/X69ELjeX2nTof+fZ10l+OyAokDAQcJAwEHEAABAACAAAEBIADC6wsAAAAAF2oUt/X69ELjeX2nTof+fZ10l+OyAokDAQcJAwEHENkMak8AAAAA')
1354        assert_equal(analysis['next'], 'creator')
1355        assert_equal(analysis['error'], 'PSBT is not valid. Input 0 spends unspendable output')
1356
1357        self.log.info("PSBT with invalid values should have error message and Creator as next")
1358        analysis = self.nodes[0].analyzepsbt('cHNidP8BAHECAAAAAfA00BFgAm6tp86RowwH6BMImQNL5zXUcTT97XoLGz0BAAAAAAD/////AgD5ApUAAAAAFgAUKNw0x8HRctAgmvoevm4u1SbN7XL87QKVAAAAABYAFPck4gF7iL4NL4wtfRAKgQbghiTUAAAAAAABAR8AgIFq49AHABYAFJUDtxf2PHo641HEOBOAIvFMNTr2AAAA')
1359        assert_equal(analysis['next'], 'creator')
1360        assert_equal(analysis['error'], 'PSBT is not valid. Input 0 has invalid value')
1361
1362        self.log.info("PSBT with signed, but not finalized, inputs should have Finalizer as next")
1363        analysis = self.nodes[0].analyzepsbt('cHNidP8BAHECAAAAAZYezcxdnbXoQCmrD79t/LzDgtUo9ERqixk8wgioAobrAAAAAAD9////AlDDAAAAAAAAFgAUy/UxxZuzZswcmFnN/E9DGSiHLUsuGPUFAAAAABYAFLsH5o0R38wXx+X2cCosTMCZnQ4baAAAAAABAR8A4fUFAAAAABYAFOBI2h5thf3+Lflb2LGCsVSZwsltIgIC/i4dtVARCRWtROG0HHoGcaVklzJUcwo5homgGkSNAnJHMEQCIGx7zKcMIGr7cEES9BR4Kdt/pzPTK3fKWcGyCJXb7MVnAiALOBgqlMH4GbC1HDh/HmylmO54fyEy4lKde7/BT/PWxwEBAwQBAAAAIgYC/i4dtVARCRWtROG0HHoGcaVklzJUcwo5homgGkSNAnIYDwVpQ1QAAIABAACAAAAAgAAAAAAAAAAAAAAiAgL+CIiB59NSCssOJRGiMYQK1chahgAaaJpIXE41Cyir+xgPBWlDVAAAgAEAAIAAAACAAQAAAAAAAAAA')
1364        assert_equal(analysis['next'], 'finalizer')
1365
1366        analysis = self.nodes[0].analyzepsbt('cHNidP8BAHECAAAAAfA00BFgAm6tp86RowwH6BMImQNL5zXUcTT97XoLGz0BAAAAAAD/////AgCAgWrj0AcAFgAUKNw0x8HRctAgmvoevm4u1SbN7XL87QKVAAAAABYAFPck4gF7iL4NL4wtfRAKgQbghiTUAAAAAAABAR8A8gUqAQAAABYAFJUDtxf2PHo641HEOBOAIvFMNTr2AAAA')
1367        assert_equal(analysis['next'], 'creator')
1368        assert_equal(analysis['error'], 'PSBT is not valid. Output amount invalid')
1369
1370        assert_raises_rpc_error(-22, "TX decode failed", self.nodes[0].analyzepsbt, "cHNidP8BAJoCAAAAAkvEW8NnDtdNtDpsmze+Ht2LH35IJcKv00jKAlUs21RrAwAAAAD/////S8Rbw2cO1020OmybN74e3Ysffkglwq/TSMoCVSzbVGsBAAAAAP7///8CwLYClQAAAAAWABSNJKzjaUb3uOxixsvh1GGE3fW7zQD5ApUAAAAAFgAUKNw0x8HRctAgmvoevm4u1SbN7XIAAAAAAAEAnQIAAAACczMa321tVHuN4GKWKRncycI22aX3uXgwSFUKM2orjRsBAAAAAP7///9zMxrfbW1Ue43gYpYpGdzJwjbZpfe5eDBIVQozaiuNGwAAAAAA/v///wIA+QKVAAAAABl2qRT9zXUVA8Ls5iVqynLHe5/vSe1XyYisQM0ClQAAAAAWABRmWQUcjSjghQ8/uH4Bn/zkakwLtAAAAAAAAQEfQM0ClQAAAAAWABRmWQUcjSjghQ8/uH4Bn/zkakwLtAAAAA==")
1371
1372        assert_raises_rpc_error(-22, "TX decode failed", self.nodes[0].walletprocesspsbt, "cHNidP8BAJoCAAAAAkvEW8NnDtdNtDpsmze+Ht2LH35IJcKv00jKAlUs21RrAwAAAAD/////S8Rbw2cO1020OmybN74e3Ysffkglwq/TSMoCVSzbVGsBAAAAAP7///8CwLYClQAAAAAWABSNJKzjaUb3uOxixsvh1GGE3fW7zQD5ApUAAAAAFgAUKNw0x8HRctAgmvoevm4u1SbN7XIAAAAAAAEAnQIAAAACczMa321tVHuN4GKWKRncycI22aX3uXgwSFUKM2orjRsBAAAAAP7///9zMxrfbW1Ue43gYpYpGdzJwjbZpfe5eDBIVQozaiuNGwAAAAAA/v///wIA+QKVAAAAABl2qRT9zXUVA8Ls5iVqynLHe5/vSe1XyYisQM0ClQAAAAAWABRmWQUcjSjghQ8/uH4Bn/zkakwLtAAAAAAAAQEfQM0ClQAAAAAWABRmWQUcjSjghQ8/uH4Bn/zkakwLtAAAAA==")
1373
1374        self.log.info("Test that we can fund psbts with external inputs specified")
1375
1376        privkey, _ = generate_keypair(wif=True)
1377
1378        self.nodes[1].createwallet("extfund")
1379        wallet = self.nodes[1].get_wallet_rpc("extfund")
1380
1381        # Make a weird but signable script. sh(wsh(pkh())) descriptor accomplishes this
1382        desc = descsum_create("sh(wsh(pkh({})))".format(privkey))
1383        res = self.nodes[0].importdescriptors([{"desc": desc, "timestamp": "now"}])
1384        assert_equal(res[0]["success"], True)
1385        addr = self.nodes[0].deriveaddresses(desc)[0]
1386        addr_info = self.nodes[0].getaddressinfo(addr)
1387
1388        self.nodes[0].sendtoaddress(addr, 10)
1389        self.nodes[0].sendtoaddress(wallet.getnewaddress(), 10)
1390        self.generate(self.nodes[0], 6)
1391        ext_utxo = self.nodes[0].listunspent(addresses=[addr])[0]
1392
1393        # An external input without solving data should result in an error
1394        assert_raises_rpc_error(-4, "Not solvable pre-selected input COutPoint(%s, %s)" % (ext_utxo["txid"][0:10], ext_utxo["vout"]), wallet.walletcreatefundedpsbt, [ext_utxo], {self.nodes[0].getnewaddress(): 15})
1395
1396        # But funding should work when the solving data is provided
1397        psbt = wallet.walletcreatefundedpsbt([ext_utxo], {self.nodes[0].getnewaddress(): 15}, 0, {"add_inputs": True, "solving_data": {"pubkeys": [addr_info['pubkey']], "scripts": [addr_info["embedded"]["scriptPubKey"], addr_info["embedded"]["embedded"]["scriptPubKey"]]}})
1398        signed = wallet.walletprocesspsbt(psbt['psbt'])
1399        assert_equal(signed['complete'], False)
1400        signed = self.nodes[0].walletprocesspsbt(signed['psbt'])
1401        assert_equal(signed['complete'], True)
1402
1403        psbt = wallet.walletcreatefundedpsbt([ext_utxo], {self.nodes[0].getnewaddress(): 15}, 0, {"add_inputs": True, "solving_data":{"descriptors": [desc]}})
1404        signed = wallet.walletprocesspsbt(psbt['psbt'])
1405        assert_equal(signed['complete'], False)
1406        signed = self.nodes[0].walletprocesspsbt(signed['psbt'])
1407        assert_equal(signed['complete'], True)
1408        final = signed['hex']
1409
1410        dec = self.nodes[0].decodepsbt(signed["psbt"])
1411        for psbt_in in dec["inputs"]:
1412            if psbt_in["previous_txid"] == ext_utxo["txid"] and psbt_in["previous_vout"] == ext_utxo["vout"]:
1413                break
1414        scriptsig_hex = psbt_in["final_scriptSig"]["hex"] if "final_scriptSig" in psbt_in else ""
1415        witness_stack_hex = psbt_in["final_scriptwitness"] if "final_scriptwitness" in psbt_in else None
1416        input_weight = calculate_input_weight(scriptsig_hex, witness_stack_hex)
1417        low_input_weight = input_weight // 2
1418        high_input_weight = input_weight * 2
1419
1420        # Input weight error conditions
1421        assert_raises_rpc_error(
1422            -8,
1423            "Input weights should be specified in inputs rather than in options.",
1424            wallet.walletcreatefundedpsbt,
1425            inputs=[ext_utxo],
1426            outputs={self.nodes[0].getnewaddress(): 15},
1427            options={"input_weights": [{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": 1000}]}
1428        )
1429
1430        # Funding should also work if the input weight is provided
1431        psbt = wallet.walletcreatefundedpsbt(
1432            inputs=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": input_weight}],
1433            outputs={self.nodes[0].getnewaddress(): 15},
1434            add_inputs=True,
1435        )
1436        signed = wallet.walletprocesspsbt(psbt["psbt"])
1437        signed = self.nodes[0].walletprocesspsbt(signed["psbt"])
1438        final = signed["hex"]
1439        assert_equal(self.nodes[0].testmempoolaccept([final])[0]["allowed"], True)
1440        # Reducing the weight should have a lower fee
1441        psbt2 = wallet.walletcreatefundedpsbt(
1442            inputs=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": low_input_weight}],
1443            outputs={self.nodes[0].getnewaddress(): 15},
1444            add_inputs=True,
1445        )
1446        assert_greater_than(psbt["fee"], psbt2["fee"])
1447        # Increasing the weight should have a higher fee
1448        psbt2 = wallet.walletcreatefundedpsbt(
1449            inputs=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": high_input_weight}],
1450            outputs={self.nodes[0].getnewaddress(): 15},
1451            add_inputs=True,
1452        )
1453        assert_greater_than(psbt2["fee"], psbt["fee"])
1454        # The provided weight should override the calculated weight when solving data is provided
1455        psbt3 = wallet.walletcreatefundedpsbt(
1456            inputs=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": high_input_weight}],
1457            outputs={self.nodes[0].getnewaddress(): 15},
1458            add_inputs=True, solving_data={"descriptors": [desc]},
1459        )
1460        assert_equal(psbt2["fee"], psbt3["fee"])
1461
1462        # Import the external utxo descriptor so that we can sign for it from the test wallet
1463        res = wallet.importdescriptors([{"desc": desc, "timestamp": "now"}])
1464        assert_equal(res[0]["success"], True)
1465        # The provided weight should override the calculated weight for a wallet input
1466        psbt3 = wallet.walletcreatefundedpsbt(
1467            inputs=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": high_input_weight}],
1468            outputs={self.nodes[0].getnewaddress(): 15},
1469            add_inputs=True,
1470        )
1471        assert_equal(psbt2["fee"], psbt3["fee"])
1472
1473        self.log.info("Test signing inputs that the wallet has keys for but is not watching the scripts")
1474        self.nodes[1].createwallet(wallet_name="scriptwatchonly", disable_private_keys=True)
1475        watchonly = self.nodes[1].get_wallet_rpc("scriptwatchonly")
1476
1477        privkey, pubkey = generate_keypair(wif=True)
1478
1479        desc = descsum_create("wsh(pkh({}))".format(pubkey.hex()))
1480        res = watchonly.importdescriptors([{"desc": desc, "timestamp": "now"}])
1481        assert_equal(res[0]["success"], True)
1482        addr = self.nodes[0].deriveaddresses(desc)[0]
1483        self.nodes[0].sendtoaddress(addr, 10)
1484        self.generate(self.nodes[0], 1)
1485        wallet_importprivkey(self.nodes[0], privkey, "now")
1486
1487        psbt = watchonly.sendall([wallet.getnewaddress()])["psbt"]
1488        signed_tx = self.nodes[0].walletprocesspsbt(psbt)
1489        self.nodes[0].sendrawtransaction(signed_tx["hex"])
1490
1491        # Same test but for taproot
1492        privkey, pubkey = generate_keypair(wif=True)
1493
1494        desc = descsum_create("tr({},pk({}))".format(H_POINT, pubkey.hex()))
1495        res = watchonly.importdescriptors([{"desc": desc, "timestamp": "now"}])
1496        assert_equal(res[0]["success"], True)
1497        addr = self.nodes[0].deriveaddresses(desc)[0]
1498        self.nodes[0].sendtoaddress(addr, 10)
1499        self.generate(self.nodes[0], 1)
1500        self.nodes[0].importdescriptors([{"desc": descsum_create("tr({})".format(privkey)), "timestamp":"now"}])