Inside Bitcoin

251        file_format = self.nodes[0].get_wallet_rpc("todump").getwalletinfo()["format"]
252        self.nodes[0].createwallet("todump2")
253        self.stop_node(0)
254
255        self.log.info('Checking dump arguments')
256        self.assert_raises_tool_error('No dump file provided. To use dump, -dumpfile=<filename> must be provided.', '-wallet=todump', 'dump')
257
258        self.log.info('Checking basic dump')
259        wallet_dump = self.nodes[0].datadir_path / "wallet.dump"
260        self.assert_tool_output('The dumpfile may contain private keys. To ensure the safety of your Bitcoin, do not share the dumpfile.\n', '-wallet=todump', '-dumpfile={}'.format(wallet_dump), 'dump')
261
262        dump_data = self.read_dump(wallet_dump)
263        orig_dump = dump_data.copy()
264        # Check the dump magic
265        assert_equal(dump_data['BITCOIN_CORE_WALLET_DUMP'], '1')
266        # Check the file format
267        assert_equal(dump_data["format"], file_format)
268
269        self.log.info('Checking that a dumpfile cannot be overwritten')
270        self.assert_raises_tool_error('File {} already exists. If you are sure this is what you want, move it out of the way first.'.format(wallet_dump),  '-wallet=todump2', '-dumpfile={}'.format(wallet_dump), 'dump')
271
272        self.log.info('Checking createfromdump arguments')
273        self.assert_raises_tool_error('No dump file provided. To use createfromdump, -dumpfile=<filename> must be provided.', '-wallet=todump', 'createfromdump')
274        non_exist_dump = self.nodes[0].datadir_path / "wallet.nodump"
275        self.assert_raises_tool_error('Dump file {} does not exist.'.format(non_exist_dump), '-wallet=todump', '-dumpfile={}'.format(non_exist_dump), 'createfromdump')
276        wallet_path = self.nodes[0].wallets_path / "todump2"
277        self.assert_raises_tool_error('Failed to create database path \'{}\'. Database already exists.'.format(wallet_path), '-wallet=todump2', '-dumpfile={}'.format(wallet_dump), 'createfromdump')
278        self.assert_raises_tool_error("Invalid parameter -descriptors", '-descriptors', '-wallet=todump2', '-dumpfile={}'.format(wallet_dump), 'createfromdump')
279
280        self.log.info('Checking createfromdump')
281        self.do_tool_createfromdump("load", "wallet.dump")
282
283        self.log.info('Checking createfromdump handling of magic and versions')
284        bad_ver_wallet_dump = self.nodes[0].datadir_path / "wallet-bad_ver1.dump"
285        dump_data["BITCOIN_CORE_WALLET_DUMP"] = "0"
286        self.write_dump(dump_data, bad_ver_wallet_dump)
287        self.assert_raises_tool_error('Error: Dumpfile version is not supported. This version of bitcoin-wallet only supports version 1 dumpfiles. Got dumpfile with version 0', '-wallet=badload', '-dumpfile={}'.format(bad_ver_wallet_dump), 'createfromdump')
288        assert not (self.nodes[0].wallets_path / "badload").is_dir()
289        bad_ver_wallet_dump = self.nodes[0].datadir_path / "wallet-bad_ver2.dump"
290        dump_data["BITCOIN_CORE_WALLET_DUMP"] = "2"
291        self.write_dump(dump_data, bad_ver_wallet_dump)
292        self.assert_raises_tool_error('Error: Dumpfile version is not supported. This version of bitcoin-wallet only supports version 1 dumpfiles. Got dumpfile with version 2', '-wallet=badload', '-dumpfile={}'.format(bad_ver_wallet_dump), 'createfromdump')
293        assert not (self.nodes[0].wallets_path / "badload").is_dir()
294        bad_magic_wallet_dump = self.nodes[0].datadir_path / "wallet-bad_magic.dump"
295        del dump_data["BITCOIN_CORE_WALLET_DUMP"]
296        dump_data["not_the_right_magic"] = "1"
297        self.write_dump(dump_data, bad_magic_wallet_dump, "not_the_right_magic")
298        self.assert_raises_tool_error('Error: Dumpfile identifier record is incorrect. Got "not_the_right_magic", expected "BITCOIN_CORE_WALLET_DUMP".', '-wallet=badload', '-dumpfile={}'.format(bad_magic_wallet_dump), 'createfromdump')
299        assert not (self.nodes[0].wallets_path / "badload").is_dir()
300
301        self.log.info('Checking createfromdump handling of checksums')
302        bad_sum_wallet_dump = self.nodes[0].datadir_path / "wallet-bad_sum1.dump"
303        dump_data = orig_dump.copy()
304        checksum = dump_data["checksum"]
305        dump_data["checksum"] = "1" * 64
306        self.write_dump(dump_data, bad_sum_wallet_dump)
307        self.assert_raises_tool_error('Error: Dumpfile checksum does not match. Computed {}, expected {}'.format(checksum, "1" * 64), '-wallet=bad', '-dumpfile={}'.format(bad_sum_wallet_dump), 'createfromdump')
308        assert not (self.nodes[0].wallets_path / "badload").is_dir()
309        bad_sum_wallet_dump = self.nodes[0].datadir_path / "wallet-bad_sum2.dump"
310        del dump_data["checksum"]
311        self.write_dump(dump_data, bad_sum_wallet_dump, skip_checksum=True)
312        self.assert_raises_tool_error('Error: Missing checksum', '-wallet=badload', '-dumpfile={}'.format(bad_sum_wallet_dump), 'createfromdump')
313        assert not (self.nodes[0].wallets_path / "badload").is_dir()
314        bad_sum_wallet_dump = self.nodes[0].datadir_path / "wallet-bad_sum3.dump"
315        dump_data["checksum"] = "2" * 10
316        self.write_dump(dump_data, bad_sum_wallet_dump)
317        self.assert_raises_tool_error('Error: Checksum is not the correct size', '-wallet=badload', '-dumpfile={}'.format(bad_sum_wallet_dump), 'createfromdump')
318        assert not (self.nodes[0].wallets_path / "badload").is_dir()
319        dump_data["checksum"] = "3" * 66
320        self.write_dump(dump_data, bad_sum_wallet_dump)
321        self.assert_raises_tool_error('Error: Checksum is not the correct size', '-wallet=badload', '-dumpfile={}'.format(bad_sum_wallet_dump), 'createfromdump')
322        assert not (self.nodes[0].wallets_path / "badload").is_dir()
323
324    def test_chainless_conflicts(self):
325        self.log.info("Test wallet tool when wallet contains conflicting transactions")
326        self.restart_node(0)
327        self.generate(self.nodes[0], 101)
328
329        def_wallet = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
330
331        self.nodes[0].createwallet("conflicts")
332        wallet = self.nodes[0].get_wallet_rpc("conflicts")
333        def_wallet.sendtoaddress(wallet.getnewaddress(), 10)
334        self.generate(self.nodes[0], 1)
335
336        # parent tx
337        parent_txid = wallet.sendtoaddress(wallet.getnewaddress(), 9)
338        parent_txid_bytes = bytes.fromhex(parent_txid)[::-1]
339        conflict_utxo = wallet.gettransaction(txid=parent_txid, verbose=True)["decoded"]["vin"][0]
340
341        # The specific assertion in MarkConflicted being tested requires that the parent tx is already loaded
342        # by the time the child tx is loaded. Since transactions end up being loaded in txid order due to how both
343        # and sqlite store things, we can just grind the child tx until it has a txid that is greater than the parent's.
344        locktime = 500000000 # Use locktime as nonce, starting at unix timestamp minimum
345        addr = wallet.getnewaddress()
346        while True:
347            child_send_res = wallet.send(outputs=[{addr: 8}], add_to_wallet=False, locktime=locktime)
348            child_txid = child_send_res["txid"]
349            child_txid_bytes = bytes.fromhex(child_txid)[::-1]
350            if (child_txid_bytes > parent_txid_bytes):
351                wallet.sendrawtransaction(child_send_res["hex"])
352                break
353            locktime += 1
354
355        # conflict with parent
356        conflict_unsigned = self.nodes[0].createrawtransaction(inputs=[conflict_utxo], outputs=[{wallet.getnewaddress(): 9.9999}])
357        conflict_signed = wallet.signrawtransactionwithwallet(conflict_unsigned)["hex"]
358        conflict_txid = self.nodes[0].sendrawtransaction(conflict_signed)
359        self.generate(self.nodes[0], 1)
360        assert_equal(wallet.gettransaction(txid=parent_txid)["confirmations"], -1)
361        assert_equal(wallet.gettransaction(txid=child_txid)["confirmations"], -1)
362        assert_equal(wallet.gettransaction(txid=conflict_txid)["confirmations"], 1)
363
364        self.stop_node(0)
365
366        # Wallet tool should successfully give info for this wallet
367        expected_output = textwrap.dedent('''\
368            Wallet info
369            ===========
370            Name: conflicts
371            Format: sqlite
372            Descriptors: yes
373            Encrypted: no
374            HD (hd seed available): yes
375            Keypool Size: 8
376            Transactions: 4
377            Address Book: 4
378        ''')
379        self.assert_tool_output(expected_output, "-wallet=conflicts", "info")
380
381    def test_dump_very_large_records(self):
382        self.log.info("Test that wallets with large records are successfully dumped")
383
384        self.start_node(0)
385        self.nodes[0].createwallet("bigrecords")
386        wallet = self.nodes[0].get_wallet_rpc("bigrecords")
387
388        # Both BDB and sqlite have maximum page sizes of 65536 bytes, with defaults of 4096
389        # When a record exceeds some size threshold, both BDB and SQLite will store the data
390        # in one or more overflow pages. We want to make sure that our tooling can dump such
391        # records, even when they span multiple pages. To make a large record, we just need
392        # to make a very big transaction.
393        self.generate(self.nodes[0], 101)
394        def_wallet = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
395        outputs = {}
396        for i in range(500):
397            outputs[wallet.getnewaddress(address_type="p2sh-segwit")] = 0.01
398        def_wallet.sendmany(amounts=outputs)
399        self.generate(self.nodes[0], 1)
400        send_res = wallet.sendall([def_wallet.getnewaddress()])
401        self.generate(self.nodes[0], 1)
402        assert_equal(send_res["complete"], True)
403        tx = wallet.gettransaction(txid=send_res["txid"], verbose=True)
404        assert_greater_than(tx["decoded"]["size"], 70000)
405
406        self.stop_node(0)
407
408        wallet_dump = self.nodes[0].datadir_path / "bigrecords.dump"
409        self.assert_tool_output("The dumpfile may contain private keys. To ensure the safety of your Bitcoin, do not share the dumpfile.\n", "-wallet=bigrecords", f"-dumpfile={wallet_dump}", "dump")
410        dump = self.read_dump(wallet_dump)
411        for k,v in dump.items():
412            if tx["hex"] in v:
413                break
414        else:
415            assert False, "Big transaction was not found in wallet dump"
416
417    def test_no_create_legacy(self):
418        self.log.info("Test that legacy wallets cannot be created")
419
420        self.assert_raises_tool_error("Invalid parameter -legacy", "-wallet=legacy", "-legacy", "create")
421        assert not (self.nodes[0].wallets_path / "legacy").exists()
422        self.assert_raises_tool_error("Invalid parameter -descriptors", "-wallet=legacy", "-descriptors=false", "create")
423        assert not (self.nodes[0].wallets_path / "legacy").exists()
424        self.assert_raises_tool_error("The -dumpfile option cannot be used with the 'create' command.", "-wallet=legacy", "-dumpfile=wallet.dump", "create")
425
426    def test_no_create_unnamed(self):
427        self.log.info("Test that unnamed (default) wallets cannot be created")
428
429        self.assert_raises_tool_error("Wallet name cannot be empty", "-wallet=", "create")
430        assert not (self.nodes[0].wallets_path / "wallet.dat").exists()
431
432        self.assert_raises_tool_error("Wallet name cannot be empty", "-wallet=", "-dumpfile=wallet.dump", "createfromdump")
433        assert not (self.nodes[0].wallets_path / "wallet.dat").exists()
434
435    def run_test(self):
436        self.wallet_path = self.nodes[0].wallets_path / self.default_wallet_name / self.wallet_data_filename
437        self.test_invalid_tool_commands_and_args()
438        # Warning: The following tests are order-dependent.
439        self.test_tool_wallet_info()
440        self.test_tool_wallet_info_after_transaction()
441        self.test_tool_wallet_create_on_existing_wallet()
442        self.test_getwalletinfo_on_different_wallet()
443        self.test_dump_createfromdump()
444        self.test_chainless_conflicts()
445        self.test_dump_very_large_records()
446        self.test_no_create_legacy()
447        self.test_no_create_unnamed()
448
449
450if __name__ == '__main__':
451    ToolWalletTest(__file__).main()
452