scan.h

Go to the documentation of this file.

// Copyright (c) 2026-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_WALLET_SCAN_H
#define BITCOIN_WALLET_SCAN_H
 
#include <uint256.h>
#include <util/time.h>
 
#include <atomic>
#include <functional>
#include <optional>
 
namespace wallet {
class CWallet;
 
struct ScanResult {
    enum { SUCCESS, FAILURE, USER_ABORT } status = SUCCESS;
 
    uint256 last_scanned_block;
    std::optional<int> last_scanned_height;
 
    uint256 last_failed_block;
};
 
class WalletRescanReserver
{
private:
    using Clock = std::chrono::steady_clock;
    using NowFn = std::function<Clock::time_point()>;
    CWallet& m_wallet;
    bool m_could_reserve{false};
    NowFn m_now;
public:
    explicit WalletRescanReserver(CWallet& w) : m_wallet(w) {}
 
    bool reserve(bool with_passphrase = false);
    bool isReserved() const;
 
    Clock::time_point now() const { return m_now ? m_now() : Clock::now(); };
 
    void setNow(NowFn now) { m_now = std::move(now); }
 
    ~WalletRescanReserver();
};
 
class ChainScanner {
private:
    CWallet& m_wallet;
 
    std::atomic<bool> m_abort{false};
    std::atomic<bool> m_scanning{false};
    std::atomic<bool> m_scanning_with_passphrase{false};
    std::atomic<SteadyClock::time_point> m_scanning_start{SteadyClock::time_point{}};
    std::atomic<double> m_scanning_progress{0};
 
    struct LoopState {
        double progress_begin{0};
        double progress_end{0};
        uint256 tip_hash;
    };
 
    bool QueueNextBlock(const uint256& block_hash, int block_height, std::optional<std::pair<uint256, int>>& next_block, std::optional<int> max_height);
    bool ScanBlock(const uint256& block_hash, int block_height, bool save_progress);
    void UpdateProgress(const LoopState& state, double progress_current, int block_height);
    void UpdateTipIfChanged(LoopState& state);
 
    friend class WalletRescanReserver;
    bool TryReserve(bool with_passphrase = false);
    void Release();
 
public:
    explicit ChainScanner(CWallet& wallet) : m_wallet(wallet) {}
 
    void Abort() { m_abort = true; }
    bool IsAborting() const { return m_abort; }
    bool IsScanning() const { return m_scanning; }
    bool IsScanningWithPassphrase() const { return m_scanning_with_passphrase; }
    SteadyClock::duration ScanningDuration() const { return m_scanning ? SteadyClock::now() - m_scanning_start.load() : SteadyClock::duration{}; }
    double ScanningProgress() const { return m_scanning ? m_scanning_progress.load() : 0; }
 
    int64_t ScanFromTime(int64_t startTime, const WalletRescanReserver& reserver);
 
    ScanResult Scan(const uint256& start_block, int start_height, std::optional<int> max_height,
                    const WalletRescanReserver& reserver, bool save_progress);
 
};
 
} // namespace wallet
 
#endif // BITCOIN_WALLET_SCAN_H