159 lines
6.9 KiB
Python
159 lines
6.9 KiB
Python
#!/usr/bin/env python3
|
|
# Copyright (c) 2022 The Moneyrocket Core developers
|
|
# Distributed under the MIT software license, see the accompanying
|
|
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
"""Test wallet import on pruned node."""
|
|
import os
|
|
|
|
from test_framework.util import assert_equal, assert_raises_rpc_error
|
|
from test_framework.blocktools import (
|
|
COINBASE_MATURITY,
|
|
create_block
|
|
)
|
|
from test_framework.blocktools import create_coinbase
|
|
from test_framework.test_framework import MoneyrocketTestFramework
|
|
|
|
from test_framework.script import (
|
|
CScript,
|
|
OP_RETURN,
|
|
OP_TRUE,
|
|
)
|
|
|
|
class WalletPruningTest(MoneyrocketTestFramework):
|
|
def add_options(self, parser):
|
|
self.add_wallet_options(parser, descriptors=False)
|
|
|
|
def set_test_params(self):
|
|
self.setup_clean_chain = True
|
|
self.num_nodes = 2
|
|
self.wallet_names = []
|
|
self.extra_args = [
|
|
[], # node dedicated to mining
|
|
['-prune=550'], # node dedicated to testing pruning
|
|
]
|
|
|
|
def skip_test_if_missing_module(self):
|
|
self.skip_if_no_wallet()
|
|
self.skip_if_no_bdb()
|
|
|
|
def mine_large_blocks(self, node, n):
|
|
# Get the block parameters for the first block
|
|
best_block = node.getblockheader(node.getbestblockhash())
|
|
height = int(best_block["height"]) + 1
|
|
self.nTime = max(self.nTime, int(best_block["time"])) + 1
|
|
previousblockhash = int(best_block["hash"], 16)
|
|
big_script = CScript([OP_RETURN] + [OP_TRUE] * 950000)
|
|
# Set mocktime to accept all future blocks
|
|
for i in self.nodes:
|
|
if i.running:
|
|
i.setmocktime(self.nTime + 600 * n)
|
|
for _ in range(n):
|
|
block = create_block(hashprev=previousblockhash, ntime=self.nTime, coinbase=create_coinbase(height, script_pubkey=big_script))
|
|
block.solve()
|
|
|
|
# Submit to the node
|
|
node.submitblock(block.serialize().hex())
|
|
|
|
previousblockhash = block.sha256
|
|
height += 1
|
|
|
|
# Simulate 10 minutes of work time per block
|
|
# Important for matching a timestamp with a block +- some window
|
|
self.nTime += 600
|
|
self.sync_all()
|
|
|
|
def test_wallet_import_pruned(self, wallet_name):
|
|
self.log.info("Make sure we can import wallet when pruned and required blocks are still available")
|
|
|
|
wallet_file = wallet_name + ".dat"
|
|
wallet_birthheight = self.get_birthheight(wallet_file)
|
|
|
|
# Verify that the block at wallet's birthheight is available at the pruned node
|
|
self.nodes[1].getblock(self.nodes[1].getblockhash(wallet_birthheight))
|
|
|
|
# Import wallet into pruned node
|
|
self.nodes[1].createwallet(wallet_name="wallet_pruned", descriptors=False, load_on_startup=True)
|
|
self.nodes[1].importwallet(os.path.join(self.nodes[0].datadir, wallet_file))
|
|
|
|
# Make sure that prune node's wallet correctly accounts for balances
|
|
assert_equal(self.nodes[1].getbalance(), self.nodes[0].getbalance())
|
|
|
|
self.log.info("- Done")
|
|
|
|
def test_wallet_import_pruned_with_missing_blocks(self, wallet_name):
|
|
self.log.info("Make sure we cannot import wallet when pruned and required blocks are not available")
|
|
|
|
wallet_file = wallet_name + ".dat"
|
|
wallet_birthheight = self.get_birthheight(wallet_file)
|
|
|
|
# Verify that the block at wallet's birthheight is not available at the pruned node
|
|
assert_raises_rpc_error(-1, "Block not available (pruned data)", self.nodes[1].getblock, self.nodes[1].getblockhash(wallet_birthheight))
|
|
|
|
# Make sure wallet cannot be imported because of missing blocks
|
|
# This will try to rescan blocks `TIMESTAMP_WINDOW` (2h) before the wallet birthheight.
|
|
# There are 6 blocks an hour, so 11 blocks (excluding birthheight).
|
|
assert_raises_rpc_error(-4, f"Pruned blocks from height {wallet_birthheight - 11} required to import keys. Use RPC call getblockchaininfo to determine your pruned height.", self.nodes[1].importwallet, os.path.join(self.nodes[0].datadir, wallet_file))
|
|
self.log.info("- Done")
|
|
|
|
def get_birthheight(self, wallet_file):
|
|
"""Gets birthheight of a wallet on node0"""
|
|
with open(os.path.join(self.nodes[0].datadir, wallet_file), 'r', encoding="utf8") as f:
|
|
for line in f:
|
|
if line.startswith('# * Best block at time of backup'):
|
|
wallet_birthheight = int(line.split(' ')[9])
|
|
return wallet_birthheight
|
|
|
|
def has_block(self, block_index):
|
|
"""Checks if the pruned node has the specific blk0000*.dat file"""
|
|
return os.path.isfile(os.path.join(self.nodes[1].datadir, self.chain, "blocks", f"blk{block_index:05}.dat"))
|
|
|
|
def create_wallet(self, wallet_name, *, unload=False):
|
|
"""Creates and dumps a wallet on the non-pruned node0 to be later import by the pruned node"""
|
|
self.nodes[0].createwallet(wallet_name=wallet_name, descriptors=False, load_on_startup=True)
|
|
self.nodes[0].dumpwallet(os.path.join(self.nodes[0].datadir, wallet_name + ".dat"))
|
|
if (unload):
|
|
self.nodes[0].unloadwallet(wallet_name)
|
|
|
|
def run_test(self):
|
|
self.nTime = 0
|
|
self.log.info("Warning! This test requires ~1.3GB of disk space")
|
|
|
|
self.log.info("Generating a long chain of blocks...")
|
|
|
|
# A blk*.dat file is 128MB
|
|
# Generate 250 light blocks
|
|
self.generate(self.nodes[0], 250)
|
|
# Generate 50MB worth of large blocks in the blk00000.dat file
|
|
self.mine_large_blocks(self.nodes[0], 50)
|
|
|
|
# Create a wallet which birth's block is in the blk00000.dat file
|
|
wallet_birthheight_1 = "wallet_birthheight_1"
|
|
assert_equal(self.has_block(1), False)
|
|
self.create_wallet(wallet_birthheight_1, unload=True)
|
|
|
|
# Generate enough large blocks to reach pruning disk limit
|
|
# Not pruning yet because we are still below PruneAfterHeight
|
|
self.mine_large_blocks(self.nodes[0], 600)
|
|
self.log.info("- Long chain created")
|
|
|
|
# Create a wallet with birth height > wallet_birthheight_1
|
|
wallet_birthheight_2 = "wallet_birthheight_2"
|
|
self.create_wallet(wallet_birthheight_2)
|
|
|
|
# Fund wallet to later verify that importwallet correctly accounts for balances
|
|
self.generatetoaddress(self.nodes[0], COINBASE_MATURITY + 1, self.nodes[0].getnewaddress(), sync_fun=self.no_op)
|
|
|
|
# We've reached pruning storage & height limit but
|
|
# pruning doesn't run until another chunk (blk*.dat file) is allocated.
|
|
# That's why we are generating another 5 large blocks
|
|
self.mine_large_blocks(self.nodes[0], 5)
|
|
|
|
# blk00000.dat file is now pruned from node1
|
|
assert_equal(self.has_block(0), False)
|
|
|
|
self.test_wallet_import_pruned(wallet_birthheight_2)
|
|
self.test_wallet_import_pruned_with_missing_blocks(wallet_birthheight_1)
|
|
|
|
if __name__ == '__main__':
|
|
WalletPruningTest().main()
|