refactor: remove CActiveMasternodeManager global, move to NodeContext

Author: kwvg

src/dsnotificationinterface.cpp

@@ -26,12 +26,14 @@
 CDSNotificationInterface::CDSNotificationInterface(CConnman& connman,
                                                    CMasternodeSync& mn_sync,
                                                    CGovernanceManager& govman,
+                                                   const CActiveMasternodeManager* const mn_activeman,
                                                    const std::unique_ptr<CDeterministicMNManager>& dmnman,
                                                    const std::unique_ptr<LLMQContext>& llmq_ctx,
                                                    const std::unique_ptr<CJContext>& cj_ctx)
   : m_connman(connman),
     m_mn_sync(mn_sync),
     m_govman(govman),
+    m_mn_activeman(mn_activeman),
     m_dmnman(dmnman),
     m_llmq_ctx(llmq_ctx),
     m_cj_ctx(cj_ctx) {}
@@ -94,7 +96,7 @@ void CDSNotificationInterface::UpdatedBlockTip(const CBlockIndex *pindexNew, con
     m_llmq_ctx->qdkgsman->UpdatedBlockTip(pindexNew, fInitialDownload);
     m_llmq_ctx->ehfSignalsHandler->UpdatedBlockTip(pindexNew);
 
-    if (!fDisableGovernance) m_govman.UpdatedBlockTip(pindexNew, m_connman);
+    if (!fDisableGovernance) m_govman.UpdatedBlockTip(pindexNew, m_connman, m_mn_activeman);
 }
 
 void CDSNotificationInterface::TransactionAddedToMempool(const CTransactionRef& ptx, int64_t nAcceptTime)

src/dsnotificationinterface.h

@@ -7,6 +7,7 @@
 
 #include <validationinterface.h>
 
+class CActiveMasternodeManager;
 class CConnman;
 class CDeterministicMNManager;
 class CGovernanceManager;
@@ -20,6 +21,7 @@ class CDSNotificationInterface : public CValidationInterface
     explicit CDSNotificationInterface(CConnman& connman,
                                       CMasternodeSync& mn_sync,
                                       CGovernanceManager& govman,
+                                      const CActiveMasternodeManager* const mn_activeman,
                                       const std::unique_ptr<CDeterministicMNManager>& dmnman,
                                       const std::unique_ptr<LLMQContext>& llmq_ctx,
                                       const std::unique_ptr<CJContext>& cj_ctx);
@@ -47,6 +49,7 @@ class CDSNotificationInterface : public CValidationInterface
     CMasternodeSync& m_mn_sync;
     CGovernanceManager& m_govman;
 
+    const CActiveMasternodeManager* const m_mn_activeman;
     const std::unique_ptr<CDeterministicMNManager>& m_dmnman;
     const std::unique_ptr<LLMQContext>& m_llmq_ctx;
     const std::unique_ptr<CJContext>& m_cj_ctx;

src/evo/mnauth.cpp

@@ -19,12 +19,13 @@
 #include <util/time.h>
 #include <validation.h>
 
-void CMNAuth::PushMNAUTH(CNode& peer, CConnman& connman, const CBlockIndex* tip)
+void CMNAuth::PushMNAUTH(CNode& peer, CConnman& connman, const CActiveMasternodeManager& mn_activeman,
+                         const CBlockIndex* tip)
 {
-    if (!fMasternodeMode) return;
+    assert(fMasternodeMode);
 
     CMNAuth mnauth;
-    if (::activeMasternodeManager->GetProTxHash().IsNull()) {
+    if (mn_activeman.GetProTxHash().IsNull()) {
         return;
     }
 
@@ -43,7 +44,7 @@ void CMNAuth::PushMNAUTH(CNode& peer, CConnman& connman, const CBlockIndex* tip)
         nOurNodeVersion = gArgs.GetArg("-pushversion", PROTOCOL_VERSION);
     }
     const bool is_basic_scheme_active{DeploymentActiveAfter(tip, Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
-    auto pk = ::activeMasternodeManager->GetPubKey();
+    auto pk = mn_activeman.GetPubKey();
     const CBLSPublicKeyVersionWrapper pubKey(pk, !is_basic_scheme_active);
     uint256 signHash = [&]() {
         if (peer.nVersion < MNAUTH_NODE_VER_VERSION || nOurNodeVersion < MNAUTH_NODE_VER_VERSION) {
@@ -53,15 +54,15 @@ void CMNAuth::PushMNAUTH(CNode& peer, CConnman& connman, const CBlockIndex* tip)
         }
     }();
 
-    mnauth.proRegTxHash = ::activeMasternodeManager->GetProTxHash();
+    mnauth.proRegTxHash = mn_activeman.GetProTxHash();
 
-    mnauth.sig = ::activeMasternodeManager->Sign(signHash);
+    mnauth.sig = mn_activeman.Sign(signHash);
 
     LogPrint(BCLog::NET_NETCONN, "CMNAuth::%s -- Sending MNAUTH, peer=%d\n", __func__, peer.GetId());
     connman.PushMessage(&peer, CNetMsgMaker(peer.GetCommonVersion()).Make(NetMsgType::MNAUTH, mnauth));
 }
 
-PeerMsgRet CMNAuth::ProcessMessage(CNode& peer, CConnman& connman, const CMasternodeSync& mn_sync,
+PeerMsgRet CMNAuth::ProcessMessage(CNode& peer, CConnman& connman, const CActiveMasternodeManager* const mn_activeman, const CMasternodeSync& mn_sync,
                                    const CDeterministicMNList& tip_mn_list, std::string_view msg_type, CDataStream& vRecv)
 {
     assert(::mmetaman->IsValid());
@@ -134,7 +135,7 @@ PeerMsgRet CMNAuth::ProcessMessage(CNode& peer, CConnman& connman, const CMaster
     }
 
     const uint256 myProTxHash = fMasternodeMode ?
-                                ::activeMasternodeManager->GetProTxHash() :
+                                Assert(mn_activeman)->GetProTxHash() :
                                 uint256();
 
     connman.ForEachNode([&](CNode* pnode2) {

src/evo/mnauth.h

@@ -9,6 +9,7 @@
 #include <net_types.h>
 #include <serialize.h>
 
+class CActiveMasternodeManager;
 class CBlockIndex;
 class CConnman;
 class CDataStream;
@@ -49,13 +50,14 @@ class CMNAuth
         READWRITE(obj.proRegTxHash, obj.sig);
     }
 
-    static void PushMNAUTH(CNode& peer, CConnman& connman, const CBlockIndex* tip);
+    static void PushMNAUTH(CNode& peer, CConnman& connman, const CActiveMasternodeManager& mn_activeman,
+                           const CBlockIndex* tip);
 
     /**
      * @pre CMasternodeMetaMan's database must be successfully loaded before
      *      attempting to call this function regardless of sync state
      */
-    static PeerMsgRet ProcessMessage(CNode& peer, CConnman& connman, const CMasternodeSync& mn_sync,
+    static PeerMsgRet ProcessMessage(CNode& peer, CConnman& connman, const CActiveMasternodeManager* const mn_activeman, const CMasternodeSync& mn_sync,
                                      const CDeterministicMNList& tip_mn_list, std::string_view msg_type, CDataStream& vRecv);
     static void NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff, CConnman& connman);
 };

src/governance/governance.cpp

@@ -671,8 +671,11 @@ std::optional<const CSuperblock> CGovernanceManager::CreateSuperblockCandidate(i
     return CSuperblock(nNextSuperblock, std::move(payments));
 }
 
-std::optional<const CGovernanceObject> CGovernanceManager::CreateGovernanceTrigger(const std::optional<const CSuperblock>& sb_opt, CConnman& connman)
+std::optional<const CGovernanceObject> CGovernanceManager::CreateGovernanceTrigger(const std::optional<const CSuperblock>& sb_opt, CConnman& connman,
+                                                                                   const CActiveMasternodeManager* const mn_activeman)
 {
+    if (!fMasternodeMode) return std::nullopt;
+
     // no sb_opt, no trigger
     if (!sb_opt.has_value()) return std::nullopt;
 
@@ -696,12 +699,12 @@ std::optional<const CGovernanceObject> CGovernanceManager::CreateGovernanceTrigg
         return std::nullopt;
     }
 
-    if (mn_payees.front()->proTxHash != ::activeMasternodeManager->GetProTxHash()) {
+    if (mn_payees.front()->proTxHash != Assert(mn_activeman)->GetProTxHash()) {
         LogPrint(BCLog::GOBJECT, "CGovernanceManager::%s we are not the payee, skipping\n", __func__);
         return std::nullopt;
     }
-    gov_sb.SetMasternodeOutpoint(::activeMasternodeManager->GetOutPoint());
-    gov_sb.Sign(*::activeMasternodeManager);
+    gov_sb.SetMasternodeOutpoint(mn_activeman->GetOutPoint());
+    gov_sb.Sign(*mn_activeman);
 
     if (std::string strError; !gov_sb.IsValidLocally(m_dmnman->GetListAtChainTip(), strError, true)) {
         LogPrint(BCLog::GOBJECT, "CGovernanceManager::%s Created trigger is invalid:%s\n", __func__, strError);
@@ -718,11 +721,12 @@ std::optional<const CGovernanceObject> CGovernanceManager::CreateGovernanceTrigg
     return std::make_optional<CGovernanceObject>(gov_sb);
 }
 
-void CGovernanceManager::VoteGovernanceTriggers(const std::optional<const CGovernanceObject>& trigger_opt, CConnman& connman)
+void CGovernanceManager::VoteGovernanceTriggers(const std::optional<const CGovernanceObject>& trigger_opt, CConnman& connman,
+                                                const CActiveMasternodeManager* const mn_activeman)
 {
     // only active masternodes can vote on triggers
     if (!fMasternodeMode) return;
-    if (::activeMasternodeManager->GetProTxHash().IsNull()) return;
+    if (Assert(mn_activeman)->GetProTxHash().IsNull()) return;
 
     LOCK2(cs_main, cs);
 
@@ -731,7 +735,7 @@ void CGovernanceManager::VoteGovernanceTriggers(const std::optional<const CGover
         assert(!votedFundingYesTriggerHash.has_value());
         // Vote YES-FUNDING for the trigger we like
         const uint256 gov_sb_hash = trigger_opt.value().GetHash();
-        if (!VoteFundingTrigger(gov_sb_hash, VOTE_OUTCOME_YES, connman)) {
+        if (!VoteFundingTrigger(gov_sb_hash, VOTE_OUTCOME_YES, connman, mn_activeman)) {
             LogPrint(BCLog::GOBJECT, "CGovernanceManager::%s Voting YES-FUNDING for new trigger:%s failed\n", __func__, gov_sb_hash.ToString());
             // this should never happen, bail out
             return;
@@ -754,7 +758,7 @@ void CGovernanceManager::VoteGovernanceTriggers(const std::optional<const CGover
             LogPrint(BCLog::GOBJECT, "CGovernanceManager::%s Not voting NO-FUNDING for trigger:%s, we voted yes for it already\n", __func__, trigger_hash.ToString());
             continue;
         }
-        if (!VoteFundingTrigger(trigger_hash, VOTE_OUTCOME_NO, connman)) {
+        if (!VoteFundingTrigger(trigger_hash, VOTE_OUTCOME_NO, connman, mn_activeman)) {
             LogPrint(BCLog::GOBJECT, "CGovernanceManager::%s Voting NO-FUNDING for trigger:%s failed\n", __func__, trigger_hash.ToString());
             // failing here is ok-ish
             continue;
@@ -763,11 +767,14 @@ void CGovernanceManager::VoteGovernanceTriggers(const std::optional<const CGover
     }
 }
 
-bool CGovernanceManager::VoteFundingTrigger(const uint256& nHash, const vote_outcome_enum_t outcome, CConnman& connman)
+bool CGovernanceManager::VoteFundingTrigger(const uint256& nHash, const vote_outcome_enum_t outcome, CConnman& connman,
+                                            const CActiveMasternodeManager* const mn_activeman)
 {
-    CGovernanceVote vote(::activeMasternodeManager->GetOutPoint(), nHash, VOTE_SIGNAL_FUNDING, outcome);
+    if (!fMasternodeMode) return false;
+
+    CGovernanceVote vote(Assert(mn_activeman)->GetOutPoint(), nHash, VOTE_SIGNAL_FUNDING, outcome);
     vote.SetTime(GetAdjustedTime());
-    vote.Sign(*::activeMasternodeManager);
+    vote.Sign(*mn_activeman);
 
     CGovernanceException exception;
     if (!ProcessVoteAndRelay(vote, exception, connman)) {
@@ -1466,7 +1473,7 @@ UniValue CGovernanceManager::ToJson() const
     return jsonObj;
 }
 
-void CGovernanceManager::UpdatedBlockTip(const CBlockIndex* pindex, CConnman& connman)
+void CGovernanceManager::UpdatedBlockTip(const CBlockIndex* pindex, CConnman& connman, const CActiveMasternodeManager* const mn_activeman)
 {
     // Note this gets called from ActivateBestChain without cs_main being held
     // so it should be safe to lock our mutex here without risking a deadlock
@@ -1478,8 +1485,8 @@ void CGovernanceManager::UpdatedBlockTip(const CBlockIndex* pindex, CConnman& co
     }
 
     const auto sb_opt = CreateSuperblockCandidate(pindex->nHeight);
-    const auto trigger_opt = CreateGovernanceTrigger(sb_opt, connman);
-    VoteGovernanceTriggers(trigger_opt, connman);
+    const auto trigger_opt = CreateGovernanceTrigger(sb_opt, connman, mn_activeman);
+    VoteGovernanceTriggers(trigger_opt, connman, mn_activeman);
 
     nCachedBlockHeight = pindex->nHeight;
     LogPrint(BCLog::GOBJECT, "CGovernanceManager::UpdatedBlockTip -- nCachedBlockHeight: %d\n", nCachedBlockHeight);

src/governance/governance.h

@@ -311,7 +311,7 @@ class CGovernanceManager : public GovernanceStore
 
     UniValue ToJson() const;
 
-    void UpdatedBlockTip(const CBlockIndex* pindex, CConnman& connman);
+    void UpdatedBlockTip(const CBlockIndex* pindex, CConnman& connman, const CActiveMasternodeManager* const mn_activeman);
     int64_t GetLastDiffTime() const { return nTimeLastDiff; }
     void UpdateLastDiffTime(int64_t nTimeIn) { nTimeLastDiff = nTimeIn; }
 
@@ -366,9 +366,12 @@ class CGovernanceManager : public GovernanceStore
 
 private:
     std::optional<const CSuperblock> CreateSuperblockCandidate(int nHeight) const;
-    std::optional<const CGovernanceObject> CreateGovernanceTrigger(const std::optional<const CSuperblock>& sb_opt, CConnman& connman);
-    void VoteGovernanceTriggers(const std::optional<const CGovernanceObject>& trigger_opt, CConnman& connman);
-    bool VoteFundingTrigger(const uint256& nHash, const vote_outcome_enum_t outcome, CConnman& connman);
+    std::optional<const CGovernanceObject> CreateGovernanceTrigger(const std::optional<const CSuperblock>& sb_opt, CConnman& connman,
+                                                                   const CActiveMasternodeManager* const mn_activeman);
+    void VoteGovernanceTriggers(const std::optional<const CGovernanceObject>& trigger_opt, CConnman& connman,
+                                const CActiveMasternodeManager* const mn_activeman);
+    bool VoteFundingTrigger(const uint256& nHash, const vote_outcome_enum_t outcome, CConnman& connman,
+                            const CActiveMasternodeManager* const mn_activeman);
     bool HasAlreadyVotedFundingTrigger() const;
 
     void RequestGovernanceObject(CNode* pfrom, const uint256& nHash, CConnman& connman, bool fUseFilter = false) const;

src/init.cpp

@@ -368,9 +368,8 @@ void PrepareShutdown(NodeContext& node)
         pdsNotificationInterface = nullptr;
     }
     if (fMasternodeMode) {
-        UnregisterValidationInterface(node.mn_activeman);
-        node.mn_activeman = nullptr;
-        ::activeMasternodeManager.reset();
+        UnregisterValidationInterface(node.mn_activeman.get());
+        node.mn_activeman.reset();
     }
 
     node.chain_clients.clear();
@@ -1727,17 +1726,16 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
         }
         fMasternodeMode = true;
         {
-            // Create and register activeMasternodeManager, will init later in ThreadImport
-            ::activeMasternodeManager = std::make_unique<CActiveMasternodeManager>(keyOperator, *node.connman, ::deterministicMNManager);
-            node.mn_activeman = ::activeMasternodeManager.get();
-            RegisterValidationInterface(node.mn_activeman);
+            // Create and register mn_activeman, will init later in ThreadImport
+            node.mn_activeman = std::make_unique<CActiveMasternodeManager>(keyOperator, *node.connman, ::deterministicMNManager);
+            RegisterValidationInterface(node.mn_activeman.get());
         }
     }
 
     assert(!node.peerman);
     node.peerman = PeerManager::make(chainparams, *node.connman, *node.addrman, node.banman.get(),
                                      *node.scheduler, chainman, *node.mempool, *node.mn_metaman, *node.mn_sync,
-                                     *node.govman, *node.sporkman, ::deterministicMNManager,
+                                     *node.govman, *node.sporkman, node.mn_activeman.get(), ::deterministicMNManager,
                                      node.cj_ctx, node.llmq_ctx, ignores_incoming_txs);
     RegisterValidationInterface(node.peerman.get());
 
@@ -1862,7 +1860,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
 #endif
 
     pdsNotificationInterface = new CDSNotificationInterface(
-        *node.connman, *node.mn_sync, *node.govman, ::deterministicMNManager, node.llmq_ctx, node.cj_ctx
+        *node.connman, *node.mn_sync, *node.govman, node.mn_activeman.get(), ::deterministicMNManager, node.llmq_ctx, node.cj_ctx
     );
     RegisterValidationInterface(pdsNotificationInterface);
 
@@ -1961,7 +1959,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
                 }
                 node.llmq_ctx.reset();
                 node.llmq_ctx = std::make_unique<LLMQContext>(chainman.ActiveChainstate(), *node.connman, *node.dmnman, *node.evodb, *node.mnhf_manager, *node.sporkman,
-                                                              *node.mempool, node.mn_activeman, *node.mn_sync, node.peerman, /* unit_tests = */ false, /* wipe = */ fReset || fReindexChainState);
+                                                              *node.mempool, node.mn_activeman.get(), *node.mn_sync, node.peerman, /* unit_tests = */ false, /* wipe = */ fReset || fReindexChainState);
                 // Have to start it early to let VerifyDB check ChainLock signatures in coinbase
                 node.llmq_ctx->Start();
 
@@ -2206,7 +2204,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
 
     // ********************************************************* Step 7c: Setup CoinJoin
 
-    node.cj_ctx = std::make_unique<CJContext>(chainman.ActiveChainstate(), *node.connman, *node.dmnman, *node.mempool, node.mn_activeman,
+    node.cj_ctx = std::make_unique<CJContext>(chainman.ActiveChainstate(), *node.connman, *node.dmnman, *node.mempool, node.mn_activeman.get(),
                                               *node.mn_sync, !ignores_incoming_txs);
 
 #ifdef ENABLE_WALLET
@@ -2379,7 +2377,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
     }
 
     chainman.m_load_block = std::thread(&util::TraceThread, "loadblk", [=, &args, &chainman, &node] {
-        ThreadImport(chainman, *node.dmnman, *pdsNotificationInterface, vImportFiles, args);
+        ThreadImport(chainman, *node.dmnman, *pdsNotificationInterface, vImportFiles, node.mn_activeman.get(), args);
     });
 
     // Wait for genesis block to be processed

src/masternode/node.cpp

@@ -15,9 +15,6 @@
 #include <validation.h>
 #include <warnings.h>
 
-// Keep track of the active Masternode
-std::unique_ptr<CActiveMasternodeManager> activeMasternodeManager;
-
 CActiveMasternodeManager::CActiveMasternodeManager(const CBLSSecretKey& sk, CConnman& connman, const std::unique_ptr<CDeterministicMNManager>& dmnman) :
     m_info(sk, sk.GetPublicKey()),
     m_connman{connman},

src/masternode/node.h

@@ -80,6 +80,4 @@ class CActiveMasternodeManager final : public CValidationInterface
     bool GetLocalAddress(CService& addrRet) EXCLUSIVE_LOCKS_REQUIRED(cs);
 };
 
-extern std::unique_ptr<CActiveMasternodeManager> activeMasternodeManager;
-
 #endif // BITCOIN_MASTERNODE_NODE_H