merge bitcoin#24595: move g_versionbitscache global to ChainstateManager

kwvg · kwvg · commit 1c00d0a27bd9 · 2025-10-20T00:26:56.000+05:30
includes: - d603f1d - eca22c7 - bb5c24b
diff --git a/src/deploymentstatus.cpp b/src/deploymentstatus.cpp
@@ -9,8 +9,6 @@
 
 #include <type_traits>
 
-VersionBitsCache g_versionbitscache;
-
 /* Basic sanity checking for BuriedDeployment/DeploymentPos enums and
  * ValidDeployment check */
 
diff --git a/src/deploymentstatus.h b/src/deploymentstatus.h
@@ -10,33 +10,30 @@
 
 #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)
+inline bool DeploymentActiveAfter(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::BuriedDeployment dep, [[maybe_unused]] VersionBitsCache& versionbitscache)
 {
     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 */
-inline bool DeploymentActiveAt(const CBlockIndex& index, const Consensus::Params& params, Consensus::BuriedDeployment dep)
+inline bool DeploymentActiveAt(const CBlockIndex& index, const Consensus::Params& params, Consensus::BuriedDeployment dep, [[maybe_unused]] VersionBitsCache& versionbitscache)
 {
     assert(Consensus::ValidDeployment(dep));
     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) */
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
@@ -212,7 +212,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     nBlockMaxSize = std::max<unsigned int>(1000, std::min<unsigned int>(MaxBlockSize(fDIP0001Active_context) - 1000, nBlockMaxSize));
     nBlockMaxSigOps = MaxBlockSigOps(fDIP0001Active_context);
 
-    pblock->nVersion = g_versionbitscache.ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
+    pblock->nVersion = m_chainstate.m_chainman.m_versionbitscache.ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
     // Non-mainnet only: allow overriding block.nVersion with
     // -blockversion=N to test forking scenarios
     if (Params().NetworkIDString() != CBaseChainParams::MAIN) {
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
@@ -1432,8 +1432,8 @@ static void SoftForkDescPushBack(const CBlockIndex* blockindex, const std::unord
 
     UniValue bip9(UniValue::VOBJ);
 
-    const ThresholdState next_state = g_versionbitscache.State(blockindex, chainman.GetConsensus(), id);
-    const ThresholdState current_state = g_versionbitscache.State(blockindex->pprev, chainman.GetConsensus(), id);
+    const ThresholdState next_state = chainman.m_versionbitscache.State(blockindex, chainman.GetConsensus(), id);
+    const ThresholdState current_state = chainman.m_versionbitscache.State(blockindex->pprev, chainman.GetConsensus(), id);
 
     const bool has_signal = (ThresholdState::STARTED == current_state || ThresholdState::LOCKED_IN == current_state);
 
@@ -1451,15 +1451,15 @@ static void SoftForkDescPushBack(const CBlockIndex* blockindex, const std::unord
 
     // BIP9 status
     bip9.pushKV("status", get_state_name(current_state));
-    int64_t since_height = g_versionbitscache.StateSinceHeight(blockindex->pprev, chainman.GetConsensus(), id);
+    int64_t since_height = chainman.m_versionbitscache.StateSinceHeight(blockindex->pprev, chainman.GetConsensus(), id);
     bip9.pushKV("since", since_height);
     bip9.pushKV("status_next", get_state_name(next_state));
 
     // BIP9 signalling status, if applicable
     if (has_signal) {
         UniValue statsUV(UniValue::VOBJ);
         std::vector<bool> signals;
-        BIP9Stats statsStruct = g_versionbitscache.Statistics(blockindex, chainman.GetConsensus(), id, &signals);
+        BIP9Stats statsStruct = chainman.m_versionbitscache.Statistics(blockindex, chainman.GetConsensus(), id, &signals);
         statsUV.pushKV("period", statsStruct.period);
         statsUV.pushKV("elapsed", statsStruct.elapsed);
         statsUV.pushKV("count", statsStruct.count);
@@ -1483,7 +1483,7 @@ static void SoftForkDescPushBack(const CBlockIndex* blockindex, const std::unord
     UniValue rv(UniValue::VOBJ);
     rv.pushKV("type", "bip9");
     if (ThresholdState::ACTIVE == next_state) {
-        rv.pushKV("height", g_versionbitscache.StateSinceHeight(blockindex, chainman.GetConsensus(), id));
+        rv.pushKV("height", chainman.m_versionbitscache.StateSinceHeight(blockindex, chainman.GetConsensus(), id));
     }
     rv.pushKV("active", ThresholdState::ACTIVE == next_state);
     rv.pushKV("bip9", bip9);
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
@@ -876,15 +876,15 @@ static RPCHelpMan getblocktemplate()
     UniValue vbavailable(UniValue::VOBJ);
     for (int j = 0; j < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++j) {
         Consensus::DeploymentPos pos = Consensus::DeploymentPos(j);
-        ThresholdState state = g_versionbitscache.State(pindexPrev, consensusParams, pos);
+        ThresholdState state = chainman.m_versionbitscache.State(pindexPrev, consensusParams, pos);
         switch (state) {
             case ThresholdState::DEFINED:
             case ThresholdState::FAILED:
                 // Not exposed to GBT at all
                 break;
             case ThresholdState::LOCKED_IN:
                 // Ensure bit is set in block version
-                pblock->nVersion |= g_versionbitscache.Mask(consensusParams, pos);
+                pblock->nVersion |= chainman.m_versionbitscache.Mask(consensusParams, pos);
                 [[fallthrough]];
             case ThresholdState::STARTED:
             {
@@ -893,7 +893,7 @@ static RPCHelpMan getblocktemplate()
                 if (setClientRules.find(vbinfo.name) == setClientRules.end()) {
                     if (!vbinfo.gbt_force) {
                         // If the client doesn't support this, don't indicate it in the [default] version
-                        pblock->nVersion &= ~g_versionbitscache.Mask(consensusParams, pos);
+                        pblock->nVersion &= ~chainman.m_versionbitscache.Mask(consensusParams, pos);
                     }
                 }
                 break;
diff --git a/src/test/dynamic_activation_thresholds_tests.cpp b/src/test/dynamic_activation_thresholds_tests.cpp
@@ -34,7 +34,7 @@ struct TestChainDATSetup : public TestChainSetup
 
     void signal(int num_blocks, bool expected_lockin)
     {
-        const auto& consensus_params = Params().GetConsensus();
+        const auto& chainman = *Assert(m_node.chainman);
         CScript coinbasePubKey = GetScriptForRawPubKey(coinbaseKey.GetPubKey());
         // Mine non-signalling blocks
         gArgs.ForceSetArg("-blockversion", "536870912");
@@ -50,21 +50,27 @@ struct TestChainDATSetup : public TestChainSetup
         }
         LOCK(cs_main);
         if (expected_lockin) {
-            BOOST_CHECK_EQUAL(g_versionbitscache.State(m_node.chainman->ActiveChain().Tip(), consensus_params, deployment_id), ThresholdState::LOCKED_IN);
+            BOOST_CHECK_EQUAL(chainman.m_versionbitscache.State(chainman.ActiveChain().Tip(), chainman.GetConsensus(),
+                                                                deployment_id),
+                              ThresholdState::LOCKED_IN);
         } else {
-            BOOST_CHECK_EQUAL(g_versionbitscache.State(m_node.chainman->ActiveChain().Tip(), consensus_params, deployment_id), ThresholdState::STARTED);
+            BOOST_CHECK_EQUAL(chainman.m_versionbitscache.State(chainman.ActiveChain().Tip(), chainman.GetConsensus(),
+                                                                deployment_id),
+                              ThresholdState::STARTED);
         }
     }
 
     void test(int activation_index, bool check_activation_at_min)
     {
-        const auto& consensus_params = Params().GetConsensus();
+        const auto& chainman = *Assert(m_node.chainman);
         CScript coinbasePubKey = GetScriptForRawPubKey(coinbaseKey.GetPubKey());
 
         {
             LOCK(cs_main);
             BOOST_CHECK_EQUAL(m_node.chainman->ActiveChain().Height(), window - 2);
-            BOOST_CHECK_EQUAL(g_versionbitscache.State(m_node.chainman->ActiveChain().Tip(), consensus_params, deployment_id), ThresholdState::DEFINED);
+            BOOST_CHECK_EQUAL(chainman.m_versionbitscache.State(m_node.chainman->ActiveChain().Tip(),
+                                                                chainman.GetConsensus(), deployment_id),
+                              ThresholdState::DEFINED);
         }
 
         CreateAndProcessBlock({}, coinbasePubKey);
@@ -73,11 +79,18 @@ struct TestChainDATSetup : public TestChainSetup
             LOCK(cs_main);
             // Advance from DEFINED to STARTED at height = window - 1
             BOOST_CHECK_EQUAL(m_node.chainman->ActiveChain().Height(), window - 1);
-            BOOST_CHECK_EQUAL(g_versionbitscache.State(m_node.chainman->ActiveChain().Tip(), consensus_params, deployment_id), ThresholdState::STARTED);
-            BOOST_CHECK_EQUAL(g_versionbitscache.Statistics(m_node.chainman->ActiveChain().Tip(), consensus_params, deployment_id).threshold, threshold(0));
+            BOOST_CHECK_EQUAL(chainman.m_versionbitscache.State(m_node.chainman->ActiveChain().Tip(),
+                                                                chainman.GetConsensus(), deployment_id),
+                              ThresholdState::STARTED);
+            BOOST_CHECK_EQUAL(chainman.m_versionbitscache
+                                  .Statistics(m_node.chainman->ActiveChain().Tip(), chainman.GetConsensus(), deployment_id)
+                                  .threshold,
+                              threshold(0));
             // Next block should be signaling by default
-            const auto pblocktemplate = BlockAssembler(m_node.chainman->ActiveChainstate(), m_node, m_node.mempool.get(), Params()).CreateNewBlock(coinbasePubKey);
-            const uint32_t bitmask = ((uint32_t)1) << consensus_params.vDeployments[deployment_id].bit;
+            const auto pblocktemplate = BlockAssembler(m_node.chainman->ActiveChainstate(), m_node,
+                                                       m_node.mempool.get(), chainman.GetParams())
+                                            .CreateNewBlock(coinbasePubKey);
+            const uint32_t bitmask = ((uint32_t)1) << chainman.GetConsensus().vDeployments[deployment_id].bit;
             BOOST_CHECK_EQUAL(m_node.chainman->ActiveChain().Tip()->nVersion & bitmask, 0);
             BOOST_CHECK_EQUAL(pblocktemplate->block.nVersion & bitmask, bitmask);
         }
@@ -90,17 +103,25 @@ struct TestChainDATSetup : public TestChainSetup
                 // Still STARTED but with a (potentially) new threshold
                 LOCK(cs_main);
                 BOOST_CHECK_EQUAL(m_node.chainman->ActiveChain().Height(), window * (i + 2) - 1);
-                BOOST_CHECK_EQUAL(g_versionbitscache.State(m_node.chainman->ActiveChain().Tip(), consensus_params, deployment_id), ThresholdState::STARTED);
-                const auto vbts = g_versionbitscache.Statistics(m_node.chainman->ActiveChain().Tip(), consensus_params, deployment_id);
+                BOOST_CHECK_EQUAL(chainman.m_versionbitscache.State(m_node.chainman->ActiveChain().Tip(),
+                                                                    chainman.GetConsensus(), deployment_id),
+                                  ThresholdState::STARTED);
+                const auto vbts = chainman.m_versionbitscache.Statistics(m_node.chainman->ActiveChain().Tip(),
+                                                                         chainman.GetConsensus(), deployment_id);
                 BOOST_CHECK_EQUAL(vbts.threshold, threshold(i + 1));
                 BOOST_CHECK(vbts.threshold <= th_start);
                 BOOST_CHECK(vbts.threshold >= th_end);
             }
         }
         if (LOCK(cs_main); check_activation_at_min) {
-            BOOST_CHECK_EQUAL(g_versionbitscache.Statistics(m_node.chainman->ActiveChain().Tip(), consensus_params, deployment_id).threshold, th_end);
+            BOOST_CHECK_EQUAL(chainman.m_versionbitscache
+                                  .Statistics(m_node.chainman->ActiveChain().Tip(), chainman.GetConsensus(), deployment_id)
+                                  .threshold,
+                              th_end);
         } else {
-            BOOST_CHECK(g_versionbitscache.Statistics(m_node.chainman->ActiveChain().Tip(), consensus_params, deployment_id).threshold > th_end);
+            BOOST_CHECK(chainman.m_versionbitscache
+                            .Statistics(m_node.chainman->ActiveChain().Tip(), chainman.GetConsensus(), deployment_id)
+                            .threshold > th_end);
         }
 
         // activate
@@ -110,7 +131,9 @@ struct TestChainDATSetup : public TestChainSetup
         }
         {
             LOCK(cs_main);
-            BOOST_CHECK_EQUAL(g_versionbitscache.State(m_node.chainman->ActiveChain().Tip(), consensus_params, deployment_id), ThresholdState::ACTIVE);
+            BOOST_CHECK_EQUAL(chainman.m_versionbitscache.State(m_node.chainman->ActiveChain().Tip(),
+                                                                chainman.GetConsensus(), deployment_id),
+                              ThresholdState::ACTIVE);
         }
 
     }
diff --git a/src/test/versionbits_tests.cpp b/src/test/versionbits_tests.cpp
diff --git a/src/validation.cpp b/src/validation.cpp
diff --git a/src/validation.h b/src/validation.h

Original file line number	Diff line number	Diff line change
`@@ -10,33 +10,30 @@`
`10`	`10`
`11`	`11`	`#include <limits>`
`12`	`12`
`13`		`-/** Global cache for versionbits deployment status */`
`14`		`-extern VersionBitsCache g_versionbitscache;`
`15`		`-`
`16`	`13`	`/** Determine if a deployment is active for the next block */`
`17`		`-inline bool DeploymentActiveAfter(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::BuriedDeployment dep)`
	`14`	`+inline bool DeploymentActiveAfter(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::BuriedDeployment dep, [[maybe_unused]] VersionBitsCache& versionbitscache)`
`18`	`15`	`{`
`19`	`16`	`assert(Consensus::ValidDeployment(dep));`
`20`	`17`	`return (pindexPrev == nullptr ? 0 : pindexPrev->nHeight + 1) >= params.DeploymentHeight(dep);`
`21`	`18`	`}`
`22`	`19`
`23`		`-inline bool DeploymentActiveAfter(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::DeploymentPos dep)`
	`20`	`+inline bool DeploymentActiveAfter(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::DeploymentPos dep, VersionBitsCache& versionbitscache)`
`24`	`21`	`{`
`25`	`22`	`assert(Consensus::ValidDeployment(dep));`
`26`		`- return ThresholdState::ACTIVE == g_versionbitscache.State(pindexPrev, params, dep);`
	`23`	`+ return ThresholdState::ACTIVE == versionbitscache.State(pindexPrev, params, dep);`
`27`	`24`	`}`
`28`	`25`
`29`	`26`	`/** Determine if a deployment is active for this block */`
`30`		`-inline bool DeploymentActiveAt(const CBlockIndex& index, const Consensus::Params& params, Consensus::BuriedDeployment dep)`
	`27`	`+inline bool DeploymentActiveAt(const CBlockIndex& index, const Consensus::Params& params, Consensus::BuriedDeployment dep, [[maybe_unused]] VersionBitsCache& versionbitscache)`
`31`	`28`	`{`
`32`	`29`	`assert(Consensus::ValidDeployment(dep));`
`33`	`30`	`return index.nHeight >= params.DeploymentHeight(dep);`
`34`	`31`	`}`
`35`	`32`
`36`		`-inline bool DeploymentActiveAt(const CBlockIndex& index, const Consensus::Params& params, Consensus::DeploymentPos dep)`
	`33`	`+inline bool DeploymentActiveAt(const CBlockIndex& index, const Consensus::Params& params, Consensus::DeploymentPos dep, VersionBitsCache& versionbitscache)`
`37`	`34`	`{`
`38`	`35`	`assert(Consensus::ValidDeployment(dep));`
`39`		`- return DeploymentActiveAfter(index.pprev, params, dep);`
	`36`	`+ return DeploymentActiveAfter(index.pprev, params, dep, versionbitscache);`
`40`	`37`	`}`
`41`	`38`
`42`	`39`	`/** Determine if a deployment is enabled (can ever be active) */`