From 62c4ec136e8a9a24587c0e4bc8a4ae12bb8af9a0 Mon Sep 17 00:00:00 2001 From: Konstantin Akimov Date: Thu, 17 Jul 2025 15:00:03 +0700 Subject: [PATCH 1/6] test: remove duplicated code from wallet_mnemonicbits.py by using helper get_mnemonic --- test/functional/wallet_mnemonicbits.py | 24 ++++++++---------------- 1 file changed, 8 insertions(+), 16 deletions(-) diff --git a/test/functional/wallet_mnemonicbits.py b/test/functional/wallet_mnemonicbits.py index 02c70a72551e..ddf4a8c432f1 100755 --- a/test/functional/wallet_mnemonicbits.py +++ b/test/functional/wallet_mnemonicbits.py @@ -88,22 +88,14 @@ def run_test(self): self.nodes[0].loadwallet("wallet_160") self.nodes[0].loadwallet("wallet_192") self.nodes[0].loadwallet("wallet_224") - if self.options.descriptors: - self.nodes[0].createwallet("wallet_256", False, True, "", False, True) # blank Descriptors - self.nodes[0].get_wallet_rpc("wallet_256").upgradetohd() - assert_equal(len(self.get_mnemonic(self.nodes[0].get_wallet_rpc(self.default_wallet_name)).split()), 12) # 12 words by default - assert_equal(len(self.nodes[0].get_wallet_rpc("wallet_160").listdescriptors(True)["descriptors"][0]["mnemonic"].split()), 15) # 15 words - assert_equal(len(self.nodes[0].get_wallet_rpc("wallet_192").listdescriptors(True)["descriptors"][0]["mnemonic"].split()), 18) # 18 words - assert_equal(len(self.nodes[0].get_wallet_rpc("wallet_224").listdescriptors(True)["descriptors"][0]["mnemonic"].split()), 21) # 21 words - assert_equal(len(self.nodes[0].get_wallet_rpc("wallet_256").listdescriptors(True)["descriptors"][0]["mnemonic"].split()), 24) # 24 words - else: - self.nodes[0].createwallet("wallet_256", False, True) # blank HD legacy - self.nodes[0].get_wallet_rpc("wallet_256").upgradetohd() - assert_equal(len(self.nodes[0].get_wallet_rpc(self.default_wallet_name).dumphdinfo()["mnemonic"].split()), 12) # 12 words by default - assert_equal(len(self.nodes[0].get_wallet_rpc("wallet_160").dumphdinfo()["mnemonic"].split()), 15) # 15 words - assert_equal(len(self.nodes[0].get_wallet_rpc("wallet_192").dumphdinfo()["mnemonic"].split()), 18) # 18 words - assert_equal(len(self.nodes[0].get_wallet_rpc("wallet_224").dumphdinfo()["mnemonic"].split()), 21) # 21 words - assert_equal(len(self.nodes[0].get_wallet_rpc("wallet_256").dumphdinfo()["mnemonic"].split()), 24) # 24 words + self.nodes[0].createwallet("wallet_256", blank=True, descriptors=self.options.descriptors) # blank wallet + self.nodes[0].get_wallet_rpc("wallet_256").upgradetohd() + + assert_equal(len(self.get_mnemonic(self.nodes[0].get_wallet_rpc(self.default_wallet_name)).split()), 12) # 12 words by default + assert_equal(len(self.get_mnemonic(self.nodes[0].get_wallet_rpc("wallet_160")).split()), 15) # 15 words + assert_equal(len(self.get_mnemonic(self.nodes[0].get_wallet_rpc("wallet_192")).split()), 18) # 18 words + assert_equal(len(self.get_mnemonic(self.nodes[0].get_wallet_rpc("wallet_224")).split()), 21) # 21 words + assert_equal(len(self.get_mnemonic(self.nodes[0].get_wallet_rpc("wallet_256")).split()), 24) # 24 words if __name__ == '__main__': From 0267fb72d1d2253ac8cb2ffc62d222169a4ec8ce Mon Sep 17 00:00:00 2001 From: Konstantin Akimov Date: Thu, 17 Jul 2025 15:30:31 +0700 Subject: [PATCH 2/6] fix: copyright for wallet_upgradetohd.py --- test/functional/wallet_upgradetohd.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/functional/wallet_upgradetohd.py b/test/functional/wallet_upgradetohd.py index 0fc1c7e4d12b..91d5954384ea 100755 --- a/test/functional/wallet_upgradetohd.py +++ b/test/functional/wallet_upgradetohd.py @@ -1,5 +1,5 @@ #!/usr/bin/env python3 -# Copyright (c) 2016 The Bitcoin Core developers +# Copyright (c) 2016-2025 The Dash Core developers # Distributed under the MIT software license, see the accompanying # file COPYING or http://www.opensource.org/licenses/mit-license.php. """ From af4b6182b4eccab763bf9d10e12613a96f36c2cf Mon Sep 17 00:00:00 2001 From: Konstantin Akimov Date: Fri, 18 Jul 2025 02:24:44 +0700 Subject: [PATCH 3/6] test: make wallet_upgradetohd works for descriptor wallets too --- test/functional/wallet_upgradetohd.py | 95 +++++++++++++++++++-------- 1 file changed, 69 insertions(+), 26 deletions(-) diff --git a/test/functional/wallet_upgradetohd.py b/test/functional/wallet_upgradetohd.py index 91d5954384ea..598a53ef9812 100755 --- a/test/functional/wallet_upgradetohd.py +++ b/test/functional/wallet_upgradetohd.py @@ -29,7 +29,27 @@ 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") @@ -37,7 +57,8 @@ def recover_non_hd(self): 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,8 +119,9 @@ 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() @@ -105,9 +129,10 @@ def run_test(self): 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 From 0322b7cde257a2bb86a263b398325fd5b0ba2ce5 Mon Sep 17 00:00:00 2001 From: Konstantin Akimov Date: Fri, 18 Jul 2025 02:57:20 +0700 Subject: [PATCH 4/6] test: ensure determinism of addresses for specific mnemonic --- test/functional/wallet_upgradetohd.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/test/functional/wallet_upgradetohd.py b/test/functional/wallet_upgradetohd.py index 598a53ef9812..daadd33d7188 100755 --- a/test/functional/wallet_upgradetohd.py +++ b/test/functional/wallet_upgradetohd.py @@ -249,6 +249,28 @@ def run_test(self): # All coins should be recovered assert_equal(balance_after, node.getbalance()) + self.log.info("Test upgradetohd with user defined mnemonic") + custom_mnemonic = "similar behave slot swim scissors throw planet view ghost laugh drift calm" + # this address belongs to custom mnemonic with no passphrase + custom_address_1 = "yLpq97zZUsFQ2rdMqhcPKkYT36MoPK4Hob" + # this address belongs to custom mnemonic with passphrase "custom-passphrase" + custom_address_2 = "yYBPeZQcqgQHu9dxA5pKBWtYbK2hwfFHxf" + node.sendtoaddress(custom_address_1, 11) + node.sendtoaddress(custom_address_2, 12) + self.generate(node, 1) + + node.createwallet("wallet-11", blank=True) + w11 = node.get_wallet_rpc("wallet-11") + w11.upgradetohd(custom_mnemonic) + assert_equal(11, w11.getbalance()) + w11.unloadwallet() + + node.createwallet("wallet-12", blank=True) + w12 = node.get_wallet_rpc("wallet-12") + w12.upgradetohd(custom_mnemonic, "custom-passphrase") + assert_equal(12, w12.getbalance()) + w12.unloadwallet() + if __name__ == '__main__': WalletUpgradeToHDTest().main () From 1e70ee89a4917d45b3c41f39ba9ac8159f3e4ab7 Mon Sep 17 00:00:00 2001 From: Konstantin Akimov Date: Fri, 18 Jul 2025 02:59:20 +0700 Subject: [PATCH 5/6] test: enable --descriptors for wallet_upgradetohd.py --- test/functional/test_runner.py | 1 + 1 file changed, 1 insertion(+) diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py index 66b5bb231c7d..d0b46d57c653 100755 --- a/test/functional/test_runner.py +++ b/test/functional/test_runner.py @@ -321,6 +321,7 @@ 'wallet_encryption.py --legacy-wallet', 'wallet_encryption.py --descriptors', 'wallet_upgradetohd.py --legacy-wallet', + 'wallet_upgradetohd.py --descriptors', 'feature_dersig.py', 'feature_cltv.py', 'feature_new_quorum_type_activation.py', From 04c8c97c182b478a7891bfe6712de10efae574ef Mon Sep 17 00:00:00 2001 From: Konstantin Akimov Date: Fri, 18 Jul 2025 03:33:11 +0700 Subject: [PATCH 6/6] test: move helper get_mnemonic to test_framework/util --- test/functional/test_framework/util.py | 23 +++++++++++++++ test/functional/wallet_mnemonicbits.py | 31 +++++--------------- test/functional/wallet_upgradetohd.py | 40 +++++++------------------- 3 files changed, 41 insertions(+), 53 deletions(-) diff --git a/test/functional/test_framework/util.py b/test/functional/test_framework/util.py index f85c80befb8a..18e068f4d4ef 100644 --- a/test/functional/test_framework/util.py +++ b/test/functional/test_framework/util.py @@ -536,6 +536,29 @@ def force_finish_mnsync(node): while not node.mnsync("status")['IsSynced']: node.mnsync("next") + +def get_mnemonic(node): + """ + Return mnemonic if known from legacy HD wallets and Descriptor Wallets + Raises exception if there is none. + """ + if not node.getwalletinfo()['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 + # Transaction/Block functions ############################# diff --git a/test/functional/wallet_mnemonicbits.py b/test/functional/wallet_mnemonicbits.py index ddf4a8c432f1..4cc40c09ef77 100755 --- a/test/functional/wallet_mnemonicbits.py +++ b/test/functional/wallet_mnemonicbits.py @@ -7,6 +7,7 @@ from test_framework.test_framework import BitcoinTestFramework from test_framework.util import ( assert_equal, + get_mnemonic, ) class WalletMnemonicbitsTest(BitcoinTestFramework): @@ -17,24 +18,6 @@ def set_test_params(self): def skip_test_if_missing_module(self): self.skip_if_no_wallet() - 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 run_test(self): self.log.info("Test -mnemonicbits") @@ -43,7 +26,7 @@ def run_test(self): self.nodes[0].assert_start_raises_init_error(['-mnemonicbits=123'], "Error: Invalid '-mnemonicbits'. Allowed values: 128, 160, 192, 224, 256.") self.start_node(0) - mnemonic_pre = self.get_mnemonic(self.nodes[0]) + mnemonic_pre = get_mnemonic(self.nodes[0]) self.nodes[0].encryptwallet('pass') @@ -91,11 +74,11 @@ def run_test(self): self.nodes[0].createwallet("wallet_256", blank=True, descriptors=self.options.descriptors) # blank wallet self.nodes[0].get_wallet_rpc("wallet_256").upgradetohd() - assert_equal(len(self.get_mnemonic(self.nodes[0].get_wallet_rpc(self.default_wallet_name)).split()), 12) # 12 words by default - assert_equal(len(self.get_mnemonic(self.nodes[0].get_wallet_rpc("wallet_160")).split()), 15) # 15 words - assert_equal(len(self.get_mnemonic(self.nodes[0].get_wallet_rpc("wallet_192")).split()), 18) # 18 words - assert_equal(len(self.get_mnemonic(self.nodes[0].get_wallet_rpc("wallet_224")).split()), 21) # 21 words - assert_equal(len(self.get_mnemonic(self.nodes[0].get_wallet_rpc("wallet_256")).split()), 24) # 24 words + assert_equal(len(get_mnemonic(self.nodes[0].get_wallet_rpc(self.default_wallet_name)).split()), 12) # 12 words by default + assert_equal(len(get_mnemonic(self.nodes[0].get_wallet_rpc("wallet_160")).split()), 15) # 15 words + assert_equal(len(get_mnemonic(self.nodes[0].get_wallet_rpc("wallet_192")).split()), 18) # 18 words + assert_equal(len(get_mnemonic(self.nodes[0].get_wallet_rpc("wallet_224")).split()), 21) # 21 words + assert_equal(len(get_mnemonic(self.nodes[0].get_wallet_rpc("wallet_256")).split()), 24) # 24 words if __name__ == '__main__': diff --git a/test/functional/wallet_upgradetohd.py b/test/functional/wallet_upgradetohd.py index daadd33d7188..7f85aacebe19 100755 --- a/test/functional/wallet_upgradetohd.py +++ b/test/functional/wallet_upgradetohd.py @@ -15,6 +15,7 @@ from test_framework.util import ( assert_equal, assert_raises_rpc_error, + get_mnemonic, ) @@ -32,25 +33,6 @@ def setup_network(self): 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] @@ -68,7 +50,7 @@ def run_test(self): assert 'hdchainid' not in node.getwalletinfo() balance_before = node.getbalance() assert node.upgradetohd() - mnemonic = self.get_mnemonic(node) + mnemonic = get_mnemonic(node) if not self.options.descriptors: chainid = node.getwalletinfo()['hdchainid'] assert_equal(len(chainid), 64) @@ -104,7 +86,7 @@ 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 != self.get_mnemonic(node) + assert mnemonic != get_mnemonic(node) if not self.options.descriptors: assert chainid != node.getwalletinfo()['hdchainid'] assert_equal(balance_non_HD, node.getbalance()) @@ -119,7 +101,7 @@ 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 != self.get_mnemonic(node) + assert mnemonic != get_mnemonic(node) if not self.options.descriptors: assert chainid != node.getwalletinfo()['hdchainid'] assert_equal(balance_non_HD, node.getbalance()) @@ -129,7 +111,7 @@ def run_test(self): 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, self.get_mnemonic(node)) + assert_equal(mnemonic, get_mnemonic(node)) if not self.options.descriptors: new_chainid = node.getwalletinfo()['hdchainid'] assert chainid != new_chainid @@ -144,7 +126,7 @@ 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, self.get_mnemonic(node)) + assert_equal(mnemonic, get_mnemonic(node)) if not self.options.descriptors: assert_equal(new_chainid, node.getwalletinfo()['hdchainid']) assert_equal(balance_non_HD, node.getbalance()) @@ -158,7 +140,7 @@ 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, self.get_mnemonic(node)) + assert_equal(mnemonic, get_mnemonic(node)) if not self.options.descriptors: assert_equal(chainid, node.getwalletinfo()['hdchainid']) node.keypoolrefill(5) @@ -171,7 +153,7 @@ 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, self.get_mnemonic(node)) + assert_equal(mnemonic, get_mnemonic(node)) if not self.options.descriptors: assert_equal(chainid, node.getwalletinfo()['hdchainid']) # All coins should be recovered @@ -182,7 +164,7 @@ 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, self.get_mnemonic(node)) + assert_equal(mnemonic, get_mnemonic(node)) if not self.options.descriptors: assert_equal(chainid, node.getwalletinfo()['hdchainid']) assert balance_after != node.getbalance() @@ -200,7 +182,7 @@ 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, self.get_mnemonic(node)) + assert_equal(mnemonic, get_mnemonic(node)) if not self.options.descriptors: assert_equal(chainid, node.getwalletinfo()['hdchainid']) # Note: wallet encryption results in additional keypool topup, @@ -237,7 +219,7 @@ def run_test(self): 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, self.get_mnemonic(node)) + assert_equal(mnemonic, get_mnemonic(node)) if not self.options.descriptors: assert_equal(chainid, node.getwalletinfo()['hdchainid']) # Note: wallet encryption results in additional keypool topup,