static void MaybeSetPeerAsAnnouncingHeaderAndIDs(NodeId nodeid, CConnman& connma     } } -static bool TipMayBeStale(const Consensus::Params &consensusParams) EXCLUSIVE_LOCKS_REQUIRED(cs_main)+bool PeerManagerImpl::TipMayBeStale() EXCLUSIVE_LOCKS_REQUIRED(cs_main) {     AssertLockHeld(cs_main);-    if (g_last_tip_update == 0) {-        g_last_tip_update = GetTime();+    const Consensus::Params& consensusParams = m_chainparams.GetConsensus();+    if (m_last_tip_update == 0) {+        m_last_tip_update = GetTime();

 namespace {      * We use this to avoid requesting transactions that have already been      * confirnmed.      */-    Mutex g_cs_recent_confirmed_transactions;-    std::unique_ptr<CRollingBloomFilter> g_recent_confirmed_transactions GUARDED_BY(g_cs_recent_confirmed_transactions);--    /** Blocks that are in flight, and that are in the queue to be downloaded. */-    struct QueuedBlock {-        uint256 hash;-        const CBlockIndex* pindex;                               //!< Optional.-        bool fValidatedHeaders;                                  //!< Whether this block has validated headers at the time of request.-        std::unique_ptr<PartiallyDownloadedBlock> partialBlock;  //!< Optional, used for CMPCTBLOCK downloads-    };-    std::map<uint256, std::pair<NodeId, std::list<QueuedBlock>::iterator> > mapBlocksInFlight GUARDED_BY(cs_main);--    /** Stack of nodes which we have set to announce using compact blocks */-    std::list<NodeId> lNodesAnnouncingHeaderAndIDs GUARDED_BY(cs_main);--    /** Number of preferable block download peers. */-    int nPreferredDownload GUARDED_BY(cs_main) = 0;--    /** Number of peers from which we're downloading blocks. */-    int nPeersWithValidatedDownloads GUARDED_BY(cs_main) = 0;+    Mutex m_cs_recent_confirmed_transactions;+    std::unique_ptr<CRollingBloomFilter> m_recent_confirmed_transactions GUARDED_BY(m_cs_recent_confirmed_transactions); -    /** Number of peers with wtxid relay. */-    int g_wtxid_relay_peers GUARDED_BY(cs_main) = 0;+    bool MarkBlockAsReceived(const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main);+    bool MarkBlockAsInFlight(NodeId nodeid, const uint256& hash, const CBlockIndex* pindex = nullptr, std::list<QueuedBlock>::iterator** pit = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_main);+    bool TipMayBeStale() EXCLUSIVE_LOCKS_REQUIRED(cs_main);+    void FindNextBlocksToDownload(NodeId nodeid, unsigned int count, std::vector<const CBlockIndex*>& vBlocks, NodeId& nodeStaller) EXCLUSIVE_LOCKS_REQUIRED(cs_main); -    /** Number of outbound peers with m_chain_sync.m_protect. */-    int g_outbound_peers_with_protect_from_disconnect GUARDED_BY(cs_main) = 0;+    std::map<uint256, std::pair<NodeId, std::list<QueuedBlock>::iterator> > mapBlocksInFlight GUARDED_BY(cs_main);      /** When our tip was last updated. */-    std::atomic<int64_t> g_last_tip_update(0);+    std::atomic<int64_t> m_last_tip_update{0};++    CTransactionRef FindTxForGetData(const CNode& peer, const GenTxid& gtxid, const std::chrono::seconds mempool_req, const std::chrono::seconds now) LOCKS_EXCLUDED(cs_main);

 namespace {      * We use this to avoid requesting transactions that have already been      * confirnmed.      */-    Mutex g_cs_recent_confirmed_transactions;-    std::unique_ptr<CRollingBloomFilter> g_recent_confirmed_transactions GUARDED_BY(g_cs_recent_confirmed_transactions);--    /** Blocks that are in flight, and that are in the queue to be downloaded. */-    struct QueuedBlock {-        uint256 hash;-        const CBlockIndex* pindex;                               //!< Optional.-        bool fValidatedHeaders;                                  //!< Whether this block has validated headers at the time of request.-        std::unique_ptr<PartiallyDownloadedBlock> partialBlock;  //!< Optional, used for CMPCTBLOCK downloads-    };-    std::map<uint256, std::pair<NodeId, std::list<QueuedBlock>::iterator> > mapBlocksInFlight GUARDED_BY(cs_main);--    /** Stack of nodes which we have set to announce using compact blocks */-    std::list<NodeId> lNodesAnnouncingHeaderAndIDs GUARDED_BY(cs_main);--    /** Number of preferable block download peers. */-    int nPreferredDownload GUARDED_BY(cs_main) = 0;--    /** Number of peers from which we're downloading blocks. */-    int nPeersWithValidatedDownloads GUARDED_BY(cs_main) = 0;+    Mutex m_cs_recent_confirmed_transactions;+    std::unique_ptr<CRollingBloomFilter> m_recent_confirmed_transactions GUARDED_BY(m_cs_recent_confirmed_transactions); -    /** Number of peers with wtxid relay. */-    int g_wtxid_relay_peers GUARDED_BY(cs_main) = 0;+    bool MarkBlockAsReceived(const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main);+    bool MarkBlockAsInFlight(NodeId nodeid, const uint256& hash, const CBlockIndex* pindex = nullptr, std::list<QueuedBlock>::iterator** pit = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_main);+    bool TipMayBeStale() EXCLUSIVE_LOCKS_REQUIRED(cs_main);+    void FindNextBlocksToDownload(NodeId nodeid, unsigned int count, std::vector<const CBlockIndex*>& vBlocks, NodeId& nodeStaller) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

 namespace {      * We use this to avoid requesting transactions that have already been      * confirnmed.      */-    Mutex g_cs_recent_confirmed_transactions;-    std::unique_ptr<CRollingBloomFilter> g_recent_confirmed_transactions GUARDED_BY(g_cs_recent_confirmed_transactions);--    /** Blocks that are in flight, and that are in the queue to be downloaded. */-    struct QueuedBlock {-        uint256 hash;-        const CBlockIndex* pindex;                               //!< Optional.-        bool fValidatedHeaders;                                  //!< Whether this block has validated headers at the time of request.-        std::unique_ptr<PartiallyDownloadedBlock> partialBlock;  //!< Optional, used for CMPCTBLOCK downloads-    };-    std::map<uint256, std::pair<NodeId, std::list<QueuedBlock>::iterator> > mapBlocksInFlight GUARDED_BY(cs_main);--    /** Stack of nodes which we have set to announce using compact blocks */-    std::list<NodeId> lNodesAnnouncingHeaderAndIDs GUARDED_BY(cs_main);--    /** Number of preferable block download peers. */-    int nPreferredDownload GUARDED_BY(cs_main) = 0;--    /** Number of peers from which we're downloading blocks. */-    int nPeersWithValidatedDownloads GUARDED_BY(cs_main) = 0;+    Mutex m_cs_recent_confirmed_transactions;

 namespace {      */     std::map<uint256, std::pair<NodeId, bool>> mapBlockSource GUARDED_BY(cs_main);

 class PeerManagerImpl final : public PeerManager      * their own locks.      */     std::map<NodeId, PeerRef> m_peer_map GUARDED_BY(m_peer_mutex);-};-} // namespace -namespace {     /** Number of nodes with fSyncStarted. */     int nSyncStarted GUARDED_BY(cs_main) = 0;

  #include <stdint.h> #include <string>+#include <tuple> #include <vector>  namespace bech32 { -/** Encode a Bech32 string. If hrp contains uppercase characters, this will cause an assertion error. */-std::string Encode(const std::string& hrp, const std::vector<uint8_t>& values);+enum class Encoding {+    INVALID, -/** Decode a Bech32 string. Returns (hrp, data). Empty hrp means failure. */-std::pair<std::string, std::vector<uint8_t>> Decode(const std::string& str);+    BECH32,  //! Bech32 encoding as defined in BIP173+    BECH32M, //! Bech32m encoding as defined in bip-bech32m

 bool ChainstateManager::ProcessNewBlock(const CChainParams& chainparams, const s         bool ret = CheckBlock(*pblock, state, chainparams.GetConsensus());         if (ret) {             // Store to disk-            ret = ::ChainstateActive().AcceptBlock(pblock, state, chainparams, &pindex, fForceProcessing, nullptr, fNewBlock);+            ret = ActiveChainstate().AcceptBlock(pblock, state, chainparams, &pindex, fForceProcessing, nullptr, fNewBlock);         }         if (!ret) {             GetMainSignals().BlockChecked(*pblock, state);             return error("%s: AcceptBlock FAILED (%s)", __func__, state.ToString());         }     } -    NotifyHeaderTip();+    NotifyHeaderTip(ActiveChainstate());      BlockValidationState state; // Only used to report errors, not invalidity - ignore it-    if (!::ChainstateActive().ActivateBestChain(state, chainparams, pblock))+    if (!ActiveChainstate().ActivateBestChain(state, chainparams, pblock))         return error("%s: ActivateBestChain failed (%s)", __func__, state.ToString());      return true; } -bool TestBlockValidity(BlockValidationState& state, const CChainParams& chainparams, const CBlock& block, CBlockIndex* pindexPrev, bool fCheckPOW, bool fCheckMerkleRoot)+bool TestBlockValidity(BlockValidationState& state, const CChainParams& chainparams, CChainState& chainstate, const CBlock& block, CBlockIndex* pindexPrev, bool fCheckPOW, bool fCheckMerkleRoot)

 static RPCHelpMan generateblock()         LOCK(cs_main);          BlockValidationState state;-        if (!TestBlockValidity(state, chainparams, block, LookupBlockIndex(block.hashPrevBlock), false, false)) {+        if (!TestBlockValidity(state, chainparams, ::ChainstateActive(), block, g_chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock), false, false)) {

 struct ChainTxData; struct DisconnectedBlockTransactions; struct PrecomputedTransactionData; struct LockPoints;+struct CCheckpointData;

 bool UndoReadFromDisk(CBlockUndo& blockundo, const CBlockIndex* pindex); bool CheckBlock(const CBlock& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true, bool fCheckMerkleRoot = true);  /** Check a block is completely valid from start to finish (only works on top of our current best block) */-bool TestBlockValidity(BlockValidationState& state, const CChainParams& chainparams, const CBlock& block, CBlockIndex* pindexPrev, bool fCheckPOW = true, bool fCheckMerkleRoot = true) EXCLUSIVE_LOCKS_REQUIRED(cs_main);+bool TestBlockValidity(BlockValidationState& state, const CChainParams& chainparams, CChainState& chainstate, const CBlock& block, CBlockIndex* pindexPrev, bool fCheckPOW = true, bool fCheckMerkleRoot = true) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

 void CTxMemPool::check(const CCoinsViewCache *pcoins) const     uint64_t innerUsage = 0;      CCoinsViewCache mempoolDuplicate(const_cast<CCoinsViewCache*>(pcoins));-    const int64_t spendheight = GetSpendHeight(mempoolDuplicate);+    const int64_t spendheight = WITH_LOCK(::cs_main, return g_chainman.m_blockman.GetSpendHeight(mempoolDuplicate));

 bool operator==(const Coin& a, const Coin& b)  void initialize_coins_view() {-    static const ECCVerifyHandle ecc_verify_handle;-    ECC_Start();-    SelectParams(CBaseChainParams::REGTEST);+    static const auto testing_setup = MakeFuzzingContext<const TestingSetup>();