// 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));

}

//! Test the rescan that loading a wallet performs when the wallet is behind

//! the chain tip: it scans from the wallet's recorded best block - a

//! mid-chain start - with cs_wallet held.

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