refactor: accept ChainstateManager in CMNHFManager ctor

kwvg · kwvg · commit 14a77f6f7108 · 2025-12-19T16:00:58.000+05:30
The `ConnectManager` approach is no longer needed.
diff --git a/src/evo/mnhftx.cpp b/src/evo/mnhftx.cpp
@@ -43,8 +43,9 @@ CMutableTransaction MNHFTxPayload::PrepareTx() const
     return tx;
 }
 
-CMNHFManager::CMNHFManager(CEvoDB& evoDb) :
-    m_evoDb{evoDb}
+CMNHFManager::CMNHFManager(CEvoDB& evoDb, const ChainstateManager& chainman) :
+    m_evoDb(evoDb),
+    m_chainman{chainman}
 {
     assert(globalInstance == nullptr);
     globalInstance = this;
@@ -58,7 +59,7 @@ CMNHFManager::~CMNHFManager()
 
 CMNHFManager::Signals CMNHFManager::GetSignalsStage(const CBlockIndex* const pindexPrev)
 {
-    if (!DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_V20)) return {};
+    if (!DeploymentActiveAfter(pindexPrev, m_chainman.GetConsensus(), Consensus::DEPLOYMENT_V20)) return {};
 
     Signals signals_tmp = GetForBlock(pindexPrev);
 
@@ -201,12 +202,11 @@ static bool extractSignals(const ChainstateManager& chainman, const llmq::CQuoru
 
 std::optional<CMNHFManager::Signals> CMNHFManager::ProcessBlock(const CBlock& block, const CBlockIndex* const pindex, bool fJustCheck, BlockValidationState& state)
 {
-    auto chainman = Assert(m_chainman.load(std::memory_order_acquire));
     auto qman = Assert(m_qman.load(std::memory_order_acquire));
 
     try {
         std::vector<uint8_t> new_signals;
-        if (!extractSignals(*chainman, *qman, block, pindex, new_signals, state)) {
+        if (!extractSignals(m_chainman, *qman, block, pindex, new_signals, state)) {
             // state is set inside extractSignals
             return std::nullopt;
         }
@@ -253,12 +253,11 @@ std::optional<CMNHFManager::Signals> CMNHFManager::ProcessBlock(const CBlock& bl
 
 bool CMNHFManager::UndoBlock(const CBlock& block, const CBlockIndex* const pindex)
 {
-    auto chainman = Assert(m_chainman.load(std::memory_order_acquire));
     auto qman = Assert(m_qman.load(std::memory_order_acquire));
 
     std::vector<uint8_t> excluded_signals;
     BlockValidationState state;
-    if (!extractSignals(*chainman, *qman, block, pindex, excluded_signals, state)) {
+    if (!extractSignals(m_chainman, *qman, block, pindex, excluded_signals, state)) {
         LogPrintf("CMNHFManager::%s: failed to extract signals\n", __func__);
         return false;
     }
@@ -330,7 +329,7 @@ std::optional<CMNHFManager::Signals> CMNHFManager::GetFromCache(const CBlockInde
     }
     {
         LOCK(cs_cache);
-        if (!DeploymentActiveAt(*pindex, Params().GetConsensus(), Consensus::DEPLOYMENT_V20)) {
+        if (!DeploymentActiveAt(*pindex, m_chainman.GetConsensus(), Consensus::DEPLOYMENT_V20)) {
             mnhfCache.insert(blockHash, signals);
             return signals;
         }
@@ -340,7 +339,7 @@ std::optional<CMNHFManager::Signals> CMNHFManager::GetFromCache(const CBlockInde
         mnhfCache.insert(blockHash, signals);
         return signals;
     }
-    if (!DeploymentActiveAt(*pindex, Params().GetConsensus(), Consensus::DEPLOYMENT_MN_RR)) {
+    if (!DeploymentActiveAt(*pindex, m_chainman.GetConsensus(), Consensus::DEPLOYMENT_MN_RR)) {
         // before mn_rr activation we are safe
         if (m_evoDb.Read(std::make_pair(DB_SIGNALS, blockHash), signals)) {
             LOCK(cs_cache);
@@ -359,7 +358,7 @@ void CMNHFManager::AddToCache(const Signals& signals, const CBlockIndex* const p
         LOCK(cs_cache);
         mnhfCache.insert(blockHash, signals);
     }
-    if (!DeploymentActiveAt(*pindex, Params().GetConsensus(), Consensus::DEPLOYMENT_V20)) return;
+    if (!DeploymentActiveAt(*pindex, m_chainman.GetConsensus(), Consensus::DEPLOYMENT_V20)) return;
 
     m_evoDb.Write(std::make_pair(DB_SIGNALS_v2, blockHash), signals);
 }
@@ -371,31 +370,26 @@ void CMNHFManager::AddSignal(const CBlockIndex* const pindex, int bit)
     AddToCache(signals, pindex);
 }
 
-void CMNHFManager::ConnectManagers(gsl::not_null<ChainstateManager*> chainman, gsl::not_null<llmq::CQuorumManager*> qman)
+void CMNHFManager::ConnectManagers(gsl::not_null<llmq::CQuorumManager*> qman)
 {
     // Do not allow double-initialization
-    assert(m_chainman.load(std::memory_order_acquire) == nullptr);
-    m_chainman.store(chainman, std::memory_order_release);
     assert(m_qman.load(std::memory_order_acquire) == nullptr);
     m_qman.store(qman, std::memory_order_release);
 }
 
 void CMNHFManager::DisconnectManagers()
 {
-    m_chainman.store(nullptr, std::memory_order_release);
     m_qman.store(nullptr, std::memory_order_release);
 }
 
 bool CMNHFManager::ForceSignalDBUpdate()
 {
-    auto chainman = Assert(m_chainman.load(std::memory_order_acquire));
-
     // force ehf signals db update
     auto dbTx = m_evoDb.BeginTransaction();
 
     const bool last_legacy = bls::bls_legacy_scheme.load();
     bls::bls_legacy_scheme.store(false);
-    GetSignalsStage(chainman->ActiveChainstate().m_chain.Tip());
+    GetSignalsStage(m_chainman.ActiveTip());
     bls::bls_legacy_scheme.store(last_legacy);
 
     dbTx->Commit();
diff --git a/src/evo/mnhftx.h b/src/evo/mnhftx.h
@@ -90,7 +90,7 @@ class CMNHFManager : public AbstractEHFManager
 {
 private:
     CEvoDB& m_evoDb;
-    std::atomic<ChainstateManager*> m_chainman{nullptr};
+    const ChainstateManager& m_chainman;
     std::atomic<llmq::CQuorumManager*> m_qman{nullptr};
 
     static constexpr size_t MNHFCacheSize = 1000;
@@ -102,7 +102,7 @@ class CMNHFManager : public AbstractEHFManager
     CMNHFManager() = delete;
     CMNHFManager(const CMNHFManager&) = delete;
     CMNHFManager& operator=(const CMNHFManager&) = delete;
-    explicit CMNHFManager(CEvoDB& evoDb);
+    explicit CMNHFManager(CEvoDB& evoDb, const ChainstateManager& chainman);
     ~CMNHFManager();
 
     /**
@@ -139,7 +139,7 @@ class CMNHFManager : public AbstractEHFManager
      * Separated from constructor to allow LLMQContext to use CMNHFManager in read-only capacity.
      * Required to mutate state.
      */
-    void ConnectManagers(gsl::not_null<ChainstateManager*> chainman, gsl::not_null<llmq::CQuorumManager*> qman);
+    void ConnectManagers(gsl::not_null<llmq::CQuorumManager*> qman);
 
     /**
      * Reset llmq::CQuorumManager pointer.
diff --git a/src/node/chainstate.cpp b/src/node/chainstate.cpp
@@ -74,7 +74,7 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
     evodb = std::make_unique<CEvoDB>(util::DbWrapperParams{.path = data_dir, .memory = dash_dbs_in_memory, .wipe = fReset || fReindexChainState});
 
     mnhf_manager.reset();
-    mnhf_manager = std::make_unique<CMNHFManager>(*evodb);
+    mnhf_manager = std::make_unique<CMNHFManager>(*evodb, chainman);
 
     chainman.InitializeChainstate(mempool, *evodb, chain_helper);
     chainman.m_total_coinstip_cache = nCoinCacheUsage;
@@ -243,7 +243,7 @@ void DashChainstateSetup(ChainstateManager& chainman,
                                              util::DbWrapperParams{.path = data_dir, .memory = llmq_dbs_in_memory, .wipe = llmq_dbs_wipe});
     mempool->ConnectManagers(dmnman.get(), llmq_ctx->isman.get());
     // Enable CMNHFManager::{Process, Undo}Block
-    mnhf_manager->ConnectManagers(&chainman, llmq_ctx->qman.get());
+    mnhf_manager->ConnectManagers(llmq_ctx->qman.get());
 
     chain_helper.reset();
     chain_helper = std::make_unique<CChainstateHelper>(*cpoolman, *dmnman, *mnhf_manager, govman, *(llmq_ctx->isman), *(llmq_ctx->quorum_block_processor),
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
@@ -222,7 +222,6 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::ve
     m_node.netfulfilledman = std::make_unique<CNetFulfilledRequestManager>();
     m_node.sporkman = std::make_unique<CSporkManager>();
     m_node.evodb = std::make_unique<CEvoDB>(util::DbWrapperParams{.path = m_node.args->GetDataDirNet(), .memory = true, .wipe = true});
-    m_node.mnhf_manager = std::make_unique<CMNHFManager>(*m_node.evodb);
 
     static bool noui_connected = false;
     if (!noui_connected) {
@@ -240,7 +239,6 @@ BasicTestingSetup::~BasicTestingSetup()
     fs::remove_all(m_path_root);
     gArgs.ClearArgs();
 
-    m_node.mnhf_manager.reset();
     m_node.evodb.reset();
     m_node.sporkman.reset();
     m_node.netfulfilledman.reset();
@@ -274,6 +272,7 @@ ChainTestingSetup::ChainTestingSetup(const std::string& chainName, const std::ve
     m_node.chainman = std::make_unique<ChainstateManager>(chainparams);
     m_node.chainman->m_blockman.m_block_tree_db = std::make_unique<CBlockTreeDB>(m_cache_sizes.block_tree_db, true);
 
+    m_node.mnhf_manager = std::make_unique<CMNHFManager>(*m_node.evodb, *m_node.chainman);
     m_node.mn_sync = std::make_unique<CMasternodeSync>(std::make_unique<NodeSyncNotifierImpl>(*m_node.connman, *m_node.netfulfilledman));
     m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.netfulfilledman, *m_node.chainman, m_node.dmnman, *m_node.mn_sync);
 
@@ -291,6 +290,7 @@ ChainTestingSetup::~ChainTestingSetup()
     GetMainSignals().UnregisterBackgroundSignalScheduler();
     m_node.govman.reset();
     m_node.mn_sync.reset();
+    m_node.mnhf_manager.reset();
     m_node.chainman.reset();
     m_node.mempool.reset();
     m_node.fee_estimator.reset();

Original file line number	Diff line number	Diff line change
`@@ -43,8 +43,9 @@ CMutableTransaction MNHFTxPayload::PrepareTx() const`
`43`	`43`	`return tx;`
`44`	`44`	`}`
`45`	`45`
`46`		`-CMNHFManager::CMNHFManager(CEvoDB& evoDb) :`
`47`		`- m_evoDb{evoDb}`
	`46`	`+CMNHFManager::CMNHFManager(CEvoDB& evoDb, const ChainstateManager& chainman) :`
	`47`	`+ m_evoDb(evoDb),`
	`48`	`+ m_chainman{chainman}`
`48`	`49`	`{`
`49`	`50`	`assert(globalInstance == nullptr);`
`50`	`51`	`globalInstance = this;`
`@@ -58,7 +59,7 @@ CMNHFManager::~CMNHFManager()`
`58`	`59`
`59`	`60`	`CMNHFManager::Signals CMNHFManager::GetSignalsStage(const CBlockIndex* const pindexPrev)`
`60`	`61`	`{`
`61`		`- if (!DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_V20)) return {};`
	`62`	`+ if (!DeploymentActiveAfter(pindexPrev, m_chainman.GetConsensus(), Consensus::DEPLOYMENT_V20)) return {};`
`62`	`63`
`63`	`64`	`Signals signals_tmp = GetForBlock(pindexPrev);`
`64`	`65`
`@@ -201,12 +202,11 @@ static bool extractSignals(const ChainstateManager& chainman, const llmq::CQuoru`
`201`	`202`
`202`	`203`	`std::optional<CMNHFManager::Signals> CMNHFManager::ProcessBlock(const CBlock& block, const CBlockIndex* const pindex, bool fJustCheck, BlockValidationState& state)`
`203`	`204`	`{`
`204`		`- auto chainman = Assert(m_chainman.load(std::memory_order_acquire));`
`205`	`205`	`auto qman = Assert(m_qman.load(std::memory_order_acquire));`
`206`	`206`
`207`	`207`	`try {`
`208`	`208`	`std::vector<uint8_t> new_signals;`
`209`		`- if (!extractSignals(chainman, qman, block, pindex, new_signals, state)) {`
	`209`	`+ if (!extractSignals(m_chainman, *qman, block, pindex, new_signals, state)) {`
`210`	`210`	`// state is set inside extractSignals`
`211`	`211`	`return std::nullopt;`
`212`	`212`	`}`
`@@ -253,12 +253,11 @@ std::optional<CMNHFManager::Signals> CMNHFManager::ProcessBlock(const CBlock& bl`
`253`	`253`
`254`	`254`	`bool CMNHFManager::UndoBlock(const CBlock& block, const CBlockIndex* const pindex)`
`255`	`255`	`{`
`256`		`- auto chainman = Assert(m_chainman.load(std::memory_order_acquire));`
`257`	`256`	`auto qman = Assert(m_qman.load(std::memory_order_acquire));`
`258`	`257`
`259`	`258`	`std::vector<uint8_t> excluded_signals;`
`260`	`259`	`BlockValidationState state;`
`261`		`- if (!extractSignals(chainman, qman, block, pindex, excluded_signals, state)) {`
	`260`	`+ if (!extractSignals(m_chainman, *qman, block, pindex, excluded_signals, state)) {`
`262`	`261`	`LogPrintf("CMNHFManager::%s: failed to extract signals\n", __func__);`
`263`	`262`	`return false;`
`264`	`263`	`}`
`@@ -330,7 +329,7 @@ std::optional<CMNHFManager::Signals> CMNHFManager::GetFromCache(const CBlockInde`
`330`	`329`	`}`
`331`	`330`	`{`
`332`	`331`	`LOCK(cs_cache);`
`333`		`- if (!DeploymentActiveAt(*pindex, Params().GetConsensus(), Consensus::DEPLOYMENT_V20)) {`
	`332`	`+ if (!DeploymentActiveAt(*pindex, m_chainman.GetConsensus(), Consensus::DEPLOYMENT_V20)) {`
`334`	`333`	`mnhfCache.insert(blockHash, signals);`
`335`	`334`	`return signals;`
`336`	`335`	`}`
`@@ -340,7 +339,7 @@ std::optional<CMNHFManager::Signals> CMNHFManager::GetFromCache(const CBlockInde`
`340`	`339`	`mnhfCache.insert(blockHash, signals);`
`341`	`340`	`return signals;`
`342`	`341`	`}`
`343`		`- if (!DeploymentActiveAt(*pindex, Params().GetConsensus(), Consensus::DEPLOYMENT_MN_RR)) {`
	`342`	`+ if (!DeploymentActiveAt(*pindex, m_chainman.GetConsensus(), Consensus::DEPLOYMENT_MN_RR)) {`
`344`	`343`	`// before mn_rr activation we are safe`
`345`	`344`	`if (m_evoDb.Read(std::make_pair(DB_SIGNALS, blockHash), signals)) {`
`346`	`345`	`LOCK(cs_cache);`
`@@ -359,7 +358,7 @@ void CMNHFManager::AddToCache(const Signals& signals, const CBlockIndex* const p`
`359`	`358`	`LOCK(cs_cache);`
`360`	`359`	`mnhfCache.insert(blockHash, signals);`
`361`	`360`	`}`
`362`		`- if (!DeploymentActiveAt(*pindex, Params().GetConsensus(), Consensus::DEPLOYMENT_V20)) return;`
	`361`	`+ if (!DeploymentActiveAt(*pindex, m_chainman.GetConsensus(), Consensus::DEPLOYMENT_V20)) return;`
`363`	`362`
`364`	`363`	`m_evoDb.Write(std::make_pair(DB_SIGNALS_v2, blockHash), signals);`
`365`	`364`	`}`
`@@ -371,31 +370,26 @@ void CMNHFManager::AddSignal(const CBlockIndex* const pindex, int bit)`
`371`	`370`	`AddToCache(signals, pindex);`
`372`	`371`	`}`
`373`	`372`
`374`		`-void CMNHFManager::ConnectManagers(gsl::not_null<ChainstateManager> chainman, gsl::not_null<llmq::CQuorumManager> qman)`
	`373`	`+void CMNHFManager::ConnectManagers(gsl::not_null<llmq::CQuorumManager*> qman)`
`375`	`374`	`{`
`376`	`375`	`// Do not allow double-initialization`
`377`		`- assert(m_chainman.load(std::memory_order_acquire) == nullptr);`
`378`		`- m_chainman.store(chainman, std::memory_order_release);`
`379`	`376`	`assert(m_qman.load(std::memory_order_acquire) == nullptr);`
`380`	`377`	`m_qman.store(qman, std::memory_order_release);`
`381`	`378`	`}`
`382`	`379`
`383`	`380`	`void CMNHFManager::DisconnectManagers()`
`384`	`381`	`{`
`385`		`- m_chainman.store(nullptr, std::memory_order_release);`
`386`	`382`	`m_qman.store(nullptr, std::memory_order_release);`
`387`	`383`	`}`
`388`	`384`
`389`	`385`	`bool CMNHFManager::ForceSignalDBUpdate()`
`390`	`386`	`{`
`391`		`- auto chainman = Assert(m_chainman.load(std::memory_order_acquire));`
`392`		`-`
`393`	`387`	`// force ehf signals db update`
`394`	`388`	`auto dbTx = m_evoDb.BeginTransaction();`
`395`	`389`
`396`	`390`	`const bool last_legacy = bls::bls_legacy_scheme.load();`
`397`	`391`	`bls::bls_legacy_scheme.store(false);`
`398`		`- GetSignalsStage(chainman->ActiveChainstate().m_chain.Tip());`
	`392`	`+ GetSignalsStage(m_chainman.ActiveTip());`
`399`	`393`	`bls::bls_legacy_scheme.store(last_legacy);`
`400`	`394`
`401`	`395`	`dbTx->Commit();`