refactor: remove CMasternodeSync global, move to NodeContext

Author: kwvg

src/coinjoin/client.cpp

@@ -1890,7 +1890,6 @@ void CCoinJoinClientManager::GetJsonInfo(UniValue& obj) const
 }
 
 void CoinJoinWalletManager::Add(CWallet& wallet) {
-    assert(::masternodeSync != nullptr);
     m_wallet_manager_map.try_emplace(
         wallet.GetName(),
         std::make_unique<CCoinJoinClientManager>(wallet, *this, m_dmnman, m_mn_sync, m_queueman)

src/evo/mnauth.cpp

@@ -61,11 +61,12 @@ void CMNAuth::PushMNAUTH(CNode& peer, CConnman& connman, const CBlockIndex* tip)
     connman.PushMessage(&peer, CNetMsgMaker(peer.GetCommonVersion()).Make(NetMsgType::MNAUTH, mnauth));
 }
 
-PeerMsgRet CMNAuth::ProcessMessage(CNode& peer, CConnman& connman, const CDeterministicMNList& tip_mn_list, std::string_view msg_type, CDataStream& vRecv)
+PeerMsgRet CMNAuth::ProcessMessage(CNode& peer, CConnman& connman, const CMasternodeSync& mn_sync,
+                                   const CDeterministicMNList& tip_mn_list, std::string_view msg_type, CDataStream& vRecv)
 {
     assert(::mmetaman->IsValid());
 
-    if (msg_type != NetMsgType::MNAUTH || !::masternodeSync->IsBlockchainSynced()) {
+    if (msg_type != NetMsgType::MNAUTH || !mn_sync.IsBlockchainSynced()) {
         // we can't verify MNAUTH messages when we don't have the latest MN list
         return {};
     }

src/evo/mnauth.h

@@ -16,6 +16,7 @@ class CDeterministicMN;
 class CDeterministicMNList;
 class CDeterministicMNListDiff;
 class CDeterministicMNManager;
+class CMasternodeSync;
 class CNode;
 
 class UniValue;
@@ -54,7 +55,8 @@ class CMNAuth
      * @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 CDeterministicMNList& tip_mn_list, std::string_view msg_type, CDataStream& vRecv);
+    static PeerMsgRet ProcessMessage(CNode& peer, CConnman& connman, 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

@@ -43,10 +43,13 @@ GovernanceStore::GovernanceStore() :
 {
 }
 
-CGovernanceManager::CGovernanceManager(CNetFulfilledRequestManager& netfulfilledman, const std::unique_ptr<CDeterministicMNManager>& dmnman) :
+CGovernanceManager::CGovernanceManager(CNetFulfilledRequestManager& netfulfilledman,
+                                       const std::unique_ptr<CDeterministicMNManager>& dmnman,
+                                       const std::unique_ptr<CMasternodeSync>& mn_sync) :
     m_db{std::make_unique<db_type>("governance.dat", "magicGovernanceCache")},
     m_netfulfilledman{netfulfilledman},
     m_dmnman{dmnman},
+    m_mn_sync{mn_sync},
     nTimeLastDiff(0),
     nCachedBlockHeight(0),
     setRequestedObjects(),
@@ -118,15 +121,15 @@ bool CGovernanceManager::SerializeVoteForHash(const uint256& nHash, CDataStream&
 PeerMsgRet CGovernanceManager::ProcessMessage(CNode& peer, CConnman& connman, std::string_view msg_type, CDataStream& vRecv)
 {
     if (fDisableGovernance) return {};
-    if (::masternodeSync == nullptr || !::masternodeSync->IsBlockchainSynced()) return {};
+    if (m_mn_sync == nullptr || !m_mn_sync->IsBlockchainSynced()) return {};
 
     const auto tip_mn_list = Assert(m_dmnman)->GetListAtChainTip();
     // ANOTHER USER IS ASKING US TO HELP THEM SYNC GOVERNANCE OBJECT DATA
     if (msg_type == NetMsgType::MNGOVERNANCESYNC) {
         // Ignore such requests until we are fully synced.
         // We could start processing this after masternode list is synced
         // but this is a heavy one so it's better to finish sync first.
-        if (!::masternodeSync->IsSynced()) return {};
+        if (!m_mn_sync->IsSynced()) return {};
 
         uint256 nProp;
         CBloomFilter filter;
@@ -157,7 +160,7 @@ PeerMsgRet CGovernanceManager::ProcessMessage(CNode& peer, CConnman& connman, st
             EraseObjectRequest(peer.GetId(), CInv(MSG_GOVERNANCE_OBJECT, nHash));
         }
 
-        if (!::masternodeSync->IsBlockchainSynced()) {
+        if (!m_mn_sync->IsBlockchainSynced()) {
             LogPrint(BCLog::GOBJECT, "MNGOVERNANCEOBJECT -- masternode list not synced\n");
             return {};
         }
@@ -225,7 +228,7 @@ PeerMsgRet CGovernanceManager::ProcessMessage(CNode& peer, CConnman& connman, st
         }
 
         // Ignore such messages until masternode list is synced
-        if (!::masternodeSync->IsBlockchainSynced()) {
+        if (!m_mn_sync->IsBlockchainSynced()) {
             LogPrint(BCLog::GOBJECT, "MNGOVERNANCEOBJECTVOTE -- masternode list not synced\n");
             return {};
         }
@@ -243,11 +246,11 @@ PeerMsgRet CGovernanceManager::ProcessMessage(CNode& peer, CConnman& connman, st
         CGovernanceException exception;
         if (ProcessVote(&peer, vote, exception, connman)) {
             LogPrint(BCLog::GOBJECT, "MNGOVERNANCEOBJECTVOTE -- %s new\n", strHash);
-            ::masternodeSync->BumpAssetLastTime("MNGOVERNANCEOBJECTVOTE");
-            vote.Relay(connman, tip_mn_list);
+            m_mn_sync->BumpAssetLastTime("MNGOVERNANCEOBJECTVOTE");
+            vote.Relay(connman, *m_mn_sync, tip_mn_list);
         } else {
             LogPrint(BCLog::GOBJECT, "MNGOVERNANCEOBJECTVOTE -- Rejected vote, error = %s\n", exception.what());
-            if ((exception.GetNodePenalty() != 0) && ::masternodeSync->IsSynced()) {
+            if ((exception.GetNodePenalty() != 0) && m_mn_sync->IsSynced()) {
                 return tl::unexpected{exception.GetNodePenalty()};
             }
             return {};
@@ -273,7 +276,7 @@ void CGovernanceManager::CheckOrphanVotes(CGovernanceObject& govobj, CConnman& c
         if (pairVote.second < nNow) {
             fRemove = true;
         } else if (govobj.ProcessVote(*this, tip_mn_list, vote, e)) {
-            vote.Relay(connman, tip_mn_list);
+            vote.Relay(connman, *Assert(m_mn_sync), tip_mn_list);
             fRemove = true;
         }
         if (fRemove) {
@@ -327,12 +330,12 @@ void CGovernanceManager::AddGovernanceObject(CGovernanceObject& govobj, CConnman
     }
 
     LogPrint(BCLog::GOBJECT, "CGovernanceManager::AddGovernanceObject -- %s new, received from peer %s\n", strHash, pfrom ? pfrom->GetLogString() : "nullptr");
-    govobj.Relay(connman);
+    govobj.Relay(connman, *Assert(m_mn_sync));
 
     // Update the rate buffer
     MasternodeRateUpdate(govobj);
 
-    ::masternodeSync->BumpAssetLastTime("CGovernanceManager::AddGovernanceObject");
+    m_mn_sync->BumpAssetLastTime("CGovernanceManager::AddGovernanceObject");
 
     // WE MIGHT HAVE PENDING/ORPHAN VOTES FOR THIS OBJECT
 
@@ -347,7 +350,7 @@ void CGovernanceManager::CheckAndRemove()
     assert(::mmetaman->IsValid());
 
     // Return on initial sync, spammed the debug.log and provided no use
-    if (::masternodeSync == nullptr || !::masternodeSync->IsBlockchainSynced()) return;
+    if (m_mn_sync == nullptr || !m_mn_sync->IsBlockchainSynced()) return;
 
     LogPrint(BCLog::GOBJECT, "CGovernanceManager::UpdateCachesAndClean\n");
 
@@ -562,7 +565,7 @@ struct sortProposalsByVotes {
 std::optional<const CSuperblock> CGovernanceManager::CreateSuperblockCandidate(int nHeight) const
 {
     if (!fMasternodeMode || fDisableGovernance) return std::nullopt;
-    if (::masternodeSync == nullptr || !::masternodeSync->IsSynced()) return std::nullopt;
+    if (m_mn_sync == nullptr || !m_mn_sync->IsSynced()) return std::nullopt;
     if (nHeight % Params().GetConsensus().nSuperblockCycle < Params().GetConsensus().nSuperblockCycle - Params().GetConsensus().nSuperblockMaturityWindow) return std::nullopt;
     if (HasAlreadyVotedFundingTrigger()) return std::nullopt;
 
@@ -788,7 +791,7 @@ void CGovernanceManager::ResetVotedFundingTrigger()
 void CGovernanceManager::DoMaintenance(CConnman& connman)
 {
     if (fDisableGovernance) return;
-    if (::masternodeSync == nullptr || !::masternodeSync->IsSynced()) return;
+    if (m_mn_sync == nullptr || !m_mn_sync->IsSynced()) return;
     if (ShutdownRequested()) return;
 
     // CHECK OBJECTS WE'VE ASKED FOR, REMOVE OLD ENTRIES
@@ -802,7 +805,7 @@ void CGovernanceManager::DoMaintenance(CConnman& connman)
 bool CGovernanceManager::ConfirmInventoryRequest(const CInv& inv)
 {
     // do not request objects until it's time to sync
-    if (!::masternodeSync->IsBlockchainSynced()) return false;
+    if (!Assert(m_mn_sync)->IsBlockchainSynced()) return false;
 
     LOCK(cs);
 
@@ -855,7 +858,7 @@ bool CGovernanceManager::ConfirmInventoryRequest(const CInv& inv)
 void CGovernanceManager::SyncSingleObjVotes(CNode& peer, const uint256& nProp, const CBloomFilter& filter, CConnman& connman)
 {
     // do not provide any data until our node is synced
-    if (!::masternodeSync->IsSynced()) return;
+    if (!Assert(m_mn_sync)->IsSynced()) return;
 
     int nVoteCount = 0;
 
@@ -907,7 +910,7 @@ PeerMsgRet CGovernanceManager::SyncObjects(CNode& peer, CConnman& connman) const
     assert(m_netfulfilledman.IsValid());
 
     // do not provide any data until our node is synced
-    if (!::masternodeSync->IsSynced()) return {};
+    if (!Assert(m_mn_sync)->IsSynced()) return {};
 
     if (m_netfulfilledman.HasFulfilledRequest(peer.addr, NetMsgType::MNGOVERNANCESYNC)) {
         // Asking for the whole list multiple times in a short period of time is no good
@@ -997,7 +1000,7 @@ bool CGovernanceManager::MasternodeRateCheck(const CGovernanceObject& govobj, bo
 
     fRateCheckBypassed = false;
 
-    if (!::masternodeSync->IsSynced() || !fRateChecksEnabled) {
+    if (!Assert(m_mn_sync)->IsSynced() || !fRateChecksEnabled) {
         return true;
     }
 
@@ -1055,6 +1058,15 @@ bool CGovernanceManager::MasternodeRateCheck(const CGovernanceObject& govobj, bo
     return false;
 }
 
+bool CGovernanceManager::ProcessVoteAndRelay(const CGovernanceVote& vote, CGovernanceException& exception, CConnman& connman)
+{
+    bool fOK = ProcessVote(/* pfrom = */ nullptr, vote, exception, connman);
+    if (fOK) {
+        vote.Relay(connman, *Assert(m_mn_sync), Assert(m_dmnman)->GetListAtChainTip());
+    }
+    return fOK;
+}
+
 bool CGovernanceManager::ProcessVote(CNode* pfrom, const CGovernanceVote& vote, CGovernanceException& exception, CConnman& connman)
 {
     ENTER_CRITICAL_SECTION(cs);
@@ -1111,7 +1123,7 @@ bool CGovernanceManager::ProcessVote(CNode* pfrom, const CGovernanceVote& vote,
 
 void CGovernanceManager::CheckPostponedObjects(CConnman& connman)
 {
-    if (!::masternodeSync->IsSynced()) return;
+    if (!Assert(m_mn_sync)->IsSynced()) return;
 
     LOCK2(cs_main, cs);
 
@@ -1159,7 +1171,7 @@ void CGovernanceManager::CheckPostponedObjects(CConnman& connman)
             if (fValid) {
                 if (fReady) {
                     LogPrint(BCLog::GOBJECT, "CGovernanceManager::CheckPostponedObjects -- additional relay: hash = %s\n", govobj.GetHash().ToString());
-                    govobj.Relay(connman);
+                    govobj.Relay(connman, *m_mn_sync);
                 } else {
                     it++;
                     continue;
@@ -1530,7 +1542,7 @@ void CGovernanceManager::CleanOrphanObjects()
 
 void CGovernanceManager::RemoveInvalidVotes()
 {
-    if (!::masternodeSync->IsSynced()) {
+    if (!Assert(m_mn_sync)->IsSynced()) {
         return;
     }
 

src/governance/governance.h

@@ -5,7 +5,6 @@
 #ifndef BITCOIN_GOVERNANCE_GOVERNANCE_H
 #define BITCOIN_GOVERNANCE_GOVERNANCE_H
 
-#include <evo/deterministicmns.h>
 #include <governance/classes.h>
 #include <governance/object.h>
 
@@ -26,6 +25,7 @@ class CDeterministicMNManager;
 class CGovernanceManager;
 class CGovernanceObject;
 class CGovernanceVote;
+class CMasternodeSync;
 class CNetFulfilledRequestManager;
 class CSporkManager;
 
@@ -257,6 +257,7 @@ class CGovernanceManager : public GovernanceStore
 
     CNetFulfilledRequestManager& m_netfulfilledman;
     const std::unique_ptr<CDeterministicMNManager>& m_dmnman;
+    const std::unique_ptr<CMasternodeSync>& m_mn_sync;
 
     int64_t nTimeLastDiff;
     // keep track of current block height
@@ -270,7 +271,9 @@ class CGovernanceManager : public GovernanceStore
     std::map<uint256, std::shared_ptr<CSuperblock>> mapTrigger;
 
 public:
-    explicit CGovernanceManager(CNetFulfilledRequestManager& netfulfilledman, const std::unique_ptr<CDeterministicMNManager>& dmnman);
+    explicit CGovernanceManager(CNetFulfilledRequestManager& netfulfilledman,
+                                const std::unique_ptr<CDeterministicMNManager>& dmnman,
+                                const std::unique_ptr<CMasternodeSync>& mn_sync);
     ~CGovernanceManager();
 
     bool LoadCache(bool load_cache);
@@ -337,14 +340,7 @@ class CGovernanceManager : public GovernanceStore
 
     bool MasternodeRateCheck(const CGovernanceObject& govobj, bool fUpdateFailStatus, bool fForce, bool& fRateCheckBypassed);
 
-    bool ProcessVoteAndRelay(const CGovernanceVote& vote, CGovernanceException& exception, CConnman& connman)
-    {
-        bool fOK = ProcessVote(nullptr, vote, exception, connman);
-        if (fOK) {
-            vote.Relay(connman, Assert(m_dmnman)->GetListAtChainTip());
-        }
-        return fOK;
-    }
+    bool ProcessVoteAndRelay(const CGovernanceVote& vote, CGovernanceException& exception, CConnman& connman);
 
     void CheckPostponedObjects(CConnman& connman);
 

src/governance/object.cpp

@@ -628,10 +628,10 @@ bool CGovernanceObject::GetCurrentMNVotes(const COutPoint& mnCollateralOutpoint,
     return true;
 }
 
-void CGovernanceObject::Relay(CConnman& connman) const
+void CGovernanceObject::Relay(CConnman& connman, const CMasternodeSync& mn_sync) const
 {
     // Do not relay until fully synced
-    if (!::masternodeSync->IsSynced()) {
+    if (!mn_sync.IsSynced()) {
         LogPrint(BCLog::GOBJECT, "CGovernanceObject::Relay -- won't relay until fully synced\n");
         return;
     }

src/governance/object.h

@@ -19,6 +19,7 @@ class CDeterministicMNList;
 class CGovernanceManager;
 class CGovernanceObject;
 class CGovernanceVote;
+class CMasternodeSync;
 class CNode;
 
 extern RecursiveMutex cs_main;
@@ -247,7 +248,7 @@ class CGovernanceObject
 
     UniValue GetJSONObject() const;
 
-    void Relay(CConnman& connman) const;
+    void Relay(CConnman& connman, const CMasternodeSync& mn_sync) const;
 
     uint256 GetHash() const;
     uint256 GetDataHash() const;

src/governance/vote.cpp

@@ -122,10 +122,10 @@ std::string CGovernanceVote::ToString(const CDeterministicMNList& tip_mn_list) c
     return ostr.str();
 }
 
-void CGovernanceVote::Relay(CConnman& connman, const CDeterministicMNList& tip_mn_list) const
+void CGovernanceVote::Relay(CConnman& connman, const CMasternodeSync& mn_sync, const CDeterministicMNList& tip_mn_list) const
 {
     // Do not relay until fully synced
-    if (!::masternodeSync->IsSynced()) {
+    if (!mn_sync.IsSynced()) {
         LogPrint(BCLog::GOBJECT, "CGovernanceVote::Relay -- won't relay until fully synced\n");
         return;
     }

src/governance/vote.h

@@ -13,6 +13,7 @@ class CBLSPublicKey;
 class CConnman;
 class CDeterministicMNList;
 class CGovernanceVote;
+class CMasternodeSync;
 class CKey;
 class CKeyID;
 
@@ -104,7 +105,7 @@ class CGovernanceVote
     bool Sign(const CActiveMasternodeManager& mn_activeman);
     bool CheckSignature(const CBLSPublicKey& pubKey) const;
     bool IsValid(const CDeterministicMNList& tip_mn_list, bool useVotingKey) const;
-    void Relay(CConnman& connman, const CDeterministicMNList& tip_mn_list) const;
+    void Relay(CConnman& connman, const CMasternodeSync& mn_sync, const CDeterministicMNList& tip_mn_list) const;
 
     const COutPoint& GetMasternodeOutpoint() const { return masternodeOutpoint; }
 

src/init.cpp

@@ -305,8 +305,7 @@ void PrepareShutdown(NodeContext& node)
 
     // After all scheduled tasks have been flushed, destroy pointers
     // and reset all to nullptr.
-    node.mn_sync = nullptr;
-    ::masternodeSync.reset();
+    node.mn_sync.reset();
     node.sporkman.reset();
     node.govman.reset();
     node.netfulfilledman.reset();
@@ -1687,7 +1686,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
     node.netfulfilledman = std::make_unique<CNetFulfilledRequestManager>();
 
     assert(!node.govman);
-    node.govman = std::make_unique<CGovernanceManager>(*node.netfulfilledman, ::deterministicMNManager);
+    node.govman = std::make_unique<CGovernanceManager>(*node.netfulfilledman, ::deterministicMNManager, node.mn_sync);
 
     assert(!node.sporkman);
     node.sporkman = std::make_unique<CSporkManager>();
@@ -1716,9 +1715,8 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
         }
     }
 
-    assert(!::masternodeSync);
-    ::masternodeSync = std::make_unique<CMasternodeSync>(*node.connman, *node.netfulfilledman, *node.govman);
-    node.mn_sync = ::masternodeSync.get();
+    assert(!node.mn_sync);
+    node.mn_sync = std::make_unique<CMasternodeSync>(*node.connman, *node.netfulfilledman, *node.govman);
 
     fMasternodeMode = false;
     std::string strMasterNodeBLSPrivKey = args.GetArg("-masternodeblsprivkey", "");
@@ -1962,7 +1960,8 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
                     node.llmq_ctx->Stop();
                 }
                 node.llmq_ctx.reset();
-                node.llmq_ctx.reset(new LLMQContext(chainman.ActiveChainstate(), *node.connman, *node.dmnman, *node.evodb, *node.mnhf_manager, *node.sporkman, *node.mempool, node.mn_activeman, node.peerman, false, fReset || fReindexChainState));
+                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);
                 // Have to start it early to let VerifyDB check ChainLock signatures in coinbase
                 node.llmq_ctx->Start();