rescan__tests_8cpp_source.html

// Copyright (c) 2012-present The Bitcoin Core developers

// Distributed under the MIT software license, see the accompanying

// file COPYING or https://opensource.org/license/mit.


#include <blockfilter.h>

#include <chain.h>

#include <index/blockfilterindex.h>

#include <interfaces/chain.h>

#include <node/blockstorage.h>

#include <test/util/common.h>

#include <test/util/logging.h>

#include <test/util/setup_common.h>

#include <test/util/validation.h>

#include <util/byte_units.h>

#include <util/check.h>

#include <validation.h>

#include <wallet/context.h>

#include <wallet/receive.h>

#include <wallet/scan.h>

#include <wallet/test/util.h>

#include <wallet/test/wallet_test_fixture.h>

#include <wallet/wallet.h>

#include <wallet/walletdb.h>


#include <boost/test/unit_test.hpp>


#include <cassert>

#include <chrono>

#include <memory>

#include <string>

#include <utility>


using node::MAX_BLOCKFILE_SIZE;


namespace wallet {


BOOST_FIXTURE_TEST_SUITE(rescan_tests, WalletTestingSetup)


BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)

{

    // Cap last block file size, and mine new block in a new block file.

    CBlockIndex* oldTip = WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain().Tip());

    WITH_LOCK(::cs_main, m_node.chainman->m_blockman.GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE);

    CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));

    CBlockIndex* newTip = WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain().Tip());


    // Verify Scan fails to read an unknown start block.

    {

        CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());

        {

            LOCK(wallet.cs_wallet);

            LOCK(Assert(m_node.chainman)->GetMutex());

            wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);

            wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());

        }

        AddKey(wallet, coinbaseKey);

        WalletRescanReserver reserver(wallet);

        reserver.reserve();

        ScanResult result = wallet.Scanner().Scan(/*start_block=*/{}, /*start_height=*/0, /*max_height=*/{}, reserver, /*save_progress=*/false);

        BOOST_CHECK_EQUAL(result.status, ScanResult::FAILURE);

        BOOST_CHECK(result.last_failed_block.IsNull());

        BOOST_CHECK(result.last_scanned_block.IsNull());

        BOOST_CHECK(!result.last_scanned_height);

        BOOST_CHECK_EQUAL(GetBalance(wallet).m_mine_immature, 0);

    }


    // Verify Scan picks up transactions in both the old

    // and new block files.

    {

        CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());

        {

            LOCK(wallet.cs_wallet);

            LOCK(Assert(m_node.chainman)->GetMutex());

            wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);

            wallet.SetLastBlockProcessed(newTip->nHeight, newTip->GetBlockHash());

        }

        AddKey(wallet, coinbaseKey);

        WalletRescanReserver reserver(wallet);

        std::chrono::steady_clock::time_point fake_time;

        reserver.setNow([&] { fake_time += 60s; return fake_time; });

        reserver.reserve();


        {

            CBlockLocator locator;

            BOOST_CHECK(WalletBatch{wallet.GetDatabase()}.ReadBestBlock(locator));

            BOOST_REQUIRE(!locator.IsNull());

            BOOST_CHECK(locator.vHave.front() == newTip->GetBlockHash());

        }


        ScanResult result = wallet.Scanner().Scan(/*start_block=*/oldTip->GetBlockHash(), /*start_height=*/oldTip->nHeight, /*max_height=*/{}, reserver, /*save_progress=*/true);

        BOOST_CHECK_EQUAL(result.status, ScanResult::SUCCESS);

        BOOST_CHECK(result.last_failed_block.IsNull());

        BOOST_CHECK_EQUAL(result.last_scanned_block, newTip->GetBlockHash());

        BOOST_CHECK_EQUAL(*result.last_scanned_height, newTip->nHeight);

        BOOST_CHECK_EQUAL(GetBalance(wallet).m_mine_immature, 100 * COIN);


        {

            CBlockLocator locator;

            BOOST_CHECK(WalletBatch{wallet.GetDatabase()}.ReadBestBlock(locator));

            BOOST_REQUIRE(!locator.IsNull());

            BOOST_CHECK(locator.vHave.front() == newTip->GetBlockHash());

        }

    }


    // Prune the older block file.

    int file_number;

    {

        LOCK(cs_main);

        file_number = oldTip->GetBlockPos().nFile;

        Assert(m_node.chainman)->m_blockman.PruneOneBlockFile(file_number);

    }

    m_node.chainman->m_blockman.UnlinkPrunedFiles({file_number});


    // Verify Scan only picks transactions in the new block

    // file.

    {

        CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());

        {

            LOCK(wallet.cs_wallet);

            LOCK(Assert(m_node.chainman)->GetMutex());

            wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);

            wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());

        }

        AddKey(wallet, coinbaseKey);

        WalletRescanReserver reserver(wallet);

        reserver.reserve();

        ScanResult result = wallet.Scanner().Scan(/*start_block=*/oldTip->GetBlockHash(), /*start_height=*/oldTip->nHeight, /*max_height=*/{}, reserver, /*save_progress=*/false);

        BOOST_CHECK_EQUAL(result.status, ScanResult::FAILURE);

        BOOST_CHECK_EQUAL(result.last_failed_block, oldTip->GetBlockHash());

        BOOST_CHECK_EQUAL(result.last_scanned_block, newTip->GetBlockHash());

        BOOST_CHECK_EQUAL(*result.last_scanned_height, newTip->nHeight);

        BOOST_CHECK_EQUAL(GetBalance(wallet).m_mine_immature, 50 * COIN);

    }


    // Prune the remaining block file.

    {

        LOCK(cs_main);

        file_number = newTip->GetBlockPos().nFile;

        Assert(m_node.chainman)->m_blockman.PruneOneBlockFile(file_number);

    }

    m_node.chainman->m_blockman.UnlinkPrunedFiles({file_number});


    // Verify Scan scans no blocks.

    {

        CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());

        {

            LOCK(wallet.cs_wallet);

            LOCK(Assert(m_node.chainman)->GetMutex());

            wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);

            wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());

        }

        AddKey(wallet, coinbaseKey);

        WalletRescanReserver reserver(wallet);

        reserver.reserve();

        ScanResult result = wallet.Scanner().Scan(/*start_block=*/oldTip->GetBlockHash(), /*start_height=*/oldTip->nHeight, /*max_height=*/{}, reserver, /*save_progress=*/false);

        BOOST_CHECK_EQUAL(result.status, ScanResult::FAILURE);

        BOOST_CHECK_EQUAL(result.last_failed_block, newTip->GetBlockHash());

        BOOST_CHECK(result.last_scanned_block.IsNull());

        BOOST_CHECK(!result.last_scanned_height);

        BOOST_CHECK_EQUAL(GetBalance(wallet).m_mine_immature, 0);

    }

}


BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions_reorged_block, TestChain100Setup)

{

    BOOST_REQUIRE(InitBlockFilterIndex([&]{ return interfaces::MakeChain(m_node); }, BlockFilterType::BASIC, 1_MiB, /*f_memory=*/true));

    BlockFilterIndex& filter_index{*Assert(GetBlockFilterIndex(BlockFilterType::BASIC))};

    BOOST_REQUIRE(filter_index.Init());

    filter_index.Sync();


    // Reorg the tip out of the active chain: invalidate it, then mine a

    // longer replacement branch paying a script unrelated to the wallets

    // below.

    CBlockIndex* stale_block = WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain().Tip());

    const uint256 stale_hash{stale_block->GetBlockHash()};

    const int stale_height{stale_block->nHeight};

    BlockValidationState state;

    BOOST_REQUIRE(m_node.chainman->ActiveChainstate().InvalidateBlock(state, stale_block));

    const CScript replacement_script{GetScriptForRawPubKey(GenerateRandomKey().GetPubKey())};

    CreateAndProcessBlock({}, replacement_script);

    CreateAndProcessBlock({}, replacement_script);

    BOOST_REQUIRE(filter_index.BlockUntilSyncedToCurrentChain());

    {

        LOCK(Assert(m_node.chainman)->GetMutex());

        BOOST_REQUIRE(!m_node.chainman->ActiveChain().Contains(*stale_block));

        BOOST_REQUIRE_EQUAL(m_node.chainman->ActiveChain().Height(), stale_height + 1);

    }


    {

        BlockFilter filter;

        BOOST_REQUIRE(filter_index.LookupFilter(stale_block, filter));

    }


    // Test wallet whose scripts do not match the stale block's filter.

    {

        CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());

        {

            LOCK(wallet.cs_wallet);

            LOCK(Assert(m_node.chainman)->GetMutex());

            wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);

            wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());

        }

        WalletRescanReserver reserver(wallet);

        reserver.reserve();

        ScanResult result = wallet.Scanner().Scan(stale_hash, stale_height, /*max_height=*/{}, reserver, /*save_progress=*/false);

        BOOST_CHECK_EQUAL(result.status, ScanResult::SUCCESS);

        BOOST_CHECK(result.last_failed_block.IsNull());

        BOOST_CHECK_EQUAL(result.last_scanned_block, stale_hash);

        BOOST_CHECK_EQUAL(*result.last_scanned_height, stale_height);

    }


    // Test wallet whose scripts do match the stale block's filter.

    {

        CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());

        {

            LOCK(wallet.cs_wallet);

            LOCK(Assert(m_node.chainman)->GetMutex());

            wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);

            wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());

        }

        AddKey(wallet, coinbaseKey); // the stale block's coinbase pays coinbaseKey

        WalletRescanReserver reserver(wallet);

        reserver.reserve();

        ScanResult result = wallet.Scanner().Scan(stale_hash, stale_height, /*max_height=*/{}, reserver, /*save_progress=*/false);

        BOOST_CHECK_EQUAL(result.status, ScanResult::FAILURE);

        BOOST_CHECK_EQUAL(result.last_failed_block, stale_hash);

        BOOST_CHECK(result.last_scanned_block.IsNull());

        BOOST_CHECK(!result.last_scanned_height);

        BOOST_CHECK(WITH_LOCK(wallet.cs_wallet, return wallet.mapWallet.empty()));

    }


    // Prune the stale block's file — the block is now not active AND unreadable.

    int file_number;

    {

        LOCK(cs_main);

        file_number = stale_block->GetBlockPos().nFile;

        Assert(m_node.chainman)->m_blockman.PruneOneBlockFile(file_number);

    }

    m_node.chainman->m_blockman.UnlinkPrunedFiles({file_number});


    {

        CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());

        {

            LOCK(wallet.cs_wallet);

            LOCK(Assert(m_node.chainman)->GetMutex());

            wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);

            wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());

        }

        AddKey(wallet, coinbaseKey);

        WalletRescanReserver reserver(wallet);

        reserver.reserve();

        ScanResult result = wallet.Scanner().Scan(stale_hash, stale_height, /*max_height=*/{}, reserver, /*save_progress=*/false);

        BOOST_CHECK_EQUAL(result.status, ScanResult::FAILURE);

        BOOST_CHECK_EQUAL(result.last_failed_block, stale_hash);

        BOOST_CHECK(result.last_scanned_block.IsNull());

        BOOST_CHECK(!result.last_scanned_height);

        BOOST_CHECK(WITH_LOCK(wallet.cs_wallet, return wallet.mapWallet.empty()));

    }


    StopIndex(filter_index, m_node);

    BOOST_REQUIRE(DestroyBlockFilterIndex(BlockFilterType::BASIC));

}


BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions_abort, TestChain100Setup)

{

    CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());

    uint256 genesis_hash;

    {

        LOCK(wallet.cs_wallet);

        LOCK(Assert(m_node.chainman)->GetMutex());

        wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);

        wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());

        genesis_hash = m_node.chainman->ActiveChain().Genesis()->GetBlockHash();

    }


    // An abort requested while no rescan is held is stale and must

    // not cancel a later scan.

    wallet.Scanner().Abort();

    WalletRescanReserver reserver(wallet);

    BOOST_CHECK(reserver.reserve());

    BOOST_CHECK(!wallet.Scanner().IsAborting());


    // An abort requested after the reservation but before the scan starts

    // (e.g. while importdescriptors is still deriving keys) must cancel the

    // scan.

    wallet.Scanner().Abort();

    ScanResult result = wallet.Scanner().Scan(genesis_hash, /*start_height=*/0, /*max_height=*/{}, reserver, /*save_progress=*/false);

    BOOST_CHECK_EQUAL(result.status, ScanResult::USER_ABORT);

    BOOST_CHECK(result.last_scanned_block.IsNull());

    BOOST_CHECK(!result.last_scanned_height);

    BOOST_CHECK(result.last_failed_block.IsNull());

}


BOOST_FIXTURE_TEST_CASE(wallet_rescan_reserver, TestingSetup)

{

    CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());


    // No scan in progress: accessors report idle state.

    BOOST_CHECK(!wallet.Scanner().IsScanning());

    BOOST_CHECK(wallet.Scanner().ScanningDuration() == SteadyClock::duration{});

    BOOST_CHECK_EQUAL(wallet.Scanner().ScanningProgress(), 0.0);


    {

        WalletRescanReserver first_reserver(wallet);

        BOOST_CHECK(first_reserver.reserve());

        BOOST_CHECK(first_reserver.isReserved());

        BOOST_CHECK(wallet.Scanner().IsScanning());

        BOOST_CHECK(!wallet.Scanner().IsScanningWithPassphrase());

        BOOST_CHECK_EQUAL(wallet.Scanner().ScanningProgress(), 0.0);


        // Only one reservation can be held at a time.

        WalletRescanReserver second_reserver(wallet);

        BOOST_CHECK(!second_reserver.reserve());

        BOOST_CHECK(!second_reserver.isReserved());

    }

    // Destroying the reserver (RAII) clears the scanning state.

    BOOST_CHECK(!wallet.Scanner().IsScanning());


    {

        WalletRescanReserver passphrase_reserver(wallet);

        BOOST_CHECK(passphrase_reserver.reserve(/*with_passphrase=*/true));

        BOOST_CHECK(wallet.Scanner().IsScanningWithPassphrase());

    }

    BOOST_CHECK(!wallet.Scanner().IsScanningWithPassphrase());

}


BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions_bounded, TestChain100Setup)

{

    uint256 genesis_hash, max_hash, tip_hash;

    int max_height, tip_height;

    {

        LOCK(Assert(m_node.chainman)->GetMutex());

        genesis_hash = m_node.chainman->ActiveChain().Genesis()->GetBlockHash();

        tip_height = m_node.chainman->ActiveChain().Height();

        tip_hash = m_node.chainman->ActiveChain().Tip()->GetBlockHash();

        max_height = tip_height - 2;

        max_hash = m_node.chainman->ActiveChain()[max_height]->GetBlockHash();

    }


    // A scan with max_height set stops exactly at max_height and does not

    // sync any blocks beyond it.

    {

        CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());

        {

            LOCK(wallet.cs_wallet);

            wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);

            wallet.SetLastBlockProcessed(tip_height, tip_hash);

        }

        AddKey(wallet, coinbaseKey);

        WalletRescanReserver reserver(wallet);

        reserver.reserve();

        ScanResult result = wallet.Scanner().Scan(genesis_hash, /*start_height=*/0, max_height, reserver, /*save_progress=*/false);

        BOOST_CHECK_EQUAL(result.status, ScanResult::SUCCESS);

        BOOST_CHECK(result.last_failed_block.IsNull());

        BOOST_CHECK_EQUAL(result.last_scanned_block, max_hash);

        BOOST_CHECK_EQUAL(*result.last_scanned_height, max_height);

        // One coinbase per block from height 1 through max_height.

        BOOST_CHECK_EQUAL(WITH_LOCK(wallet.cs_wallet, return wallet.mapWallet.size()), static_cast<size_t>(max_height));

    }


    // A single-block range (start == max_height == tip) scans exactly that

    // block.

    {

        CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());

        {

            LOCK(wallet.cs_wallet);

            wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);

            wallet.SetLastBlockProcessed(tip_height, tip_hash);

        }

        AddKey(wallet, coinbaseKey);

        WalletRescanReserver reserver(wallet);

        reserver.reserve();

        ScanResult result = wallet.Scanner().Scan(tip_hash, tip_height, tip_height, reserver, /*save_progress=*/false);

        BOOST_CHECK_EQUAL(result.status, ScanResult::SUCCESS);

        BOOST_CHECK(result.last_failed_block.IsNull());

        BOOST_CHECK_EQUAL(result.last_scanned_block, tip_hash);

        BOOST_CHECK_EQUAL(*result.last_scanned_height, tip_height);

        BOOST_CHECK_EQUAL(WITH_LOCK(wallet.cs_wallet, return wallet.mapWallet.size()), 1U);

    }

}


BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions_tip_extension, TestChain100Setup)

{

    CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());

    uint256 genesis_hash;

    int start_tip_height{0};

    {

        LOCK(wallet.cs_wallet);

        LOCK(Assert(m_node.chainman)->GetMutex());

        wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);

        start_tip_height = m_node.chainman->ActiveChain().Height();

        wallet.SetLastBlockProcessed(start_tip_height, m_node.chainman->ActiveChain().Tip()->GetBlockHash());

        genesis_hash = m_node.chainman->ActiveChain().Genesis()->GetBlockHash();

    }

    AddKey(wallet, coinbaseKey);


    // Connect a block while the scan is running (the handler fires on the

    // scanning thread as the scan starts) and advance the wallet's tip, as

    // the blockConnected notification would. The scan must pick up the new

    // tip instead of stopping at the height it started with.

    uint256 new_tip_hash;

    bool extended{false};

    auto handler = wallet.ShowProgress.connect([&](const std::string&, int) {

        if (extended) return;

        extended = true;

        CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));

        LOCK(wallet.cs_wallet);

        LOCK(Assert(m_node.chainman)->GetMutex());

        const CBlockIndex* new_tip = m_node.chainman->ActiveChain().Tip();

        new_tip_hash = new_tip->GetBlockHash();

        wallet.SetLastBlockProcessed(new_tip->nHeight, new_tip_hash);

    });


    WalletRescanReserver reserver(wallet);

    reserver.reserve();

    ScanResult result = wallet.Scanner().Scan(genesis_hash, /*start_height=*/0, /*max_height=*/{}, reserver, /*save_progress=*/false);

    handler.disconnect();

    BOOST_CHECK_EQUAL(result.status, ScanResult::SUCCESS);

    BOOST_CHECK_EQUAL(result.last_scanned_block, new_tip_hash);

    BOOST_CHECK_EQUAL(*result.last_scanned_height, start_tip_height + 1);

}


BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions_no_progress_saved, TestChain100Setup)

{

    CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());

    uint256 genesis_hash, tip_hash;

    int max_height;

    {

        LOCK(wallet.cs_wallet);

        LOCK(Assert(m_node.chainman)->GetMutex());

        wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);

        tip_hash = m_node.chainman->ActiveChain().Tip()->GetBlockHash();

        wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), tip_hash);

        genesis_hash = m_node.chainman->ActiveChain().Genesis()->GetBlockHash();

        max_height = m_node.chainman->ActiveChain().Height() - 2;

    }

    AddKey(wallet, coinbaseKey);


    WalletRescanReserver reserver(wallet);

    // Advance the clock on every call so that every scanned block would be

    // eligible for a progress write if save_progress were set.

    std::chrono::steady_clock::time_point fake_time;

    reserver.setNow([&] { fake_time += 60s; return fake_time; });

    reserver.reserve();


    ScanResult result = wallet.Scanner().Scan(genesis_hash, /*start_height=*/0, max_height, reserver, /*save_progress=*/false);

    BOOST_CHECK_EQUAL(result.status, ScanResult::SUCCESS);


    // With save_progress=false the scan must not touch the wallet's best

    // block record: it still points at the tip written when the descriptor

    // was added, not at any block the scan visited.

    CBlockLocator locator;

    BOOST_CHECK(WalletBatch{wallet.GetDatabase()}.ReadBestBlock(locator));

    BOOST_CHECK(!locator.IsNull());

    BOOST_CHECK_EQUAL(locator.vHave.front(), tip_hash);

}


BOOST_FIXTURE_TEST_CASE(rescan_from_time, TestChain100Setup)

{

    // Cap last block file size, and mine new block in a new block file.

    CBlockIndex* old_tip = WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain().Tip());

    WITH_LOCK(::cs_main, m_node.chainman->m_blockman.GetBlockFileInfo(old_tip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE);

    CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));

    CBlockIndex* new_tip = WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain().Tip());


    // Prune the older block file.

    int file_number;

    {

        LOCK(cs_main);

        file_number = old_tip->GetBlockPos().nFile;

        Assert(m_node.chainman)->m_blockman.PruneOneBlockFile(file_number);

    }

    m_node.chainman->m_blockman.UnlinkPrunedFiles({file_number});


    CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());

    {

        LOCK(wallet.cs_wallet);

        LOCK(Assert(m_node.chainman)->GetMutex());

        wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);

        wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());

    }

    AddKey(wallet, coinbaseKey);

    WalletRescanReserver reserver(wallet);

    reserver.reserve();


    // Blocks before the prune point cannot be read: the returned timestamp

    // is moved past the last unreadable block, telling the caller from when

    // the rescan is actually complete.

    const int64_t genesis_time{WITH_LOCK(::cs_main, return m_node.chainman->ActiveChain().Genesis()->GetBlockTime())};

    BOOST_CHECK_EQUAL(wallet.Scanner().ScanFromTime(genesis_time, reserver),

                      WITH_LOCK(::cs_main, return old_tip->GetBlockTimeMax()) + TIMESTAMP_WINDOW + 1);


    bool scan_logged{false};

    DebugLogHelper scan_check{"Rescan started from block", [&](const std::string* s) {

        if (s) scan_logged = true;

        return false;

    }};

    // A timestamp past the tip requires no scanning and is returned unchanged.

    const int64_t future_time{WITH_LOCK(::cs_main, return new_tip->GetBlockTimeMax()) + TIMESTAMP_WINDOW + 1};

    BOOST_CHECK(!scan_logged);

    BOOST_CHECK_EQUAL(wallet.Scanner().ScanFromTime(future_time, reserver), future_time);

}


BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions_missing_filter, TestChain100Setup)

{

    // Enable the block filter index but do not sync it: no filters are

    // available, so the scan must inspect every block rather than treat

    // the missing filters as misses and skip blocks.

    BOOST_REQUIRE(InitBlockFilterIndex([&]{ return interfaces::MakeChain(m_node); }, BlockFilterType::BASIC, 1_MiB, /*f_memory=*/true));

    BlockFilterIndex& filter_index{*Assert(GetBlockFilterIndex(BlockFilterType::BASIC))};

    BOOST_REQUIRE(filter_index.Init());


    {

        CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());

        uint256 genesis_hash, tip_hash;

        int tip_height;

        {

            LOCK(wallet.cs_wallet);

            LOCK(Assert(m_node.chainman)->GetMutex());

            wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);

            genesis_hash = m_node.chainman->ActiveChain().Genesis()->GetBlockHash();

            tip_height = m_node.chainman->ActiveChain().Height();

            auto tip{m_node.chainman->ActiveChain().Tip()};

            tip_hash = tip->GetBlockHash();

            wallet.SetLastBlockProcessed(tip_height, tip_hash);

            BlockFilter filter;

            BOOST_REQUIRE(!filter_index.LookupFilter(tip, filter));

        }

        AddKey(wallet, coinbaseKey);

        WalletRescanReserver reserver(wallet);

        reserver.reserve();

        bool fast_scan_logged{false};

        DebugLogHelper scan_check{"fast variant using block filters", [&](const std::string* s) {

            if (s) fast_scan_logged = true;

            return false;

        }};

        ScanResult result = wallet.Scanner().Scan(genesis_hash, /*start_height=*/0, /*max_height=*/{}, reserver, /*save_progress=*/false);

        BOOST_REQUIRE(fast_scan_logged);

        BOOST_CHECK_EQUAL(result.status, ScanResult::SUCCESS);

        BOOST_CHECK(result.last_failed_block.IsNull());

        BOOST_CHECK_EQUAL(result.last_scanned_block, tip_hash);

        BOOST_CHECK_EQUAL(*result.last_scanned_height, tip_height);

        // One coinbase per block from height 1 through the tip.

        BOOST_CHECK_EQUAL(WITH_LOCK(wallet.cs_wallet, return wallet.mapWallet.size()), static_cast<size_t>(tip_height));

    }


    StopIndex(filter_index, m_node);

    BOOST_REQUIRE(DestroyBlockFilterIndex(BlockFilterType::BASIC));

}


BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions_attach_chain, TestChain100Setup)

{

    // Do not wait for sqlite to flush data to disk to improve performance

    m_args.ForceSetArg("-unsafesqlitesync", "1");


    // Create a wallet owning the coinbases, and unload it at the current tip.

    WalletContext context;

    context.args = &m_args;

    context.chain = m_node.chain.get();

    auto wallet = TestCreateWallet(context);

    AddKey(*wallet, coinbaseKey);

    TestUnloadWallet(std::move(wallet));


    // Extend the chain while the wallet is not loaded.

    constexpr int NEW_BLOCKS{5};

    for (int i = 0; i < NEW_BLOCKS; ++i) {

        CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));

    }


    int tip_height;

    uint256 tip_hash;

    {

        LOCK(Assert(m_node.chainman)->GetMutex());

        tip_height = m_node.chainman->ActiveChain().Height();

        tip_hash = m_node.chainman->ActiveChain().Tip()->GetBlockHash();

    }


    // Loading the wallet must rescan the extension from the recorded best

    // block and find its coinbases.

    wallet = TestLoadWallet(context);

    {

        LOCK(wallet->cs_wallet);

        BOOST_CHECK_EQUAL(wallet->GetLastBlockHeight(), tip_height);

        BOOST_CHECK_EQUAL(wallet->GetLastBlockHash(), tip_hash);

        // The extension's coinbases plus the one of the recorded best block:

        // the load rescan starts mid-chain, at that block inclusive.

        BOOST_CHECK_EQUAL(wallet->mapWallet.size(), static_cast<size_t>(NEW_BLOCKS + 1));

    }

    TestUnloadWallet(std::move(wallet));

}


BOOST_AUTO_TEST_SUITE_END()


} // namespace wallet

COIN
constexpr CAmount COIN
The amount of satoshis in one BTC.
Definition amount.h:15

m_node
node::NodeContext m_node
Definition bitcoin-gui.cpp:48

BlockFilterType::BASIC
@ BASIC

DestroyBlockFilterIndex
bool DestroyBlockFilterIndex(BlockFilterType filter_type)
Destroy the block filter index with the given type.
Definition blockfilterindex.cpp:466

GetBlockFilterIndex
BlockFilterIndex * GetBlockFilterIndex(BlockFilterType filter_type)
Get a block filter index by type.
Definition blockfilterindex.cpp:445

InitBlockFilterIndex
bool InitBlockFilterIndex(std::function< std::unique_ptr< interfaces::Chain >()> make_chain, BlockFilterType filter_type, size_t n_cache_size, bool f_memory, bool f_wipe)
Initialize a block filter index for the given type if one does not already exist.
Definition blockfilterindex.cpp:456

blockfilterindex.h

blockstorage.h

byte_units.h

TIMESTAMP_WINDOW
constexpr int64_t TIMESTAMP_WINDOW
Timestamp window used as a grace period by code that compares external timestamps (such as timestamps...
Definition chain.h:37

check.h

Assert
#define Assert(val)
Identity function.
Definition check.h:119

BlockFilter
Complete block filter struct as defined in BIP 157.
Definition blockfilter.h:116

BlockFilterIndex
BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of bloc...
Definition blockfilterindex.h:41

BlockValidationState
Definition validation.h:133

CBlockIndex
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition chain.h:94

CScript
Serialized script, used inside transaction inputs and outputs.
Definition script.h:406

DebugLogHelper
Definition logging.h:15

base_blob::IsNull
constexpr bool IsNull() const
Definition uint256.h:50

uint256
256-bit opaque blob.
Definition uint256.h:196

wallet::CWallet
A CWallet maintains a set of transactions and balances, and provides the ability to create new transa...
Definition wallet.h:318

wallet::WalletBatch
Access to the wallet database.
Definition walletdb.h:199

wallet::WalletRescanReserver
RAII object to check and reserve a wallet rescan.
Definition scan.h:37

cs_main
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition cs_main.cpp:8

BOOST_FIXTURE_TEST_SUITE
BOOST_FIXTURE_TEST_SUITE(cuckoocache_tests, BasicTestingSetup)
Test Suite for CuckooCache.

BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()

chain.h

chain.h

GenerateRandomKey
CKey GenerateRandomKey(bool compressed) noexcept
Definition key.cpp:354

interfaces::MakeChain
std::unique_ptr< Chain > MakeChain(node::NodeContext &node)
Return implementation of Chain interface.
Definition interfaces.cpp:1072

node::MAX_BLOCKFILE_SIZE
constexpr unsigned int MAX_BLOCKFILE_SIZE
The maximum size of a blk?????.dat file (since 0.8)
Definition blockstorage.h:124

wallet
Definition coin_selection.cpp:31

wallet::CreateMockableWalletDatabase
std::unique_ptr< WalletDatabase > CreateMockableWalletDatabase()
Definition util.cpp:126

wallet::BOOST_FIXTURE_TEST_CASE
BOOST_FIXTURE_TEST_CASE(wallet_coinsresult_test, BasicTestingSetup)
Definition coinselector_tests.cpp:1354

wallet::TestUnloadWallet
void TestUnloadWallet(std::shared_ptr< CWallet > &&wallet)
Definition util.cpp:103

wallet::AddKey
void AddKey(CWallet &wallet, const CKey &key)
Definition util.cpp:45

wallet::TestLoadWallet
std::shared_ptr< CWallet > TestLoadWallet(std::unique_ptr< WalletDatabase > database, WalletContext &context)
Definition util.cpp:81

wallet::GetBalance
Balance GetBalance(const CWallet &wallet, const int min_depth, bool avoid_reuse, bool include_nonmempool)
Definition receive.cpp:245

wallet::TestCreateWallet
std::shared_ptr< CWallet > TestCreateWallet(std::unique_ptr< WalletDatabase > database, WalletContext &context, uint64_t create_flags)
Definition util.cpp:57

wallet::WALLET_FLAG_DESCRIPTORS
@ WALLET_FLAG_DESCRIPTORS
Indicate that this wallet supports DescriptorScriptPubKeyMan.
Definition walletutil.h:53

BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition object.cpp:17

BOOST_CHECK
#define BOOST_CHECK(expr)
Definition object.cpp:16

receive.h

handler
bool(* handler)(const std::any &context, HTTPRequest *req, const std::string &strReq)
Definition rest.cpp:1198

scan.h

setup_common.h

GetPubKey
static bool GetPubKey(const SigningProvider &provider, const SignatureData &sigdata, const CKeyID &address, CPubKey &pubkey)
Definition sign.cpp:243

GetScriptForRawPubKey
CScript GetScriptForRawPubKey(const CPubKey &pubKey)
Generate a P2PK script for the given pubkey.
Definition solver.cpp:213

CBlockLocator
Describes a place in the block chain to another node such that if the other node doesn't have the sam...
Definition block.h:117

CBlockLocator::vHave
std::vector< uint256 > vHave
Definition block.h:127

CBlockLocator::IsNull
bool IsNull() const
Definition block.h:145

TestChain100Setup
Testing fixture that pre-creates a 100-block REGTEST-mode block chain.
Definition setup_common.h:143

TestingSetup
Testing setup that configures a complete environment.
Definition setup_common.h:119

node::NodeContext::chainman
std::unique_ptr< ChainstateManager > chainman
Definition context.h:74

node::NodeContext::chain
std::unique_ptr< interfaces::Chain > chain
Definition context.h:78

wallet::ScanResult
Result of a wallet scan.
Definition scan.h:19

wallet::ScanResult::last_scanned_block
uint256 last_scanned_block
Hash and height of most recent block that was successfully scanned.
Definition scan.h:25

wallet::ScanResult::status
enum wallet::ScanResult::@19 status

wallet::ScanResult::last_scanned_height
std::optional< int > last_scanned_height
Definition scan.h:26

wallet::ScanResult::USER_ABORT
@ USER_ABORT
Definition scan.h:20

wallet::ScanResult::SUCCESS
@ SUCCESS
Definition scan.h:20

wallet::ScanResult::FAILURE
@ FAILURE
Definition scan.h:20

wallet::ScanResult::last_failed_block
uint256 last_failed_block
Height of the most recent block that could not be scanned due to read errors or pruning.
Definition scan.h:32

wallet::WalletContext
WalletContext struct containing references to state shared between CWallet instances,...
Definition context.h:36

wallet::WalletContext::chain
interfaces::Chain * chain
Definition context.h:37

wallet::WalletContext::args
ArgsManager * args
Definition context.h:39

LOCK
#define LOCK(cs)
Definition sync.h:268

WITH_LOCK
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition sync.h:299

common.h

logging.h

StopIndex
void StopIndex(BaseIndex &index, node::NodeContext &node)
Drain validation callbacks before stopping an index, matching Shutdown() in init.cpp.
Definition validation.cpp:158

validation.h

Ticks
constexpr auto Ticks(Dur2 d)
Helper to count the seconds of a duration/time_point.
Definition time.h:82

validation.h

context.h

util.h

wallet.h

wallet_test_fixture.h

context
WalletContext context
Definition wallet_tests.cpp:130

walletdb.h