historical/moneyrocket.git/test/functional/wallet_pruning.py

#!/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()