refactor: accept ChainstateManager in CMNHFManager ctor

The `ConnectManager` approach is no longer needed.

Author: kwvg

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;
@@ -198,12 +199,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;
         }
@@ -250,12 +250,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;
     }
@@ -369,31 +368,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();

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.

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

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