refactor: move EHF signals handler to ActiveContext

Author: kwvg

src/dsnotificationinterface.cpp

@@ -92,7 +92,6 @@ void CDSNotificationInterface::UpdatedBlockTip(const CBlockIndex *pindexNew, con
 
     m_llmq_ctx->qman->UpdatedBlockTip(pindexNew, m_connman, fInitialDownload);
     m_llmq_ctx->qdkgsman->UpdatedBlockTip(pindexNew, fInitialDownload);
-    m_llmq_ctx->ehfSignalsHandler->UpdatedBlockTip(pindexNew, /* is_masternode = */ m_mn_activeman != nullptr);
 
     if (m_govman.IsValid()) {
         m_govman.UpdatedBlockTip(pindexNew, m_connman, m_peerman, m_mn_activeman);

src/init.cpp

@@ -2167,10 +2167,10 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     assert(!node.active_ctx);
     assert(!g_active_notification_interface);
     if (node.mn_activeman) {
-        node.active_ctx = std::make_unique<ActiveContext>(chainman, *node.connman, *node.dmnman, *node.cj_ctx->dstxman, *node.mn_metaman,
+        node.active_ctx = std::make_unique<ActiveContext>(chainman, *node.connman, *node.dmnman, *node.cj_ctx->dstxman, *node.mn_metaman, *node.mnhf_manager,
                                                           *node.llmq_ctx, *node.sporkman, *node.mempool, *node.peerman, *node.mn_activeman,
                                                           *node.mn_sync);
-        g_active_notification_interface = std::make_unique<ActiveNotificationInterface>(*node.mn_activeman);
+        g_active_notification_interface = std::make_unique<ActiveNotificationInterface>(*node.active_ctx, *node.mn_activeman);
         RegisterValidationInterface(g_active_notification_interface.get());
     }
 

src/llmq/context.cpp

@@ -10,7 +10,6 @@
 #include <llmq/blockprocessor.h>
 #include <llmq/debug.h>
 #include <llmq/dkgsessionmgr.h>
-#include <llmq/ehf_signals.h>
 #include <llmq/quorums.h>
 #include <llmq/signing.h>
 #include <llmq/signing_shares.h>
@@ -38,8 +37,7 @@ LLMQContext::LLMQContext(ChainstateManager& chainman, CDeterministicMNManager& d
     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)}
+                                                      mempool, mn_sync, unit_tests, wipe)}
 {
     // Have to start it early to let VerifyDB check ChainLock signatures in coinbase
     bls_worker->Start();

src/llmq/context.h

@@ -24,7 +24,6 @@ namespace llmq {
 class CChainLocksHandler;
 class CDKGDebugManager;
 class CDKGSessionManager;
-class CEHFSignalsHandler;
 class CInstantSendManager;
 class CQuorumBlockProcessor;
 class CQuorumManager;
@@ -70,7 +69,6 @@ struct LLMQContext {
     const std::unique_ptr<llmq::CSigSharesManager> shareman;
     const std::unique_ptr<llmq::CChainLocksHandler> clhandler;
     const std::unique_ptr<llmq::CInstantSendManager> isman;
-    const std::unique_ptr<llmq::CEHFSignalsHandler> ehfSignalsHandler;
 };
 
 #endif // BITCOIN_LLMQ_CONTEXT_H

src/llmq/ehf_signals.cpp

@@ -34,14 +34,10 @@ CEHFSignalsHandler::~CEHFSignalsHandler()
     sigman.UnregisterRecoveredSigsListener(this);
 }
 
-void CEHFSignalsHandler::UpdatedBlockTip(const CBlockIndex* const pindexNew, bool is_masternode)
+void CEHFSignalsHandler::UpdatedBlockTip(const CBlockIndex* const pindexNew)
 {
     if (!DeploymentActiveAfter(pindexNew, Params().GetConsensus(), Consensus::DEPLOYMENT_V20)) return;
 
-    if (!is_masternode) {
-        return;
-    }
-
     const auto ehfSignals = mnhfman.GetSignalsStage(pindexNew);
     for (const auto& deployment : Params().GetConsensus().vDeployments) {
         // Skip deployments that do not use dip0023

src/llmq/ehf_signals.h

@@ -43,7 +43,7 @@ class CEHFSignalsHandler : public CRecoveredSigsListener
     /**
      * Since Tip is updated it could be a time to generate EHF Signal
      */
-    void UpdatedBlockTip(const CBlockIndex* const pindexNew, bool is_masternode) EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    void UpdatedBlockTip(const CBlockIndex* const pindexNew) EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
     [[nodiscard]] MessageProcessingResult HandleNewRecoveredSig(const CRecoveredSig& recoveredSig) override
         EXCLUSIVE_LOCKS_REQUIRED(!cs);

src/masternode/active/context.cpp

@@ -10,11 +10,12 @@
 #include <instantsend/instantsend.h>
 #include <instantsend/signing.h>
 #include <llmq/context.h>
+#include <llmq/ehf_signals.h>
 #include <validation.h>
 
 ActiveContext::ActiveContext(ChainstateManager& chainman, CConnman& connman, CDeterministicMNManager& dmnman,
-                             CDSTXManager& dstxman, CMasternodeMetaMan& mn_metaman, LLMQContext& llmq_ctx,
-                             CSporkManager& sporkman, CTxMemPool& mempool, PeerManager& peerman,
+                             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},
     cl_signer{std::make_unique<chainlock::ChainLockSigner>(chainman.ActiveChainstate(), *llmq_ctx.clhandler,
@@ -23,7 +24,9 @@ ActiveContext::ActiveContext(ChainstateManager& chainman, CConnman& connman, CDe
                                                                *llmq_ctx.isman, *llmq_ctx.sigman, *llmq_ctx.shareman,
                                                                *llmq_ctx.qman, sporkman, mempool, mn_sync)},
     cj_server{std::make_unique<CCoinJoinServer>(chainman, connman, dmnman, dstxman, mn_metaman, mempool, peerman,
-                                                mn_activeman, mn_sync, *llmq_ctx.isman)}
+                                                mn_activeman, mn_sync, *llmq_ctx.isman)},
+    ehf_sighandler{std::make_unique<llmq::CEHFSignalsHandler>(chainman, mnhfman, *llmq_ctx.sigman, *llmq_ctx.shareman,
+                                                              *llmq_ctx.qman)}
 {
     m_llmq_ctx.clhandler->ConnectSigner(cl_signer.get());
     m_llmq_ctx.isman->ConnectSigner(is_signer.get());

src/masternode/active/context.h

@@ -15,6 +15,7 @@ class CDeterministicMNManager;
 class CDSTXManager;
 class CMasternodeMetaMan;
 class CMasternodeSync;
+class CMNHFManager;
 class CSporkManager;
 class CTxMemPool;
 class PeerManager;
@@ -25,6 +26,9 @@ class ChainLockSigner;
 namespace instantsend {
 class InstantSendSigner;
 } // namespace instantsend
+namespace llmq {
+class CEHFSignalsHandler;
+} // namespace llmq
 
 struct ActiveContext {
 private:
@@ -41,9 +45,10 @@ struct ActiveContext {
 public:
     ActiveContext() = delete;
     ActiveContext(const ActiveContext&) = delete;
-    ActiveContext(ChainstateManager& chainman, CConnman& connman, CDeterministicMNManager& dmnman, CDSTXManager& dstxman,
-                  CMasternodeMetaMan& mn_metaman, LLMQContext& llmq_ctx, CSporkManager& sporkman, CTxMemPool& mempool,
-                  PeerManager& peerman, const CActiveMasternodeManager& mn_activeman, const CMasternodeSync& mn_sync);
+    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();
 
     /*
@@ -52,6 +57,7 @@ struct ActiveContext {
      * TODO: Move CActiveMasternodeManager here when dependents have been migrated
      */
     const std::unique_ptr<CCoinJoinServer> cj_server;
+    const std::unique_ptr<llmq::CEHFSignalsHandler> ehf_sighandler;
 };
 
 #endif // BITCOIN_MASTERNODE_ACTIVE_CONTEXT_H

src/masternode/active/notificationinterface.cpp

@@ -4,9 +4,12 @@
 
 #include <masternode/active/notificationinterface.h>
 
+#include <llmq/ehf_signals.h>
+#include <masternode/active/context.h>
 #include <masternode/node.h>
 
-ActiveNotificationInterface::ActiveNotificationInterface(CActiveMasternodeManager& mn_activeman) :
+ActiveNotificationInterface::ActiveNotificationInterface(ActiveContext& active_ctx, CActiveMasternodeManager& mn_activeman) :
+    m_active_ctx{active_ctx},
     m_mn_activeman{mn_activeman}
 {
 }
@@ -18,6 +21,7 @@ void ActiveNotificationInterface::UpdatedBlockTip(const CBlockIndex* pindexNew,
         return;
 
     m_mn_activeman.UpdatedBlockTip(pindexNew, pindexFork, fInitialDownload);
+    m_active_ctx.ehf_sighandler->UpdatedBlockTip(pindexNew);
 }
 
 std::unique_ptr<ActiveNotificationInterface> g_active_notification_interface;

src/masternode/active/notificationinterface.h

@@ -8,20 +8,22 @@
 #include <validationinterface.h>
 
 class CActiveMasternodeManager;
+struct ActiveContext;
 
 class ActiveNotificationInterface final : public CValidationInterface
 {
 public:
     ActiveNotificationInterface() = delete;
     ActiveNotificationInterface(const ActiveNotificationInterface&) = delete;
-    explicit ActiveNotificationInterface(CActiveMasternodeManager& mn_activeman);
+    explicit ActiveNotificationInterface(ActiveContext& active_ctx, CActiveMasternodeManager& mn_activeman);
     virtual ~ActiveNotificationInterface() = default;
 
 protected:
     // CValidationInterface
     void UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload) override;
 
 private:
+    ActiveContext& m_active_ctx;
     CActiveMasternodeManager& m_mn_activeman;
 };