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 <utility>
#include <vector>

class BlockValidationState;
class CBlockIndex;
class CBlockTreeDB;
class CBlockUndo;
class CChainParams;
class CChain;
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 int MAX_BLOCKS_IN_TRANSIT_PER_PEER = 16;
static const unsigned int BLOCK_STALLING_TIMEOUT = 2;
static const unsigned int MAX_HEADERS_RESULTS = 2000;
static const int MAX_CMPCTBLOCK_DEPTH = 5;
static const int MAX_BLOCKTXN_DEPTH = 10;
static const unsigned int BLOCK_DOWNLOAD_WINDOW = 1024;
static const unsigned int DATABASE_WRITE_INTERVAL = 60 * 60;
static const unsigned int DATABASE_FLUSH_INTERVAL = 24 * 60 * 60;
static const int64_t BLOCK_DOWNLOAD_TIMEOUT_BASE = 1000000;
static const int64_t BLOCK_DOWNLOAD_TIMEOUT_PER_PEER = 500000;

static const int64_t DEFAULT_MAX_TIP_AGE = 24 * 60 * 60;
static const int64_t MAX_FEE_ESTIMATION_TIP_AGE = 3 * 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 unsigned int MAX_BLOCKS_TO_ANNOUNCE = 8;

static const int MAX_UNCONNECTING_HEADERS = 10;

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;

enum class SynchronizationState { INIT_REINDEX, INIT_DOWNLOAD, POST_INIT };

extern RecursiveMutex cs_main;
extern CTxMemPool g_mempool;
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 size_t nCoinCacheUsage;

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;
static const unsigned int MIN_BLOCKS_TO_KEEP = 288;
static const unsigned int NODE_NETWORK_LIMITED_MIN_BLOCKS = 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;

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; }
};

bool LoadExternalBlockFile(const Config &config, FILE *fileIn,
                           FlatFilePos *dbp = nullptr);

bool LoadGenesisBlock(const CChainParams &chainparams);

void UnloadBlockIndex();

void ThreadScriptCheck(int worker_num);

bool GetTransaction(const TxId &txid, CTransactionRef &txOut,
                    const Consensus::Params &params, BlockHash &hashBlock,
                    const CBlockIndex *const blockIndex = nullptr);

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, const Amount nAbsurdFee,
                        bool test_accept = false)
    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);

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

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

    bool AcceptBlockHeader(const Config &config, const CBlockHeader &block,
                           BlockValidationState &state, CBlockIndex **ppindex)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
};

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;

    std::unique_ptr<CoinsViews> m_coins_views;

    const CBlockIndex *m_finalizedBlockIndex GUARDED_BY(cs_main) = nullptr;

public:
    explicit CChainState(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() 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(); }

    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, ::g_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, m_cs_chainstate);
    bool ParkBlock(const Config &config, BlockValidationState &state,
                   CBlockIndex *pindex)
        LOCKS_EXCLUDED(cs_main, m_cs_chainstate);

    bool FinalizeBlock(const Config &config, BlockValidationState &state,
                       CBlockIndex *pindex)
        LOCKS_EXCLUDED(cs_main, 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);

    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, ::g_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, ::g_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);

    CChainState &
    InitializeChainstate(const BlockHash &snapshot_blockhash = BlockHash())
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

    std::vector<CChainState *> GetAll();

    CChain &ActiveChain() const;
    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);

    void PruneOneBlockFile(const int fileNumber)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);

    bool LoadBlockIndex(const Consensus::Params &params)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);

    void Unload() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

    void Reset();
};

extern ChainstateManager g_chainman GUARDED_BY(::cs_main);

CChainState &ChainstateActive();

CChain &ChainActive();

BlockMap &BlockIndex();

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