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

doc/release-notes-7061.md

@@ -0,0 +1,8 @@
+# RPC changes
+
+- `quorum dkginfo` will now require that nodes run either in watch-only mode (`-watchquorums`) or as an
+  active masternode (i.e. masternode mode) as regular nodes do not have insight into network DKG activity.
+
+- `quorum dkgstatus` will no longer emit the return values `time`, `timeStr` and `session` on nodes that
+  do not run in either watch-only or masternode mode as regular nodes do not have insight into network
+  DKG activity.

src/Makefile.am

@@ -145,6 +145,11 @@ 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 \
   spentindex.h \
@@ -271,19 +276,19 @@ BITCOIN_CORE_H = \
   llmq/options.h \
   llmq/params.h \
   llmq/quorums.h \
+  llmq/quorumsman.h \
   llmq/signhash.h \
   llmq/signing.h \
   llmq/net_signing.h \
   llmq/signing_shares.h \
   llmq/snapshot.h \
   llmq/types.h \
   llmq/utils.h \
+  llmq/observer/context.h \
+  llmq/observer/quorums.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 \
@@ -470,6 +475,11 @@ 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 \
   addrman.cpp \
@@ -539,15 +549,15 @@ libbitcoin_node_a_SOURCES = \
   llmq/net_signing.cpp \
   llmq/options.cpp \
   llmq/quorums.cpp \
+  llmq/quorumsman.cpp \
   llmq/signhash.cpp \
   llmq/signing.cpp \
   llmq/signing_shares.cpp \
   llmq/snapshot.cpp \
   llmq/utils.cpp \
+  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 \
@@ -910,6 +920,7 @@ libbitcoin_common_a_SOURCES = \
   evo/netinfo.cpp \
   external_signer.cpp \
   governance/common.cpp \
+  governance/core_write.cpp \
   init/common.cpp \
   key.cpp \
   key_io.cpp \

src/active/context.cpp

@@ -0,0 +1,113 @@
+// 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 <coinjoin/server.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 <validation.h>
+
+ActiveContext::ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman, CConnman& connman,
+                             CDeterministicMNManager& dmnman, CDSTXManager& dstxman, 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)},
+    cj_server{std::make_unique<CCoinJoinServer>(chainman, connman, dmnman, dstxman, mn_metaman, mempool, peerman,
+                                                *nodeman, mn_sync, isman)},
+    dkgdbgman{std::make_unique<llmq::CDKGDebugManager>()},
+    qdkgsman{std::make_unique<llmq::CDKGSessionManager>(chainman.ActiveChainstate(), dmnman, qsnapman, 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,
+                                                           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::dkg::ActiveSessionHandler> {
+        return std::make_unique<llmq::dkg::ActiveSessionHandler>(bls_worker, chainman.ActiveChainstate(), dmnman,
+                                                                 mn_metaman, *dkgdbgman, *qdkgsman, qblockman, qsnapman,
+                                                                 *nodeman, 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->RegisterAsRecoveredSigsListener();
+    is_signer->RegisterAsRecoveredSigsListener();
+    shareman->RegisterAsRecoveredSigsListener();
+}
+
+void ActiveContext::Stop()
+{
+    shareman->UnregisterAsRecoveredSigsListener();
+    is_signer->UnregisterAsRecoveredSigsListener();
+    cl_signer->UnregisterAsRecoveredSigsListener();
+    shareman->Stop();
+    qdkgsman->StopThreads();
+    qman_handler->Stop();
+}
+
+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/active/context.h

@@ -0,0 +1,102 @@
+// 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.
+
+#ifndef BITCOIN_ACTIVE_CONTEXT_H
+#define BITCOIN_ACTIVE_CONTEXT_H
+
+#include <llmq/options.h>
+
+#include <validationinterface.h>
+
+#include <memory>
+
+class CActiveMasternodeManager;
+class CBLSSecretKey;
+class CBLSWorker;
+class ChainstateManager;
+class CCoinJoinServer;
+class CConnman;
+class CDeterministicMNManager;
+class CDSTXManager;
+class CGovernanceManager;
+class CMasternodeMetaMan;
+class CMasternodeSync;
+class CMNHFManager;
+class CSporkManager;
+class CTxMemPool;
+class GovernanceSigner;
+class PeerManager;
+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 final : public CValidationInterface {
+private:
+    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(CBLSWorker& bls_worker, ChainstateManager& chainman, CConnman& connman,
+                           CDeterministicMNManager& dmnman, CDSTXManager& dstxman, 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();
+
+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
+     */
+    const std::unique_ptr<CActiveMasternodeManager> nodeman;
+    const std::unique_ptr<CCoinJoinServer> cj_server;
+    const std::unique_ptr<llmq::CDKGDebugManager> dkgdbgman;
+    const std::unique_ptr<llmq::CDKGSessionManager> qdkgsman;
+    const std::unique_ptr<llmq::CSigSharesManager> shareman;
+
+private:
+    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;
+};
+
+#endif // BITCOIN_ACTIVE_CONTEXT_H