refactor: inline PreVerifyRecoveredSig to CSigningManager::VerifyAndProcessRecoveredSig ex-ProcessRecoveredSig

knst · knst · commit adf888e1cd60 · 2025-12-03T21:29:46.000+07:00
diff --git a/src/llmq/net_signing.cpp b/src/llmq/net_signing.cpp
@@ -18,22 +18,6 @@
 
 #include <unordered_map>
 
-static bool PreVerifyRecoveredSig(Consensus::LLMQType& llmqType, const llmq::CQuorumManager& quorum_manager,
-                                  const llmq::CRecoveredSig& recoveredSig)
-{
-    auto quorum = quorum_manager.GetQuorum(llmqType, recoveredSig.getQuorumHash());
-
-    if (!quorum) {
-        LogPrint(BCLog::LLMQ, "NetSigning::%s -- quorum %s not found\n", __func__, recoveredSig.getQuorumHash().ToString());
-        return false;
-    }
-    if (!llmq::IsQuorumActive(llmqType, quorum_manager, quorum->qc->quorumHash)) {
-        return false;
-    }
-
-    return true;
-}
-
 void NetSigning::ProcessMessage(CNode& pfrom, const std::string& msg_type, CDataStream& vRecv)
 {
     if (msg_type != NetMsgType::QSIGREC) return;
@@ -44,15 +28,11 @@ void NetSigning::ProcessMessage(CNode& pfrom, const std::string& msg_type, CData
     WITH_LOCK(cs_main, m_peer_manager->PeerEraseObjectRequest(pfrom.GetId(),
                                                               CInv{MSG_QUORUM_RECOVERED_SIG, recoveredSig->GetHash()}));
 
-    auto llmqType = recoveredSig->getLlmqType();
-    if (!Params().GetLLMQ(llmqType).has_value()) {
+    if (!Params().GetLLMQ(recoveredSig->getLlmqType()).has_value()) {
         m_peer_manager->PeerMisbehaving(pfrom.GetId(), 100);
     }
-    if (!PreVerifyRecoveredSig(llmqType, m_sig_manager.Qman(), *recoveredSig)) {
-        return;
-    }
 
-    m_sig_manager.ProcessRecoveredSig(pfrom.GetId(), std::move(recoveredSig));
+    m_sig_manager.VerifyAndProcessRecoveredSig(pfrom.GetId(), std::move(recoveredSig));
 }
 
 void NetSigning::Start()
diff --git a/src/llmq/signing.cpp b/src/llmq/signing.cpp
@@ -361,8 +361,20 @@ bool CSigningManager::GetRecoveredSigForGetData(const uint256& hash, CRecoveredS
     return true;
 }
 
-void CSigningManager::ProcessRecoveredSig(NodeId from, std::shared_ptr<CRecoveredSig> recoveredSig)
+void CSigningManager::VerifyAndProcessRecoveredSig(NodeId from, std::shared_ptr<CRecoveredSig> recoveredSig)
 {
+    auto llmq_type = recoveredSig->getLlmqType();
+    auto quorum = qman.GetQuorum(llmq_type, recoveredSig->getQuorumHash());
+
+    if (!quorum) {
+        LogPrint(BCLog::LLMQ, "NetSigning::%s -- quorum %s not found\n", __func__,
+                 recoveredSig->getQuorumHash().ToString());
+        return;
+    }
+    if (!IsQuorumActive(llmq_type, qman, quorum->qc->quorumHash)) {
+        return;
+    }
+
     // It's important to only skip seen *valid* sig shares here. See comment for CBatchedSigShare
     // We don't receive recovered sigs in batches, but we do batched verification per node on these
     if (db.HasRecoveredSigForHash(recoveredSig->GetHash())) {
diff --git a/src/llmq/signing.h b/src/llmq/signing.h
@@ -182,7 +182,7 @@ class CSigningManager
     bool AlreadyHave(const CInv& inv) const EXCLUSIVE_LOCKS_REQUIRED(!cs_pending);
     bool GetRecoveredSigForGetData(const uint256& hash, CRecoveredSig& ret) const;
 
-    void ProcessRecoveredSig(NodeId from, std::shared_ptr<CRecoveredSig> recovered_sig)
+    void VerifyAndProcessRecoveredSig(NodeId from, std::shared_ptr<CRecoveredSig> recovered_sig)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_pending);
 
     // This is called when a recovered signature was was reconstructed from another P2P message and is known to be valid
@@ -197,7 +197,6 @@ class CSigningManager
     void TruncateRecoveredSig(Consensus::LLMQType llmqType, const uint256& id);
 
     // Used by NetSigning:
-    const CQuorumManager& Qman() { return qman; }
     [[nodiscard]] Uint256HashMap<std::shared_ptr<const CRecoveredSig>> FetchPendingReconstructed()
         EXCLUSIVE_LOCKS_REQUIRED(!cs_pending);
     [[nodiscard]] bool CollectPendingRecoveredSigsToVerify(
