Merge #6933: backport: merge bitcoin#24595 (move g_versionbitscache global to ChainstateManager)

2dc0a25 lint: update circular dependencies allowlist (Kittywhiskers Van Gogh)
95d5f97 merge bitcoin#24595: move g_versionbitscache global to ChainstateManager (Kittywhiskers Van Gogh)
14a77f6 refactor: accept `ChainstateManager` in `CMNHFManager` ctor (Kittywhiskers Van Gogh)
838cfcb refactor: move `IsQuorumTypeEnabled` to `ChainstateManager` (Kittywhiskers Van Gogh)
d4dc191 refactor: adapt LLMQ logic to `DeploymentActive{At,After}` (Kittywhiskers Van Gogh)
2f9210f refactor: abstract masternode structures from Qt wallet (Kittywhiskers Van Gogh)
dc3f6bd trivial: force stricter lambda signature for `ForEachMN{,Shared}()` (Kittywhiskers Van Gogh)
a223b8c refactor: adapt CbTx, CreditPool logic to `DeploymentActive{At,After}` (Kittywhiskers Van Gogh)
b25e4fd refactor: adapt ProTx logic to `DeploymentActive{At,After}` (Kittywhiskers Van Gogh)
07ea998 partial bitcoin#24595: move g_versionbitscache global to ChainstateManager (Kittywhiskers Van Gogh)

Pull request description:

  ## Additional Information

  * Depends on #6923

  * To reduce the diff size owing to Dash's extensive use of hardforks, `DeploymentActive{After,At}()` calls that simply require a height check have been moved to an explicit height check. This reduces the amount of "thread the needle" refactoring needed to provide `ChainstateManager`.

  * As the versionbits cache is now a member of `ChainstateManager`, all `DeploymentActive{After,At}()` calls needed to be adapted to pass a reference to `ChainstateManager`, which has necessitated substantial refactoring. For this reason, the backport has been isolated into a separate PR.

     > ℹ️ **Note**
     >
     > This text was written back when `CDeterministicMNList` and `CDeterministicMN` needed to accept `ChainstateManager`. Through hardening, this is no longer true. The underlying logic has still been retained to allow for future forks which may impact deterministic masternode logic.

    * Currently, Qt code is knowledgeable of objects like `CDeterministicMNList` and `CDeterministicMN`. This was fine because none of the functions called demanded knowledge of classes explicitly isolated from Qt code like `CChainState`, access to which is instead mediated through interfaces.

    * As the deglobalization now requires knowledge of `ChainstateManager`, both `CDeterministicMNList` and `CDeterministicMN` have been implemented as interfaces `interfaces::MnList` and `interfaces::MnEntry` respectively.

      * The problem of ensuring access to the context as `CDeterministicMNList` is updated from sources that cannot set the context themselves has been managed with a workaround, namely `interfaces::MnList::copyContextTo()`. The lifecycle of `MnList` will be as follows:

        A blank `MnList` is initialised without a context

        https://github.com/dashpay/dash/blob/1dcd28147a1eed2bb1096b5eb20073aa368b9dae/src/qt/clientmodel.cpp#L53

        The latest `MnList` is fetched with `interfaces::EVO::getListAtChainTip()`

        https://github.com/dashpay/dash/blob/1dcd28147a1eed2bb1096b5eb20073aa368b9dae/src/qt/clientmodel.cpp#L120-L126

        `interfaces::EVO` lends its node context to the `MnList`

        https://github.com/dashpay/dash/blob/1dcd28147a1eed2bb1096b5eb20073aa368b9dae/src/node/interfaces.cpp#L197-L206

        Calls like `interfaces::MnList::getProjectedMNPayees()` now work

        https://github.com/dashpay/dash/blob/1dcd28147a1eed2bb1096b5eb20073aa368b9dae/src/node/interfaces.cpp#L166-L174

        Event handler gives us the newest masternode list but doesn't have access to node context

        https://github.com/dashpay/dash/blob/1dcd28147a1eed2bb1096b5eb20073aa368b9dae/src/qt/clientmodel.cpp#L322-L325

        Context from older masternode list is copied into newer list

        https://github.com/dashpay/dash/blob/1dcd28147a1eed2bb1096b5eb20073aa368b9dae/src/qt/clientmodel.cpp#L108

  ## Breaking Changes

  None expected.

  ## Checklist

  - [x] I have performed a self-review of my own code
  - [x] I have commented my code, particularly in hard-to-understand areas
  - [x] I have added or updated relevant unit/integration/functional/e2e tests
  - [x] I have made corresponding changes to the documentation **(note: N/A)**
  - [x] I have assigned this pull request to a milestone _(for repository code-owners and collaborators only)_

ACKs for top commit:
  UdjinM6:
    utACK 2dc0a25

Tree-SHA512: 43523121366dd940ebf3eca3e30a7988412d438a4b11e7d9b1e27adfbdfb9778888a8f7bd67b2837bf907704e6a2c43d6884ad284dbbdf9fc8ecee17b71992cd

Author: PastaPastaPasta

src/coinjoin/client.cpp

@@ -1044,9 +1044,8 @@ CDeterministicMNCPtr CCoinJoinClientManager::GetRandomNotUsedMasternode()
     // fill a vector
     std::vector<CDeterministicMNCPtr> vpMasternodesShuffled;
     vpMasternodesShuffled.reserve(nCountEnabled);
-    mnList.ForEachMNShared(true, [&vpMasternodesShuffled](const CDeterministicMNCPtr& dmn) {
-        vpMasternodesShuffled.emplace_back(dmn);
-    });
+    mnList.ForEachMNShared(/*onlyValid=*/true,
+                           [&vpMasternodesShuffled](const auto& dmn) { vpMasternodesShuffled.emplace_back(dmn); });
 
     // shuffle pointers
     Shuffle(vpMasternodesShuffled.begin(), vpMasternodesShuffled.end(), FastRandomContext());

src/deploymentstatus.cpp

@@ -9,8 +9,6 @@
 
 #include <type_traits>
 
-VersionBitsCache g_versionbitscache;
-
 /* Basic sanity checking for BuriedDeployment/DeploymentPos enums and
  * ValidDeployment check */
 

src/deploymentstatus.h

@@ -10,20 +10,17 @@
 
 #include <limits>
 
-/** Global cache for versionbits deployment status */
-extern VersionBitsCache g_versionbitscache;
-
 /** Determine if a deployment is active for the next block */
 inline bool DeploymentActiveAfter(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::BuriedDeployment dep)
 {
     assert(Consensus::ValidDeployment(dep));
     return (pindexPrev == nullptr ? 0 : pindexPrev->nHeight + 1) >= params.DeploymentHeight(dep);
 }
 
-inline bool DeploymentActiveAfter(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::DeploymentPos dep)
+inline bool DeploymentActiveAfter(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::DeploymentPos dep, VersionBitsCache& versionbitscache)
 {
     assert(Consensus::ValidDeployment(dep));
-    return ThresholdState::ACTIVE == g_versionbitscache.State(pindexPrev, params, dep);
+    return ThresholdState::ACTIVE == versionbitscache.State(pindexPrev, params, dep);
 }
 
 /** Determine if a deployment is active for this block */
@@ -33,10 +30,10 @@ inline bool DeploymentActiveAt(const CBlockIndex& index, const Consensus::Params
     return index.nHeight >= params.DeploymentHeight(dep);
 }
 
-inline bool DeploymentActiveAt(const CBlockIndex& index, const Consensus::Params& params, Consensus::DeploymentPos dep)
+inline bool DeploymentActiveAt(const CBlockIndex& index, const Consensus::Params& params, Consensus::DeploymentPos dep, VersionBitsCache& versionbitscache)
 {
     assert(Consensus::ValidDeployment(dep));
-    return DeploymentActiveAfter(index.pprev, params, dep);
+    return DeploymentActiveAfter(index.pprev, params, dep, versionbitscache);
 }
 
 /** Determine if a deployment is enabled (can ever be active) */

src/evo/creditpool.cpp

@@ -61,7 +61,7 @@ static std::optional<CreditPoolDataPerBlock> GetCreditDataFromBlock(const gsl::n
                                                                     const Consensus::Params& consensusParams)
 {
     // There's no CbTx before DIP0003 activation
-    if (!DeploymentActiveAt(*block_index, Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0003)) {
+    if (!DeploymentActiveAt(*block_index, consensusParams, Consensus::DEPLOYMENT_DIP0003)) {
         return std::nullopt;
     }
 
@@ -117,7 +117,7 @@ std::string CCreditPool::ToString() const
 
 std::optional<CCreditPool> CCreditPoolManager::GetFromCache(const CBlockIndex& block_index)
 {
-    if (!DeploymentActiveAt(block_index, Params().GetConsensus(), Consensus::DEPLOYMENT_V20)) return CCreditPool{};
+    if (!DeploymentActiveAt(block_index, m_chainman.GetConsensus(), Consensus::DEPLOYMENT_V20)) return CCreditPool{};
 
     const uint256 block_hash = block_index.GetBlockHash();
     CCreditPool pool;
@@ -148,10 +148,9 @@ void CCreditPoolManager::AddToCache(const uint256& block_hash, int height, const
     }
 }
 
-CCreditPool CCreditPoolManager::ConstructCreditPool(const gsl::not_null<const CBlockIndex*> block_index,
-                                                    CCreditPool prev, const Consensus::Params& consensusParams)
+CCreditPool CCreditPoolManager::ConstructCreditPool(const gsl::not_null<const CBlockIndex*> block_index, CCreditPool prev)
 {
-    std::optional<CreditPoolDataPerBlock> opt_block_data = GetCreditDataFromBlock(block_index, consensusParams);
+    std::optional<CreditPoolDataPerBlock> opt_block_data = GetCreditDataFromBlock(block_index, m_chainman.GetConsensus());
     if (!opt_block_data) {
         // If reading of previous block is not successfully, but
         // prev contains credit pool related data, something strange happened
@@ -178,20 +177,21 @@ CCreditPool CCreditPoolManager::ConstructCreditPool(const gsl::not_null<const CB
     }
 
     const CBlockIndex* distant_block_index{
-        block_index->GetAncestor(block_index->nHeight - Params().CreditPoolPeriodBlocks())};
+        block_index->GetAncestor(block_index->nHeight - m_chainman.GetParams().CreditPoolPeriodBlocks())};
     CAmount distantUnlocked{0};
     if (distant_block_index) {
-        if (std::optional<CreditPoolDataPerBlock> distant_block{GetCreditDataFromBlock(distant_block_index, consensusParams)};
+        if (std::optional<CreditPoolDataPerBlock> distant_block{
+                GetCreditDataFromBlock(distant_block_index, m_chainman.GetConsensus())};
             distant_block) {
             distantUnlocked = distant_block->unlocked;
         }
     }
 
     CAmount currentLimit = blockData.credit_pool;
     const CAmount latelyUnlocked = prev.latelyUnlocked + blockData.unlocked - distantUnlocked;
-    if (DeploymentActiveAt(*block_index, Params().GetConsensus(), Consensus::DEPLOYMENT_V24)) {
+    if (DeploymentActiveAt(*block_index, m_chainman, Consensus::DEPLOYMENT_V24)) {
         currentLimit = std::max(CAmount(0), std::min(currentLimit, LimitAmountV24 - latelyUnlocked));
-    } else if (DeploymentActiveAt(*block_index, Params().GetConsensus(), Consensus::DEPLOYMENT_WITHDRAWALS)) {
+    } else if (DeploymentActiveAt(*block_index, m_chainman.GetConsensus(), Consensus::DEPLOYMENT_WITHDRAWALS)) {
         currentLimit = std::min(currentLimit, LimitAmountV22);
     } else {
         // Unlock limits in pre-v22 are max(100, min(.10 * assetlockpool, 1000)) inside window
@@ -221,7 +221,7 @@ CCreditPool CCreditPoolManager::ConstructCreditPool(const gsl::not_null<const CB
 
 }
 
-CCreditPool CCreditPoolManager::GetCreditPool(const CBlockIndex* block_index, const Consensus::Params& consensusParams)
+CCreditPool CCreditPoolManager::GetCreditPool(const CBlockIndex* block_index)
 {
     std::stack<gsl::not_null<const CBlockIndex*>> to_calculate;
 
@@ -232,14 +232,15 @@ CCreditPool CCreditPoolManager::GetCreditPool(const CBlockIndex* block_index, co
     }
     if (block_index == nullptr) poolTmp = CCreditPool{};
     while (!to_calculate.empty()) {
-        poolTmp = ConstructCreditPool(to_calculate.top(), *poolTmp, consensusParams);
+        poolTmp = ConstructCreditPool(to_calculate.top(), *poolTmp);
         to_calculate.pop();
     }
     return *poolTmp;
 }
 
-CCreditPoolManager::CCreditPoolManager(CEvoDB& _evoDb) :
-    evoDb{_evoDb}
+CCreditPoolManager::CCreditPoolManager(CEvoDB& _evoDb, const ChainstateManager& chainman) :
+    evoDb{_evoDb},
+    m_chainman{chainman}
 {
 }
 
@@ -326,7 +327,7 @@ std::optional<CCreditPoolDiff> GetCreditPoolDiffForBlock(CCreditPoolManager& cpo
                                                          const CAmount blockSubsidy, BlockValidationState& state)
 {
     try {
-        const CCreditPool creditPool = cpoolman.GetCreditPool(pindexPrev, consensusParams);
+        const CCreditPool creditPool = cpoolman.GetCreditPool(pindexPrev);
         LogPrint(BCLog::CREDITPOOL, "%s: CCreditPool is %s\n", __func__, creditPool.ToString());
         CCreditPoolDiff creditPoolDiff(creditPool, pindexPrev, consensusParams, blockSubsidy);
         for (size_t i = 1; i < block.vtx.size(); ++i) {

src/evo/creditpool.h

@@ -17,12 +17,14 @@
 #include <evo/assetlocktx.h>
 
 #include <gsl/pointers.h>
+
 #include <optional>
 #include <unordered_set>
 
+class BlockValidationState;
 class CBlock;
 class CBlockIndex;
-class BlockValidationState;
+class ChainstateManager;
 class CEvoDB;
 class TxValidationState;
 namespace Consensus {
@@ -114,6 +116,7 @@ class CCreditPoolManager
     Uint256LruHashMap<CCreditPool> creditPoolCache GUARDED_BY(cache_mutex){CreditPoolCacheSize};
 
     CEvoDB& evoDb;
+    const ChainstateManager& m_chainman;
 
     static constexpr int DISK_SNAPSHOT_PERIOD = 576; // once per day
 
@@ -126,23 +129,22 @@ class CCreditPoolManager
     CCreditPoolManager() = delete;
     CCreditPoolManager(const CCreditPoolManager&) = delete;
     CCreditPoolManager& operator=(const CCreditPoolManager&) = delete;
-    explicit CCreditPoolManager(CEvoDB& _evoDb);
+    explicit CCreditPoolManager(CEvoDB& _evoDb, const ChainstateManager& chainman);
     ~CCreditPoolManager();
 
     /**
       * @return CCreditPool with data or with empty depends on activation V19 at that block
       * In case if block is invalid the function GetCreditPool throws an exception
       * it can happen if there limits of withdrawal (unlock) exceed
       */
-    CCreditPool GetCreditPool(const CBlockIndex* block, const Consensus::Params& consensusParams)
-        EXCLUSIVE_LOCKS_REQUIRED(!cache_mutex);
+    CCreditPool GetCreditPool(const CBlockIndex* block) EXCLUSIVE_LOCKS_REQUIRED(!cache_mutex);
 
 private:
     std::optional<CCreditPool> GetFromCache(const CBlockIndex& block_index) EXCLUSIVE_LOCKS_REQUIRED(!cache_mutex);
     void AddToCache(const uint256& block_hash, int height, const CCreditPool& pool) EXCLUSIVE_LOCKS_REQUIRED(!cache_mutex);
 
-    CCreditPool ConstructCreditPool(const gsl::not_null<const CBlockIndex*> block_index, CCreditPool prev,
-                                    const Consensus::Params& consensusParams) EXCLUSIVE_LOCKS_REQUIRED(!cache_mutex);
+    CCreditPool ConstructCreditPool(const gsl::not_null<const CBlockIndex*> block_index, CCreditPool prev)
+        EXCLUSIVE_LOCKS_REQUIRED(!cache_mutex);
 };
 
 std::optional<CCreditPoolDiff> GetCreditPoolDiffForBlock(CCreditPoolManager& cpoolman, const node::BlockManager& blockman, const llmq::CQuorumManager& qman,