validation.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2019 The Bitcoin Core developers
// Copyright (c) 2017-2020 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_VALIDATION_H
#define BITCOIN_VALIDATION_H
 
#if defined(HAVE_CONFIG_H)
#include <config/bitcoin-config.h>
#endif
 
#include <arith_uint256.h>
#include <attributes.h>
#include <blockfileinfo.h>
#include <blockindexcomparators.h>
#include <chain.h>
#include <common/bloom.h>
#include <config.h>
#include <consensus/amount.h>
#include <consensus/consensus.h>
#include <deploymentstatus.h>
#include <disconnectresult.h>
#include <flatfile.h>
#include <kernel/chain.h>
#include <kernel/chainparams.h>
#include <kernel/chainstatemanager_opts.h>
#include <kernel/cs_main.h>
#include <node/blockstorage.h>
#include <policy/packages.h>
#include <script/script_error.h>
#include <script/script_metrics.h>
#include <script/scriptcache.h>
#include <script/sigcache.h>
#include <shutdown.h>
#include <sync.h>
#include <txdb.h>
#include <txmempool.h> // For CTxMemPool::cs
#include <uint256.h>
#include <util/check.h>
#include <util/fs.h>
#include <util/result.h>
#include <util/time.h>
#include <util/translation.h>
 
#include <atomic>
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <thread>
#include <type_traits>
#include <utility>
#include <vector>
 
class BlockPolicyValidationState;
class CChainParams;
class Chainstate;
class ChainstateManager;
class CScriptCheck;
class CTxMemPool;
class CTxUndo;
class DisconnectedBlockTransactions;
 
struct ChainTxData;
struct FlatFilePos;
struct PrecomputedTransactionData;
struct LockPoints;
struct AssumeutxoData;
namespace node {
class SnapshotMetadata;
} // namespace node
namespace Consensus {
struct Params;
} // namespace Consensus
namespace avalanche {
class Processor;
} // namespace avalanche
namespace util {
class SignalInterrupt;
} // namespace util
 
#define MIN_TRANSACTION_SIZE                                                   \
    (::GetSerializeSize(CTransaction(), PROTOCOL_VERSION))
 
static const int MAX_SCRIPTCHECK_THREADS = 15;
static const int DEFAULT_SCRIPTCHECK_THREADS = 0;
 
static const bool DEFAULT_PEERBLOOMFILTERS = true;
 
static const unsigned int MIN_BLOCKS_TO_KEEP = 288;
static const signed int DEFAULT_CHECKBLOCKS = 6;
static constexpr int DEFAULT_CHECKLEVEL{3};
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES = 550 * 1024 * 1024;
 
enum class SynchronizationState { INIT_REINDEX, INIT_DOWNLOAD, POST_INIT };
 
extern GlobalMutex g_best_block_mutex;
extern std::condition_variable g_best_block_cv;
extern const CBlockIndex *g_best_block;
 
extern const std::vector<std::string> CHECKLEVEL_DOC;
 
class BlockValidationOptions {
private:
    uint64_t excessiveBlockSize;
    bool checkPoW : 1;
    bool checkMerkleRoot : 1;
 
public:
    // Do full validation by default
    explicit BlockValidationOptions(const Config &config);
    explicit BlockValidationOptions(uint64_t _excessiveBlockSize,
                                    bool _checkPow = true,
                                    bool _checkMerkleRoot = true)
        : excessiveBlockSize(_excessiveBlockSize), checkPoW(_checkPow),
          checkMerkleRoot(_checkMerkleRoot) {}
 
    BlockValidationOptions withCheckPoW(bool _checkPoW = true) const {
        BlockValidationOptions ret = *this;
        ret.checkPoW = _checkPoW;
        return ret;
    }
 
    BlockValidationOptions
    withCheckMerkleRoot(bool _checkMerkleRoot = true) const {
        BlockValidationOptions ret = *this;
        ret.checkMerkleRoot = _checkMerkleRoot;
        return ret;
    }
 
    bool shouldValidatePoW() const { return checkPoW; }
    bool shouldValidateMerkleRoot() const { return checkMerkleRoot; }
    uint64_t getExcessiveBlockSize() const { return excessiveBlockSize; }
};
 
void StartScriptCheckWorkerThreads(int threads_num);
 
void StopScriptCheckWorkerThreads();
 
Amount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams);
 
bool FatalError(kernel::Notifications &notifications,
                BlockValidationState &state, const std::string &strMessage,
                const bilingual_str &userMessage = {});
 
double GuessVerificationProgress(const ChainTxData &data,
                                 const CBlockIndex *pindex);
 
void PruneBlockFilesManual(Chainstate &active_chainstate,
                           int nManualPruneHeight);
 
// clang-format off
// clang-format on
struct MempoolAcceptResult {
    enum class ResultType {
        VALID,
        INVALID,
        MEMPOOL_ENTRY,
    };
    const ResultType m_result_type;
 
    const TxValidationState m_state;
 
    const std::optional<int64_t> m_vsize;
    const std::optional<Amount> m_base_fees;
    const std::optional<CFeeRate> m_effective_feerate;
    const std::optional<std::vector<TxId>> m_txids_fee_calculations;
 
    static MempoolAcceptResult Failure(TxValidationState state) {
        return MempoolAcceptResult(state);
    }
 
    static MempoolAcceptResult
    FeeFailure(TxValidationState state, CFeeRate effective_feerate,
               const std::vector<TxId> &txids_fee_calculations) {
        return MempoolAcceptResult(state, effective_feerate,
                                   txids_fee_calculations);
    }
 
    static MempoolAcceptResult
    Success(int64_t vsize, Amount fees, CFeeRate effective_feerate,
            const std::vector<TxId> &txids_fee_calculations) {
        return MempoolAcceptResult(ResultType::VALID, vsize, fees,
                                   effective_feerate, txids_fee_calculations);
    }
 
    static MempoolAcceptResult MempoolTx(int64_t vsize, Amount fees) {
        return MempoolAcceptResult(vsize, fees);
    }
 
    // Private constructors. Use static methods MempoolAcceptResult::Success,
    // etc. to construct.
private:
    explicit MempoolAcceptResult(TxValidationState state)
        : m_result_type(ResultType::INVALID), m_state(state),
          m_base_fees(std::nullopt) {
        // Can be invalid or error
        Assume(!state.IsValid());
    }
 
    explicit MempoolAcceptResult(
        ResultType result_type, int64_t vsize, Amount fees,
        CFeeRate effective_feerate,
        const std::vector<TxId> &txids_fee_calculations)
        : m_result_type(result_type), m_vsize{vsize}, m_base_fees(fees),
          m_effective_feerate(effective_feerate),
          m_txids_fee_calculations(txids_fee_calculations) {}
 
    explicit MempoolAcceptResult(
        TxValidationState state, CFeeRate effective_feerate,
        const std::vector<TxId> &txids_fee_calculations)
        : m_result_type(ResultType::INVALID), m_state(state),
          m_effective_feerate(effective_feerate),
          m_txids_fee_calculations(txids_fee_calculations) {}
 
    explicit MempoolAcceptResult(int64_t vsize, Amount fees)
        : m_result_type(ResultType::MEMPOOL_ENTRY), m_vsize{vsize},
          m_base_fees(fees) {}
};
 
struct PackageMempoolAcceptResult {
    PackageValidationState m_state;
    std::map<TxId, MempoolAcceptResult> m_tx_results;
 
    explicit PackageMempoolAcceptResult(
        PackageValidationState state,
        std::map<TxId, MempoolAcceptResult> &&results)
        : m_state{state}, m_tx_results(std::move(results)) {}
 
    explicit PackageMempoolAcceptResult(const TxId &txid,
                                        const MempoolAcceptResult &result)
        : m_tx_results{{txid, result}} {}
};
 
MempoolAcceptResult
AcceptToMemoryPool(Chainstate &active_chainstate, const CTransactionRef &tx,
                   int64_t accept_time, bool bypass_limits,
                   bool test_accept = false, unsigned int heightOverride = 0)
    EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
PackageMempoolAcceptResult
ProcessNewPackage(Chainstate &active_chainstate, CTxMemPool &pool,
                  const Package &txns, bool test_accept)
    EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
class CheckInputsLimiter {
protected:
    std::atomic<int64_t> remaining;
 
public:
    explicit CheckInputsLimiter(int64_t limit) : remaining(limit) {}
 
    bool consume_and_check(int consumed) {
        auto newvalue = (remaining -= consumed);
        return newvalue >= 0;
    }
 
    bool check() { return remaining >= 0; }
};
 
class TxSigCheckLimiter : public CheckInputsLimiter {
public:
    TxSigCheckLimiter() : CheckInputsLimiter(MAX_TX_SIGCHECKS) {}
 
    // Let's make this bad boy copiable.
    TxSigCheckLimiter(const TxSigCheckLimiter &rhs)
        : CheckInputsLimiter(rhs.remaining.load()) {}
 
    TxSigCheckLimiter &operator=(const TxSigCheckLimiter &rhs) {
        remaining = rhs.remaining.load();
        return *this;
    }
 
    static TxSigCheckLimiter getDisabled() {
        TxSigCheckLimiter txLimiter;
        // Historically, there has not been a transaction with more than 20k sig
        // checks on testnet or mainnet, so this effectively disable sigchecks.
        txLimiter.remaining = 20000;
        return txLimiter;
    }
};
 
class ValidationCache {
private:
    CSHA256 m_script_execution_cache_hasher;
 
public:
    CuckooCache::cache<ScriptCacheElement, ScriptCacheHasher>
        m_script_execution_cache;
    SignatureCache m_signature_cache;
 
    ValidationCache(size_t script_execution_cache_bytes,
                    size_t signature_cache_bytes);
 
    ValidationCache(const ValidationCache &) = delete;
    ValidationCache &operator=(const ValidationCache &) = delete;
 
    CSHA256 ScriptExecutionCacheHasher() const {
        return m_script_execution_cache_hasher;
    }
};
 
bool CheckInputScripts(const CTransaction &tx, TxValidationState &state,
                       const CCoinsViewCache &view, const uint32_t flags,
                       bool sigCacheStore, bool scriptCacheStore,
                       const PrecomputedTransactionData &txdata,
                       ValidationCache &validation_cache, int &nSigChecksOut,
                       TxSigCheckLimiter &txLimitSigChecks,
                       CheckInputsLimiter *pBlockLimitSigChecks,
                       std::vector<CScriptCheck> *pvChecks)
    EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
static inline bool
CheckInputScripts(const CTransaction &tx, TxValidationState &state,
                  const CCoinsViewCache &view, const uint32_t flags,
                  bool sigCacheStore, bool scriptCacheStore,
                  const PrecomputedTransactionData &txdata,
                  ValidationCache &validation_cache, int &nSigChecksOut)
    EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
    TxSigCheckLimiter nSigChecksTxLimiter;
    return CheckInputScripts(
        tx, state, view, flags, sigCacheStore, scriptCacheStore, txdata,
        validation_cache, nSigChecksOut, nSigChecksTxLimiter, nullptr, nullptr);
}
 
void SpendCoins(CCoinsViewCache &view, const CTransaction &tx, CTxUndo &txundo,
                int nHeight);
 
void UpdateCoins(CCoinsViewCache &view, const CTransaction &tx, CTxUndo &txundo,
                 int nHeight);
 
std::vector<Coin> GetSpentCoins(const CTransactionRef &ptx,
                                const CCoinsViewCache &coins_view);
 
std::optional<LockPoints> CalculateLockPointsAtTip(CBlockIndex *tip,
                                                   const CCoinsView &coins_view,
                                                   const CTransaction &tx);
 
bool CheckSequenceLocksAtTip(CBlockIndex *tip, const LockPoints &lock_points);
 
class CScriptCheck {
private:
    CTxOut m_tx_out;
    const CTransaction *ptxTo;
    unsigned int nIn;
    uint32_t nFlags;
    bool cacheStore;
    ScriptExecutionMetrics metrics;
    PrecomputedTransactionData txdata;
    SignatureCache *m_signature_cache;
    TxSigCheckLimiter *pTxLimitSigChecks;
    CheckInputsLimiter *pBlockLimitSigChecks;
 
public:
    CScriptCheck(const CTxOut &outIn, const CTransaction &txToIn,
                 SignatureCache &signature_cache, unsigned int nInIn,
                 uint32_t nFlagsIn, bool cacheIn,
                 const PrecomputedTransactionData &txdataIn,
                 TxSigCheckLimiter *pTxLimitSigChecksIn = nullptr,
                 CheckInputsLimiter *pBlockLimitSigChecksIn = nullptr)
        : m_tx_out(outIn), ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn),
          cacheStore(cacheIn), txdata(txdataIn),
          m_signature_cache(&signature_cache),
          pTxLimitSigChecks(pTxLimitSigChecksIn),
          pBlockLimitSigChecks(pBlockLimitSigChecksIn) {}
 
    CScriptCheck(const CScriptCheck &) = delete;
    CScriptCheck &operator=(const CScriptCheck &) = delete;
    CScriptCheck(CScriptCheck &&) = default;
    CScriptCheck &operator=(CScriptCheck &&) = default;
 
    std::optional<std::pair<ScriptError, std::string>> operator()();
 
    ScriptExecutionMetrics GetScriptExecutionMetrics() const { return metrics; }
};
 
// CScriptCheck is used a lot in std::vector, make sure that's efficient
static_assert(std::is_nothrow_move_assignable_v<CScriptCheck>);
static_assert(std::is_nothrow_move_constructible_v<CScriptCheck>);
static_assert(std::is_nothrow_destructible_v<CScriptCheck>);
 
bool CheckBlock(const CBlock &block, BlockValidationState &state,
                const Consensus::Params &params,
                BlockValidationOptions validationOptions);
 
bool TestBlockValidity(
    BlockValidationState &state, const CChainParams &params,
    Chainstate &chainstate, const CBlock &block, CBlockIndex *pindexPrev,
    const std::function<NodeClock::time_point()> &adjusted_time_callback,
    BlockValidationOptions validationOptions) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
bool HasValidProofOfWork(const std::vector<CBlockHeader> &headers,
                         const Consensus::Params &consensusParams);
 
bool IsBlockMutated(const CBlock &block);
 
arith_uint256 CalculateHeadersWork(const std::vector<CBlockHeader> &headers);
 
enum class VerifyDBResult {
    SUCCESS,
    CORRUPTED_BLOCK_DB,
    INTERRUPTED,
    SKIPPED_L3_CHECKS,
    SKIPPED_MISSING_BLOCKS,
};
 
class CVerifyDB {
private:
    kernel::Notifications &m_notifications;
 
public:
    CVerifyDB();
 
public:
    explicit CVerifyDB(kernel::Notifications &notifications);
    ~CVerifyDB();
 
    [[nodiscard]] VerifyDBResult VerifyDB(Chainstate &chainstate,
                                          CCoinsView &coinsview,
                                          int nCheckLevel, int nCheckDepth)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
};
 
enum class FlushStateMode { NONE, IF_NEEDED, PERIODIC, ALWAYS };
 
class CoinsViews {
public:
    CCoinsViewDB m_dbview GUARDED_BY(cs_main);
 
    CCoinsViewErrorCatcher m_catcherview GUARDED_BY(cs_main);
 
    std::unique_ptr<CCoinsViewCache> m_cacheview GUARDED_BY(cs_main);
 
    CoinsViews(DBParams db_params, CoinsViewOptions options);
 
    void InitCache() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
};
 
enum class CoinsCacheSizeState {
    CRITICAL = 2,
    LARGE = 1,
    OK = 0
};
 
class Chainstate {
protected:
    Mutex m_chainstate_mutex;
 
    CTxMemPool *m_mempool;
 
    std::unique_ptr<CoinsViews> m_coins_views;
 
    bool m_disabled GUARDED_BY(::cs_main){false};
 
    mutable Mutex cs_avalancheFinalizedBlockIndex;
 
    const CBlockIndex *m_avalancheFinalizedBlockIndex
        GUARDED_BY(cs_avalancheFinalizedBlockIndex) = nullptr;
 
    CRollingBloomFilter m_filterParkingPoliciesApplied =
        CRollingBloomFilter{1000, 0.000001};
 
    CBlockIndex const *m_best_fork_tip = nullptr;
    CBlockIndex const *m_best_fork_base = nullptr;
 
    const CBlockIndex *m_cached_snapshot_base GUARDED_BY(::cs_main){nullptr};
 
public:
    node::BlockManager &m_blockman;
 
    ChainstateManager &m_chainman;
 
    explicit Chainstate(
        CTxMemPool *mempool, node::BlockManager &blockman,
        ChainstateManager &chainman,
        std::optional<BlockHash> from_snapshot_blockhash = std::nullopt);
 
    ChainstateRole GetRole() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    void InitCoinsDB(size_t cache_size_bytes, bool in_memory, bool should_wipe,
                     std::string leveldb_name = "chainstate");
 
    void InitCoinsCache(size_t cache_size_bytes)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    bool CanFlushToDisk() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        AssertLockHeld(::cs_main);
        return m_coins_views && m_coins_views->m_cacheview;
    }
 
    CChain m_chain;
 
    const std::optional<BlockHash> m_from_snapshot_blockhash{};
 
    const CBlockIndex *SnapshotBase() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    std::set<CBlockIndex *, CBlockIndexWorkComparator> setBlockIndexCandidates;
 
    CCoinsViewCache &CoinsTip() EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        AssertLockHeld(::cs_main);
        Assert(m_coins_views);
        return *Assert(m_coins_views->m_cacheview);
    }
 
    CCoinsViewDB &CoinsDB() EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        AssertLockHeld(::cs_main);
        return Assert(m_coins_views)->m_dbview;
    }
 
    CTxMemPool *GetMempool() { return m_mempool; }
 
    CCoinsViewErrorCatcher &CoinsErrorCatcher()
        EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
        AssertLockHeld(::cs_main);
        return Assert(m_coins_views)->m_catcherview;
    }
 
    void ResetCoinsViews() { m_coins_views.reset(); }
 
    bool HasCoinsViews() const { return (bool)m_coins_views; }
 
    size_t m_coinsdb_cache_size_bytes{0};
 
    size_t m_coinstip_cache_size_bytes{0};
 
    bool ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    bool FlushStateToDisk(BlockValidationState &state, FlushStateMode mode,
                          int nManualPruneHeight = 0);
 
    void ForceFlushStateToDisk();
 
    void PruneAndFlush();
 
    bool ActivateBestChain(BlockValidationState &state,
                           std::shared_ptr<const CBlock> pblock = nullptr,
                           avalanche::Processor *const avalanche = nullptr)
        EXCLUSIVE_LOCKS_REQUIRED(!m_chainstate_mutex,
                                 !cs_avalancheFinalizedBlockIndex)
            LOCKS_EXCLUDED(cs_main);
 
    // Block (dis)connection on a given view:
    DisconnectResult DisconnectBlock(const CBlock &block,
                                     const CBlockIndex *pindex,
                                     CCoinsViewCache &view)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
    bool ConnectBlock(const CBlock &block, BlockValidationState &state,
                      CBlockIndex *pindex, CCoinsViewCache &view,
                      BlockValidationOptions options,
                      Amount *blockFees = nullptr, bool fJustCheck = false)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    // Apply the effects of a block disconnection on the UTXO set.
    bool DisconnectTip(BlockValidationState &state,
                       DisconnectedBlockTransactions *disconnectpool)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs);
 
    // Manual block validity manipulation:
    bool PreciousBlock(BlockValidationState &state, CBlockIndex *pindex,
                       avalanche::Processor *const avalanche = nullptr)
        EXCLUSIVE_LOCKS_REQUIRED(!m_chainstate_mutex,
                                 !cs_avalancheFinalizedBlockIndex)
            LOCKS_EXCLUDED(cs_main);
    bool InvalidateBlock(BlockValidationState &state, CBlockIndex *pindex)
        LOCKS_EXCLUDED(cs_main)
            EXCLUSIVE_LOCKS_REQUIRED(!m_chainstate_mutex,
                                     !cs_avalancheFinalizedBlockIndex);
    bool ParkBlock(BlockValidationState &state, CBlockIndex *pindex)
        LOCKS_EXCLUDED(cs_main)
            EXCLUSIVE_LOCKS_REQUIRED(!m_chainstate_mutex,
                                     !cs_avalancheFinalizedBlockIndex);
 
    bool AvalancheFinalizeBlock(CBlockIndex *pindex,
                                avalanche::Processor &avalanche)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main, !cs_avalancheFinalizedBlockIndex);
 
    void ClearAvalancheFinalizedBlock()
        EXCLUSIVE_LOCKS_REQUIRED(!cs_avalancheFinalizedBlockIndex);
 
    bool IsBlockAvalancheFinalized(const CBlockIndex *pindex) const
        EXCLUSIVE_LOCKS_REQUIRED(!cs_avalancheFinalizedBlockIndex);
 
    void SetBlockFailureFlags(CBlockIndex *pindex)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    void ResetBlockFailureFlags(CBlockIndex *pindex)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    template <typename F>
    bool UpdateFlagsForBlock(CBlockIndex *pindexBase, CBlockIndex *pindex, F f)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    template <typename F, typename C, typename AC>
    void UpdateFlags(CBlockIndex *pindex, CBlockIndex *&pindexReset, F f,
                     C fChild, AC fAncestorWasChanged)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    void UnparkBlockAndChildren(CBlockIndex *pindex)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    void UnparkBlock(CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    bool ReplayBlocks();
 
    bool LoadGenesisBlock();
 
    void TryAddBlockIndexCandidate(CBlockIndex *pindex)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    void PruneBlockIndexCandidates();
 
    void ClearBlockIndexCandidates() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    const CBlockIndex *FindForkInGlobalIndex(const CBlockLocator &locator) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    void
    LoadMempool(const fs::path &load_path,
                fsbridge::FopenFn mockable_fopen_function = fsbridge::fopen);
 
    bool LoadChainTip() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    CoinsCacheSizeState GetCoinsCacheSizeState()
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    CoinsCacheSizeState
    GetCoinsCacheSizeState(size_t max_coins_cache_size_bytes,
                           size_t max_mempool_size_bytes)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    std::string ToString() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    RecursiveMutex *MempoolMutex() const LOCK_RETURNED(m_mempool->cs) {
        return m_mempool ? &m_mempool->cs : nullptr;
    }
 
private:
    bool ActivateBestChainStep(
        BlockValidationState &state, CBlockIndex *pindexMostWork,
        const std::shared_ptr<const CBlock> &pblock, bool &fInvalidFound,
        const avalanche::Processor *const avalanche = nullptr,
        ChainstateRole = ChainstateRole::NORMAL)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs,
                                 !cs_avalancheFinalizedBlockIndex);
    bool ConnectTip(BlockValidationState &state,
                    BlockPolicyValidationState &blockPolicyState,
                    CBlockIndex *pindexNew,
                    const std::shared_ptr<const CBlock> &pblock,
                    DisconnectedBlockTransactions &disconnectpool,
                    const avalanche::Processor *const avalanche = nullptr,
                    ChainstateRole chainstate_role = ChainstateRole::NORMAL)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs,
                                 !cs_avalancheFinalizedBlockIndex);
    void InvalidBlockFound(CBlockIndex *pindex,
                           const BlockValidationState &state)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main, !cs_avalancheFinalizedBlockIndex);
    CBlockIndex *
    FindMostWorkChain(std::vector<const CBlockIndex *> &blocksToReconcile,
                      bool fAutoUnpark)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main, !cs_avalancheFinalizedBlockIndex);
 
    bool RollforwardBlock(const CBlockIndex *pindex, CCoinsViewCache &inputs)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    void UnparkBlockImpl(CBlockIndex *pindex, bool fClearChildren)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    bool UnwindBlock(BlockValidationState &state, CBlockIndex *pindex,
                     bool invalidate)
        EXCLUSIVE_LOCKS_REQUIRED(m_chainstate_mutex,
                                 !cs_avalancheFinalizedBlockIndex);
 
    void CheckForkWarningConditions() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    void CheckForkWarningConditionsOnNewFork(CBlockIndex *pindexNewForkTip)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    void InvalidChainFound(CBlockIndex *pindexNew)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main, !cs_avalancheFinalizedBlockIndex);
 
    const CBlockIndex *FindBlockToFinalize(CBlockIndex *pindexNew)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    void UpdateTip(const CBlockIndex *pindexNew)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    NodeClock::time_point m_next_write{NodeClock::time_point::max()};
 
    [[nodiscard]] util::Result<void> InvalidateCoinsDBOnDisk()
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    friend ChainstateManager;
};
 
enum class SnapshotCompletionResult {
    SUCCESS,
    SKIPPED,
 
    // Expected assumeutxo configuration data is not found for the height of the
    // base block.
    MISSING_CHAINPARAMS,
 
    // Failed to generate UTXO statistics (to check UTXO set hash) for the
    // background chainstate.
    STATS_FAILED,
 
    // The UTXO set hash of the background validation chainstate does not match
    // the one expected by assumeutxo chainparams.
    HASH_MISMATCH,
 
    // The blockhash of the current tip of the background validation chainstate
    // does not match the one expected by the snapshot chainstate.
    BASE_BLOCKHASH_MISMATCH,
};
 
class ChainstateManager {
private:
    std::unique_ptr<Chainstate> m_ibd_chainstate GUARDED_BY(::cs_main);
 
    std::unique_ptr<Chainstate> m_snapshot_chainstate GUARDED_BY(::cs_main);
 
    Chainstate *m_active_chainstate GUARDED_BY(::cs_main){nullptr};
 
    CBlockIndex *m_best_invalid GUARDED_BY(::cs_main){nullptr};
    CBlockIndex *m_best_parked GUARDED_BY(::cs_main){nullptr};
 
    [[nodiscard]] bool
    PopulateAndValidateSnapshot(Chainstate &snapshot_chainstate,
                                AutoFile &coins_file,
                                const node::SnapshotMetadata &metadata);
    bool AcceptBlockHeader(
        const CBlockHeader &block, BlockValidationState &state,
        CBlockIndex **ppindex, bool min_pow_checked,
        const std::optional<CCheckpointData> &test_checkpoints = std::nullopt)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    friend Chainstate;
 
    bool IsUsable(const Chainstate *const pchainstate) const
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        return pchainstate && !pchainstate->m_disabled;
    }
 
    SteadyMilliseconds m_last_presync_update GUARDED_BY(::cs_main){};
 
public:
    using Options = kernel::ChainstateManagerOpts;
 
    explicit ChainstateManager(const util::SignalInterrupt &interrupt,
                               Options options,
                               node::BlockManager::Options blockman_options);
 
    std::function<void()> snapshot_download_completed = std::function<void()>();
 
    const Config &GetConfig() const { return m_options.config; }
 
    const CChainParams &GetParams() const {
        return m_options.config.GetChainParams();
    }
    const Consensus::Params &GetConsensus() const {
        return m_options.config.GetChainParams().GetConsensus();
    }
    bool ShouldCheckBlockIndex() const {
        return *Assert(m_options.check_block_index);
    }
    const arith_uint256 &MinimumChainWork() const {
        return *Assert(m_options.minimum_chain_work);
    }
    const BlockHash &AssumedValidBlock() const {
        return *Assert(m_options.assumed_valid_block);
    }
    kernel::Notifications &GetNotifications() const {
        return m_options.notifications;
    }
    int StopAtHeight() const { return m_options.stop_at_height; }
 
    void CheckBlockIndex();
 
    RecursiveMutex &GetMutex() const LOCK_RETURNED(::cs_main) {
        return ::cs_main;
    }
 
    const util::SignalInterrupt &m_interrupt;
    const Options m_options;
    std::thread m_thread_load;
    node::BlockManager m_blockman;
 
    ValidationCache m_validation_cache;
 
    mutable std::atomic<bool> m_cached_finished_ibd{false};
 
    std::atomic<int32_t> nBlockSequenceId{1};
 
    int32_t nBlockReverseSequenceId = -1;
    arith_uint256 nLastPreciousChainwork = 0;
 
    // Reset the memory-only sequence counters we use to track block arrival
    // (used by tests to reset state)
    void ResetBlockSequenceCounters() EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        AssertLockHeld(::cs_main);
        nBlockSequenceId = 1;
        nBlockReverseSequenceId = -1;
    }
 
    std::set<CBlockIndex *> m_failed_blocks;
 
    CBlockIndex *m_best_header GUARDED_BY(::cs_main){nullptr};
 
    size_t m_total_coinstip_cache{0};
    //
    size_t m_total_coinsdb_cache{0};
 
    //                                  constructor
    Chainstate &InitializeChainstate(CTxMemPool *mempool)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    std::vector<Chainstate *> GetAll();
 
    [[nodiscard]] util::Result<CBlockIndex *>
    ActivateSnapshot(AutoFile &coins_file,
                     const node::SnapshotMetadata &metadata, bool in_memory);
 
    SnapshotCompletionResult MaybeCompleteSnapshotValidation()
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    const CBlockIndex *GetSnapshotBaseBlock() const
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    Chainstate &ActiveChainstate() const;
    CChain &ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex()) {
        return ActiveChainstate().m_chain;
    }
    int ActiveHeight() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex()) {
        return ActiveChain().Height();
    }
    CBlockIndex *ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex()) {
        return ActiveChain().Tip();
    }
 
    const CBlockIndex *GetAvalancheFinalizedTip() const;
 
    bool BackgroundSyncInProgress() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex()) {
        return IsUsable(m_snapshot_chainstate.get()) &&
               IsUsable(m_ibd_chainstate.get());
    }
 
    const CBlockIndex *GetBackgroundSyncTip() const
        EXCLUSIVE_LOCKS_REQUIRED(GetMutex()) {
        return BackgroundSyncInProgress() ? m_ibd_chainstate->m_chain.Tip()
                                          : nullptr;
    }
 
    node::BlockMap &BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        AssertLockHeld(::cs_main);
        return m_blockman.m_block_index;
    }
 
    bool IsSnapshotActive() const;
 
    std::optional<BlockHash> SnapshotBlockhash() const;
 
    bool IsSnapshotValidated() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        return m_snapshot_chainstate && m_ibd_chainstate &&
               m_ibd_chainstate->m_disabled;
    }
 
    bool IsInitialBlockDownload() const;
 
    void LoadExternalBlockFile(FILE *fileIn, FlatFilePos *dbp = nullptr,
                               std::multimap<BlockHash, FlatFilePos>
                                   *blocks_with_unknown_parent = nullptr,
                               avalanche::Processor *const avalanche = nullptr);
 
    bool ProcessNewBlock(const std::shared_ptr<const CBlock> &block,
                         bool force_processing, bool min_pow_checked,
                         bool *new_block,
                         avalanche::Processor *const avalanche = nullptr)
        LOCKS_EXCLUDED(cs_main);
 
    bool ProcessNewBlockHeaders(
        const std::vector<CBlockHeader> &block, bool min_pow_checked,
        BlockValidationState &state, const CBlockIndex **ppindex = nullptr,
        const std::optional<CCheckpointData> &test_checkpoints = std::nullopt)
        LOCKS_EXCLUDED(cs_main);
 
    bool AcceptBlock(const std::shared_ptr<const CBlock> &pblock,
                     BlockValidationState &state, bool fRequested,
                     const FlatFilePos *dbp, bool *fNewBlock,
                     bool min_pow_checked) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    void ReceivedBlockTransactions(const CBlock &block, CBlockIndex *pindexNew,
                                   const FlatFilePos &pos)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    [[nodiscard]] MempoolAcceptResult
    ProcessTransaction(const CTransactionRef &tx, bool test_accept = false)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    bool LoadBlockIndex() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    void MaybeRebalanceCaches() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    void ReportHeadersPresync(const arith_uint256 &work, int64_t height,
                              int64_t timestamp);
 
    bool DetectSnapshotChainstate(CTxMemPool *mempool)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    void ResetChainstates() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    [[nodiscard]] bool DeleteSnapshotChainstate()
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    Chainstate &ActivateExistingSnapshot(BlockHash base_blockhash)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    bool ValidatedSnapshotCleanup() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    Chainstate &GetChainstateForIndexing() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    std::pair<int, int> GetPruneRange(const Chainstate &chainstate,
                                      int last_height_can_prune)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    std::optional<int> GetSnapshotBaseHeight() const
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    void RecalculateBestHeader() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    bool DumpRecentHeadersTime(const fs::path &filePath) const
        EXCLUSIVE_LOCKS_REQUIRED(GetMutex());
    bool LoadRecentHeadersTime(const fs::path &filePath)
        EXCLUSIVE_LOCKS_REQUIRED(GetMutex());
};
 
template <typename DEP>
bool DeploymentActiveAfter(const CBlockIndex *pindexPrev,
                           const ChainstateManager &chainman, DEP dep) {
    return DeploymentActiveAfter(pindexPrev, chainman.GetConsensus(), dep);
}
 
template <typename DEP>
bool DeploymentActiveAt(const CBlockIndex &index,
                        const ChainstateManager &chainman, DEP dep) {
    return DeploymentActiveAt(index, chainman.GetConsensus(), dep);
}
 
#endif // BITCOIN_VALIDATION_H