refactor: break circular dependencies llmq/blockprocessor <-> llmq/commitment

Author: knst

src/llmq/blockprocessor.cpp

@@ -45,25 +45,6 @@ static const std::string DB_MINED_COMMITMENT_BY_INVERSED_HEIGHT_Q_INDEXED = "q_m
 
 static const std::string DB_BEST_BLOCK_UPGRADE = "q_bbu2";
 
-bool BlsCheck::operator()()
-{
-    if (m_pubkeys.size() > 1) {
-        if (!m_sig.VerifySecureAggregated(m_pubkeys, m_msg_hash)) {
-            LogPrint(BCLog::LLMQ, "%s\n", m_id_string);
-            return false;
-        }
-    } else if (m_pubkeys.size() == 1) {
-        if (!m_sig.VerifyInsecure(m_pubkeys.back(), m_msg_hash)) {
-            LogPrint(BCLog::LLMQ, "%s\n", m_id_string);
-            return false;
-        }
-    } else {
-        // It is supposed to be at least one public key!
-        return false;
-    }
-    return true;
-}
-
 CQuorumBlockProcessor::CQuorumBlockProcessor(CChainState& chainstate, CDeterministicMNManager& dmnman, CEvoDB& evoDb,
                                              CQuorumSnapshotManager& qsnapman) :
     m_chainstate(chainstate),
@@ -225,7 +206,7 @@ bool CQuorumBlockProcessor::ProcessBlock(const CBlock& block, gsl::not_null<cons
     }
 
     if (fBLSChecks) {
-        CCheckQueueControl<BlsCheck> queue_control(&m_bls_queue);
+        CCheckQueueControl<utils::BlsCheck> queue_control(&m_bls_queue);
         for (const auto& [_, qc] : qcs) {
             if (qc.IsNull()) continue;
             const auto* pQuorumBaseBlockIndex = m_chainstate.m_blockman.LookupBlockIndex(qc.quorumHash);

src/llmq/blockprocessor.h

@@ -10,6 +10,7 @@
 #include <bls/bls.h>
 #include <checkqueue.h>
 #include <llmq/params.h>
+#include <llmq/utils.h>
 #include <protocol.h>
 #include <saltedhasher.h>
 #include <sync.h>
@@ -38,33 +39,6 @@ class CQuorumSnapshotManager;
 
 using CFinalCommitmentPtr = std::unique_ptr<CFinalCommitment>;
 
-struct BlsCheck {
-    CBLSSignature m_sig;
-    std::vector<CBLSPublicKey> m_pubkeys;
-    uint256 m_msg_hash;
-    std::string m_id_string;
-
-    BlsCheck() = default;
-
-    BlsCheck(CBLSSignature sig, std::vector<CBLSPublicKey> pubkeys, uint256 msg_hash, std::string id_string) :
-        m_sig(sig),
-        m_pubkeys(pubkeys),
-        m_msg_hash(msg_hash),
-        m_id_string(id_string)
-    {
-    }
-
-    void swap(BlsCheck& obj)
-    {
-        std::swap(m_sig, obj.m_sig);
-        std::swap(m_pubkeys, obj.m_pubkeys);
-        std::swap(m_msg_hash, obj.m_msg_hash);
-        std::swap(m_id_string, obj.m_id_string);
-    }
-
-    bool operator()();
-};
-
 class CQuorumBlockProcessor
 {
 private:
@@ -73,7 +47,7 @@ class CQuorumBlockProcessor
     CEvoDB& m_evoDb;
     CQuorumSnapshotManager& m_qsnapman;
 
-    CCheckQueue<BlsCheck> m_bls_queue{32};
+    CCheckQueue<utils::BlsCheck> m_bls_queue{32};
 
     mutable Mutex minableCommitmentsCs;
     std::map<std::pair<Consensus::LLMQType, uint256>, uint256> minableCommitmentsByQuorum GUARDED_BY(minableCommitmentsCs);

src/llmq/commitment.cpp

@@ -11,7 +11,6 @@
 #include <checkqueue.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
-#include <llmq/blockprocessor.h>
 #include <llmq/options.h>
 #include <llmq/utils.h>
 #include <logging.h>
@@ -31,7 +30,7 @@ CFinalCommitment::CFinalCommitment(const Consensus::LLMQParams& params, const ui
 
 bool CFinalCommitment::VerifySignatureAsync(CDeterministicMNManager& dmnman, CQuorumSnapshotManager& qsnapman,
                                             gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex,
-                                            CCheckQueueControl<BlsCheck>* queue_control) const
+                                            CCheckQueueControl<utils::BlsCheck>* queue_control) const
 {
     auto members = utils::GetAllQuorumMembers(llmqType, dmnman, qsnapman, pQuorumBaseBlockIndex);
     const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
@@ -69,7 +68,7 @@ bool CFinalCommitment::VerifySignatureAsync(CDeterministicMNManager& dmnman, CQu
         std::string members_id_string{
             strprintf("CFinalCommitment -- q[%s] invalid aggregated members signature", quorumHash.ToString())};
         if (queue_control) {
-            std::vector<BlsCheck> vChecks;
+            std::vector<utils::BlsCheck> vChecks;
             vChecks.emplace_back(membersSig, memberPubKeys, commitmentHash, members_id_string);
             queue_control->Add(vChecks);
         } else {
@@ -81,7 +80,7 @@ bool CFinalCommitment::VerifySignatureAsync(CDeterministicMNManager& dmnman, CQu
     }
     std::string qsig_id_string{strprintf("CFinalCommitment -- q[%s] invalid quorum signature", quorumHash.ToString())};
     if (queue_control) {
-        std::vector<BlsCheck> vChecks;
+        std::vector<utils::BlsCheck> vChecks;
         std::vector<CBLSPublicKey> public_keys;
         public_keys.push_back(quorumPublicKey);
         vChecks.emplace_back(quorumSig, public_keys, commitmentHash, qsig_id_string);

src/llmq/commitment.h

@@ -31,7 +31,10 @@ namespace llmq
 {
 class CQuorumSnapshotManager;
 
+namespace utils
+{
 struct BlsCheck;
+} // namespace utils
 // This message is an aggregation of all received premature commitments and only valid if
 // enough (>=threshold) premature commitments were aggregated
 // This is mined on-chain as part of TRANSACTION_QUORUM_COMMITMENT
@@ -71,7 +74,7 @@ class CFinalCommitment
 
     bool VerifySignatureAsync(CDeterministicMNManager& dmnman, CQuorumSnapshotManager& qsnapman,
                               gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex,
-                              CCheckQueueControl<BlsCheck>* queue_control) const;
+                              CCheckQueueControl<utils::BlsCheck>* queue_control) const;
     bool Verify(CDeterministicMNManager& dmnman, CQuorumSnapshotManager& qsnapman,
                 gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, bool checkSigs) const;
     bool VerifyNull() const;

src/llmq/utils.cpp

@@ -882,6 +882,25 @@ void AddQuorumProbeConnections(const Consensus::LLMQParams& llmqParams, CConnman
     }
 }
 
+bool BlsCheck::operator()()
+{
+    if (m_pubkeys.size() > 1) {
+        if (!m_sig.VerifySecureAggregated(m_pubkeys, m_msg_hash)) {
+            LogPrint(BCLog::LLMQ, "%s\n", m_id_string);
+            return false;
+        }
+    } else if (m_pubkeys.size() == 1) {
+        if (!m_sig.VerifyInsecure(m_pubkeys.back(), m_msg_hash)) {
+            LogPrint(BCLog::LLMQ, "%s\n", m_id_string);
+            return false;
+        }
+    } else {
+        // It is supposed to be at least one public key!
+        return false;
+    }
+    return true;
+}
+
 template <typename CacheType>
 void InitQuorumsCache(CacheType& cache, bool limit_by_connections)
 {

src/llmq/utils.h

@@ -5,6 +5,7 @@
 #ifndef BITCOIN_LLMQ_UTILS_H
 #define BITCOIN_LLMQ_UTILS_H
 
+#include <bls/bls.h>
 #include <gsl/pointers.h>
 #include <llmq/params.h>
 #include <saltedhasher.h>
@@ -56,8 +57,36 @@ void AddQuorumProbeConnections(const Consensus::LLMQParams& llmqParams, CConnman
                                const CSporkManager& sporkman, const CDeterministicMNList& tip_mn_list,
                                gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& myProTxHash);
 
+struct BlsCheck {
+    CBLSSignature m_sig;
+    std::vector<CBLSPublicKey> m_pubkeys;
+    uint256 m_msg_hash;
+    std::string m_id_string;
+
+    BlsCheck() = default;
+
+    BlsCheck(CBLSSignature sig, std::vector<CBLSPublicKey> pubkeys, uint256 msg_hash, std::string id_string) :
+        m_sig(sig),
+        m_pubkeys(pubkeys),
+        m_msg_hash(msg_hash),
+        m_id_string(id_string)
+    {
+    }
+
+    void swap(BlsCheck& obj)
+    {
+        std::swap(m_sig, obj.m_sig);
+        std::swap(m_pubkeys, obj.m_pubkeys);
+        std::swap(m_msg_hash, obj.m_msg_hash);
+        std::swap(m_id_string, obj.m_id_string);
+    }
+
+    bool operator()();
+};
+
 template <typename CacheType>
 void InitQuorumsCache(CacheType& cache, bool limit_by_connections = true);
+
 } // namespace utils
 } // namespace llmq