Inside Bitcoin

251        self.assert_list_txs_equal(basic1.listtransactions(), listtransactions_compatibility(txs))
252
253        self.log.info("Test backup file can be successfully restored")
254        self.old_node.restorewallet("basic1_restored", basic1_migrate['backup_path'])
255        basic1_restored = self.old_node.get_wallet_rpc("basic1_restored")
256        basic1_restored_wi = basic1_restored.getwalletinfo()
257        assert_equal(basic1_restored_wi['balance'], bal)
258        assert_equal(basic1_restored.listaddressgroupings(), addr_gps)
259        self.assert_list_txs_equal(listtransactions_compatibility(basic1_restored.listtransactions()), txs)
260
261        # restart master node and verify that everything is still there
262        self.restart_node(0)
263        self.connect_nodes(0, 1)
264        default = self.master_node.get_wallet_rpc(self.default_wallet_name)
265        self.master_node.loadwallet("basic1")
266        basic1 = self.master_node.get_wallet_rpc("basic1")
267        assert_equal(basic1.getbalance(), bal)
268        self.assert_list_txs_equal(basic1.listtransactions(), txs)
269
270        self.log.info("Test migration of a wallet with balance received on the seed")
271        basic2 = self.create_legacy_wallet("basic2")
272        basic2_seed = get_generate_key()
273        basic2.sethdseed(True, basic2_seed.privkey)
274        assert_equal(basic2.getbalance(), 0)
275
276        # Receive coins on different output types for the same seed
277        basic2_balance = 0
278        for addr in [basic2_seed.p2pkh_addr, basic2_seed.p2wpkh_addr, basic2_seed.p2sh_p2wpkh_addr]:
279            send_value = random.randint(1, 4)
280            default.sendtoaddress(addr, send_value)
281            basic2_balance += send_value
282            self.generate(self.master_node, 1)
283            assert_equal(basic2.getbalance(), basic2_balance)
284        basic2_txs = basic2.listtransactions()
285
286        # Now migrate and test that we still have the same balance/transactions
287        _, basic2 = self.migrate_and_get_rpc("basic2")
288        assert_equal(basic2.getbalance(), basic2_balance)
289        self.assert_list_txs_equal(basic2.listtransactions(), listtransactions_compatibility(basic2_txs))
290
291        # Now test migration on a descriptor wallet
292        self.log.info("Test \"nothing to migrate\" when the user tries to migrate a loaded wallet with no legacy data")
293        assert_raises_rpc_error(-4, "Error: This wallet is already a descriptor wallet", basic2.migratewallet)
294
295        self.log.info("Test \"nothing to migrate\" when the user tries to migrate an unloaded wallet with no legacy data")
296        basic2.unloadwallet()
297        assert_raises_rpc_error(-4, "Error: This wallet is already a descriptor wallet", self.master_node.migratewallet, "basic2")
298
299    def test_multisig(self):
300        default = self.master_node.get_wallet_rpc(self.default_wallet_name)
301
302        # Contrived case where all the multisig keys are in a single wallet
303        self.log.info("Test migration of a wallet with all keys for a multisig")
304        multisig0 = self.create_legacy_wallet("multisig0")
305        addr1 = multisig0.getnewaddress()
306        addr2 = multisig0.getnewaddress()
307        addr3 = multisig0.getnewaddress()
308
309        ms_info = multisig0.addmultisigaddress(2, [addr1, addr2, addr3])
310
311        _, multisig0 = self.migrate_and_get_rpc("multisig0")
312        ms_addr_info = multisig0.getaddressinfo(ms_info["address"])
313        assert_equal(ms_addr_info["ismine"], True)
314        assert_equal(ms_addr_info["desc"], ms_info["descriptor"])
315        assert_equal("multisig0_watchonly" in self.master_node.listwallets(), False)
316        assert_equal("multisig0_solvables" in self.master_node.listwallets(), False)
317
318        pub1 = multisig0.getaddressinfo(addr1)["pubkey"]
319        pub2 = multisig0.getaddressinfo(addr2)["pubkey"]
320
321        # Some keys in multisig do not belong to this wallet
322        self.log.info("Test migration of a wallet that has some keys in a multisig")
323        multisig1 = self.create_legacy_wallet("multisig1")
324        ms_info = multisig1.addmultisigaddress(2, [multisig1.getnewaddress(), pub1, pub2])
325        ms_info2 = multisig1.addmultisigaddress(2, [multisig1.getnewaddress(), pub1, pub2])
326
327        addr1 = ms_info["address"]
328        addr2 = ms_info2["address"]
329        txid = default.sendtoaddress(addr1, 10)
330        multisig1.importaddress(addr1)
331        assert_equal(multisig1.getaddressinfo(addr1)["ismine"], False)
332        assert_equal(multisig1.getaddressinfo(addr1)["iswatchonly"], True)
333        assert_equal(multisig1.getaddressinfo(addr1)["solvable"], True)
334        self.generate(self.master_node, 1)
335        multisig1.gettransaction(txid)
336        assert_equal(multisig1.getbalances()["watchonly"]["trusted"], 10)
337        assert_equal(multisig1.getaddressinfo(addr2)["ismine"], False)
338        assert_equal(multisig1.getaddressinfo(addr2)["iswatchonly"], False)
339        assert_equal(multisig1.getaddressinfo(addr2)["solvable"], True)
340
341        # Migrating multisig1 should see the multisig is no longer part of multisig1
342        # A new wallet multisig1_watchonly is created which has the multisig address
343        # Transaction to multisig is in multisig1_watchonly and not multisig1
344        _, multisig1 = self.migrate_and_get_rpc("multisig1")
345        assert_equal(multisig1.getaddressinfo(addr1)["ismine"], False)
346        assert_equal(multisig1.getaddressinfo(addr1)["solvable"], False)
347        assert_raises_rpc_error(-5, "Invalid or non-wallet transaction id", multisig1.gettransaction, txid)
348        assert_equal(multisig1.getbalance(), 0)
349        assert_equal(multisig1.listtransactions(), [])
350
351        assert_equal("multisig1_watchonly" in self.master_node.listwallets(), True)
352        ms1_watchonly = self.master_node.get_wallet_rpc("multisig1_watchonly")
353        ms1_wallet_info = ms1_watchonly.getwalletinfo()
354        assert_equal(ms1_wallet_info['descriptors'], True)
355        assert_equal(ms1_wallet_info['private_keys_enabled'], False)
356        self.assert_is_sqlite("multisig1_watchonly")
357        assert_equal(ms1_watchonly.getaddressinfo(addr1)["ismine"], True)
358        assert_equal(ms1_watchonly.getaddressinfo(addr1)["solvable"], True)
359        # Because addr2 was not being watched, it isn't in multisig1_watchonly but rather multisig1_solvables
360        assert_equal(ms1_watchonly.getaddressinfo(addr2)["ismine"], False)
361        assert_equal(ms1_watchonly.getaddressinfo(addr2)["solvable"], False)
362        ms1_watchonly.gettransaction(txid)
363        assert_equal(ms1_watchonly.getbalance(), 10)
364
365        # Migrating multisig1 should see the second multisig is no longer part of multisig1
366        # A new wallet multisig1_solvables is created which has the second address
367        # This should have no transactions
368        assert_equal("multisig1_solvables" in self.master_node.listwallets(), True)
369        ms1_solvable = self.master_node.get_wallet_rpc("multisig1_solvables")
370        ms1_wallet_info = ms1_solvable.getwalletinfo()
371        assert_equal(ms1_wallet_info['descriptors'], True)
372        assert_equal(ms1_wallet_info['private_keys_enabled'], False)
373        self.assert_is_sqlite("multisig1_solvables")
374        assert_equal(ms1_solvable.getaddressinfo(addr1)["ismine"], False)
375        assert_equal(ms1_solvable.getaddressinfo(addr1)["solvable"], False)
376        assert_equal(ms1_solvable.getaddressinfo(addr2)["ismine"], True)
377        assert_equal(ms1_solvable.getaddressinfo(addr2)["solvable"], True)
378        assert_equal(ms1_solvable.getbalance(), 0)
379        assert_equal(ms1_solvable.listtransactions(), [])
380
381
382    def test_other_watchonly(self):
383        default = self.master_node.get_wallet_rpc(self.default_wallet_name)
384
385        # Wallet with an imported address. Should be the same thing as the multisig test
386        self.log.info("Test migration of a wallet with watchonly imports")
387        imports0 = self.create_legacy_wallet("imports0")
388
389        # External address label
390        imports0.setlabel(default.getnewaddress(), "external")
391
392        # Normal non-watchonly tx
393        received_addr = imports0.getnewaddress()
394        imports0.setlabel(received_addr, "Receiving")
395        received_txid = default.sendtoaddress(received_addr, 10)
396
397        # Watchonly tx
398        import_addr = default.getnewaddress()
399        imports0.importaddress(import_addr)
400        imports0.setlabel(import_addr, "imported")
401        received_watchonly_txid = default.sendtoaddress(import_addr, 10)
402
403        # Received watchonly tx that is then spent
404        import_sent_addr = default.getnewaddress()
405        imports0.importaddress(import_sent_addr)
406        received_sent_watchonly_utxo = self.create_outpoints(node=default, outputs=[{import_sent_addr: 10}])[0]
407
408        send = default.sendall(recipients=[default.getnewaddress()], inputs=[received_sent_watchonly_utxo])
409        sent_watchonly_txid = send["txid"]
410
411        # Tx that has both a watchonly and spendable output
412        watchonly_spendable_txid = default.send(outputs=[{received_addr: 1}, {import_addr:1}])["txid"]
413
414        self.generate(self.master_node, 2)
415        received_watchonly_tx_info = imports0.gettransaction(received_watchonly_txid, True)
416        received_sent_watchonly_tx_info = imports0.gettransaction(received_sent_watchonly_utxo["txid"], True)
417
418        balances = imports0.getbalances()
419        spendable_bal = balances["mine"]["trusted"]
420        watchonly_bal = balances["watchonly"]["trusted"]
421        assert_equal(len(imports0.listtransactions(include_watchonly=True)), 6)
422
423        # Mock time forward a bit so we can check that tx metadata is preserved
424        self.master_node.setmocktime(int(time.time()) + 100)
425
426        # Migrate
427        _, imports0 = self.migrate_and_get_rpc("imports0")
428        assert_raises_rpc_error(-5, "Invalid or non-wallet transaction id", imports0.gettransaction, received_watchonly_txid)
429        assert_raises_rpc_error(-5, "Invalid or non-wallet transaction id", imports0.gettransaction, received_sent_watchonly_utxo['txid'])
430        assert_raises_rpc_error(-5, "Invalid or non-wallet transaction id", imports0.gettransaction, sent_watchonly_txid)
431        assert_equal(len(imports0.listtransactions()), 2)
432        imports0.gettransaction(received_txid)
433        imports0.gettransaction(watchonly_spendable_txid)
434        assert_equal(imports0.getbalance(), spendable_bal)
435
436        assert_equal("imports0_watchonly" in self.master_node.listwallets(), True)
437        watchonly = self.master_node.get_wallet_rpc("imports0_watchonly")
438        watchonly_info = watchonly.getwalletinfo()
439        assert_equal(watchonly_info["descriptors"], True)
440        self.assert_is_sqlite("imports0_watchonly")
441        assert_equal(watchonly_info["private_keys_enabled"], False)
442        received_migrated_watchonly_tx_info = watchonly.gettransaction(received_watchonly_txid)
443        assert_equal(received_watchonly_tx_info["time"], received_migrated_watchonly_tx_info["time"])
444        assert_equal(received_watchonly_tx_info["timereceived"], received_migrated_watchonly_tx_info["timereceived"])
445        received_sent_migrated_watchonly_tx_info = watchonly.gettransaction(received_sent_watchonly_utxo["txid"])
446        assert_equal(received_sent_watchonly_tx_info["time"], received_sent_migrated_watchonly_tx_info["time"])
447        assert_equal(received_sent_watchonly_tx_info["timereceived"], received_sent_migrated_watchonly_tx_info["timereceived"])
448        watchonly.gettransaction(sent_watchonly_txid)
449        watchonly.gettransaction(watchonly_spendable_txid)
450        assert_equal(watchonly.getbalance(), watchonly_bal)
451        assert_raises_rpc_error(-5, "Invalid or non-wallet transaction id", watchonly.gettransaction, received_txid)
452        assert_equal(len(watchonly.listtransactions(include_watchonly=True)), 4)
453
454        # Check that labels were migrated and persisted to watchonly wallet
455        self.master_node.unloadwallet("imports0_watchonly")
456        self.master_node.loadwallet("imports0_watchonly")
457        labels = watchonly.listlabels()
458        assert "external" in labels
459        assert "imported" in labels
460
461    def test_no_privkeys(self):
462        default = self.master_node.get_wallet_rpc(self.default_wallet_name)
463
464        # Migrating an actual watchonly wallet should not create a new watchonly wallet
465        self.log.info("Test migration of a pure watchonly wallet")
466        watchonly0 = self.create_legacy_wallet("watchonly0", disable_private_keys=True)
467
468        addr = default.getnewaddress()
469        desc = default.getaddressinfo(addr)["desc"]
470        res = watchonly0.importmulti([
471            {
472                "desc": desc,
473                "watchonly": True,
474                "timestamp": "now",
475            }])
476        assert_equal(res[0]['success'], True)
477        default.sendtoaddress(addr, 10)
478        self.generate(self.master_node, 1)
479
480        _, watchonly0 = self.migrate_and_get_rpc("watchonly0")
481        assert_equal("watchonly0_watchonly" in self.master_node.listwallets(), False)
482        info = watchonly0.getwalletinfo()
483        assert_equal(info["descriptors"], True)
484        assert_equal(info["private_keys_enabled"], False)
485        self.assert_is_sqlite("watchonly0")
486
487        # Migrating a wallet with pubkeys added to the keypool
488        self.log.info("Test migration of a pure watchonly wallet with pubkeys in keypool")
489        watchonly1 = self.create_legacy_wallet("watchonly1", disable_private_keys=True)
490
491        addr1 = default.getnewaddress(address_type="bech32")
492        addr2 = default.getnewaddress(address_type="bech32")
493        desc1 = default.getaddressinfo(addr1)["desc"]
494        desc2 = default.getaddressinfo(addr2)["desc"]
495        res = watchonly1.importmulti([
496            {
497                "desc": desc1,
498                "keypool": True,
499                "timestamp": "now",
500            },