Inside Bitcoin

751        migrate_res = self.master_node.migratewallet("plainfile")
752        assert_equal(f"plainfile_{mocked_time}.legacy.bak", os.path.basename(migrate_res["backup_path"]))
753        wallet = self.master_node.get_wallet_rpc("plainfile")
754        info = wallet.getwalletinfo()
755        assert_equal(info["descriptors"], True)
756        assert_equal(info["format"], "sqlite")
757
758        assert (self.master_node.wallets_path / "plainfile").is_dir()
759        assert (self.master_node.wallets_path / "plainfile" / "wallet.dat").is_file()
760
761    def test_addressbook(self):
762        df_wallet = self.master_node.get_wallet_rpc(self.default_wallet_name)
763
764        self.log.info("Test migration of address book data")
765        wallet = self.create_legacy_wallet("legacy_addrbook")
766        df_wallet.sendtoaddress(wallet.getnewaddress(), 3)
767
768        # Import watch-only script to create a watch-only wallet after migration
769        watch_addr = df_wallet.getnewaddress()
770        wallet.importaddress(watch_addr)
771        df_wallet.sendtoaddress(watch_addr, 2)
772
773        # Import solvable script
774        multi_addr1 = wallet.getnewaddress()
775        multi_addr2 = wallet.getnewaddress()
776        multi_addr3 = df_wallet.getnewaddress()
777        wallet.importpubkey(df_wallet.getaddressinfo(multi_addr3)["pubkey"])
778        ms_addr_info = wallet.addmultisigaddress(2, [multi_addr1, multi_addr2, multi_addr3])
779
780        self.generate(self.master_node, 1)
781
782        # Test vectors
783        addr_external = {
784            "addr": df_wallet.getnewaddress(),
785            "is_mine": False,
786            "is_change": False,
787            "label": ""
788        }
789        addr_external_with_label = {
790            "addr": df_wallet.getnewaddress(),
791            "is_mine": False,
792            "is_change": False,
793            "label": "external"
794        }
795        addr_internal = {
796            "addr": wallet.getnewaddress(),
797            "is_mine": True,
798            "is_change": False,
799            "label": ""
800        }
801        addr_internal_with_label = {
802            "addr": wallet.getnewaddress(),
803            "is_mine": True,
804            "is_change": False,
805            "label": "internal"
806        }
807        change_address = {
808            "addr": wallet.getrawchangeaddress(),
809            "is_mine": True,
810            "is_change": True,
811            "label": None
812        }
813        watch_only_addr = {
814            "addr": watch_addr,
815            "is_mine": False,
816            "is_change": False,
817            "label": "imported"
818        }
819        ms_addr = {
820            "addr": ms_addr_info['address'],
821            "is_mine": False,
822            "is_change": False,
823            "label": "multisig"
824        }
825
826        # To store the change address in the addressbook need to send coins to it
827        wallet.send(outputs=[{wallet.getnewaddress(): 2}], options={"change_address": change_address['addr']})
828        self.generate(self.master_node, 1)
829
830        # Util wrapper func for 'addr_info'
831        def check(info, node):
832            self.check_address(node, info['addr'], info['is_mine'], info['is_change'], info["label"])
833
834        # Pre-migration: set label and perform initial checks
835        for addr_info in [addr_external, addr_external_with_label, addr_internal, addr_internal_with_label, change_address, watch_only_addr, ms_addr]:
836            if not addr_info['is_change']:
837                wallet.setlabel(addr_info['addr'], addr_info["label"])
838            check(addr_info, wallet)
839
840        # Migrate wallet
841        info_migration, wallet = self.migrate_and_get_rpc("legacy_addrbook")
842        wallet_wo = self.master_node.get_wallet_rpc(info_migration["watchonly_name"])
843        wallet_solvables = self.master_node.get_wallet_rpc(info_migration["solvables_name"])
844
845        #########################
846        # Post migration checks #
847        #########################
848
849        # First check the main wallet
850        for addr_info in [addr_external, addr_external_with_label, addr_internal, addr_internal_with_label, change_address, ms_addr]:
851            check(addr_info, wallet)
852
853        # Watch-only wallet will contain the watch-only entry (with 'is_mine=True') and all external addresses ('send')
854        self.check_address(wallet_wo, watch_only_addr['addr'], is_mine=True, is_change=watch_only_addr['is_change'], label=watch_only_addr["label"])
855        for addr_info in [addr_external, addr_external_with_label, ms_addr]:
856            check(addr_info, wallet_wo)
857
858        # Solvables wallet will contain the multisig entry (with 'is_mine=True') and all external addresses ('send')
859        self.check_address(wallet_solvables, ms_addr['addr'], is_mine=True, is_change=ms_addr['is_change'], label=ms_addr["label"])
860        for addr_info in [addr_external, addr_external_with_label]:
861            check(addr_info, wallet_solvables)
862
863        ########################################################################################
864        # Now restart migrated wallets and verify that the addressbook entries are still there #
865        ########################################################################################
866
867        # First the main wallet
868        self.master_node.unloadwallet("legacy_addrbook")
869        self.master_node.loadwallet("legacy_addrbook")
870        for addr_info in [addr_external, addr_external_with_label, addr_internal, addr_internal_with_label, change_address, ms_addr]:
871            check(addr_info, wallet)
872
873        # Watch-only wallet
874        self.master_node.unloadwallet(info_migration["watchonly_name"])
875        self.master_node.loadwallet(info_migration["watchonly_name"])
876        self.check_address(wallet_wo, watch_only_addr['addr'], is_mine=True, is_change=watch_only_addr['is_change'], label=watch_only_addr["label"])
877        for addr_info in [addr_external, addr_external_with_label, ms_addr]:
878            check(addr_info, wallet_wo)
879
880        # Solvables wallet
881        self.master_node.unloadwallet(info_migration["solvables_name"])
882        self.master_node.loadwallet(info_migration["solvables_name"])
883        self.check_address(wallet_solvables, ms_addr['addr'], is_mine=True, is_change=ms_addr['is_change'], label=ms_addr["label"])
884        for addr_info in [addr_external, addr_external_with_label]:
885            check(addr_info, wallet_solvables)
886
887    def test_migrate_raw_p2sh(self):
888        self.log.info("Test migration of watch-only raw p2sh script")
889        df_wallet = self.master_node.get_wallet_rpc(self.default_wallet_name)
890        wallet = self.create_legacy_wallet("raw_p2sh")
891
892        def send_to_script(script, amount):
893            tx = CTransaction()
894            tx.vout.append(CTxOut(nValue=amount*COIN, scriptPubKey=script))
895
896            hex_tx = df_wallet.fundrawtransaction(tx.serialize().hex())['hex']
897            signed_tx = df_wallet.signrawtransactionwithwallet(hex_tx)
898            df_wallet.sendrawtransaction(signed_tx['hex'])
899            self.generate(self.master_node, 1)
900
901        # Craft sh(pkh(key)) script and send coins to it
902        pubkey = df_wallet.getaddressinfo(df_wallet.getnewaddress())["pubkey"]
903        script_pkh = key_to_p2pkh_script(pubkey)
904        script_sh_pkh = script_to_p2sh_script(script_pkh)
905        send_to_script(script=script_sh_pkh, amount=2)
906
907        # Import script and check balance
908        wallet.importaddress(address=script_pkh.hex(), label="raw_spk", rescan=True, p2sh=True)
909        assert_equal(wallet.getbalances()['watchonly']['trusted'], 2)
910
911        # Craft wsh(pkh(key)) and send coins to it
912        pubkey = df_wallet.getaddressinfo(df_wallet.getnewaddress())["pubkey"]
913        script_wsh_pkh = script_to_p2wsh_script(key_to_p2pkh_script(pubkey))
914        send_to_script(script=script_wsh_pkh, amount=3)
915
916        # Import script and check balance
917        wallet.importaddress(address=script_wsh_pkh.hex(), label="raw_spk2", rescan=True, p2sh=False)
918        assert_equal(wallet.getbalances()['watchonly']['trusted'], 5)
919
920        # Import sh(pkh()) script, by using importaddress(), with the p2sh flag enabled.
921        # This will wrap the script under another sh level, which is invalid!, and store it inside the wallet.
922        # The migration process must skip the invalid scripts and the addressbook records linked to them.
923        # They are not being watched by the current wallet, nor should be watched by the migrated one.
924        label_sh_pkh = "raw_sh_pkh"
925        script_pkh = key_to_p2pkh_script(df_wallet.getaddressinfo(df_wallet.getnewaddress())["pubkey"])
926        script_sh_pkh = script_to_p2sh_script(script_pkh)
927        addy_script_sh_pkh = script_to_p2sh(script_pkh)  # valid script address
928        addy_script_double_sh_pkh = script_to_p2sh(script_sh_pkh)  # invalid script address
929
930        # Note: 'importaddress()' will add two scripts, a valid one sh(pkh()) and an invalid one 'sh(sh(pkh()))'.
931        #       Both of them will be stored with the same addressbook label. And only the latter one should
932        #       be discarded during migration. The first one must be migrated.
933        wallet.importaddress(address=script_sh_pkh.hex(), label=label_sh_pkh, rescan=False, p2sh=True)
934
935        # Migrate wallet and re-check balance
936        info_migration, wallet = self.migrate_and_get_rpc("raw_p2sh")
937        wallet_wo = self.master_node.get_wallet_rpc(info_migration["watchonly_name"])
938
939        # Watch-only balance is under "mine".
940        assert_equal(wallet_wo.getbalances()['mine']['trusted'], 5)
941        # The watch-only scripts are no longer part of the main wallet
942        assert_equal(wallet.getbalances()['mine']['trusted'], 0)
943
944        # The invalid sh(sh(pk())) script label must not be part of the main wallet anymore
945        assert label_sh_pkh not in wallet.listlabels()
946        # But, the standard sh(pkh()) script should be part of the watch-only wallet.
947        addrs_by_label = wallet_wo.getaddressesbylabel(label_sh_pkh)
948        assert addy_script_sh_pkh in addrs_by_label
949        assert addy_script_double_sh_pkh not in addrs_by_label
950
951        # Also, the watch-only wallet should have the descriptor for the standard sh(pkh())
952        desc = descsum_create(f"addr({addy_script_sh_pkh})")
953        assert desc in [it['desc'] for it in wallet_wo.listdescriptors()['descriptors']]
954        # And doesn't have a descriptor for the invalid one
955        desc_invalid = descsum_create(f"addr({addy_script_double_sh_pkh})")
956        assert_equal(next((it['desc'] for it in wallet_wo.listdescriptors()['descriptors'] if it['desc'] == desc_invalid), None), None)
957
958        # Just in case, also verify wallet restart
959        self.master_node.unloadwallet(info_migration["watchonly_name"])
960        self.master_node.loadwallet(info_migration["watchonly_name"])
961        assert_equal(wallet_wo.getbalances()['mine']['trusted'], 5)
962
963    def test_conflict_txs(self):
964        self.log.info("Test migration when wallet contains conflicting transactions")
965        def_wallet = self.master_node.get_wallet_rpc(self.default_wallet_name)
966
967        wallet = self.create_legacy_wallet("conflicts")
968        def_wallet.sendtoaddress(wallet.getnewaddress(), 10)
969        self.generate(self.master_node, 1)
970
971        # parent tx
972        parent_txid = wallet.sendtoaddress(wallet.getnewaddress(), 9)
973        parent_txid_bytes = bytes.fromhex(parent_txid)[::-1]
974        conflict_utxo = wallet.gettransaction(txid=parent_txid, verbose=True)["decoded"]["vin"][0]
975
976        # The specific assertion in MarkConflicted being tested requires that the parent tx is already loaded
977        # by the time the child tx is loaded. Since transactions end up being loaded in txid order due to how
978        # sqlite stores things, we can just grind the child tx until it has a txid that is greater than the parent's.
979        locktime = 500000000 # Use locktime as nonce, starting at unix timestamp minimum
980        addr = wallet.getnewaddress()
981        while True:
982            child_send_res = wallet.send(outputs=[{addr: 8}], options={"add_to_wallet": False, "locktime": locktime})
983            child_txid = child_send_res["txid"]
984            child_txid_bytes = bytes.fromhex(child_txid)[::-1]
985            if (child_txid_bytes > parent_txid_bytes):
986                wallet.sendrawtransaction(child_send_res["hex"])
987                break
988            locktime += 1
989
990        # conflict with parent
991        conflict_unsigned = self.master_node.createrawtransaction(inputs=[conflict_utxo], outputs=[{wallet.getnewaddress(): 9.9999}])
992        conflict_signed = wallet.signrawtransactionwithwallet(conflict_unsigned)["hex"]
993        conflict_txid = self.master_node.sendrawtransaction(conflict_signed)
994        self.generate(self.master_node, 1)
995        assert_equal(wallet.gettransaction(txid=parent_txid)["confirmations"], -1)
996        assert_equal(wallet.gettransaction(txid=child_txid)["confirmations"], -1)
997        assert_equal(wallet.gettransaction(txid=conflict_txid)["confirmations"], 1)
998
999        _, wallet = self.migrate_and_get_rpc("conflicts")
1000        assert_equal(wallet.gettransaction(txid=parent_txid)["confirmations"], -1)