Inside Bitcoin

1251
1252        # Craft wsh(pkh(key))
1253        pubkey = wallet.getaddressinfo(wallet.getnewaddress())["pubkey"]
1254        pkh_script = key_to_p2pkh_script(pubkey).hex()
1255        wsh_pkh_script = script_to_p2wsh_script(pkh_script).hex()
1256        wsh_pkh_addr = script_to_p2wsh(pkh_script)
1257
1258        # Legacy single key scripts (i.e. pkh(key) and pk(key)) are not inserted into mapScripts
1259        # automatically, they need to be imported directly if we want to receive to P2WSH (or P2SH)
1260        # wrappings of such scripts.
1261        wallet.importaddress(address=pkh_script, p2sh=False)
1262        wallet.importaddress(address=wsh_pkh_script, p2sh=False)
1263
1264        def_wallet.sendtoaddress(wsh_pkh_addr, 5)
1265        self.generate(self.nodes[0], 6)
1266        assert_equal(wallet.getbalances()['mine']['trusted'], 5)
1267
1268        _, wallet = self.migrate_and_get_rpc("p2wsh")
1269
1270        assert_equal(wallet.getbalances()['mine']['trusted'], 5)
1271        addr_info = wallet.getaddressinfo(wsh_pkh_addr)
1272        assert_equal(addr_info["ismine"], True)
1273        assert_equal(addr_info["solvable"], True)
1274
1275        wallet.unloadwallet()
1276
1277    def test_disallowed_p2wsh(self):
1278        self.log.info("Test that P2WSH output scripts with invalid witnessScripts are not migrated and do not cause migration failure")
1279        def_wallet = self.master_node.get_wallet_rpc(self.default_wallet_name)
1280
1281        wallet = self.create_legacy_wallet("invalid_p2wsh")
1282
1283        invalid_addrs = []
1284
1285        # For a P2WSH output script stored in the legacy wallet's mapScripts, both the native P2WSH
1286        # and the P2SH-P2WSH are detected by IsMine. We need to verify that descriptors for both
1287        # output scripts are added to the resulting descriptor wallet.
1288        # However, this cannot be done using a multisig as wallet migration treats multisigs specially.
1289        # Instead, this is tested by importing a wsh(pkh()) script. But importing this directly will
1290        # insert the wsh() into setWatchOnly which means that the setWatchOnly migration ends up handling
1291        # this case, which we do not want.
1292        # In order to get the wsh(pkh()) into only mapScripts and not setWatchOnly, we need to utilize
1293        # importmulti and wrap the wsh(pkh()) inside of a sh(). This will insert the sh(wsh(pkh())) into
1294        # setWatchOnly but not the wsh(pkh()).
1295        # Furthermore, migration should not migrate the wsh(pkh()) if the key is uncompressed.
1296        comp_wif, comp_pubkey = generate_keypair(compressed=True, wif=True)
1297        comp_pkh_script = key_to_p2pkh_script(comp_pubkey).hex()
1298        comp_wsh_pkh_script = script_to_p2wsh_script(comp_pkh_script).hex()
1299        comp_sh_wsh_pkh_script = script_to_p2sh_script(comp_wsh_pkh_script).hex()
1300        comp_wsh_pkh_addr = script_to_p2wsh(comp_pkh_script)
1301
1302        uncomp_wif, uncomp_pubkey = generate_keypair(compressed=False, wif=True)
1303        uncomp_pkh_script = key_to_p2pkh_script(uncomp_pubkey).hex()
1304        uncomp_wsh_pkh_script = script_to_p2wsh_script(uncomp_pkh_script).hex()
1305        uncomp_sh_wsh_pkh_script = script_to_p2sh_script(uncomp_wsh_pkh_script).hex()
1306        uncomp_wsh_pkh_addr = script_to_p2wsh(uncomp_pkh_script)
1307        invalid_addrs.append(uncomp_wsh_pkh_addr)
1308
1309        import_res = wallet.importmulti([
1310            {
1311                "scriptPubKey": comp_sh_wsh_pkh_script,
1312                "timestamp": "now",
1313                "redeemscript": comp_wsh_pkh_script,
1314                "witnessscript": comp_pkh_script,
1315                "keys": [
1316                    comp_wif,
1317                ],
1318            },
1319            {
1320                "scriptPubKey": uncomp_sh_wsh_pkh_script,
1321                "timestamp": "now",
1322                "redeemscript": uncomp_wsh_pkh_script,
1323                "witnessscript": uncomp_pkh_script,
1324                "keys": [
1325                    uncomp_wif,
1326                ],
1327            },
1328        ])
1329        assert_equal(import_res[0]["success"], True)
1330        assert_equal(import_res[1]["success"], True)
1331
1332        # Create a wsh(sh(pkh())) - P2SH inside of P2WSH is invalid
1333        comp_sh_pkh_script = script_to_p2sh_script(comp_pkh_script).hex()
1334        wsh_sh_pkh_script = script_to_p2wsh_script(comp_sh_pkh_script).hex()
1335        wsh_sh_pkh_addr = script_to_p2wsh(comp_sh_pkh_script)
1336        invalid_addrs.append(wsh_sh_pkh_addr)
1337
1338        # Import wsh(sh(pkh()))
1339        wallet.importaddress(address=comp_sh_pkh_script, p2sh=False)
1340        wallet.importaddress(address=wsh_sh_pkh_script, p2sh=False)
1341
1342        # Create a wsh(wsh(pkh())) - P2WSH inside of P2WSH is invalid
1343        wsh_wsh_pkh_script = script_to_p2wsh_script(comp_wsh_pkh_script).hex()
1344        wsh_wsh_pkh_addr = script_to_p2wsh(comp_wsh_pkh_script)
1345        invalid_addrs.append(wsh_wsh_pkh_addr)
1346
1347        # Import wsh(wsh(pkh()))
1348        wallet.importaddress(address=wsh_wsh_pkh_script, p2sh=False)
1349
1350        # The wsh(pkh()) with a compressed key is always valid, so we should see that the wallet detects it as ismine, not
1351        # watchonly, and can provide us information about the witnessScript via "embedded"
1352        comp_wsh_pkh_addr_info = wallet.getaddressinfo(comp_wsh_pkh_addr)
1353        assert_equal(comp_wsh_pkh_addr_info["ismine"], True)
1354        assert_equal(comp_wsh_pkh_addr_info["iswatchonly"], False)
1355        assert "embedded" in comp_wsh_pkh_addr_info
1356
1357        # The invalid addresses are invalid, so the legacy wallet should not detect them as ismine,
1358        # nor consider them watchonly. However, because the legacy wallet has the witnessScripts/redeemScripts,
1359        # we should see information about those in "embedded"
1360        for addr in invalid_addrs:
1361            addr_info = wallet.getaddressinfo(addr)
1362            assert_equal(addr_info["ismine"], False)
1363            assert_equal(addr_info["iswatchonly"], False)
1364            assert "embedded" in addr_info
1365
1366        # Fund those output scripts, although the invalid addresses will not have any balance.
1367        # This behavior follows as the addresses are not ismine.
1368        def_wallet.send([{comp_wsh_pkh_addr: 1}] + [{k: i + 1} for i, k in enumerate(invalid_addrs)])
1369        self.generate(self.nodes[0], 6)
1370        bal = wallet.getbalances()
1371        assert_equal(bal["mine"]["trusted"], 1)
1372        assert_equal(bal["watchonly"]["trusted"], 0)
1373
1374        res, wallet = self.migrate_and_get_rpc("invalid_p2wsh")
1375        assert "watchonly_name" not in res
1376        assert "solvables_name" not in res
1377
1378        assert_equal(wallet.getbalances()["mine"]["trusted"], 1)
1379
1380        # After migration, the wsh(pkh()) with a compressed key is still valid and the descriptor wallet will have
1381        # information about the witnessScript
1382        comp_wsh_pkh_addr_info = wallet.getaddressinfo(comp_wsh_pkh_addr)
1383        assert_equal(comp_wsh_pkh_addr_info["ismine"], True)
1384        assert "embedded" in comp_wsh_pkh_addr_info
1385
1386        # After migration, the invalid addresses should still not be detected as ismine and not watchonly.
1387        # The descriptor wallet should not have migrated these at all, so there should additionally be no
1388        # information in "embedded" about the witnessScripts/redeemScripts.
1389        for addr in invalid_addrs:
1390            addr_info = wallet.getaddressinfo(addr)
1391            assert_equal(addr_info["ismine"], False)
1392            assert "embedded" not in addr_info
1393
1394        wallet.unloadwallet()
1395
1396    def test_miniscript(self):
1397        # It turns out that due to how signing logic works, legacy wallets that have valid miniscript witnessScripts
1398        # and the private keys for them can still sign and spend them, even though output scripts involving them
1399        # as a witnessScript would not be detected as ISMINE_SPENDABLE.
1400        self.log.info("Test migration of a legacy wallet containing miniscript")
1401        def_wallet = self.master_node.get_wallet_rpc(self.default_wallet_name)
1402        wallet = self.create_legacy_wallet("miniscript")
1403
1404        privkey, _ = generate_keypair(compressed=True, wif=True)
1405
1406        # Make a descriptor where we only have some of the keys. This will be migrated to the watchonly wallet.
1407        some_keys_priv_desc = descsum_create(f"wsh(or_b(pk({privkey}),s:pk(029ffbe722b147f3035c87cb1c60b9a5947dd49c774cc31e94773478711a929ac0)))")
1408        some_keys_addr = self.master_node.deriveaddresses(some_keys_priv_desc)[0]
1409
1410        # Make a descriptor where we have all of the keys. This will stay in the migrated wallet
1411        all_keys_priv_desc = descsum_create(f"wsh(and_v(v:pk({privkey}),1))")
1412        all_keys_addr = self.master_node.deriveaddresses(all_keys_priv_desc)[0]
1413
1414        imp = wallet.importmulti([
1415            {
1416                "desc": some_keys_priv_desc,
1417                "timestamp": "now",
1418            },
1419            {
1420                "desc": all_keys_priv_desc,
1421                "timestamp": "now",
1422            }
1423        ])
1424        assert_equal(imp[0]["success"], True)
1425        assert_equal(imp[1]["success"], True)
1426
1427        def_wallet.sendtoaddress(some_keys_addr, 1)
1428        def_wallet.sendtoaddress(all_keys_addr, 1)
1429        self.generate(self.master_node, 6)
1430        # Check that the miniscript can be spent by the legacy wallet
1431        send_res = wallet.send(outputs=[{some_keys_addr: 1},{all_keys_addr: 0.75}], include_watching=True, change_address=def_wallet.getnewaddress())
1432        assert_equal(send_res["complete"], True)
1433        self.generate(self.old_node, 6)
1434        assert_equal(wallet.getbalances()["watchonly"]["trusted"], 1.75)
1435
1436        _, wallet = self.migrate_and_get_rpc("miniscript")
1437
1438        # The miniscript with all keys should be in the migrated wallet
1439        assert_equal(wallet.getbalances()["mine"], {"trusted": 0.75, "untrusted_pending": 0, "immature": 0, "nonmempool": 0})
1440        assert_equal(wallet.getaddressinfo(all_keys_addr)["ismine"], True)
1441        assert_equal(wallet.getaddressinfo(some_keys_addr)["ismine"], False)
1442
1443        # The miniscript with some keys should be in the watchonly wallet
1444        assert "miniscript_watchonly" in self.master_node.listwallets()
1445        watchonly = self.master_node.get_wallet_rpc("miniscript_watchonly")
1446        assert_equal(watchonly.getbalances()["mine"], {"trusted": 1, "untrusted_pending": 0, "immature": 0, "nonmempool": 0})
1447        assert_equal(watchonly.getaddressinfo(some_keys_addr)["ismine"], True)
1448        assert_equal(watchonly.getaddressinfo(all_keys_addr)["ismine"], False)
1449
1450    def test_taproot(self):
1451        # It turns out that due to how signing logic works, legacy wallets that have the private key for a Taproot
1452        # output key will be able to sign and spend those scripts, even though they would not be detected as ISMINE_SPENDABLE.
1453        self.log.info("Test migration of Taproot scripts")
1454        def_wallet = self.master_node.get_wallet_rpc(self.default_wallet_name)
1455        wallet = self.create_legacy_wallet("taproot")
1456
1457        privkey, _ = generate_keypair(compressed=True, wif=True)
1458
1459        rawtr_desc = descsum_create(f"rawtr({privkey})")
1460        rawtr_addr = self.master_node.deriveaddresses(rawtr_desc)[0]
1461        rawtr_spk = self.master_node.validateaddress(rawtr_addr)["scriptPubKey"]
1462        tr_desc = descsum_create(f"tr({privkey})")
1463        tr_addr = self.master_node.deriveaddresses(tr_desc)[0]
1464        tr_spk = self.master_node.validateaddress(tr_addr)["scriptPubKey"]
1465        tr_script_desc = descsum_create(f"tr(9ffbe722b147f3035c87cb1c60b9a5947dd49c774cc31e94773478711a929ac0,pk({privkey}))")
1466        tr_script_addr = self.master_node.deriveaddresses(tr_script_desc)[0]
1467        tr_script_spk = self.master_node.validateaddress(tr_script_addr)["scriptPubKey"]
1468
1469        wallet.importaddress(rawtr_spk)
1470        wallet.importaddress(tr_spk)
1471        wallet.importaddress(tr_script_spk)
1472        wallet.importprivkey(privkey)
1473
1474        txid = def_wallet.send([{rawtr_addr: 1},{tr_addr: 2}, {tr_script_addr: 3}])["txid"]
1475        rawtr_vout = find_vout_for_address(self.master_node, txid, rawtr_addr)
1476        tr_vout = find_vout_for_address(self.master_node, txid, tr_addr)
1477        tr_script_vout = find_vout_for_address(self.master_node, txid, tr_script_addr)
1478        self.generate(self.master_node, 6)
1479        assert_equal(wallet.getbalances()["watchonly"]["trusted"], 6)
1480
1481        # Check that the rawtr can be spent by the legacy wallet
1482        send_res = wallet.send(outputs=[{rawtr_addr: 0.5}], include_watching=True, change_address=def_wallet.getnewaddress(), inputs=[{"txid": txid, "vout": rawtr_vout}])
1483        assert_equal(send_res["complete"], True)
1484        self.generate(self.old_node, 6)
1485        assert_equal(wallet.getbalances()["watchonly"]["trusted"], 5.5)
1486        assert_equal(wallet.getbalances()["mine"]["trusted"], 0)
1487
1488        # Check that the tr() cannot be spent by the legacy wallet
1489        send_res = wallet.send(outputs=[{def_wallet.getnewaddress(): 4}], include_watching=True, inputs=[{"txid": txid, "vout": tr_vout}, {"txid": txid, "vout": tr_script_vout}])
1490        assert_equal(send_res["complete"], False)
1491
1492        res, wallet = self.migrate_and_get_rpc("taproot")
1493
1494        # The rawtr should be migrated
1495        assert_equal(wallet.getbalances()["mine"], {"trusted": 0.5, "untrusted_pending": 0, "immature": 0, "nonmempool": 0})
1496        assert_equal(wallet.getaddressinfo(rawtr_addr)["ismine"], True)
1497        assert_equal(wallet.getaddressinfo(tr_addr)["ismine"], False)
1498        assert_equal(wallet.getaddressinfo(tr_script_addr)["ismine"], False)
1499
1500        # The tr() with some keys should be in the watchonly wallet