refactor: move CSigSharesManager to ActiveContext, drop CActiveMasternodeManager from CSigSharesManager

src/Makefile.am

@@ -135,6 +135,8 @@ endif
 .PHONY: FORCE check-symbols check-security
 # dash core #
 BITCOIN_CORE_H = \
+  active/context.h \
+  active/notificationinterface.h \
   addrdb.h \
   addressindex.h \
   spentindex.h \
@@ -258,6 +260,7 @@ BITCOIN_CORE_H = \
   llmq/signing.h \
   llmq/signing_shares.h \
   llmq/snapshot.h \
+  llmq/types.h \
   llmq/utils.h \
   logging.h \
   logging/timer.h \
@@ -450,6 +453,8 @@ 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/notificationinterface.cpp \
   addrdb.cpp \
   addressindex.cpp \
   addrman.cpp \

src/active/context.cpp

@@ -0,0 +1,62 @@
+// 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 <chainlock/chainlock.h>
+#include <chainlock/signing.h>
+#include <coinjoin/server.h>
+#include <instantsend/instantsend.h>
+#include <instantsend/signing.h>
+#include <llmq/context.h>
+#include <llmq/dkgsessionmgr.h>
+#include <llmq/ehf_signals.h>
+#include <llmq/signing_shares.h>
+#include <validation.h>
+
+ActiveContext::ActiveContext(ChainstateManager& chainman, CConnman& connman, CDeterministicMNManager& dmnman,
+                             CDSTXManager& dstxman, CMasternodeMetaMan& mn_metaman, CMNHFManager& mnhfman,
+                             LLMQContext& llmq_ctx, CSporkManager& sporkman, CTxMemPool& mempool, PeerManager& peerman,
+                             const CActiveMasternodeManager& mn_activeman, const CMasternodeSync& mn_sync) :
+    m_llmq_ctx{llmq_ctx},
+    cj_server{std::make_unique<CCoinJoinServer>(chainman, connman, dmnman, dstxman, mn_metaman, mempool, peerman,
+                                                mn_activeman, mn_sync, *llmq_ctx.isman)},
+    shareman{std::make_unique<llmq::CSigSharesManager>(connman, chainman.ActiveChainstate(), *llmq_ctx.sigman, peerman,
+                                                       mn_activeman, *llmq_ctx.qman, sporkman)},
+    ehf_sighandler{
+        std::make_unique<llmq::CEHFSignalsHandler>(chainman, mnhfman, *llmq_ctx.sigman, *shareman, *llmq_ctx.qman)},
+    cl_signer{std::make_unique<chainlock::ChainLockSigner>(chainman.ActiveChainstate(), *llmq_ctx.clhandler,
+                                                           *llmq_ctx.sigman, *shareman, sporkman, mn_sync)},
+    is_signer{std::make_unique<instantsend::InstantSendSigner>(chainman.ActiveChainstate(), *llmq_ctx.clhandler,
+                                                               *llmq_ctx.isman, *llmq_ctx.sigman, *shareman,
+                                                               *llmq_ctx.qman, sporkman, mempool, mn_sync)}
+{
+    m_llmq_ctx.clhandler->ConnectSigner(cl_signer.get());
+    m_llmq_ctx.isman->ConnectSigner(is_signer.get());
+}
+
+ActiveContext::~ActiveContext()
+{
+    m_llmq_ctx.clhandler->DisconnectSigner();
+    m_llmq_ctx.isman->DisconnectSigner();
+}
+
+void ActiveContext::Interrupt()
+{
+    shareman->InterruptWorkerThread();
+}
+
+void ActiveContext::Start(CConnman& connman, PeerManager& peerman)
+{
+    m_llmq_ctx.qdkgsman->StartThreads(connman, peerman);
+    shareman->RegisterAsRecoveredSigsListener();
+    shareman->StartWorkerThread();
+}
+
+void ActiveContext::Stop()
+{
+    shareman->StopWorkerThread();
+    shareman->UnregisterAsRecoveredSigsListener();
+    m_llmq_ctx.qdkgsman->StopThreads();
+}

src/active/context.h

@@ -0,0 +1,70 @@
+// 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 <memory>
+
+class CActiveMasternodeManager;
+class ChainstateManager;
+class CCoinJoinServer;
+class CConnman;
+class CDeterministicMNManager;
+class CDSTXManager;
+class CMasternodeMetaMan;
+class CMasternodeSync;
+class CMNHFManager;
+class CSporkManager;
+class CTxMemPool;
+class PeerManager;
+struct LLMQContext;
+namespace chainlock {
+class ChainLockSigner;
+} // namespace chainlock
+namespace instantsend {
+class InstantSendSigner;
+} // namespace instantsend
+namespace llmq {
+class CEHFSignalsHandler;
+class CSigSharesManager;
+} // namespace llmq
+
+struct ActiveContext {
+private:
+    // TODO: Switch to references to members when migration is finished
+    LLMQContext& m_llmq_ctx;
+
+public:
+    ActiveContext() = delete;
+    ActiveContext(const ActiveContext&) = delete;
+    ActiveContext(ChainstateManager& chainman, CConnman& connman, CDeterministicMNManager& dmnman,
+                  CDSTXManager& dstxman, CMasternodeMetaMan& mn_metaman, CMNHFManager& mnhfman, LLMQContext& llmq_ctx,
+                  CSporkManager& sporkman, CTxMemPool& mempool, PeerManager& peerman,
+                  const CActiveMasternodeManager& mn_activeman, const CMasternodeSync& mn_sync);
+    ~ActiveContext();
+
+    void Interrupt();
+    void Start(CConnman& connman, PeerManager& peerman);
+    void Stop();
+
+    /*
+     * 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
+     */
+    const std::unique_ptr<CCoinJoinServer> cj_server;
+    const std::unique_ptr<llmq::CSigSharesManager> shareman;
+    const std::unique_ptr<llmq::CEHFSignalsHandler> ehf_sighandler;
+
+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<chainlock::ChainLockSigner> cl_signer;
+    const std::unique_ptr<instantsend::InstantSendSigner> is_signer;
+};
+
+#endif // BITCOIN_ACTIVE_CONTEXT_H

src/active/notificationinterface.cpp

@@ -0,0 +1,33 @@
+// 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/notificationinterface.h>
+
+#include <active/context.h>
+#include <llmq/ehf_signals.h>
+#include <llmq/signing_shares.h>
+#include <masternode/node.h>
+
+ActiveNotificationInterface::ActiveNotificationInterface(ActiveContext& active_ctx, CActiveMasternodeManager& mn_activeman) :
+    m_active_ctx{active_ctx},
+    m_mn_activeman{mn_activeman}
+{
+}
+
+void ActiveNotificationInterface::UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork,
+                                                  bool fInitialDownload)
+{
+    if (fInitialDownload || pindexNew == pindexFork) // In IBD or blocks were disconnected without any new ones
+        return;
+
+    m_mn_activeman.UpdatedBlockTip(pindexNew, pindexFork, fInitialDownload);
+    m_active_ctx.ehf_sighandler->UpdatedBlockTip(pindexNew);
+}
+
+void ActiveNotificationInterface::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig)
+{
+    m_active_ctx.shareman->NotifyRecoveredSig(sig);
+}
+
+std::unique_ptr<ActiveNotificationInterface> g_active_notification_interface;

src/active/notificationinterface.h

@@ -0,0 +1,38 @@
+// 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_NOTIFICATIONINTERFACE_H
+#define BITCOIN_ACTIVE_NOTIFICATIONINTERFACE_H
+
+#include <validationinterface.h>
+
+#include <memory>
+
+class CActiveMasternodeManager;
+struct ActiveContext;
+namespace llmq {
+class CRecoveredSig;
+} // namespace llmq
+
+class ActiveNotificationInterface final : public CValidationInterface
+{
+public:
+    ActiveNotificationInterface() = delete;
+    ActiveNotificationInterface(const ActiveNotificationInterface&) = delete;
+    explicit ActiveNotificationInterface(ActiveContext& active_ctx, CActiveMasternodeManager& mn_activeman);
+    virtual ~ActiveNotificationInterface() = default;
+
+protected:
+    // CValidationInterface
+    void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig) override;
+    void UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload) override;
+
+private:
+    ActiveContext& m_active_ctx;
+    CActiveMasternodeManager& m_mn_activeman;
+};
+
+extern std::unique_ptr<ActiveNotificationInterface> g_active_notification_interface;
+
+#endif // BITCOIN_ACTIVE_NOTIFICATIONINTERFACE_H

src/chainlock/chainlock.cpp

@@ -43,20 +43,16 @@ bool AreChainLocksEnabled(const CSporkManager& sporkman)
     return sporkman.IsSporkActive(SPORK_19_CHAINLOCKS_ENABLED);
 }
 
-CChainLocksHandler::CChainLocksHandler(CChainState& chainstate, CQuorumManager& _qman, CSigningManager& _sigman,
-                                       CSigSharesManager& _shareman, CSporkManager& sporkman, CTxMemPool& _mempool,
-                                       const CMasternodeSync& mn_sync, bool is_masternode) :
+CChainLocksHandler::CChainLocksHandler(CChainState& chainstate, CQuorumManager& _qman, CSporkManager& sporkman,
+                                       CTxMemPool& _mempool, const CMasternodeSync& mn_sync) :
     m_chainstate{chainstate},
     qman{_qman},
     spork_manager{sporkman},
     mempool{_mempool},
     m_mn_sync{mn_sync},
     scheduler{std::make_unique<CScheduler>()},
     scheduler_thread{
-        std::make_unique<std::thread>(std::thread(util::TraceThread, "cl-schdlr", [&] { scheduler->serviceQueue(); }))},
-    m_signer{is_masternode
-                 ? std::make_unique<chainlock::ChainLockSigner>(chainstate, *this, _sigman, _shareman, sporkman, mn_sync)
-                 : nullptr}
+        std::make_unique<std::thread>(std::thread(util::TraceThread, "cl-schdlr", [&] { scheduler->serviceQueue(); }))}
 {
 }
 

src/chainlock/chainlock.h

@@ -14,6 +14,7 @@
 #include <sync.h>
 
 #include <chainlock/signing.h>
+#include <llmq/types.h>
 
 #include <gsl/pointers.h>
 
@@ -33,7 +34,6 @@ namespace llmq {
 class CInstantSendManager;
 class CQuorumManager;
 class CSigningManager;
-class CSigSharesManager;
 enum class VerifyRecSigStatus;
 
 class CChainLocksHandler final : public chainlock::ChainLockSignerParent
@@ -47,7 +47,7 @@ class CChainLocksHandler final : public chainlock::ChainLockSignerParent
     std::unique_ptr<CScheduler> scheduler;
     std::unique_ptr<std::thread> scheduler_thread;
 
-    std::unique_ptr<chainlock::ChainLockSigner> m_signer{nullptr};
+    chainlock::ChainLockSigner* m_signer{nullptr};
 
     mutable Mutex cs;
     std::atomic<bool> tryLockChainTipScheduled{false};
@@ -60,18 +60,25 @@ class CChainLocksHandler final : public chainlock::ChainLockSignerParent
     const CBlockIndex* bestChainLockBlockIndex GUARDED_BY(cs){nullptr};
     const CBlockIndex* lastNotifyChainLockBlockIndex GUARDED_BY(cs){nullptr};
 
-    std::unordered_map<uint256, std::chrono::seconds, StaticSaltedHasher> txFirstSeenTime GUARDED_BY(cs);
+    Uint256HashMap<std::chrono::seconds> txFirstSeenTime GUARDED_BY(cs);
 
     std::map<uint256, std::chrono::seconds> seenChainLocks GUARDED_BY(cs);
 
     std::atomic<std::chrono::seconds> lastCleanupTime{0s};
 
 public:
-    explicit CChainLocksHandler(CChainState& chainstate, CQuorumManager& _qman, CSigningManager& _sigman,
-                                CSigSharesManager& _shareman, CSporkManager& sporkman, CTxMemPool& _mempool,
-                                const CMasternodeSync& mn_sync, bool is_masternode);
+    explicit CChainLocksHandler(CChainState& chainstate, CQuorumManager& _qman, CSporkManager& sporkman,
+                                CTxMemPool& _mempool, const CMasternodeSync& mn_sync);
     ~CChainLocksHandler();
 
+    void ConnectSigner(gsl::not_null<chainlock::ChainLockSigner*> signer)
+    {
+        // Prohibit double initialization
+        assert(m_signer == nullptr);
+        m_signer = signer;
+    }
+    void DisconnectSigner() { m_signer = nullptr; }
+
     void Start(const llmq::CInstantSendManager& isman);
     void Stop();
 

src/chainlock/signing.cpp

@@ -9,6 +9,7 @@
 
 #include <chainlock/clsig.h>
 #include <instantsend/instantsend.h>
+#include <llmq/signing_shares.h>
 #include <masternode/sync.h>
 #include <spork.h>
 
@@ -140,7 +141,7 @@ void ChainLockSigner::TrySignChainTip(const llmq::CInstantSendManager& isman)
         lastSignedMsgHash = msgHash;
     }
 
-    m_sigman.AsyncSignIfMember(Params().GetConsensus().llmqTypeChainLocks, m_shareman, requestId, msgHash);
+    m_shareman.AsyncSignIfMember(Params().GetConsensus().llmqTypeChainLocks, m_sigman, requestId, msgHash);
 }
 
 void ChainLockSigner::EraseFromBlockHashTxidMap(const uint256& hash)

src/coinjoin/client.h

@@ -5,14 +5,15 @@
 #ifndef BITCOIN_COINJOIN_CLIENT_H
 #define BITCOIN_COINJOIN_CLIENT_H
 
-#include <coinjoin/util.h>
-#include <coinjoin/coinjoin.h>
-
 #include <net_types.h>
 #include <protocol.h>
 #include <util/ranges.h>
 #include <util/translation.h>
 
+#include <coinjoin/coinjoin.h>
+#include <coinjoin/util.h>
+#include <llmq/types.h>
+
 #include <atomic>
 #include <deque>
 #include <memory>
@@ -21,7 +22,6 @@
 class CCoinJoinClientManager;
 class CCoinJoinClientQueueManager;
 class CConnman;
-class CDeterministicMN;
 class CDeterministicMNManager;
 class ChainstateManager;
 class CMasternodeMetaMan;
@@ -33,8 +33,6 @@ class PeerManager;
 
 class UniValue;
 
-using CDeterministicMNCPtr = std::shared_ptr<const CDeterministicMN>;
-
 class CPendingDsaRequest
 {
 private:

src/coinjoin/context.cpp

@@ -7,22 +7,19 @@
 #ifdef ENABLE_WALLET
 #include <coinjoin/client.h>
 #endif // ENABLE_WALLET
-#include <coinjoin/server.h>
+#include <coinjoin/coinjoin.h>
 
-CJContext::CJContext(ChainstateManager& chainman, CConnman& connman, CDeterministicMNManager& dmnman,
-                     CMasternodeMetaMan& mn_metaman, CTxMemPool& mempool,
-                     const CActiveMasternodeManager* const mn_activeman, const CMasternodeSync& mn_sync,
-                     const llmq::CInstantSendManager& isman, std::unique_ptr<PeerManager>& peerman, bool relay_txes) :
-    dstxman{std::make_unique<CDSTXManager>()},
+CJContext::CJContext(ChainstateManager& chainman, CDeterministicMNManager& dmnman, CMasternodeMetaMan& mn_metaman,
+                     CTxMemPool& mempool, const CActiveMasternodeManager* const mn_activeman,
+                     const CMasternodeSync& mn_sync, const llmq::CInstantSendManager& isman, bool relay_txes) :
 #ifdef ENABLE_WALLET
     walletman{std::make_unique<CoinJoinWalletManager>(chainman, dmnman, mn_metaman, mempool, mn_sync, isman, queueman,
                                                       /*is_masternode=*/mn_activeman != nullptr)},
     queueman{relay_txes ? std::make_unique<CCoinJoinClientQueueManager>(*walletman, dmnman, mn_metaman, mn_sync,
                                                                         /*is_masternode=*/mn_activeman != nullptr)
                         : nullptr},
 #endif // ENABLE_WALLET
-    server{std::make_unique<CCoinJoinServer>(chainman, connman, dmnman, *dstxman, mn_metaman, mempool, mn_activeman,
-                                             mn_sync, isman, peerman)}
+    dstxman{std::make_unique<CDSTXManager>()}
 {}
 
 CJContext::~CJContext() {}