refactor: remove dependencies of CChainState on CMasternodeSync

src/evo/chainhelper.cpp

@@ -17,14 +17,13 @@
 CChainstateHelper::CChainstateHelper(CEvoDB& evodb, CDeterministicMNManager& dmnman, CGovernanceManager& govman,
                                      llmq::CInstantSendManager& isman, llmq::CQuorumBlockProcessor& qblockman,
                                      llmq::CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
-                                     const Consensus::Params& consensus_params, const CMasternodeSync& mn_sync,
-                                     const CSporkManager& sporkman, const chainlock::Chainlocks& chainlocks,
-                                     const llmq::CQuorumManager& qman) :
+                                     const Consensus::Params& consensus_params, const CSporkManager& sporkman,
+                                     const chainlock::Chainlocks& chainlocks, const llmq::CQuorumManager& qman) :
     isman{isman},
     credit_pool_manager{std::make_unique<CCreditPoolManager>(evodb, chainman)},
     m_chainlocks{chainlocks},
     ehf_manager{std::make_unique<CMNHFManager>(evodb, chainman, qman)},
-    mn_payments{std::make_unique<CMNPaymentsProcessor>(dmnman, govman, chainman, consensus_params, mn_sync, sporkman)},
+    mn_payments{std::make_unique<CMNPaymentsProcessor>(dmnman, govman, chainman, consensus_params, sporkman)},
     special_tx{std::make_unique<CSpecialTxProcessor>(*credit_pool_manager, dmnman, *ehf_manager, qblockman, qsnapman,
                                                      chainman, consensus_params, chainlocks, qman)}
 {}

src/evo/chainhelper.h

@@ -15,7 +15,6 @@ class CDeterministicMNManager;
 class CEvoDB;
 class CGovernanceManager;
 class ChainstateManager;
-class CMasternodeSync;
 class CMNHFManager;
 class CMNPaymentsProcessor;
 class CSpecialTxProcessor;
@@ -60,9 +59,8 @@ class CChainstateHelper
     explicit CChainstateHelper(CEvoDB& evodb, CDeterministicMNManager& dmnman, CGovernanceManager& govman,
                                llmq::CInstantSendManager& isman, llmq::CQuorumBlockProcessor& qblockman,
                                llmq::CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
-                               const Consensus::Params& consensus_params, const CMasternodeSync& mn_sync,
-                               const CSporkManager& sporkman, const chainlock::Chainlocks& chainlocks,
-                               const llmq::CQuorumManager& qman);
+                               const Consensus::Params& consensus_params, const CSporkManager& sporkman,
+                               const chainlock::Chainlocks& chainlocks, const llmq::CQuorumManager& qman);
     ~CChainstateHelper();
 
     /** Passthrough functions to chainlock::Chainlocks */

src/governance/governance.cpp

@@ -96,6 +96,8 @@ bool CGovernanceManager::LoadCache(bool load_cache)
     return is_valid;
 }
 
+bool CGovernanceManager::IsValidAndSynced() const { return is_valid && m_mn_sync.IsSynced(); }
+
 void CGovernanceManager::RelayObject(const CGovernanceObject& obj)
 {
     AssertLockNotHeld(cs_relay);

src/governance/governance.h

@@ -273,6 +273,7 @@ class CGovernanceManager : public GovernanceStore, public GovernanceSignerParent
 
     // Basic initialization and querying
     bool IsValid() const override { return is_valid; }
+    bool IsValidAndSynced() const;
     bool LoadCache(bool load_cache)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_store);
     [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);

src/init.cpp

@@ -1992,7 +1992,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
                                               chainman,
                                               *node.govman,
                                               *node.mn_metaman,
-                                              *node.mn_sync,
                                               *node.sporkman,
                                               *node.chainlocks,
                                               node.chain_helper,

src/instantsend/instantsend.cpp

@@ -6,7 +6,6 @@
 
 #include <chainparams.h>
 #include <consensus/validation.h>
-#include <masternode/sync.h>
 #include <node/blockstorage.h>
 #include <spork.h>
 #include <stats/client.h>
@@ -15,11 +14,9 @@ using node::fImporting;
 using node::fReindex;
 
 namespace llmq {
-CInstantSendManager::CInstantSendManager(CSporkManager& sporkman, const CMasternodeSync& mn_sync,
-                                         const util::DbWrapperParams& db_params) :
+CInstantSendManager::CInstantSendManager(CSporkManager& sporkman, const util::DbWrapperParams& db_params) :
     db{db_params},
-    spork_manager{sporkman},
-    m_mn_sync{mn_sync}
+    spork_manager{sporkman}
 {
 }
 
@@ -471,9 +468,6 @@ bool CInstantSendManager::IsInstantSendEnabled() const
 
 bool CInstantSendManager::RejectConflictingBlocks() const
 {
-    if (!m_mn_sync.IsBlockchainSynced()) {
-        return false;
-    }
     if (!spork_manager.IsSporkActive(SPORK_3_INSTANTSEND_BLOCK_FILTERING)) {
         LogPrint(BCLog::INSTANTSEND, "%s: spork3 is off, skipping transaction locking checks\n", __func__);
         return false;

src/instantsend/instantsend.h

@@ -20,7 +20,6 @@
 
 class CBlockIndex;
 class CDataStream;
-class CMasternodeSync;
 class CSporkManager;
 namespace Consensus {
 struct LLMQParams;
@@ -54,7 +53,6 @@ class CInstantSendManager
 private:
     instantsend::CInstantSendDb db;
     CSporkManager& spork_manager;
-    const CMasternodeSync& m_mn_sync;
 
     mutable Mutex cs_pendingLocks;
     // Incoming and not verified yet
@@ -90,8 +88,7 @@ class CInstantSendManager
     CInstantSendManager() = delete;
     CInstantSendManager(const CInstantSendManager&) = delete;
     CInstantSendManager& operator=(const CInstantSendManager&) = delete;
-    explicit CInstantSendManager(CSporkManager& sporkman, const CMasternodeSync& mn_sync,
-                                 const util::DbWrapperParams& db_params);
+    explicit CInstantSendManager(CSporkManager& sporkman, const util::DbWrapperParams& db_params);
     ~CInstantSendManager();
 
     void AddNonLockedTx(const CTransactionRef& tx, const CBlockIndex* pindexMined)

src/llmq/context.cpp

@@ -13,17 +13,16 @@
 #include <validation.h>
 
 LLMQContext::LLMQContext(CDeterministicMNManager& dmnman, CEvoDB& evo_db, CSporkManager& sporkman,
-                         ChainstateManager& chainman, const CMasternodeSync& mn_sync,
-                         const util::DbWrapperParams& db_params, int8_t bls_threads, int16_t worker_count,
-                         int64_t max_recsigs_age) :
+                         ChainstateManager& chainman, const util::DbWrapperParams& db_params, int8_t bls_threads,
+                         int16_t worker_count, int64_t max_recsigs_age) :
     bls_worker{std::make_shared<CBLSWorker>()},
     qsnapman{std::make_unique<llmq::CQuorumSnapshotManager>(evo_db)},
     quorum_block_processor{std::make_unique<llmq::CQuorumBlockProcessor>(chainman.ActiveChainstate(), dmnman, evo_db,
                                                                          *qsnapman, bls_threads)},
     qman{std::make_unique<llmq::CQuorumManager>(*bls_worker, dmnman, evo_db, *quorum_block_processor, *qsnapman,
                                                 chainman, db_params)},
     sigman{std::make_unique<llmq::CSigningManager>(*qman, db_params, max_recsigs_age)},
-    isman{std::make_unique<llmq::CInstantSendManager>(sporkman, mn_sync, db_params)}
+    isman{std::make_unique<llmq::CInstantSendManager>(sporkman, db_params)}
 {
     // Have to start it early to let VerifyDB check ChainLock signatures in coinbase
     bls_worker->Start(worker_count);

src/llmq/context.h

@@ -13,7 +13,6 @@ class CBLSWorker;
 class ChainstateManager;
 class CDeterministicMNManager;
 class CEvoDB;
-class CMasternodeSync;
 class CSporkManager;
 class PeerManager;
 
@@ -34,9 +33,8 @@ struct LLMQContext {
     LLMQContext(const LLMQContext&) = delete;
     LLMQContext& operator=(const LLMQContext&) = delete;
     explicit LLMQContext(CDeterministicMNManager& dmnman, CEvoDB& evo_db, CSporkManager& sporkman,
-                         ChainstateManager& chainman, const CMasternodeSync& mn_sync,
-                         const util::DbWrapperParams& db_params, int8_t bls_threads, int16_t worker_count,
-                         int64_t max_recsigs_age);
+                         ChainstateManager& chainman, const util::DbWrapperParams& db_params, int8_t bls_threads,
+                         int16_t worker_count, int64_t max_recsigs_age);
     ~LLMQContext();
 
     /** Guaranteed if LLMQContext is initialized then all members are valid too

src/masternode/payments.cpp

@@ -160,7 +160,7 @@ CAmount PlatformShare(const CAmount reward)
     int nOffset = nBlockHeight % m_consensus_params.nBudgetPaymentsCycleBlocks;
     if (nOffset < m_consensus_params.nBudgetPaymentsWindowBlocks) {
         // NOTE: old budget system is disabled since 12.1
-        if(m_mn_sync.IsSynced()) {
+        if (m_govman.IsValidAndSynced()) {
             // no old budget blocks should be accepted here on mainnet,
             // testnet/devnet/regtest should produce regular blocks only
             LogPrint(BCLog::GOBJECT, "CMNPaymentsProcessor::%s -- WARNING! Client synced but old budget system is disabled, checking block value against block reward\n", __func__);
@@ -232,7 +232,7 @@ bool CMNPaymentsProcessor::IsBlockValueValid(const CBlock& block, const int nBlo
         return false;
     }
 
-    if (!m_mn_sync.IsSynced() || !m_govman.IsValid()) {
+    if (!m_govman.IsValidAndSynced()) {
         LogPrint(BCLog::MNPAYMENTS, "CMNPaymentsProcessor::%s -- WARNING! Not enough data, checked superblock max bounds only\n", __func__);
         // not enough data for full checks but at least we know that the superblock limits were honored.
         // We rely on the network to have followed the correct chain in this case
@@ -291,7 +291,7 @@ bool CMNPaymentsProcessor::IsBlockPayeeValid(const CTransaction& txNew, const CB
         return false;
     }
 
-    if (!m_mn_sync.IsSynced() || !m_govman.IsValid()) {
+    if (!m_govman.IsValidAndSynced()) {
         // governance data is either incomplete or non-existent
         LogPrint(BCLog::MNPAYMENTS, "CMNPaymentsProcessor::%s -- WARNING! Not enough data, skipping superblock payee checks\n", __func__);
         return true;  // not an error

src/masternode/payments.h

@@ -15,7 +15,6 @@ class CBlockIndex;
 class CDeterministicMNManager;
 class CGovernanceManager;
 class ChainstateManager;
-class CMasternodeSync;
 class CTransaction;
 class CSporkManager;
 class CTxOut;
@@ -37,7 +36,6 @@ class CMNPaymentsProcessor
     CGovernanceManager& m_govman;
     const ChainstateManager& m_chainman;
     const Consensus::Params& m_consensus_params;
-    const CMasternodeSync& m_mn_sync;
     const CSporkManager& m_sporkman;
 
 private:
@@ -50,10 +48,16 @@ class CMNPaymentsProcessor
     [[nodiscard]] bool IsOldBudgetBlockValueValid(const CBlock& block, const int nBlockHeight, const CAmount blockReward, std::string& strErrorRet);
 
 public:
-    explicit CMNPaymentsProcessor(CDeterministicMNManager& dmnman, CGovernanceManager& govman, const ChainstateManager& chainman,
-                                  const Consensus::Params& consensus_params, const CMasternodeSync& mn_sync, const CSporkManager& sporkman) :
-        m_dmnman{dmnman}, m_govman{govman}, m_chainman{chainman}, m_consensus_params{consensus_params}, m_mn_sync{mn_sync},
-        m_sporkman{sporkman} {}
+    explicit CMNPaymentsProcessor(CDeterministicMNManager& dmnman, CGovernanceManager& govman,
+                                  const ChainstateManager& chainman, const Consensus::Params& consensus_params,
+                                  const CSporkManager& sporkman) :
+        m_dmnman{dmnman},
+        m_govman{govman},
+        m_chainman{chainman},
+        m_consensus_params{consensus_params},
+        m_sporkman{sporkman}
+    {
+    }
 
     bool IsBlockValueValid(const CBlock& block, const int nBlockHeight, const CAmount blockReward, std::string& strErrorRet, const bool check_superblock);
     bool IsBlockPayeeValid(const CTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward, const bool check_superblock);

src/masternode/sync.cpp

@@ -9,6 +9,11 @@
 #include <util/time.h>
 #include <util/translation.h>
 
+#include <cassert>
+
+void NullNodeSyncNotifier::SyncReset() { assert(false); }
+void NullNodeSyncNotifier::SyncFinished() { assert(false); }
+
 CMasternodeSync::CMasternodeSync(std::unique_ptr<NodeSyncNotifier>&& sync_notifier) :
     nTimeAssetSyncStarted{GetTime()},
     nTimeLastBumped{GetTime()},

src/masternode/sync.h

@@ -32,6 +32,20 @@ class NodeSyncNotifier
     virtual ~NodeSyncNotifier() = default;
 };
 
+/** Stub implementation for use in chainstate-only (non-network) contexts.
+ *  CMasternodeSync constructed with this notifier permanently returns
+ *  IsBlockchainSynced()=false and IsSynced()=false, which correctly disables
+ *  network-dependent validation paths.
+ *
+ *  Asserts on any call — if sync state is being advanced, a real notifier
+ *  (NodeSyncNotifierImpl) must be used instead. */
+class NullNodeSyncNotifier final : public NodeSyncNotifier
+{
+public:
+    void SyncReset() override;
+    void SyncFinished() override;
+};
+
 //
 // CMasternodeSync : Sync masternode assets in stages
 //

src/node/chainstate.cpp

@@ -37,7 +37,6 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
                                                      ChainstateManager& chainman,
                                                      CGovernanceManager& govman,
                                                      CMasternodeMetaMan& mn_metaman,
-                                                     CMasternodeSync& mn_sync,
                                                      CSporkManager& sporkman,
                                                      chainlock::Chainlocks& chainlocks,
                                                      std::unique_ptr<CChainstateHelper>& chain_helper,
@@ -83,7 +82,7 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
     pblocktree.reset();
     pblocktree.reset(new CBlockTreeDB(nBlockTreeDBCache, block_tree_db_in_memory, fReset));
 
-    DashChainstateSetup(chainman, govman, mn_metaman, mn_sync, sporkman, chainlocks, chain_helper,
+    DashChainstateSetup(chainman, govman, mn_metaman, sporkman, chainlocks, chain_helper,
                         dmnman, *evodb, llmq_ctx, mempool, data_dir, dash_dbs_in_memory,
                         /*llmq_dbs_wipe=*/fReset || fReindexChainState, bls_threads, worker_count,
                         max_recsigs_age, consensus_params);
@@ -209,7 +208,6 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
 void DashChainstateSetup(ChainstateManager& chainman,
                          CGovernanceManager& govman,
                          CMasternodeMetaMan& mn_metaman,
-                         CMasternodeSync& mn_sync,
                          CSporkManager& sporkman,
                          chainlock::Chainlocks& chainlocks,
                          std::unique_ptr<CChainstateHelper>& chain_helper,
@@ -230,13 +228,13 @@ void DashChainstateSetup(ChainstateManager& chainman,
     dmnman = std::make_unique<CDeterministicMNManager>(evodb, mn_metaman);
 
     llmq_ctx.reset();
-    llmq_ctx = std::make_unique<LLMQContext>(*dmnman, evodb, sporkman, chainman, mn_sync,
+    llmq_ctx = std::make_unique<LLMQContext>(*dmnman, evodb, sporkman, chainman,
                                              util::DbWrapperParams{.path = data_dir, .memory = llmq_dbs_in_memory, .wipe = llmq_dbs_wipe},
                                              bls_threads, worker_count, max_recsigs_age);
     mempool->ConnectManagers(dmnman.get(), llmq_ctx->isman.get());
     chain_helper.reset();
     chain_helper = std::make_unique<CChainstateHelper>(evodb, *dmnman, govman, *(llmq_ctx->isman), *(llmq_ctx->quorum_block_processor),
-                                                       *(llmq_ctx->qsnapman), chainman, consensus_params, mn_sync, sporkman, chainlocks,
+                                                       *(llmq_ctx->qsnapman), chainman, consensus_params, sporkman, chainlocks,
                                                        *(llmq_ctx->qman));
 }
 

src/node/chainstate.h

@@ -17,7 +17,6 @@ class CEvoDB;
 class CGovernanceManager;
 class ChainstateManager;
 class CMasternodeMetaMan;
-class CMasternodeSync;
 class CSporkManager;
 class CTxMemPool;
 struct LLMQContext;
@@ -80,7 +79,6 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
                                                      ChainstateManager& chainman,
                                                      CGovernanceManager& govman,
                                                      CMasternodeMetaMan& mn_metaman,
-                                                     CMasternodeSync& mn_sync,
                                                      CSporkManager& sporkman,
                                                      chainlock::Chainlocks& chainlocks,
                                                      std::unique_ptr<CChainstateHelper>& chain_helper,
@@ -111,7 +109,6 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
 void DashChainstateSetup(ChainstateManager& chainman,
                          CGovernanceManager& govman,
                          CMasternodeMetaMan& mn_metaman,
-                         CMasternodeSync& mn_sync,
                          CSporkManager& sporkman,
                          chainlock::Chainlocks& chainlocks,
                          std::unique_ptr<CChainstateHelper>& chain_helper,