test: make wallet_upgradetohd works for descriptor wallets too

knst · knst · commit af4b6182b4ec · 2025-07-18T03:22:48.000+07:00
diff --git a/test/functional/wallet_upgradetohd.py b/test/functional/wallet_upgradetohd.py
@@ -29,15 +29,36 @@ def skip_test_if_missing_module(self):
     def setup_network(self):
         self.add_nodes(self.num_nodes, self.extra_args)
         self.start_nodes()
-        self.import_deterministic_coinbase_privkeys()
+        self.nodes[0].createwallet(self.default_wallet_name, blank=True, load_on_startup=True)
+        self.nodes[0].importprivkey(privkey=self.nodes[0].get_deterministic_priv_key().key, label='coinbase', rescan=True)
+
+    # TODO: remove duplicated code with wallet_mnemonicbits.py
+    def get_mnemonic(self, node):
+        if not self.options.descriptors:
+            return node.dumphdinfo()["mnemonic"]
+
+        mnemonic = None
+        descriptors = node.listdescriptors(True)['descriptors']
+        for desc in descriptors:
+            if desc['desc'][:4] == 'pkh(':
+                if mnemonic is None:
+                    mnemonic = desc['mnemonic']
+                else:
+                    assert_equal(mnemonic, desc['mnemonic'])
+            elif desc['desc'][:6] == 'combo(':
+                assert 'mnemonic' not in desc
+            else:
+                raise AssertionError(f"Unknown descriptor type: {desc['desc']}")
+        return mnemonic
 
     def recover_non_hd(self):
         self.log.info("Recover non-HD wallet to check different upgrade paths")
         node = self.nodes[0]
         self.stop_node(0)
         shutil.copyfile(os.path.join(node.datadir, "non_hd.bak"), os.path.join(node.datadir, self.chain, self.default_wallet_name, self.wallet_data_filename))
         self.start_node(0)
-        assert 'hdchainid' not in node.getwalletinfo()
+        if not self.options.descriptors:
+            assert 'hdchainid' not in node.getwalletinfo()
 
     def run_test(self):
         node = self.nodes[0]
@@ -47,9 +68,10 @@ def run_test(self):
         assert 'hdchainid' not in node.getwalletinfo()
         balance_before = node.getbalance()
         assert node.upgradetohd()
-        mnemonic = node.dumphdinfo()['mnemonic']
-        chainid = node.getwalletinfo()['hdchainid']
-        assert_equal(len(chainid), 64)
+        mnemonic = self.get_mnemonic(node)
+        if not self.options.descriptors:
+            chainid = node.getwalletinfo()['hdchainid']
+            assert_equal(len(chainid), 64)
         assert_equal(balance_before, node.getbalance())
 
         self.log.info("Should be spendable and should use correct paths")
@@ -82,8 +104,9 @@ def run_test(self):
 
         self.log.info("No mnemonic, no mnemonic passphrase, no wallet passphrase, should result in completely different keys")
         assert node.upgradetohd()
-        assert mnemonic != node.dumphdinfo()['mnemonic']
-        assert chainid != node.getwalletinfo()['hdchainid']
+        assert mnemonic != self.get_mnemonic(node)
+        if not self.options.descriptors:
+            assert chainid != node.getwalletinfo()['hdchainid']
         assert_equal(balance_non_HD, node.getbalance())
         node.keypoolrefill(5)
         node.rescanblockchain()
@@ -96,18 +119,20 @@ def run_test(self):
         self.restart_node(0, extra_args=['-keypool=10'])
         assert node.upgradetohd("", "", "", True)
         # Completely different keys, no HD coins should be recovered
-        assert mnemonic != node.dumphdinfo()['mnemonic']
-        assert chainid != node.getwalletinfo()['hdchainid']
+        assert mnemonic != self.get_mnemonic(node)
+        if not self.options.descriptors:
+            assert chainid != node.getwalletinfo()['hdchainid']
         assert_equal(balance_non_HD, node.getbalance())
 
         self.recover_non_hd()
 
         self.log.info("Same mnemonic, another mnemonic passphrase, no wallet passphrase, should result in a different set of keys")
         new_mnemonic_passphrase = "somewords"
         assert node.upgradetohd(mnemonic, new_mnemonic_passphrase)
-        assert_equal(mnemonic, node.dumphdinfo()['mnemonic'])
-        new_chainid = node.getwalletinfo()['hdchainid']
-        assert chainid != new_chainid
+        assert_equal(mnemonic, self.get_mnemonic(node))
+        if not self.options.descriptors:
+            new_chainid = node.getwalletinfo()['hdchainid']
+            assert chainid != new_chainid
         assert_equal(balance_non_HD, node.getbalance())
         node.keypoolrefill(5)
         node.rescanblockchain()
@@ -119,8 +144,9 @@ def run_test(self):
 
         self.log.info("Same mnemonic, another mnemonic passphrase, no wallet passphrase, should result in a different set of keys (again)")
         assert node.upgradetohd(mnemonic, new_mnemonic_passphrase)
-        assert_equal(mnemonic, node.dumphdinfo()['mnemonic'])
-        assert_equal(new_chainid, node.getwalletinfo()['hdchainid'])
+        assert_equal(mnemonic, self.get_mnemonic(node))
+        if not self.options.descriptors:
+            assert_equal(new_chainid, node.getwalletinfo()['hdchainid'])
         assert_equal(balance_non_HD, node.getbalance())
         node.keypoolrefill(5)
         node.rescanblockchain()
@@ -132,8 +158,9 @@ def run_test(self):
 
         self.log.info("Same mnemonic, no mnemonic passphrase, no wallet passphrase, should recover all coins after rescan")
         assert node.upgradetohd(mnemonic)
-        assert_equal(mnemonic, node.dumphdinfo()['mnemonic'])
-        assert_equal(chainid, node.getwalletinfo()['hdchainid'])
+        assert_equal(mnemonic, self.get_mnemonic(node))
+        if not self.options.descriptors:
+            assert_equal(chainid, node.getwalletinfo()['hdchainid'])
         node.keypoolrefill(5)
         assert balance_after != node.getbalance()
         node.rescanblockchain()
@@ -144,8 +171,9 @@ def run_test(self):
         self.log.info("Same mnemonic, no mnemonic passphrase, no wallet passphrase, large enough keepool, should recover all coins with no extra rescan")
         self.restart_node(0, extra_args=['-keypool=10'])
         assert node.upgradetohd(mnemonic)
-        assert_equal(mnemonic, node.dumphdinfo()['mnemonic'])
-        assert_equal(chainid, node.getwalletinfo()['hdchainid'])
+        assert_equal(mnemonic, self.get_mnemonic(node))
+        if not self.options.descriptors:
+            assert_equal(chainid, node.getwalletinfo()['hdchainid'])
         # All coins should be recovered
         assert_equal(balance_after, node.getbalance())
 
@@ -154,8 +182,9 @@ def run_test(self):
         self.log.info("Same mnemonic, no mnemonic passphrase, no wallet passphrase, large enough keepool, rescan is skipped initially, should recover all coins after rescanblockchain")
         self.restart_node(0, extra_args=['-keypool=10'])
         assert node.upgradetohd(mnemonic, "", "", False)
-        assert_equal(mnemonic, node.dumphdinfo()['mnemonic'])
-        assert_equal(chainid, node.getwalletinfo()['hdchainid'])
+        assert_equal(mnemonic, self.get_mnemonic(node))
+        if not self.options.descriptors:
+            assert_equal(chainid, node.getwalletinfo()['hdchainid'])
         assert balance_after != node.getbalance()
         node.rescanblockchain()
         # All coins should be recovered
@@ -171,8 +200,9 @@ def run_test(self):
         self.start_node(0, extra_args=['-rescan'])
         assert_raises_rpc_error(-13, "Error: Please enter the wallet passphrase with walletpassphrase first.", node.dumphdinfo)
         node.walletpassphrase(walletpass, 100)
-        assert_equal(mnemonic, node.dumphdinfo()['mnemonic'])
-        assert_equal(chainid, node.getwalletinfo()['hdchainid'])
+        assert_equal(mnemonic, self.get_mnemonic(node))
+        if not self.options.descriptors:
+            assert_equal(chainid, node.getwalletinfo()['hdchainid'])
         # Note: wallet encryption results in additional keypool topup,
         # so we can't compare new balance to balance_non_HD here,
         # assert_equal(balance_non_HD, node.getbalance())  # won't work
@@ -191,12 +221,25 @@ def run_test(self):
         node.wait_until_stopped()
         self.start_node(0, extra_args=['-rescan'])
         assert_raises_rpc_error(-13, "Error: Wallet encrypted but passphrase not supplied to RPC.", node.upgradetohd, mnemonic)
-        assert_raises_rpc_error(-1,  "Error: The wallet passphrase entered was incorrect", node.upgradetohd, mnemonic, "", "wrongpass")
+        if not self.options.descriptors:
+            assert_raises_rpc_error(-1,  "Error: The wallet passphrase entered was incorrect", node.upgradetohd, mnemonic, "", "wrongpass")
+        else:
+            assert_raises_rpc_error(-1,  "SetupDescriptorScriptPubKeyMans: Wallet is locked, cannot setup new descriptors", node.upgradetohd, mnemonic, "", "wrongpass")
+        if self.options.descriptors:
+            # TODO - implement auto-unlock descriptor wallet
+            node.walletpassphrase(walletpass, 100)
         assert node.upgradetohd(mnemonic, "", walletpass)
-        assert_raises_rpc_error(-13, "Error: Please enter the wallet passphrase with walletpassphrase first.", node.dumphdinfo)
+        # TODO - drop it too!
+        if self.options.descriptors:
+            node.walletlock()
+        if not self.options.descriptors:
+            assert_raises_rpc_error(-13, "Error: Please enter the wallet passphrase with walletpassphrase first.", node.dumphdinfo)
+        else:
+            assert_raises_rpc_error(-13, "Error: Please enter the wallet passphrase with walletpassphrase first.", node.listdescriptors, True)
         node.walletpassphrase(walletpass, 100)
-        assert_equal(mnemonic, node.dumphdinfo()['mnemonic'])
-        assert_equal(chainid, node.getwalletinfo()['hdchainid'])
+        assert_equal(mnemonic, self.get_mnemonic(node))
+        if not self.options.descriptors:
+            assert_equal(chainid, node.getwalletinfo()['hdchainid'])
         # Note: wallet encryption results in additional keypool topup,
         # so we can't compare new balance to balance_non_HD here,
         # assert_equal(balance_non_HD, node.getbalance())  # won't work
