refactor: keep base DKG handler lightweight, follow IWYU

kwvg · UdjinM6 · kwvg · commit a93f8ae79724 · 2026-01-06T23:26:30.000+05:30
Co-authored-by: UdjinM6 &lt;UdjinM6@users.noreply.github.com&gt;
diff --git a/src/active/dkgsessionhandler.cpp b/src/active/dkgsessionhandler.cpp
@@ -24,8 +24,7 @@ ActiveDKGSessionHandler::ActiveDKGSessionHandler(
     llmq::CDKGDebugManager& dkgdbgman, llmq::CDKGSessionManager& qdkgsman, llmq::CQuorumBlockProcessor& qblockman,
     llmq::CQuorumSnapshotManager& qsnapman, const CActiveMasternodeManager& mn_activeman, const ChainstateManager& chainman,
     const CSporkManager& sporkman, const Consensus::LLMQParams& llmq_params, bool quorums_watch, int quorums_idx) :
-    llmq::CDKGSessionHandler(bls_worker, dmnman, dkgdbgman, qdkgsman, qsnapman, chainman, llmq_params, quorums_watch,
-                             quorums_idx),
+    llmq::CDKGSessionHandler(llmq_params),
     m_bls_worker{bls_worker},
     m_dmnman{dmnman},
     m_mn_metaman{mn_metaman},
@@ -36,7 +35,8 @@ ActiveDKGSessionHandler::ActiveDKGSessionHandler(
     m_mn_activeman{mn_activeman},
     m_chainman{chainman},
     m_sporkman{sporkman},
-    m_quorums_watch{quorums_watch}
+    m_quorums_watch{quorums_watch},
+    quorumIndex{quorums_idx}
 {
 }
 
diff --git a/src/active/dkgsessionhandler.h b/src/active/dkgsessionhandler.h
@@ -9,6 +9,33 @@
 
 #include <gsl/pointers.h>
 
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <thread>
+
+class CActiveMasternodeManager;
+class CBLSWorker;
+class CBlockIndex;
+class CConnman;
+class ChainstateManager;
+class CDeterministicMNManager;
+class CMasternodeMetaMan;
+class CSporkManager;
+class PeerManager;
+namespace Consensus {
+struct LLMQParams;
+} // namespace Consensus
+namespace llmq {
+class CDKGSession;
+class CDKGDebugManager;
+class CDKGSessionManager;
+class CQuorumBlockProcessor;
+class CQuorumSnapshotManager;
+} // namespace llmq
+
 namespace llmq {
 class ActiveDKGSessionHandler final : public llmq::CDKGSessionHandler
 {
@@ -27,12 +54,14 @@ class ActiveDKGSessionHandler final : public llmq::CDKGSessionHandler
     const ChainstateManager& m_chainman;
     const CSporkManager& m_sporkman;
     const bool m_quorums_watch{false};
+    const int quorumIndex;
 
 private:
     std::atomic<bool> stopRequested{false};
     std::atomic<int> currentHeight{-1};
     std::string m_thread_name;
     std::thread phaseHandlerThread;
+    std::unique_ptr<CDKGSession> curSession{nullptr};
 
     mutable Mutex cs_phase_qhash;
     QuorumPhase phase GUARDED_BY(cs_phase_qhash){QuorumPhase::Idle};
diff --git a/src/llmq/dkgsessionhandler.cpp b/src/llmq/dkgsessionhandler.cpp
@@ -4,27 +4,15 @@
 
 #include <llmq/dkgsessionhandler.h>
 
-#include <evo/deterministicmns.h>
-#include <llmq/commitment.h>
-#include <llmq/debug.h>
-#include <llmq/dkgsession.h>
-#include <llmq/options.h>
-#include <llmq/utils.h>
-#include <util/underlying.h>
-
-#include <deploymentstatus.h>
-#include <chainparams.h>
-#include <net_processing.h>
-#include <validation.h>
-#include <util/thread.h>
+#include <hash.h>
+#include <logging.h>
+#include <span.h>
+
+#include <stdexcept>
 
 namespace llmq {
-CDKGSessionHandler::CDKGSessionHandler(CBLSWorker& _blsWorker, CDeterministicMNManager& dmnman,
-                                       CDKGDebugManager& _dkgDebugManager, CDKGSessionManager& _dkgManager,
-                                       CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
-                                       const Consensus::LLMQParams& _params, bool quorums_watch, int _quorumIndex) :
+CDKGSessionHandler::CDKGSessionHandler(const Consensus::LLMQParams& _params) :
     params{_params},
-    quorumIndex{_quorumIndex},
     // we allow size*2 messages as we need to make sure we see bad behavior (double messages)
     pendingContributions{(size_t)_params.size * 2, MSG_QUORUM_CONTRIB},
     pendingComplaints{(size_t)_params.size * 2, MSG_QUORUM_COMPLAINT},
diff --git a/src/llmq/dkgsessionhandler.h b/src/llmq/dkgsessionhandler.h
@@ -9,39 +9,34 @@
 
 #include <net.h> // for NodeId
 #include <net_processing.h>
+#include <protocol.h>
+#include <serialize.h>
+#include <streams.h>
+#include <sync.h>
+#include <uint256.h>
 
-#include <atomic>
 #include <list>
 #include <map>
 #include <memory>
-#include <optional>
 #include <set>
-#include <string>
 #include <string_view>
-#include <thread>
 #include <vector>
 
-class CActiveMasternodeManager;
-class CBLSWorker;
 class CBlockIndex;
 class CConnman;
-class ChainstateManager;
-class CDeterministicMNManager;
-class CMasternodeMetaMan;
-class CSporkManager;
 class PeerManager;
 
+namespace Consensus {
+struct LLMQParams;
+} // namespace Consensus
+
 namespace llmq
 {
 class CDKGContribution;
 class CDKGComplaint;
 class CDKGJustification;
 class CDKGPrematureCommitment;
-class CDKGDebugManager;
-class CDKGSession;
 class CDKGSessionManager;
-class CQuorumBlockProcessor;
-class CQuorumSnapshotManager;
 
 enum class QuorumPhase {
     Initialized = 1,
@@ -131,9 +126,7 @@ class CDKGSessionHandler
     friend class CDKGSessionManager;
 
 protected:
-    std::unique_ptr<CDKGSession> curSession{nullptr};
     const Consensus::LLMQParams& params;
-    const int quorumIndex;
 
     // Do not guard these, they protect their internals themselves
     CDKGPendingMessages pendingContributions;
@@ -142,9 +135,7 @@ class CDKGSessionHandler
     CDKGPendingMessages pendingPrematureCommitments;
 
 public:
-    CDKGSessionHandler(CBLSWorker& _blsWorker, CDeterministicMNManager& dmnman, CDKGDebugManager& _dkgDebugManager,
-                       CDKGSessionManager& _dkgManager, CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
-                       const Consensus::LLMQParams& _params, bool quorums_watch, int _quorumIndex);
+    explicit CDKGSessionHandler(const Consensus::LLMQParams& _params);
     virtual ~CDKGSessionHandler();
 
     [[nodiscard]] MessageProcessingResult ProcessMessage(NodeId from, std::string_view msg_type, CDataStream& vRecv);
diff --git a/src/llmq/observer/context.cpp b/src/llmq/observer/context.cpp
@@ -26,9 +26,8 @@ ObserverContext::ObserverContext(CBLSWorker& bls_worker, CConnman& connman, CDet
                                                         sync_map, quorums_recovery)}
 {
     qdkgsman->InitializeHandlers([&](const Consensus::LLMQParams& llmq_params,
-                                     int quorum_idx) -> std::unique_ptr<llmq::CDKGSessionHandler> {
-        return std::make_unique<llmq::CDKGSessionHandler>(bls_worker, dmnman, *dkgdbgman, *qdkgsman, qsnapman, chainman,
-                                                          llmq_params, /*quorums_watch=*/true, quorum_idx);
+                                     [[maybe_unused]] int quorum_idx) -> std::unique_ptr<llmq::CDKGSessionHandler> {
+        return std::make_unique<llmq::CDKGSessionHandler>(llmq_params);
     });
     m_qman.ConnectManagers(qman_handler.get(), qdkgsman.get());
 }

Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,8 @@ ObserverContext::ObserverContext(CBLSWorker& bls_worker, CConnman& connman, CDet`
`26`	`26`	`sync_map, quorums_recovery)}`
`27`	`27`	`{`
`28`	`28`	`qdkgsman->InitializeHandlers([&](const Consensus::LLMQParams& llmq_params,`
`29`		`- int quorum_idx) -> std::unique_ptr<llmq::CDKGSessionHandler> {`
`30`		`- return std::make_unique<llmq::CDKGSessionHandler>(bls_worker, dmnman, dkgdbgman, qdkgsman, qsnapman, chainman,`
`31`		`- llmq_params, /quorums_watch=/true, quorum_idx);`
	`29`	`+ [[maybe_unused]] int quorum_idx) -> std::unique_ptr<llmq::CDKGSessionHandler> {`
	`30`	`+ return std::make_unique<llmq::CDKGSessionHandler>(llmq_params);`
`32`	`31`	`});`
`33`	`32`	`m_qman.ConnectManagers(qman_handler.get(), qdkgsman.get());`
`34`	`33`	`}`