refactor: move ChainLock signer to ActiveContext

Author: kwvg

src/chainlock/chainlock.cpp

@@ -44,19 +44,15 @@ bool AreChainLocksEnabled(const CSporkManager& sporkman)
 }
 
 CChainLocksHandler::CChainLocksHandler(CChainState& chainstate, CQuorumManager& _qman, CSigningManager& _sigman,
-                                       CSigSharesManager& _shareman, CSporkManager& sporkman, CTxMemPool& _mempool,
-                                       const CMasternodeSync& mn_sync, bool is_masternode) :
+                                       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

@@ -33,7 +33,6 @@ namespace llmq {
 class CInstantSendManager;
 class CQuorumManager;
 class CSigningManager;
-class CSigSharesManager;
 enum class VerifyRecSigStatus;
 
 class CChainLocksHandler final : public chainlock::ChainLockSignerParent
@@ -47,7 +46,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};
@@ -68,10 +67,17 @@ class CChainLocksHandler final : public chainlock::ChainLockSignerParent
 
 public:
     explicit CChainLocksHandler(CChainState& chainstate, CQuorumManager& _qman, CSigningManager& _sigman,
-                                CSigSharesManager& _shareman, CSporkManager& sporkman, CTxMemPool& _mempool,
-                                const CMasternodeSync& mn_sync, bool is_masternode);
+                                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/llmq/context.cpp

@@ -35,8 +35,8 @@ LLMQContext::LLMQContext(ChainstateManager& chainman, CDeterministicMNManager& d
                                                 unit_tests, wipe)},
     sigman{std::make_unique<llmq::CSigningManager>(mn_activeman, chainman.ActiveChainstate(), *qman, unit_tests, wipe)},
     shareman{std::make_unique<llmq::CSigSharesManager>(*sigman, mn_activeman, *qman, sporkman)},
-    clhandler{std::make_unique<llmq::CChainLocksHandler>(chainman.ActiveChainstate(), *qman, *sigman, *shareman,
-                                                         sporkman, mempool, mn_sync, is_masternode)},
+    clhandler{std::make_unique<llmq::CChainLocksHandler>(chainman.ActiveChainstate(), *qman, *sigman, sporkman, mempool,
+                                                         mn_sync)},
     isman{std::make_unique<llmq::CInstantSendManager>(*clhandler, chainman.ActiveChainstate(), *qman, *sigman, sporkman,
                                                       mempool, mn_sync, unit_tests, wipe)},
     ehfSignalsHandler{std::make_unique<llmq::CEHFSignalsHandler>(chainman, mnhfman, *sigman, *shareman, *qman)}

src/masternode/active/context.cpp

@@ -4,21 +4,27 @@
 
 #include <masternode/active/context.h>
 
+#include <chainlock/chainlock.h>
+#include <chainlock/signing.h>
 #include <instantsend/instantsend.h>
 #include <instantsend/signing.h>
 #include <llmq/context.h>
 
 ActiveContext::ActiveContext(CChainState& chainstate, LLMQContext& llmq_ctx, CSporkManager& sporkman,
                              CTxMemPool& mempool, const CMasternodeSync& mn_sync) :
     m_llmq_ctx{llmq_ctx},
+    cl_signer{std::make_unique<chainlock::ChainLockSigner>(chainstate, *llmq_ctx.clhandler, *llmq_ctx.sigman,
+                                                           *llmq_ctx.shareman, sporkman, mn_sync)},
     is_signer{std::make_unique<instantsend::InstantSendSigner>(chainstate, *llmq_ctx.clhandler, *llmq_ctx.isman,
                                                                *llmq_ctx.sigman, *llmq_ctx.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();
 }

src/masternode/active/context.h

@@ -12,6 +12,9 @@ class CMasternodeSync;
 class CSporkManager;
 class CTxMemPool;
 struct LLMQContext;
+namespace chainlock {
+class ChainLockSigner;
+} // namespace chainlock
 namespace instantsend {
 class InstantSendSigner;
 } // namespace instantsend
@@ -24,6 +27,7 @@ struct ActiveContext {
      * 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;
 
 public: