refactor: abstract away parent implementation from handler

kwvg · kwvg · commit 25c87e40d581 · 2025-12-29T15:04:08.000+05:30
diff --git a/src/active/quorums.cpp b/src/active/quorums.cpp
@@ -9,7 +9,7 @@
 #include <llmq/commitment.h>
 #include <llmq/dkgsessionmgr.h>
 #include <llmq/options.h>
-#include <llmq/quorumsman.h>
+#include <llmq/quorums.h>
 #include <llmq/utils.h>
 #include <masternode/node.h>
 #include <masternode/sync.h>
@@ -25,7 +25,7 @@
 
 namespace llmq {
 QuorumParticipant::QuorumParticipant(CBLSWorker& bls_worker, CConnman& connman, CDeterministicMNManager& dmnman,
-                                     CQuorumManager& qman, CQuorumSnapshotManager& qsnapman,
+                                     QuorumHandlerParent& qman, CQuorumSnapshotManager& qsnapman,
                                      const CActiveMasternodeManager& mn_activeman, const ChainstateManager& chainman,
                                      const CMasternodeSync& mn_sync, const CSporkManager& sporkman,
                                      const llmq::QvvecSyncModeMap& sync_map, bool quorums_recovery, bool quorums_watch) :
@@ -123,9 +123,8 @@ MessageProcessingResult QuorumParticipant::ProcessEncryptedContribs(CNode& pfrom
             }
 
             std::vector<CBLSIESEncryptedObject<CBLSSecretKey>> vecEncrypted;
-            if (!m_qman.m_qdkgsman ||
-                !m_qman.m_qdkgsman->GetEncryptedContributions(request.GetLLMQType(), block_index,
-                                                              quorum.qc->validMembers, request.GetProTxHash(), vecEncrypted)) {
+            if (!m_qman.GetEncryptedContributions(request.GetLLMQType(), block_index,
+                                                  quorum.qc->validMembers, request.GetProTxHash(), vecEncrypted)) {
                 request.SetError(CQuorumDataRequest::Errors::ENCRYPTED_CONTRIBUTIONS_MISSING);
                 return request_limit_exceeded ? MisbehavingError{25, "request limit exceeded"} : MessageProcessingResult{};
             }
diff --git a/src/active/quorums.h b/src/active/quorums.h
@@ -7,7 +7,6 @@
 
 #include <bls/bls.h>
 #include <llmq/observer/quorums.h>
-#include <llmq/quorumsman.h>
 #include <llmq/types.h>
 #include <msg_result.h>
 
@@ -28,14 +27,14 @@ class CDeterministicMNManager;
 class CDKGSessionManager;
 class CNode;
 class CSporkManager;
-
 namespace llmq {
 class CQuorum;
 class CQuorumDataRequest;
-class CQuorumManager;
 class CQuorumSnapshotManager;
 enum class QvvecSyncMode : int8_t;
+} // namespace llmq
 
+namespace llmq {
 class QuorumParticipant final : public QuorumObserver
 {
 private:
@@ -48,7 +47,7 @@ class QuorumParticipant final : public QuorumObserver
     QuorumParticipant(const QuorumParticipant&) = delete;
     QuorumParticipant& operator=(const QuorumParticipant&) = delete;
     explicit QuorumParticipant(CBLSWorker& bls_worker, CConnman& connman, CDeterministicMNManager& dmnman,
-                               CQuorumManager& qman, CQuorumSnapshotManager& qsnapman,
+                               QuorumHandlerParent& qman, CQuorumSnapshotManager& qsnapman,
                                const CActiveMasternodeManager& mn_activeman, const ChainstateManager& chainman,
                                const CMasternodeSync& mn_sync, const CSporkManager& sporkman,
                                const llmq::QvvecSyncModeMap& sync_map, bool quorums_recovery, bool quorums_watch);
diff --git a/src/chainlock/chainlock.h b/src/chainlock/chainlock.h
@@ -38,7 +38,7 @@ namespace llmq {
 class CInstantSendManager;
 class CQuorumManager;
 class CSigningManager;
-enum class VerifyRecSigStatus;
+enum class VerifyRecSigStatus : uint8_t;
 
 class CChainLocksHandler final : public chainlock::ChainLockSignerParent
 {
diff --git a/src/llmq/observer/quorums.cpp b/src/llmq/observer/quorums.cpp
@@ -7,9 +7,10 @@
 #include <evo/deterministicmns.h>
 #include <llmq/commitment.h>
 #include <llmq/options.h>
-#include <llmq/quorumsman.h>
+#include <llmq/quorums.h>
 #include <llmq/utils.h>
 #include <masternode/sync.h>
+#include <unordered_lru_cache.h>
 
 #include <chain.h>
 #include <chainparams.h>
@@ -20,7 +21,7 @@
 #include <cxxtimer.hpp>
 
 namespace llmq {
-QuorumObserver::QuorumObserver(CConnman& connman, CDeterministicMNManager& dmnman, CQuorumManager& qman,
+QuorumObserver::QuorumObserver(CConnman& connman, CDeterministicMNManager& dmnman, QuorumHandlerParent& qman,
                                CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
                                const CMasternodeSync& mn_sync, const CSporkManager& sporkman,
                                const llmq::QvvecSyncModeMap& sync_map, bool quorums_recovery) :
@@ -66,18 +67,8 @@ void QuorumObserver::UpdatedBlockTip(const CBlockIndex* pindexNew, bool fInitial
         CheckQuorumConnections(params, pindexNew);
     }
 
-    {
-        // Cleanup expired data requests
-        LOCK(m_qman.cs_data_requests);
-        auto it = m_qman.mapQuorumDataRequests.begin();
-        while (it != m_qman.mapQuorumDataRequests.end()) {
-            if (it->second.IsExpired(/*add_bias=*/true)) {
-                it = m_qman.mapQuorumDataRequests.erase(it);
-            } else {
-                ++it;
-            }
-        }
-    }
+    // Cleanup expired data requests
+    m_qman.CleanupExpiredDataRequests();
 
     TriggerQuorumDataRecoveryThreads(pindexNew);
     StartCleanupOldQuorumDataThread(pindexNew);
@@ -231,14 +222,10 @@ void QuorumObserver::DataRecoveryThread(gsl::not_null<const CBlockIndex*> block_
                 }
                 // Access the member list of the quorum with the calculated offset applied to balance the load equally
                 pCurrentMemberHash = &vecMemberHashes[(start_offset + nTries++) % vecMemberHashes.size()];
-                {
-                    LOCK(m_qman.cs_data_requests);
-                    const CQuorumDataRequestKey key(*pCurrentMemberHash, true, pQuorum->qc->quorumHash, pQuorum->qc->llmqType);
-                    auto it = m_qman.mapQuorumDataRequests.find(key);
-                    if (it != m_qman.mapQuorumDataRequests.end() && !it->second.IsExpired(/*add_bias=*/true)) {
-                        printLog("Already asked");
-                        continue;
-                    }
+                if (m_qman.IsDataRequestPending(*pCurrentMemberHash, /*we_requested=*/true, pQuorum->qc->quorumHash,
+                                                pQuorum->qc->llmqType)) {
+                    printLog("Already asked");
+                    continue;
                 }
                 // Sleep a bit depending on the start offset to balance out multiple requests to same masternode
                 quorumThreadInterrupt.sleep_for(std::chrono::milliseconds(start_offset * 100));
@@ -257,20 +244,20 @@ void QuorumObserver::DataRecoveryThread(gsl::not_null<const CBlockIndex*> block_
                     nTimeLastSuccess = GetTime<std::chrono::seconds>().count();
                     printLog("Requested");
                 } else {
-                    LOCK(m_qman.cs_data_requests);
-                    const CQuorumDataRequestKey key(*pCurrentMemberHash, true, pQuorum->qc->quorumHash, pQuorum->qc->llmqType);
-                    auto it = m_qman.mapQuorumDataRequests.find(key);
-                    if (it == m_qman.mapQuorumDataRequests.end()) {
+                    const auto status = m_qman.GetDataRequestStatus(*pCurrentMemberHash, /*we_requested=*/true,
+                                                                    pQuorum->qc->quorumHash, pQuorum->qc->llmqType);
+                    switch (status) {
+                    case DataRequestStatus::NotFound:
                         printLog("Failed");
                         pNode->fDisconnect = true;
                         pCurrentMemberHash = nullptr;
                         return;
-                    } else if (it->second.IsProcessed()) {
+                    case DataRequestStatus::Processed:
                         printLog("Processed");
                         pNode->fDisconnect = true;
                         pCurrentMemberHash = nullptr;
                         return;
-                    } else {
+                    case DataRequestStatus::Pending:
                         printLog("Waiting");
                         return;
                     }
@@ -377,7 +364,7 @@ void QuorumObserver::StartCleanupOldQuorumDataThread(gsl::not_null<const CBlockI
         }
 
         if (!quorumThreadInterrupt) {
-            WITH_LOCK(m_qman.cs_db, DataCleanupHelper(*m_qman.db, dbKeysToSkip));
+            m_qman.CleanupOldQuorumData(dbKeysToSkip);
         }
 
         LogPrint(BCLog::LLMQ, "QuorumObserver::StartCleanupOldQuorumDataThread -- done. time=%d\n", t.count());
diff --git a/src/llmq/observer/quorums.h b/src/llmq/observer/quorums.h
@@ -6,7 +6,8 @@
 #define BITCOIN_LLMQ_OBSERVER_QUORUMS_H
 
 #include <bls/bls.h>
-#include <llmq/quorumsman.h>
+#include <bls/bls_ies.h>
+#include <llmq/options.h>
 #include <llmq/types.h>
 #include <msg_result.h>
 
@@ -16,23 +17,58 @@
 #include <sync.h>
 #include <threadsafety.h>
 #include <uint256.h>
+#include <util/threadinterrupt.h>
 
 #include <ctpl_stl.h>
+#include <gsl/pointers.h>
 
 #include <map>
+#include <set>
 
 class CConnman;
+class CDataStream;
+class CDeterministicMNManager;
+class CMasternodeSync;
+class CNode;
+class CSporkManager;
+namespace llmq {
+class CQuorumDataRequest;
+class CQuorumSnapshotManager;
+} // namespace llmq
 
 namespace llmq {
-class CQuorumManager;
-enum class QvvecSyncMode : int8_t;
+enum class DataRequestStatus : uint8_t {
+    NotFound,
+    Pending,
+    Processed,
+};
+
+class QuorumHandlerParent
+{
+public:
+    virtual ~QuorumHandlerParent() = default;
+    virtual bool GetEncryptedContributions(Consensus::LLMQType llmq_type, const CBlockIndex* block_index,
+                                           const std::vector<bool>& valid_members, const uint256& protx_hash,
+                                           std::vector<CBLSIESEncryptedObject<CBLSSecretKey>>& vec_enc) const = 0;
+    virtual bool IsDataRequestPending(const uint256& proRegTx, bool we_requested, const uint256& quorumHash,
+                                      Consensus::LLMQType llmqType) const = 0;
+    virtual bool RequestQuorumData(CNode* pfrom, CConnman& connman, const CQuorum& quorum, uint16_t nDataMask,
+                                   const uint256& proTxHash) const = 0;
+    virtual DataRequestStatus GetDataRequestStatus(const uint256& proRegTx, bool we_requested,
+                                                   const uint256& quorumHash, Consensus::LLMQType llmqType) const = 0;
+    virtual std::vector<CQuorumCPtr> ScanQuorums(Consensus::LLMQType llmqType,
+                                                 gsl::not_null<const CBlockIndex*> pindexStart,
+                                                 size_t nCountRequested) const = 0;
+    virtual void CleanupExpiredDataRequests() const = 0;
+    virtual void CleanupOldQuorumData(const std::set<uint256>& dbKeysToSkip) const = 0;
+};
 
 class QuorumObserver
 {
 protected:
     CConnman& m_connman;
     CDeterministicMNManager& m_dmnman;
-    CQuorumManager& m_qman;
+    QuorumHandlerParent& m_qman;
     CQuorumSnapshotManager& m_qsnapman;
     const ChainstateManager& m_chainman;
     const CMasternodeSync& m_mn_sync;
@@ -51,7 +87,7 @@ class QuorumObserver
     QuorumObserver() = delete;
     QuorumObserver(const QuorumObserver&) = delete;
     QuorumObserver& operator=(const QuorumObserver&) = delete;
-    explicit QuorumObserver(CConnman& connman, CDeterministicMNManager& dmnman, CQuorumManager& qman,
+    explicit QuorumObserver(CConnman& connman, CDeterministicMNManager& dmnman, QuorumHandlerParent& qman,
                             CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
                             const CMasternodeSync& mn_sync, const CSporkManager& sporkman,
                             const llmq::QvvecSyncModeMap& sync_map, bool quorums_recovery);
diff --git a/src/llmq/quorumsman.cpp b/src/llmq/quorumsman.cpp
@@ -4,7 +4,6 @@
 
 #include <llmq/quorumsman.h>
 
-#include <active/quorums.h>
 #include <bls/bls.h>
 #include <bls/bls_ies.h>
 #include <evo/deterministicmns.h>
@@ -54,6 +53,16 @@ CQuorumManager::~CQuorumManager()
     }
 }
 
+bool CQuorumManager::GetEncryptedContributions(Consensus::LLMQType llmq_type, const CBlockIndex* block_index,
+                                               const std::vector<bool>& valid_members, const uint256& protx_hash,
+                                               std::vector<CBLSIESEncryptedObject<CBLSSecretKey>>& vec_enc) const
+{
+    if (m_qdkgsman) {
+        return m_qdkgsman->GetEncryptedContributions(llmq_type, block_index, valid_members, protx_hash, vec_enc);
+    }
+    return false;
+}
+
 CQuorumPtr CQuorumManager::BuildQuorumFromCommitment(const Consensus::LLMQType llmqType, gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, bool populate_cache) const
 {
     const uint256& quorumHash{pQuorumBaseBlockIndex->GetBlockHash()};
@@ -313,6 +322,49 @@ bool CQuorumManager::IsWatching() const
     return false;
 }
 
+bool CQuorumManager::IsDataRequestPending(const uint256& proRegTx, bool we_requested, const uint256& quorumHash,
+                                          Consensus::LLMQType llmqType) const
+{
+    const CQuorumDataRequestKey key{proRegTx, we_requested, quorumHash, llmqType};
+    LOCK(cs_data_requests);
+    const auto it = mapQuorumDataRequests.find(key);
+    return it != mapQuorumDataRequests.end() && !it->second.IsExpired(/*add_bias=*/true);
+}
+
+DataRequestStatus CQuorumManager::GetDataRequestStatus(const uint256& proRegTx, bool we_requested,
+                                                       const uint256& quorumHash, Consensus::LLMQType llmqType) const
+{
+    const CQuorumDataRequestKey key{proRegTx, we_requested, quorumHash, llmqType};
+    LOCK(cs_data_requests);
+    const auto it = mapQuorumDataRequests.find(key);
+    if (it == mapQuorumDataRequests.end()) {
+        return DataRequestStatus::NotFound;
+    }
+    if (it->second.IsProcessed()) {
+        return DataRequestStatus::Processed;
+    }
+    return DataRequestStatus::Pending;
+}
+
+void CQuorumManager::CleanupExpiredDataRequests() const
+{
+    LOCK(cs_data_requests);
+    auto it = mapQuorumDataRequests.begin();
+    while (it != mapQuorumDataRequests.end()) {
+        if (it->second.IsExpired(/*add_bias=*/true)) {
+            it = mapQuorumDataRequests.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}
+
+void CQuorumManager::CleanupOldQuorumData(const std::set<uint256>& dbKeysToSkip) const
+{
+    LOCK(cs_db);
+    DataCleanupHelper(*db, dbKeysToSkip);
+}
+
 CQuorumCPtr CQuorumManager::GetQuorum(Consensus::LLMQType llmqType, const uint256& quorumHash) const
 {
     const CBlockIndex* pQuorumBaseBlockIndex = [&]() {
diff --git a/src/llmq/quorumsman.h b/src/llmq/quorumsman.h
@@ -6,6 +6,7 @@
 #define BITCOIN_LLMQ_QUORUMSMAN_H
 
 #include <evo/types.h>
+#include <llmq/observer/quorums.h>
 #include <llmq/options.h>
 #include <llmq/params.h>
 #include <llmq/quorums.h>
@@ -42,7 +43,7 @@ struct DbWrapperParams;
 } // namespace util
 
 namespace llmq {
-enum class VerifyRecSigStatus {
+enum class VerifyRecSigStatus : uint8_t {
     NoQuorum,
     Invalid,
     Valid,
@@ -60,7 +61,7 @@ class QuorumParticipant;
  *
  * It is also responsible for initialization of the intra-quorum connections for new quorums.
  */
-class CQuorumManager
+class CQuorumManager final : public QuorumHandlerParent
 {
     friend class llmq::QuorumObserver;
     friend class llmq::QuorumParticipant;
@@ -123,14 +124,19 @@ class CQuorumManager
         m_qdkgsman = nullptr;
     }
 
+    bool GetEncryptedContributions(Consensus::LLMQType llmq_type, const CBlockIndex* block_index,
+                                   const std::vector<bool>& valid_members, const uint256& protx_hash,
+                                   std::vector<CBLSIESEncryptedObject<CBLSSecretKey>>& vec_enc) const override;
+
     [[nodiscard]] MessageProcessingResult ProcessMessage(CNode& pfrom, CConnman& connman, std::string_view msg_type,
                                                          CDataStream& vRecv)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !cs_data_requests, !cs_map_quorums, !m_cache_cs);
 
     static bool HasQuorum(Consensus::LLMQType llmqType, const CQuorumBlockProcessor& quorum_block_processor, const uint256& quorumHash);
 
     bool RequestQuorumData(CNode* pfrom, CConnman& connman, const CQuorum& quorum, uint16_t nDataMask,
-                           const uint256& proTxHash = uint256()) const EXCLUSIVE_LOCKS_REQUIRED(!cs_data_requests);
+                           const uint256& proTxHash = uint256()) const override
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_data_requests);
 
     // all these methods will lock cs_main for a short period of time
     CQuorumCPtr GetQuorum(Consensus::LLMQType llmqType, const uint256& quorumHash) const
@@ -140,12 +146,20 @@ class CQuorumManager
 
     // this one is cs_main-free
     std::vector<CQuorumCPtr> ScanQuorums(Consensus::LLMQType llmqType, gsl::not_null<const CBlockIndex*> pindexStart,
-                                         size_t nCountRequested) const
+                                         size_t nCountRequested) const override
         EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !cs_map_quorums, !cs_scan_quorums, !m_cache_cs);
 
     bool IsMasternode() const;
     bool IsWatching() const;
 
+    bool IsDataRequestPending(const uint256& proRegTx, bool we_requested, const uint256& quorumHash,
+                              Consensus::LLMQType llmqType) const override EXCLUSIVE_LOCKS_REQUIRED(!cs_data_requests);
+    DataRequestStatus GetDataRequestStatus(const uint256& proRegTx, bool we_requested, const uint256& quorumHash,
+                                           Consensus::LLMQType llmqType) const override
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_data_requests);
+    void CleanupExpiredDataRequests() const override EXCLUSIVE_LOCKS_REQUIRED(!cs_data_requests);
+    void CleanupOldQuorumData(const std::set<uint256>& dbKeysToSkip) const override EXCLUSIVE_LOCKS_REQUIRED(!cs_db);
+
 private:
     // all private methods here are cs_main-free
     bool BuildQuorumContributions(const CFinalCommitmentPtr& fqc, const std::shared_ptr<CQuorum>& quorum) const;

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ namespace llmq {`
`38`	`38`	`class CInstantSendManager;`
`39`	`39`	`class CQuorumManager;`
`40`	`40`	`class CSigningManager;`
`41`		`-enum class VerifyRecSigStatus;`
	`41`	`+enum class VerifyRecSigStatus : uint8_t;`
`42`	`42`
`43`	`43`	`class CChainLocksHandler final : public chainlock::ChainLockSignerParent`
`44`	`44`	`{`