refactor: drop dependency of CInstantSendManager on chainlocks

Author: knst

src/init.cpp

@@ -2208,7 +2208,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 
     // ********************************************************* Step 7d: Setup other Dash services
 
-    node.peerman->AddExtraHandler(std::make_unique<NetInstantSend>(node.peerman.get(), *node.llmq_ctx->isman, node.active_ctx ? node.active_ctx->is_signer.get() : nullptr, *node.llmq_ctx->sigman, *node.llmq_ctx->qman, chainman.ActiveChainstate(), *node.mempool, *node.mn_sync));
+    node.peerman->AddExtraHandler(std::make_unique<NetInstantSend>(node.peerman.get(), *node.llmq_ctx->isman, node.active_ctx ? node.active_ctx->is_signer.get() : nullptr, *node.llmq_ctx->sigman, *node.llmq_ctx->qman, *node.chainlocks, chainman.ActiveChainstate(), *node.mempool, *node.mn_sync));
     node.peerman->AddExtraHandler(std::make_unique<llmq::NetSigning>(node.peerman.get(), *node.llmq_ctx->sigman, node.active_ctx ? node.active_ctx->shareman.get() : nullptr, *node.sporkman));
 
     if (node.active_ctx) {

src/instantsend/instantsend.cpp

@@ -4,7 +4,6 @@
 
 #include <instantsend/instantsend.h>
 
-#include <chainlock/chainlock.h>
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <masternode/sync.h>
@@ -16,10 +15,8 @@ using node::fImporting;
 using node::fReindex;
 
 namespace llmq {
-CInstantSendManager::CInstantSendManager(const chainlock::Chainlocks& chainlocks, CSporkManager& sporkman,
-                                         const util::DbWrapperParams& db_params) :
+CInstantSendManager::CInstantSendManager(CSporkManager& sporkman, const util::DbWrapperParams& db_params) :
     db{db_params},
-    m_chainlocks{chainlocks},
     spork_manager{sporkman}
 {
 }

src/instantsend/instantsend.h

@@ -30,10 +30,6 @@ namespace util {
 struct DbWrapperParams;
 } // namespace util
 
-namespace chainlock {
-class Chainlocks;
-}
-
 namespace instantsend {
 
 struct PendingISLockFromPeer {
@@ -57,8 +53,6 @@ class CInstantSendManager
 {
 private:
     instantsend::CInstantSendDb db;
-
-    const chainlock::Chainlocks& m_chainlocks;
     CSporkManager& spork_manager;
 
     mutable Mutex cs_pendingLocks;
@@ -95,8 +89,7 @@ class CInstantSendManager
     CInstantSendManager() = delete;
     CInstantSendManager(const CInstantSendManager&) = delete;
     CInstantSendManager& operator=(const CInstantSendManager&) = delete;
-    explicit CInstantSendManager(const chainlock::Chainlocks& chainlocks, CSporkManager& sporkman,
-                                 const util::DbWrapperParams& db_params);
+    explicit CInstantSendManager(CSporkManager& sporkman, const util::DbWrapperParams& db_params);
     ~CInstantSendManager();
 
     void AddNonLockedTx(const CTransactionRef& tx, const CBlockIndex* pindexMined)
@@ -122,7 +115,6 @@ class CInstantSendManager
         EXCLUSIVE_LOCKS_REQUIRED(!cs_pendingLocks);
     [[nodiscard]] std::vector<CTransactionRef> PrepareTxToRetry()
         EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingRetry);
-    const chainlock::Chainlocks& Chainlocks() { return m_chainlocks; }
 
     void RemoveBlockISLocks(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex);
     void WriteBlockISLocks(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex);

src/instantsend/net_instantsend.cpp

@@ -376,7 +376,7 @@ void NetInstantSend::ProcessInstantSendLock(NodeId from, const uint256& hash, co
         }
         // Let's see if the TX that was locked by this islock is already mined in a ChainLocked block. If yes,
         // we can simply ignore the islock, as the ChainLock implies locking of all TXs in that chain
-        if (minedHeight.has_value() && m_is_manager.Chainlocks().HasChainLock(*minedHeight, hashBlock)) {
+        if (minedHeight.has_value() && m_chainlocks.HasChainLock(*minedHeight, hashBlock)) {
             LogPrint(BCLog::INSTANTSEND, /* Continued */
                      "NetSigning::%s -- txlock=%s, islock=%s: dropping islock as it already got a "
                      "ChainLock in block %s, peer=%d\n",
@@ -501,7 +501,7 @@ void NetInstantSend::UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockI
 {
     bool fDIP0008Active = pindexNew->pprev && pindexNew->pprev->nHeight >= Params().GetConsensus().DIP0008Height;
 
-    if (m_is_manager.Chainlocks().IsEnabled() && fDIP0008Active) {
+    if (m_chainlocks.IsEnabled() && fDIP0008Active) {
         // Nothing to do here. We should keep all islocks and let chainlocks handle them.
         return;
     }
@@ -529,7 +529,7 @@ void NetInstantSend::BlockConnected(const std::shared_ptr<const CBlock>& pblock,
     m_is_manager.CacheTipHeight(pindex);
 
     if (m_mn_sync.IsBlockchainSynced()) {
-        const bool has_chainlock = m_is_manager.Chainlocks().HasChainLock(pindex->nHeight, pindex->GetBlockHash());
+        const bool has_chainlock = m_chainlocks.HasChainLock(pindex->nHeight, pindex->GetBlockHash());
         for (const auto& tx : pblock->vtx) {
             if (tx->IsCoinBase() || tx->vin.empty()) {
                 // coinbase and TXs with no inputs can't be locked
@@ -571,7 +571,7 @@ void NetInstantSend::ResolveBlockConflicts(const uint256& islockHash, const inst
     bool hasChainLockedConflict = false;
     for (const auto& p : conflicts) {
         const auto* pindex = p.first;
-        if (m_is_manager.Chainlocks().HasChainLock(pindex->nHeight, pindex->GetBlockHash())) {
+        if (m_chainlocks.HasChainLock(pindex->nHeight, pindex->GetBlockHash())) {
             hasChainLockedConflict = true;
             break;
         }

src/instantsend/net_instantsend.h

@@ -18,6 +18,10 @@ namespace Consensus {
 struct LLMQParams;
 } // namespace Consensus
 
+namespace chainlock {
+class Chainlocks;
+} // namespace chainlock
+
 class CMasternodeSync;
 class CTxMemPool;
 
@@ -38,12 +42,14 @@ class NetInstantSend final : public NetHandler, public CValidationInterface
 public:
     NetInstantSend(PeerManagerInternal* peer_manager, llmq::CInstantSendManager& is_manager,
                    instantsend::InstantSendSigner* signer, llmq::CSigningManager& sigman, llmq::CQuorumManager& qman,
-                   CChainState& chainstate, CTxMemPool& mempool, const CMasternodeSync& mn_sync) :
+                   const chainlock::Chainlocks& chainlocks, CChainState& chainstate, CTxMemPool& mempool,
+                   const CMasternodeSync& mn_sync) :
         NetHandler(peer_manager),
         m_is_manager{is_manager},
         m_signer{signer},
         m_sigman{sigman},
         m_qman(qman),
+        m_chainlocks{chainlocks},
         m_chainstate{chainstate},
         m_mempool{mempool},
         m_mn_sync{mn_sync}
@@ -104,6 +110,7 @@ class NetInstantSend final : public NetHandler, public CValidationInterface
     instantsend::InstantSendSigner* m_signer; // non-null only for masternode
     llmq::CSigningManager& m_sigman;
     llmq::CQuorumManager& m_qman;
+    const chainlock::Chainlocks& m_chainlocks;
     CChainState& m_chainstate;
     CTxMemPool& m_mempool;
     const CMasternodeSync& m_mn_sync;

src/llmq/context.cpp

@@ -13,16 +13,16 @@
 #include <validation.h>
 
 LLMQContext::LLMQContext(CDeterministicMNManager& dmnman, CEvoDB& evo_db, CSporkManager& sporkman,
-                         chainlock::Chainlocks& chainlocks, ChainstateManager& chainman,
-                         const util::DbWrapperParams& db_params, int8_t bls_threads, int64_t max_recsigs_age) :
+                         ChainstateManager& chainman, const util::DbWrapperParams& db_params, int8_t bls_threads,
+                         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>(chainlocks, sporkman, 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();

src/llmq/context.h

@@ -16,10 +16,6 @@ class CEvoDB;
 class CSporkManager;
 class PeerManager;
 
-namespace chainlock {
-class Chainlocks;
-}
-
 namespace llmq {
 class CInstantSendManager;
 class CQuorumBlockProcessor;
@@ -37,8 +33,8 @@ struct LLMQContext {
     LLMQContext(const LLMQContext&) = delete;
     LLMQContext& operator=(const LLMQContext&) = delete;
     explicit LLMQContext(CDeterministicMNManager& dmnman, CEvoDB& evo_db, CSporkManager& sporkman,
-                         chainlock::Chainlocks& chainlocks, ChainstateManager& chainman,
-                         const util::DbWrapperParams& db_params, int8_t bls_threads, int64_t max_recsigs_age);
+                         ChainstateManager& chainman, const util::DbWrapperParams& db_params, int8_t bls_threads,
+                         int64_t max_recsigs_age);
     ~LLMQContext();
 
     /** Guaranteed if LLMQContext is initialized then all members are valid too

src/node/chainstate.cpp

@@ -227,7 +227,7 @@ void DashChainstateSetup(ChainstateManager& chainman,
     dmnman = std::make_unique<CDeterministicMNManager>(evodb, mn_metaman);
 
     llmq_ctx.reset();
-    llmq_ctx = std::make_unique<LLMQContext>(*dmnman, evodb, sporkman, chainlocks, chainman,
+    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, max_recsigs_age);
     mempool->ConnectManagers(dmnman.get(), llmq_ctx->isman.get());