Inside Bitcoin

251
252        # Downgrade: load on the old release, then force it to rewrite the tx
253        # record by disconnecting the block that confirmed the canonical tx.
254        old_dir = node_old.wallets_path / wallet_name
255        shutil.copytree(node_master.wallets_path / wallet_name, old_dir)
256        node_old.loadwallet(wallet_name)
257        old_wallet = node_old.get_wallet_rpc(wallet_name)
258        assert_equal(old_wallet.gettransaction(txid)["hex"], key_path_tx)
259        old_wallet.invalidateblock(block_hash)
260        old_wallet.syncwithvalidationinterfacequeue()
261        old_wallet.unloadwallet()
262
263        # Re-open on master: the alternate must still be there
264        self.cleanup_folder(node_master.wallets_path / wallet_name)
265        shutil.copytree(old_dir, node_master.wallets_path / wallet_name)
266        node_master.loadwallet(wallet_name)
267        wallet = node_master.get_wallet_rpc(wallet_name)
268        assert_equal(wallet.gettransaction(txid)["alternate_wtxids"], [script_path_wtxid])
269        wallet.unloadwallet()
270
271
272    def run_test(self):
273        node_miner = self.nodes[0]
274        node_master = self.nodes[1]
275        node_v21 = self.nodes[self.num_nodes - 2]
276        node_v20 = self.nodes[self.num_nodes - 1] # bdb only
277
278        previous_nodes = self.nodes[2:] # All previous version nodes
279        legacy_nodes = self.nodes[-6:] # Nodes that support legacy wallets
280        descriptors_nodes = self.nodes[2:-1] # Nodes that support descriptor wallets
281
282        self.generatetoaddress(node_miner, COINBASE_MATURITY + 1, node_miner.getnewaddress())
283
284        # Sanity check the test framework:
285        assert_equal(node_v20.getblockchaininfo()["blocks"], COINBASE_MATURITY + 1)
286
287        self.log.info("Test wallet backwards compatibility...")
288        # Create a number of wallets and open them in older versions:
289
290        # w1: regular wallet, created on master: update this test when default
291        #     wallets can no longer be opened by older versions.
292        node_master.createwallet(wallet_name="w1")
293        wallet = node_master.get_wallet_rpc("w1")
294        info = wallet.getwalletinfo()
295        assert info['private_keys_enabled']
296        assert info['keypoolsize'] > 0
297        # Create a confirmed transaction, receiving coins
298        address = wallet.getnewaddress()
299        node_miner.sendtoaddress(address, 10)
300        self.sync_mempools()
301        self.generate(node_miner, 1)
302        # Create a conflicting transaction using RBF
303        return_address = node_miner.getnewaddress()
304        tx1_id = node_master.sendtoaddress(return_address, 1)
305        tx2_id = node_master.bumpfee(tx1_id)["txid"]
306        # Confirm the transaction
307        self.sync_mempools()
308        self.generate(node_miner, 1)
309        # Create another conflicting transaction using RBF
310        tx3_id = node_master.sendtoaddress(return_address, 1)
311        tx4_id = node_master.bumpfee(tx3_id)["txid"]
312        self.sync_mempools()
313        # Abandon transaction, but don't confirm
314        node_master.abandontransaction(tx3_id)
315
316        # w2: wallet with private keys disabled, created on master: update this
317        #     test when default wallets private keys disabled can no longer be
318        #     opened by older versions.
319        node_master.createwallet(wallet_name="w2", disable_private_keys=True)
320        wallet = node_master.get_wallet_rpc("w2")
321        info = wallet.getwalletinfo()
322        assert_equal(info['private_keys_enabled'], False)
323        assert_equal(info['keypoolsize'], 0)
324
325        # w3: blank wallet, created on master: update this
326        #     test when default blank wallets can no longer be opened by older versions.
327        node_master.createwallet(wallet_name="w3", blank=True)
328        wallet = node_master.get_wallet_rpc("w3")
329        info = wallet.getwalletinfo()
330        assert info['private_keys_enabled']
331        assert_equal(info['keypoolsize'], 0)
332
333        node_master.createwallet(wallet_name="miniscript")
334        wallet = node_master.get_wallet_rpc("miniscript")
335        miniscript_desc = "wsh(or_b(pk([deadbeef/0h/1h/2h]tprv8ZgxMBicQKsPerQj6m35no46amfKQdjY7AhLnmatHYXs8S4MTgeZYkWAn4edSGwwL3vkSiiGqSZQrmy5D3P5gBoqgvYP2fCUpBwbKTMTAkL/3h/*),s:pk([beefdead/4h/5h]tpubD6NzVbkrYhZ4YU9vM1s53UhD75UyJatx8EMzMZ3VUjR2FciNfLLkAw6a4pWACChzobTseNqdWk4G7ZdBqRDLtLSACKykTScmqibb1ZrCvJu/6/7/*)))"
336        miniscript_apos = miniscript_desc.replace("[beefdead/4h/5h]", "[beefdead/4'/5']")
337        assert miniscript_apos != miniscript_desc
338        for desc in [miniscript_desc, miniscript_apos]:
339            res = wallet.importdescriptors([{"desc": descsum_create(desc), "timestamp":"now"}])
340            assert_equal(res[0]["success"], True)
341
342        # Unload wallets and copy to older nodes:
343        node_master_wallets_dir = node_master.wallets_path
344        node_master.unloadwallet("w1")
345        node_master.unloadwallet("w2")
346        node_master.unloadwallet("w3")
347        node_master.unloadwallet("miniscript")
348
349        for node in previous_nodes:
350            # Copy wallets to previous version
351            for wallet in os.listdir(node_master_wallets_dir):
352                dest = node.wallets_path / wallet
353                source = node_master_wallets_dir / wallet
354                shutil.copytree(source, dest)
355
356        self.log.info("Test that a wallet made on master can be opened on:")
357        # This test only works on the nodes that support descriptor wallets
358        # since we can no longer create legacy wallets.
359        for node in descriptors_nodes:
360            self.log.info(f"- {node.version}")
361            for wallet_name in ["w1", "w2", "w3", "miniscript"]:
362                if self.major_version_less_than(node, 22) and wallet_name == "w1":
363                    # Descriptor wallets created after 0.21 have taproot descriptors which 0.21 does not support, tested below
364                    continue
365                if self.major_version_less_than(node, 24) and wallet_name == "miniscript":
366                    # Miniscript was introduced in 24.0
367                    continue
368                # Also try to reopen on master after opening on old
369                for n in [node, node_master]:
370                    # 31.0 and 31.1 have a descriptor id calculation incompatibility.
371                    # Miniscript descriptors imported into node versions other than 31.0 will
372                    # result in wallets that cannot be loaded into 31.0 and 31.1.
373                    # These wallets will emit a "Wallet corrupted" error.
374                    if wallet_name == "miniscript" and n.version in (310000, 310100):
375                        assert_raises_rpc_error(-4, "Wallet corrupted", n.loadwallet, wallet_name)
376                        continue
377
378                    n.loadwallet(wallet_name)
379                    wallet = n.get_wallet_rpc(wallet_name)
380                    info = wallet.getwalletinfo()
381                    if wallet_name == "w1":
382                        assert_equal(info['private_keys_enabled'], True)
383                        assert info['keypoolsize'] > 0
384                        txs = wallet.listtransactions()
385                        assert_equal(len(txs), 5)
386                        assert_equal(txs[1]["txid"], tx1_id)
387                        assert_equal(txs[2]["walletconflicts"], [tx1_id])
388                        assert_equal(txs[1]["replaced_by_txid"], tx2_id)
389                        assert not txs[1]["abandoned"]
390                        assert_equal(txs[1]["confirmations"], -1)
391                        assert_equal(txs[2]["blockindex"], 1)
392                        assert txs[3]["abandoned"]
393                        assert_equal(txs[4]["walletconflicts"], [tx3_id])
394                        assert_equal(txs[3]["replaced_by_txid"], tx4_id)
395                        assert not hasattr(txs[3], "blockindex")
396                    elif wallet_name == "w2":
397                        assert_equal(info['private_keys_enabled'], False)
398                        assert_equal(info['keypoolsize'], 0)
399                    elif wallet_name == "w3":
400                        assert_equal(info['private_keys_enabled'], True)
401                        assert_equal(info['keypoolsize'], 0)
402                    elif wallet_name == "miniscript":
403                        descs = wallet.listdescriptors()["descriptors"]
404                        assert any(desc["desc"].startswith("wsh(or_b(pk") for desc in descs), "Miniscript descriptor missing"
405
406                    # Copy back to master
407                    wallet.unloadwallet()
408                    if n == node:
409                        (node_master.wallets_path / wallet_name / "wallet.dat").unlink()
410                        (node_master.wallets_path / wallet_name).rmdir()
411                        shutil.copytree(
412                            n.wallets_path / wallet_name,
413                            node_master.wallets_path / wallet_name,
414                        )
415
416        # Check that descriptor wallets don't work on legacy only nodes
417        self.log.info("Test descriptor wallet incompatibility on v0.20")
418        # Descriptor wallets appear to be corrupted wallets to old software
419        assert self.major_version_equals(node_v20, 20)
420        for wallet_name in ["w1", "w2", "w3"]:
421            assert_raises_rpc_error(-4, "Wallet file verification failed: wallet.dat corrupt, salvage failed", node_v20.loadwallet, wallet_name)
422
423        # w1 cannot be opened by 0.21 since it contains a taproot descriptor
424        self.log.info("Test that 0.21 cannot open wallet containing tr() descriptors")
425        assert_raises_rpc_error(-1, "map::at", node_v21.loadwallet, "w1")
426
427        self.log.info("Test that a wallet can upgrade to and downgrade from master, from:")
428        for node in descriptors_nodes:
429            self.log.info(f"- {node.version}")
430            wallet_name = f"up_{node.version}"
431            node.createwallet(wallet_name=wallet_name, descriptors=True)
432            wallet_prev = node.get_wallet_rpc(wallet_name)
433            address = wallet_prev.getnewaddress('', "bech32")
434            addr_info = wallet_prev.getaddressinfo(address)
435
436            hdkeypath = addr_info["hdkeypath"].replace("'", "h")
437            pubkey = addr_info["pubkey"]
438
439            if self.major_version_at_least(node, 24):
440                res = wallet_prev.importdescriptors([{"desc": descsum_create(miniscript_desc), "timestamp":"now"}])
441                assert_equal(res[0]["success"], True)
442
443            # Make a backup of the wallet file
444            backup_path = os.path.join(self.options.tmpdir, f"{wallet_name}.dat")
445            wallet_prev.backupwallet(backup_path)
446
447            # Remove the wallet from old node
448            wallet_prev.unloadwallet()
449
450            # Open backup with sqlite and get flags
451            def get_flags(conn):
452                flags_rec = conn.execute(f"SELECT value FROM main WHERE key = x'{ser_string(b'flags').hex()}'").fetchone()
453                return int.from_bytes(flags_rec[0], byteorder="little")
454
455            old_flags = self.inspect_sqlite_db(backup_path, get_flags)
456
457            # Restore the wallet to master
458            load_res = node_master.restorewallet(wallet_name, backup_path)
459            # There should be no warnings
460            assert "warnings" not in load_res
461
462            wallet = node_master.get_wallet_rpc(wallet_name)
463            info = wallet.getaddressinfo(address)
464            descriptor = f"wpkh([{info['hdmasterfingerprint']}{hdkeypath[1:]}]{pubkey})"
465            assert_equal(info["desc"], descsum_create(descriptor))
466
467            if self.major_version_at_least(node, 24):
468                descs = wallet.listdescriptors()["descriptors"]
469                assert any(desc["desc"].startswith("wsh(or_b(pk") for desc in descs), "Miniscript descriptor missing"
470
471            # Make backup so the wallet can be copied back to old node
472            down_wallet_name = f"re_down_{node.version}"
473            down_backup_path = os.path.join(self.options.tmpdir, f"{down_wallet_name}.dat")
474            wallet.backupwallet(down_backup_path)
475
476            # Check that taproot descriptors can be added to 0.21 wallets
477            # This must be done after the backup is created so that 0.21 can still load
478            # the backup
479            if self.major_version_equals(node, 21):
480                assert_raises_rpc_error(-12, "No bech32m addresses available", wallet.getnewaddress, address_type="bech32m")
481                xpubs = wallet.gethdkeys(active_only=True)
482                assert_equal(len(xpubs), 1)
483                assert_equal(len(xpubs[0]["descriptors"]), 6)
484                wallet.createwalletdescriptor("bech32m")
485                xpubs = wallet.gethdkeys(active_only=True)
486                assert_equal(len(xpubs), 1)
487                assert_equal(len(xpubs[0]["descriptors"]), 8)
488                tr_descs = [desc["desc"] for desc in xpubs[0]["descriptors"] if desc["desc"].startswith("tr(")]
489                assert_equal(len(tr_descs), 2)
490                for desc in tr_descs:
491                    assert info["hdmasterfingerprint"] in desc
492                wallet.getnewaddress(address_type="bech32m")
493
494            wallet.unloadwallet()
495
496            # Open the wallet with sqlite and inspect the flags and records
497            def check_upgraded_records(conn, old_flags):
498                flags_rec = conn.execute(f"SELECT value FROM main WHERE key = x'{ser_string(b'flags').hex()}'").fetchone()
499                new_flags = int.from_bytes(flags_rec[0], byteorder="little")
500                diff_flags = new_flags & ~old_flags