refactor: extract CActiveMasternodeManager from LLMQContext (3/n, DKG session isolation, ActiveContext consolidation)

src/Makefile.am

@@ -151,6 +151,10 @@ endif
 .PHONY: FORCE check-symbols check-security
 # dash core #
 BITCOIN_CORE_H = \
+  active/context.h \
+  active/dkgsession.h \
+  active/dkgsessionhandler.h \
+  active/masternode.h \
   active/quorums.h \
   addrdb.h \
   addressindex.h \
@@ -292,9 +296,6 @@ BITCOIN_CORE_H = \
   logging.h \
   logging/timer.h \
   mapport.h \
-  masternode/active/context.h \
-  masternode/active/notificationinterface.h \
-  masternode/node.h \
   masternode/meta.h \
   masternode/payments.h \
   masternode/sync.h \
@@ -482,6 +483,10 @@ libbitcoin_util_a-clientversion.$(OBJEXT): obj/build.h
 libbitcoin_node_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(BOOST_CPPFLAGS) $(MINIUPNPC_CPPFLAGS) $(NATPMP_CPPFLAGS) $(EVENT_CFLAGS) $(EVENT_PTHREADS_CFLAGS)
 libbitcoin_node_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_node_a_SOURCES = \
+  active/context.cpp \
+  active/dkgsession.cpp \
+  active/dkgsessionhandler.cpp \
+  active/masternode.cpp \
   active/quorums.cpp \
   addrdb.cpp \
   addressindex.cpp \
@@ -562,9 +567,6 @@ libbitcoin_node_a_SOURCES = \
   llmq/observer/context.cpp \
   llmq/observer/quorums.cpp \
   mapport.cpp \
-  masternode/active/context.cpp \
-  masternode/active/notificationinterface.cpp \
-  masternode/node.cpp \
   masternode/meta.cpp \
   masternode/payments.cpp \
   masternode/sync.cpp \

src/active/context.cpp

@@ -0,0 +1,122 @@
+// Copyright (c) 2025 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <active/context.h>
+
+#include <active/dkgsessionhandler.h>
+#include <active/masternode.h>
+#include <active/quorums.h>
+#include <chainlock/chainlock.h>
+#include <chainlock/signing.h>
+#include <governance/governance.h>
+#include <governance/signing.h>
+#include <instantsend/instantsend.h>
+#include <instantsend/signing.h>
+#include <llmq/context.h>
+#include <llmq/debug.h>
+#include <llmq/dkgsessionmgr.h>
+#include <llmq/ehf_signals.h>
+#include <llmq/quorumsman.h>
+#include <llmq/signing_shares.h>
+
+#include <util/check.h>
+#include <validation.h>
+
+ActiveContext::ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman, CConnman& connman,
+                             CDeterministicMNManager& dmnman, CGovernanceManager& govman,
+                             CMasternodeMetaMan& mn_metaman, CMNHFManager& mnhfman, CSporkManager& sporkman,
+                             CTxMemPool& mempool, llmq::CChainLocksHandler& clhandler, llmq::CInstantSendManager& isman,
+                             llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumManager& qman,
+                             llmq::CQuorumSnapshotManager& qsnapman, llmq::CSigningManager& sigman,
+                             PeerManager& peerman, const CMasternodeSync& mn_sync, const CBLSSecretKey& operator_sk,
+                             const llmq::QvvecSyncModeMap& sync_map, const util::DbWrapperParams& db_params,
+                             bool quorums_recovery, bool quorums_watch) :
+    m_clhandler{clhandler},
+    m_isman{isman},
+    m_qman{qman},
+    nodeman{std::make_unique<CActiveMasternodeManager>(connman, dmnman, operator_sk)},
+    dkgdbgman{std::make_unique<llmq::CDKGDebugManager>()},
+    qdkgsman{std::make_unique<llmq::CDKGSessionManager>(dmnman, qsnapman, chainman, sporkman, db_params, quorums_watch)},
+    shareman{std::make_unique<llmq::CSigSharesManager>(connman, chainman.ActiveChainstate(), sigman, peerman, *nodeman,
+                                                       qman, sporkman)},
+    gov_signer{std::make_unique<GovernanceSigner>(connman, dmnman, govman, *nodeman, chainman, mn_sync)},
+    ehf_sighandler{std::make_unique<llmq::CEHFSignalsHandler>(chainman, mnhfman, sigman, *shareman, qman)},
+    qman_handler{std::make_unique<llmq::QuorumParticipant>(bls_worker, connman, dmnman, qman, qsnapman, *nodeman, chainman,
+                                                           mn_sync, sporkman, sync_map, quorums_recovery, quorums_watch)},
+    cl_signer{std::make_unique<chainlock::ChainLockSigner>(chainman.ActiveChainstate(), clhandler, sigman, *shareman,
+                                                           sporkman, mn_sync)},
+    is_signer{std::make_unique<instantsend::InstantSendSigner>(chainman.ActiveChainstate(), clhandler, isman, sigman,
+                                                               *shareman, qman, sporkman, mempool, mn_sync)}
+{
+    qdkgsman->InitializeHandlers([&](const Consensus::LLMQParams& llmq_params,
+                                     int quorum_idx) -> std::unique_ptr<llmq::ActiveDKGSessionHandler> {
+        return std::make_unique<llmq::ActiveDKGSessionHandler>(bls_worker, dmnman, mn_metaman, *dkgdbgman, *qdkgsman,
+                                                               qblockman, qsnapman, *nodeman, chainman, sporkman,
+                                                               llmq_params, quorums_watch, quorum_idx);
+    });
+    m_clhandler.ConnectSigner(cl_signer.get());
+    m_isman.ConnectSigner(is_signer.get());
+    m_qman.ConnectManagers(qman_handler.get(), qdkgsman.get());
+}
+
+ActiveContext::~ActiveContext()
+{
+    m_qman.DisconnectManagers();
+    m_isman.DisconnectSigner();
+    m_clhandler.DisconnectSigner();
+}
+
+void ActiveContext::Interrupt()
+{
+    shareman->InterruptWorkerThread();
+}
+
+void ActiveContext::Start(CConnman& connman, PeerManager& peerman)
+{
+    qman_handler->Start();
+    qdkgsman->StartThreads(connman, peerman);
+    shareman->Start();
+    cl_signer->RegisterRecoveryInterface();
+    is_signer->RegisterRecoveryInterface();
+    shareman->RegisterRecoveryInterface();
+}
+
+void ActiveContext::Stop()
+{
+    shareman->UnregisterRecoveryInterface();
+    is_signer->UnregisterRecoveryInterface();
+    cl_signer->UnregisterRecoveryInterface();
+    shareman->Stop();
+    qdkgsman->StopThreads();
+    qman_handler->Stop();
+}
+
+CCoinJoinServer& ActiveContext::GetCJServer() const
+{
+    return *Assert(m_cj_server);
+}
+
+void ActiveContext::SetCJServer(gsl::not_null<CCoinJoinServer*> cj_server)
+{
+    // Prohibit double initialization
+    assert(m_cj_server == nullptr);
+    m_cj_server = cj_server;
+}
+
+void ActiveContext::UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload)
+{
+    if (fInitialDownload || pindexNew == pindexFork) // In IBD or blocks were disconnected without any new ones
+        return;
+
+    nodeman->UpdatedBlockTip(pindexNew, pindexFork, fInitialDownload);
+    ehf_sighandler->UpdatedBlockTip(pindexNew);
+    gov_signer->UpdatedBlockTip(pindexNew);
+    qdkgsman->UpdatedBlockTip(pindexNew, fInitialDownload);
+    qman_handler->UpdatedBlockTip(pindexNew, fInitialDownload);
+}
+
+void ActiveContext::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, bool proactive_relay)
+{
+    shareman->NotifyRecoveredSig(sig, proactive_relay);
+}

src/masternode/active/context.h → src/active/context.h

@@ -2,14 +2,20 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_MASTERNODE_ACTIVE_CONTEXT_H
-#define BITCOIN_MASTERNODE_ACTIVE_CONTEXT_H
+#ifndef BITCOIN_ACTIVE_CONTEXT_H
+#define BITCOIN_ACTIVE_CONTEXT_H
 
 #include <llmq/options.h>
 
+#include <validationinterface.h>
+
+#include <gsl/pointers.h>
+
 #include <memory>
 
 class CActiveMasternodeManager;
+class CBLSSecretKey;
+class CBLSWorker;
 class ChainstateManager;
 class CCoinJoinServer;
 class CConnman;
@@ -22,65 +28,81 @@ class CSporkManager;
 class CTxMemPool;
 class GovernanceSigner;
 class PeerManager;
-struct LLMQContext;
 namespace chainlock {
 class ChainLockSigner;
 } // namespace chainlock
 namespace instantsend {
 class InstantSendSigner;
 } // namespace instantsend
 namespace llmq {
+class CChainLocksHandler;
 class CDKGDebugManager;
 class CDKGSessionManager;
 class CEHFSignalsHandler;
+class CInstantSendManager;
+class CQuorumBlockProcessor;
+class CQuorumManager;
+class CQuorumSnapshotManager;
+class CSigningManager;
 class CSigSharesManager;
 class QuorumParticipant;
 } // namespace llmq
 namespace util {
 struct DbWrapperParams;
 } // namespace util
 
-struct ActiveContext {
+struct ActiveContext final : public CValidationInterface {
 private:
-    // TODO: Switch to references to members when migration is finished
-    LLMQContext& m_llmq_ctx;
+    llmq::CChainLocksHandler& m_clhandler;
+    llmq::CInstantSendManager& m_isman;
+    llmq::CQuorumManager& m_qman;
 
 public:
     ActiveContext() = delete;
     ActiveContext(const ActiveContext&) = delete;
     ActiveContext& operator=(const ActiveContext&) = delete;
-    explicit ActiveContext(CCoinJoinServer& cj_server, CConnman& connman, CDeterministicMNManager& dmnman,
-                           CGovernanceManager& govman, ChainstateManager& chainman, CMasternodeMetaMan& mn_metaman,
-                           CMNHFManager& mnhfman, CSporkManager& sporkman, CTxMemPool& mempool, LLMQContext& llmq_ctx,
-                           PeerManager& peerman, const CActiveMasternodeManager& mn_activeman,
-                           const CMasternodeSync& mn_sync, const llmq::QvvecSyncModeMap& sync_map,
-                           const util::DbWrapperParams& db_params, bool quorums_recovery, bool quorums_watch);
+    explicit ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman, CConnman& connman,
+                           CDeterministicMNManager& dmnman, CGovernanceManager& govman, CMasternodeMetaMan& mn_metaman,
+                           CMNHFManager& mnhfman, CSporkManager& sporkman, CTxMemPool& mempool,
+                           llmq::CChainLocksHandler& clhandler, llmq::CInstantSendManager& isman,
+                           llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumManager& qman,
+                           llmq::CQuorumSnapshotManager& qsnapman, llmq::CSigningManager& sigman, PeerManager& peerman,
+                           const CMasternodeSync& mn_sync, const CBLSSecretKey& operator_sk,
+                           const llmq::QvvecSyncModeMap& sync_map, const util::DbWrapperParams& db_params,
+                           bool quorums_recovery, bool quorums_watch);
     ~ActiveContext();
 
     void Interrupt();
     void Start(CConnman& connman, PeerManager& peerman);
     void Stop();
 
+    CCoinJoinServer& GetCJServer() const;
+    void SetCJServer(gsl::not_null<CCoinJoinServer*> cj_server);
+
+protected:
+    // CValidationInterface
+    void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, bool proactive_relay) override;
+    void UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload) override;
+
+public:
     /*
      * Entities that are only utilized when masternode mode is enabled
      * and are accessible in their own right
-     * TODO: Move CActiveMasternodeManager here when dependents have been migrated
      */
-    CCoinJoinServer& m_cj_server;
-    const std::unique_ptr<GovernanceSigner> gov_signer;
+    const std::unique_ptr<CActiveMasternodeManager> nodeman;
     const std::unique_ptr<llmq::CDKGDebugManager> dkgdbgman;
     const std::unique_ptr<llmq::CDKGSessionManager> qdkgsman;
     const std::unique_ptr<llmq::CSigSharesManager> shareman;
-    const std::unique_ptr<llmq::CEHFSignalsHandler> ehf_sighandler;
-    const std::unique_ptr<llmq::QuorumParticipant> qman_handler;
 
 private:
-    /*
-     * Entities that are registered with LLMQContext members are not accessible
-     * and are managed with (Dis)connectSigner() in the (c/d)tor instead
-     */
+    const std::unique_ptr<GovernanceSigner> gov_signer;
+    const std::unique_ptr<llmq::CEHFSignalsHandler> ehf_sighandler;
+    const std::unique_ptr<llmq::QuorumParticipant> qman_handler;
     const std::unique_ptr<chainlock::ChainLockSigner> cl_signer;
     const std::unique_ptr<instantsend::InstantSendSigner> is_signer;
+
+    /** Owned by PeerManager, use GetCJServer() */
+    CCoinJoinServer* m_cj_server{nullptr};
 };
 
-#endif // BITCOIN_MASTERNODE_ACTIVE_CONTEXT_H
+#endif // BITCOIN_ACTIVE_CONTEXT_H