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 <amount.h>
#include <blockfileinfo.h>
#include <blockindexworkcomparator.h>
#include <coins.h>
#include <consensus/consensus.h>
#include <disconnectresult.h>
#include <flatfile.h>
#include <fs.h>
#include <protocol.h> // For CMessageHeader::MessageMagic
#include <script/script_error.h>
#include <script/script_metrics.h>
#include <sync.h>
#include <txdb.h>
#include <txmempool.h> // For CTxMemPool::cs
#include <versionbits.h>
 
#include <atomic>
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <utility>
#include <vector>
 
class BlockValidationState;
class CBlockIndex;
class CBlockTreeDB;
class CBlockUndo;
class CChainParams;
class CChain;
class CChainState;
class CConnman;
class CInv;
class ChainstateManager;
class Config;
class CScriptCheck;
class CTxMemPool;
class CTxUndo;
class DisconnectedBlockTransactions;
class TxValidationState;
 
struct ChainTxData;
struct FlatFilePos;
struct PrecomputedTransactionData;
struct LockPoints;
 
namespace Consensus {
struct Params;
}
 
#define MIN_TRANSACTION_SIZE                                                   \
    (::GetSerializeSize(CTransaction(), PROTOCOL_VERSION))
 
static const Amount DEFAULT_MIN_RELAY_TX_FEE_PER_KB(1000 * SATOSHI);
static const Amount DEFAULT_UTXO_FEE = Amount::zero();
static const unsigned int DEFAULT_MEMPOOL_EXPIRY = 336;
static const unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB
static const int MAX_SCRIPTCHECK_THREADS = 15;
static const int DEFAULT_SCRIPTCHECK_THREADS = 0;
static const int64_t DEFAULT_MAX_TIP_AGE = 24 * 60 * 60;
static const bool DEFAULT_CHECKPOINTS_ENABLED = true;
static const bool DEFAULT_TXINDEX = false;
static const char *const DEFAULT_BLOCKFILTERINDEX = "0";
 
static const bool DEFAULT_PERSIST_MEMPOOL = true;
static const bool DEFAULT_FEEFILTER = true;
 
static const bool DEFAULT_PEERBLOOMFILTERS = true;
 
static const int DEFAULT_STOPATHEIGHT = 0;
static const int DEFAULT_MAX_REORG_DEPTH = 10;
static const int64_t DEFAULT_MIN_FINALIZATION_DELAY = 2 * 60 * 60;
static const unsigned int MIN_BLOCKS_TO_KEEP = 288;
static const signed int DEFAULT_CHECKBLOCKS = 6;
static const unsigned 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 RecursiveMutex cs_main;
typedef std::unordered_map<BlockHash, CBlockIndex *, BlockHasher> BlockMap;
extern Mutex g_best_block_mutex;
extern std::condition_variable g_best_block_cv;
extern uint256 g_best_block;
extern std::atomic_bool fImporting;
extern std::atomic_bool fReindex;
extern bool fRequireStandard;
extern bool fCheckBlockIndex;
extern bool fCheckpointsEnabled;
 
extern CFeeRate minRelayTxFee;
extern int64_t nMaxTipAge;
 
extern BlockHash hashAssumeValid;
 
extern arith_uint256 nMinimumChainWork;
 
extern CBlockIndex *pindexBestHeader;
 
extern bool fHavePruned;
extern bool fPruneMode;
extern uint64_t nPruneTarget;
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 LoadExternalBlockFile(const Config &config, FILE *fileIn,
                           FlatFilePos *dbp = nullptr);
 
bool LoadGenesisBlock(const CChainParams &chainparams);
 
void UnloadBlockIndex(CTxMemPool *mempool, ChainstateManager &chainman);
 
void ThreadScriptCheck(int worker_num);
 
CTransactionRef GetTransaction(const CBlockIndex *const block_index,
                               const CTxMemPool *const mempool,
                               const TxId &txid,
                               const Consensus::Params &consensusParams,
                               BlockHash &hashBlock);
bool ActivateBestChain(
    const Config &config, BlockValidationState &state,
    std::shared_ptr<const CBlock> pblock = std::shared_ptr<const CBlock>());
Amount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams);
 
double GuessVerificationProgress(const ChainTxData &data,
                                 const CBlockIndex *pindex);
 
uint64_t CalculateCurrentUsage();
 
void UnlinkPrunedFiles(const std::set<int> &setFilesToPrune);
 
void PruneBlockFilesManual(int nManualPruneHeight);
 
bool AcceptToMemoryPool(const Config &config, CTxMemPool &pool,
                        TxValidationState &state, const CTransactionRef &tx,
                        bool bypass_limits, bool test_accept = false,
                        Amount *fee_out = nullptr)
    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 ConnectTrace;
 
bool CheckInputScripts(const CTransaction &tx, TxValidationState &state,
                       const CCoinsViewCache &view, const uint32_t flags,
                       bool sigCacheStore, bool scriptCacheStore,
                       const PrecomputedTransactionData &txdata,
                       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, int &nSigChecksOut)
    EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
    TxSigCheckLimiter nSigChecksTxLimiter;
    return CheckInputScripts(tx, state, view, flags, sigCacheStore,
                             scriptCacheStore, txdata, nSigChecksOut,
                             nSigChecksTxLimiter, nullptr, nullptr);
}
 
ThresholdState VersionBitsTipState(const Consensus::Params &params,
                                   Consensus::DeploymentPos pos);
 
ThresholdState VersionBitsBlockState(const Consensus::Params &params,
                                     Consensus::DeploymentPos pos,
                                     const CBlockIndex *pindex);
 
BIP9Stats VersionBitsTipStatistics(const Consensus::Params &params,
                                   Consensus::DeploymentPos pos);
 
int VersionBitsTipStateSinceHeight(const Consensus::Params &params,
                                   Consensus::DeploymentPos pos);
 
void UpdateCoins(const CTransaction &tx, CCoinsViewCache &inputs, int nHeight);
 
void SpendCoins(CCoinsViewCache &view, const CTransaction &tx, CTxUndo &txundo,
                int nHeight);
 
void UpdateCoins(CCoinsViewCache &view, const CTransaction &tx, int nHeight);
void UpdateCoins(CCoinsViewCache &view, const CTransaction &tx, CTxUndo &txundo,
                 int nHeight);
 
bool TestLockPointValidity(const LockPoints *lp)
    EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
bool CheckSequenceLocks(const CTxMemPool &pool, const CTransaction &tx,
                        int flags, LockPoints *lp = nullptr,
                        bool useExistingLockPoints = false)
    EXCLUSIVE_LOCKS_REQUIRED(::cs_main, pool.cs);
 
class CScriptCheck {
private:
    CTxOut m_tx_out;
    const CTransaction *ptxTo;
    unsigned int nIn;
    uint32_t nFlags;
    bool cacheStore;
    ScriptError error;
    ScriptExecutionMetrics metrics;
    PrecomputedTransactionData txdata;
    TxSigCheckLimiter *pTxLimitSigChecks;
    CheckInputsLimiter *pBlockLimitSigChecks;
 
public:
    CScriptCheck()
        : ptxTo(nullptr), nIn(0), nFlags(0), cacheStore(false),
          error(ScriptError::UNKNOWN), txdata(), pTxLimitSigChecks(nullptr),
          pBlockLimitSigChecks(nullptr) {}
 
    CScriptCheck(const CTxOut &outIn, const CTransaction &txToIn,
                 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), error(ScriptError::UNKNOWN), txdata(txdataIn),
          pTxLimitSigChecks(pTxLimitSigChecksIn),
          pBlockLimitSigChecks(pBlockLimitSigChecksIn) {}
 
    bool operator()();
 
    void swap(CScriptCheck &check) {
        std::swap(ptxTo, check.ptxTo);
        std::swap(m_tx_out, check.m_tx_out);
        std::swap(nIn, check.nIn);
        std::swap(nFlags, check.nFlags);
        std::swap(cacheStore, check.cacheStore);
        std::swap(error, check.error);
        std::swap(metrics, check.metrics);
        std::swap(txdata, check.txdata);
        std::swap(pTxLimitSigChecks, check.pTxLimitSigChecks);
        std::swap(pBlockLimitSigChecks, check.pBlockLimitSigChecks);
    }
 
    ScriptError GetScriptError() const { return error; }
 
    ScriptExecutionMetrics GetScriptExecutionMetrics() const { return metrics; }
};
 
bool UndoReadFromDisk(CBlockUndo &blockundo, const CBlockIndex *pindex);
 
bool CheckBlock(const CBlock &block, BlockValidationState &state,
                const Consensus::Params &params,
                BlockValidationOptions validationOptions);
 
bool ContextualCheckTransactionForCurrentBlock(const Consensus::Params &params,
                                               const CTransaction &tx,
                                               TxValidationState &state,
                                               int flags = -1)
    EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
bool TestBlockValidity(BlockValidationState &state, const CChainParams &params,
                       const CBlock &block, CBlockIndex *pindexPrev,
                       BlockValidationOptions validationOptions)
    EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
class CVerifyDB {
public:
    CVerifyDB();
    ~CVerifyDB();
    bool VerifyDB(const Config &config, CCoinsView *coinsview, int nCheckLevel,
                  int nCheckDepth);
};
 
CBlockIndex *LookupBlockIndex(const BlockHash &hash)
    EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
CBlockIndex *FindForkInGlobalIndex(const CChain &chain,
                                   const CBlockLocator &locator)
    EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
enum class FlushStateMode { NONE, IF_NEEDED, PERIODIC, ALWAYS };
 
extern std::unique_ptr<CCoinsViewCache> pcoinsTip;
 
class BlockManager {
    friend CChainState;
 
private:
    void FindFilesToPruneManual(std::set<int> &setFilesToPrune,
                                int nManualPruneHeight, int chain_tip_height);
 
    void FindFilesToPrune(std::set<int> &setFilesToPrune,
                          uint64_t nPruneAfterHeight, int chain_tip_height,
                          bool is_ibd);
 
public:
    BlockMap m_block_index GUARDED_BY(cs_main);
 
    std::set<CBlockIndex *> m_failed_blocks;
 
    std::multimap<CBlockIndex *, CBlockIndex *> m_blocks_unlinked;
 
    bool LoadBlockIndex(const Consensus::Params &consensus_params,
                        CBlockTreeDB &blocktree,
                        std::set<CBlockIndex *, CBlockIndexWorkComparator>
                            &block_index_candidates)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    void Unload() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    CBlockIndex *AddToBlockIndex(const CBlockHeader &block)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    CBlockIndex *InsertBlockIndex(const BlockHash &hash)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    void PruneOneBlockFile(const int fileNumber)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    bool AcceptBlockHeader(const Config &config, const CBlockHeader &block,
                           BlockValidationState &state, CBlockIndex **ppindex)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    ~BlockManager() { Unload(); }
};
 
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(std::string ldb_name, size_t cache_size_bytes, bool in_memory,
               bool should_wipe);
 
    void InitCache() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
};
 
enum class CoinsCacheSizeState {
    CRITICAL = 2,
    LARGE = 1,
    OK = 0
};
 
class CChainState {
private:
    RecursiveMutex m_cs_chainstate;
 
    std::atomic<int32_t> nBlockSequenceId{1};
    int32_t nBlockReverseSequenceId = -1;
    arith_uint256 nLastPreciousChainwork = 0;
 
    mutable std::atomic<bool> m_cached_finished_ibd{false};
 
    BlockManager &m_blockman;
 
    CTxMemPool &m_mempool;
 
    std::unique_ptr<CoinsViews> m_coins_views;
 
    const CBlockIndex *m_finalizedBlockIndex GUARDED_BY(cs_main) = nullptr;
 
public:
    explicit CChainState(CTxMemPool &mempool, BlockManager &blockman,
                         BlockHash from_snapshot_blockhash = BlockHash());
 
    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() EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
        return m_coins_views && m_coins_views->m_cacheview;
    }
 
    CChain m_chain;
 
    const BlockHash m_from_snapshot_blockhash{};
 
    std::set<CBlockIndex *, CBlockIndexWorkComparator> setBlockIndexCandidates;
 
    CCoinsViewCache &CoinsTip() EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
        assert(m_coins_views->m_cacheview);
        return *m_coins_views->m_cacheview.get();
    }
 
    CCoinsViewDB &CoinsDB() { return m_coins_views->m_dbview; }
 
    CCoinsViewErrorCatcher &CoinsErrorCatcher()
        EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
        return m_coins_views->m_catcherview;
    }
 
    void ResetCoinsViews() { m_coins_views.reset(); }
 
    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(const CChainParams &chainparams,
                          BlockValidationState &state, FlushStateMode mode,
                          int nManualPruneHeight = 0);
 
    void ForceFlushStateToDisk();
 
    void PruneAndFlush();
 
    bool ActivateBestChain(
        const Config &config, BlockValidationState &state,
        std::shared_ptr<const CBlock> pblock = std::shared_ptr<const CBlock>())
        LOCKS_EXCLUDED(cs_main);
 
    bool AcceptBlock(const Config &config,
                     const std::shared_ptr<const CBlock> &pblock,
                     BlockValidationState &state, bool fRequested,
                     const FlatFilePos *dbp, bool *fNewBlock)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    // Block (dis)connection on a given view:
    DisconnectResult DisconnectBlock(const CBlock &block,
                                     const CBlockIndex *pindex,
                                     CCoinsViewCache &view);
    bool ConnectBlock(const CBlock &block, BlockValidationState &state,
                      CBlockIndex *pindex, CCoinsViewCache &view,
                      const CChainParams &params,
                      BlockValidationOptions options, bool fJustCheck = false)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    // Block disconnection on our pcoinsTip:
    bool DisconnectTip(const CChainParams &params, BlockValidationState &state,
                       DisconnectedBlockTransactions *disconnectpool)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool.cs);
 
    // Manual block validity manipulation:
    bool PreciousBlock(const Config &config, BlockValidationState &state,
                       CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main);
    bool InvalidateBlock(const Config &config, BlockValidationState &state,
                         CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main)
        EXCLUSIVE_LOCKS_REQUIRED(!m_cs_chainstate);
    bool ParkBlock(const Config &config, BlockValidationState &state,
                   CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main)
        EXCLUSIVE_LOCKS_REQUIRED(!m_cs_chainstate);
 
    bool FinalizeBlock(const Config &config, BlockValidationState &state,
                       CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main)
        EXCLUSIVE_LOCKS_REQUIRED(!m_cs_chainstate);
    const CBlockIndex *GetFinalizedBlock() const
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    bool IsBlockFinalized(const CBlockIndex *pindex) const
        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 UnparkBlockImpl(CBlockIndex *pindex, bool fClearChildren)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    bool ReplayBlocks(const Consensus::Params &params);
    bool LoadGenesisBlock(const CChainParams &chainparams);
 
    void PruneBlockIndexCandidates();
 
    void UnloadBlockIndex() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    bool IsInitialBlockDownload() const;
 
    void CheckBlockIndex(const Consensus::Params &consensusParams);
 
    void LoadMempool(const Config &config, const ArgsManager &args);
 
    bool LoadChainTip(const CChainParams &chainparams)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    CoinsCacheSizeState GetCoinsCacheSizeState(const CTxMemPool *tx_pool)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    CoinsCacheSizeState GetCoinsCacheSizeState(
        const CTxMemPool *tx_pool, 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);
 
private:
    bool ActivateBestChainStep(const Config &config,
                               BlockValidationState &state,
                               CBlockIndex *pindexMostWork,
                               const std::shared_ptr<const CBlock> &pblock,
                               bool &fInvalidFound, ConnectTrace &connectTrace)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool.cs);
    bool ConnectTip(const Config &config, BlockValidationState &state,
                    CBlockIndex *pindexNew,
                    const std::shared_ptr<const CBlock> &pblock,
                    ConnectTrace &connectTrace,
                    DisconnectedBlockTransactions &disconnectpool)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool.cs);
    void InvalidBlockFound(CBlockIndex *pindex,
                           const BlockValidationState &state)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    void InvalidChainFound(CBlockIndex *pindexNew)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    CBlockIndex *FindMostWorkChain() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    bool MarkBlockAsFinal(BlockValidationState &state,
                          const CBlockIndex *pindex)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    void ReceivedBlockTransactions(const CBlock &block, CBlockIndex *pindexNew,
                                   const FlatFilePos &pos)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    bool RollforwardBlock(const CBlockIndex *pindex, CCoinsViewCache &inputs,
                          const Consensus::Params &params)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    bool UnwindBlock(const Config &config, BlockValidationState &state,
                     CBlockIndex *pindex, bool invalidate)
        EXCLUSIVE_LOCKS_REQUIRED(m_cs_chainstate);
 
    friend ChainstateManager;
};
 
bool PreciousBlock(const Config &config, BlockValidationState &state,
                   CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main);
 
void ResetBlockFailureFlags(CBlockIndex *pindex)
    EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
void UnparkBlockAndChildren(CBlockIndex *pindex)
    EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
void UnparkBlock(CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
class ChainstateManager {
private:
    std::unique_ptr<CChainState> m_ibd_chainstate;
 
    std::unique_ptr<CChainState> m_snapshot_chainstate;
 
    CChainState *m_active_chainstate{nullptr};
 
    bool m_snapshot_validated{false};
 
    // For access to m_active_chainstate.
    friend CChainState &ChainstateActive();
    friend CChain &ChainActive();
 
public:
    BlockManager m_blockman GUARDED_BY(::cs_main);
 
    int64_t m_total_coinstip_cache{0};
    //
    int64_t m_total_coinsdb_cache{0};
 
    //                                  constructor
    CChainState &
    InitializeChainstate(CTxMemPool &mempool,
                         const BlockHash &snapshot_blockhash = BlockHash())
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    std::vector<CChainState *> GetAll();
 
    CChainState &ActiveChainstate() const;
    CChain &ActiveChain() const { return ActiveChainstate().m_chain; }
    int ActiveHeight() const { return ActiveChain().Height(); }
    CBlockIndex *ActiveTip() const { return ActiveChain().Tip(); }
 
    BlockMap &BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        return m_blockman.m_block_index;
    }
 
    bool IsSnapshotActive() const;
 
    std::optional<BlockHash> SnapshotBlockhash() const;
 
    bool IsSnapshotValidated() const { return m_snapshot_validated; }
 
    bool IsBackgroundIBD(CChainState *chainstate) const;
 
    CChainState &ValidatedChainstate() const;
 
    CChain &ValidatedChain() const { return ValidatedChainstate().m_chain; }
    CBlockIndex *ValidatedTip() const { return ValidatedChain().Tip(); }
 
    bool ProcessNewBlock(const Config &config,
                         const std::shared_ptr<const CBlock> pblock,
                         bool fForceProcessing, bool *fNewBlock)
        LOCKS_EXCLUDED(cs_main);
 
    bool ProcessNewBlockHeaders(const Config &config,
                                const std::vector<CBlockHeader> &block,
                                BlockValidationState &state,
                                const CBlockIndex **ppindex = nullptr)
        LOCKS_EXCLUDED(cs_main);
 
    bool LoadBlockIndex(const Consensus::Params &params)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    void Unload() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    void Reset();
 
    void MaybeRebalanceCaches() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
};
 
extern ChainstateManager g_chainman GUARDED_BY(::cs_main);
 
CChainState &ChainstateActive();
 
CChain &ChainActive();
 
extern std::unique_ptr<CBlockTreeDB> pblocktree;
 
int GetSpendHeight(const CCoinsViewCache &inputs);
 
int32_t ComputeBlockVersion(const CBlockIndex *pindexPrev,
                            const Consensus::Params &params);
 
CBlockFileInfo *GetBlockFileInfo(size_t n);
 
bool DumpMempool(const CTxMemPool &pool);
 
bool LoadMempool(const Config &config, CTxMemPool &pool);
 
bool IsBlockPruned(const CBlockIndex *pblockindex);
 
#endif // BITCOIN_VALIDATION_H