refactor: llmq/chainlocks no more depends on net_processing

Author: knst

src/llmq/chainlocks.cpp

@@ -12,7 +12,6 @@
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <masternode/sync.h>
-#include <net_processing.h>
 #include <node/blockstorage.h>
 #include <node/ui_interface.h>
 #include <scheduler.h>
@@ -21,14 +20,15 @@
 #include <util/thread.h>
 #include <util/time.h>
 #include <validation.h>
+#include <validationinterface.h>
 
 namespace llmq
 {
 std::unique_ptr<CChainLocksHandler> chainLocksHandler;
 
 CChainLocksHandler::CChainLocksHandler(CChainState& chainstate, CConnman& _connman, CMasternodeSync& mn_sync, CQuorumManager& _qman,
                                        CSigningManager& _sigman, CSigSharesManager& _shareman, CSporkManager& sporkManager,
-                                       CTxMemPool& _mempool, const std::unique_ptr<PeerManager>& peerman) :
+                                       CTxMemPool& _mempool) :
     m_chainstate(chainstate),
     connman(_connman),
     m_mn_sync(mn_sync),
@@ -37,7 +37,6 @@ CChainLocksHandler::CChainLocksHandler(CChainState& chainstate, CConnman& _connm
     shareman(_shareman),
     spork_manager(sporkManager),
     mempool(_mempool),
-    m_peerman(peerman),
     scheduler(std::make_unique<CScheduler>()),
     scheduler_thread(std::make_unique<std::thread>(std::thread(util::TraceThread, "cl-schdlr", [&] { scheduler->serviceQueue(); })))
 {
@@ -91,21 +90,22 @@ CChainLockSig CChainLocksHandler::GetBestChainLock() const
     return bestChainLock;
 }
 
-void CChainLocksHandler::ProcessMessage(const CNode& pfrom, const std::string& msg_type, CDataStream& vRecv)
+PeerMsgRet CChainLocksHandler::ProcessMessage(const CNode& pfrom, const std::string& msg_type, CDataStream& vRecv)
 {
     if (!AreChainLocksEnabled(spork_manager)) {
-        return;
+        return {};
     }
 
     if (msg_type == NetMsgType::CLSIG) {
         CChainLockSig clsig;
         vRecv >> clsig;
 
-        ProcessNewChainLock(pfrom.GetId(), clsig, ::SerializeHash(clsig));
+        return ProcessNewChainLock(pfrom.GetId(), clsig, ::SerializeHash(clsig));
     }
+    return {};
 }
 
-void CChainLocksHandler::ProcessNewChainLock(const NodeId from, const llmq::CChainLockSig& clsig, const uint256& hash)
+PeerMsgRet CChainLocksHandler::ProcessNewChainLock(const NodeId from, const llmq::CChainLockSig& clsig, const uint256& hash)
 {
     CheckActiveState();
 
@@ -119,21 +119,21 @@ void CChainLocksHandler::ProcessNewChainLock(const NodeId from, const llmq::CCha
     {
         LOCK(cs);
         if (!seenChainLocks.emplace(hash, GetTimeMillis()).second) {
-            return;
+            return {};
         }
 
         if (!bestChainLock.IsNull() && clsig.getHeight() <= bestChainLock.getHeight()) {
             // no need to process/relay older CLSIGs
-            return;
+            return {};
         }
     }
 
     if (!VerifyChainLock(clsig)) {
         LogPrint(BCLog::CHAINLOCKS, "CChainLocksHandler::%s -- invalid CLSIG (%s), peer=%d\n", __func__, clsig.ToString(), from);
         if (from != -1) {
-            m_peerman->Misbehaving(from, 10);
+            return tl::unexpected{10};
         }
-        return;
+        return {};
     }
 
     CBlockIndex* pindex = WITH_LOCK(cs_main, return m_chainstate.m_blockman.LookupBlockIndex(clsig.getBlockHash()));
@@ -150,7 +150,7 @@ void CChainLocksHandler::ProcessNewChainLock(const NodeId from, const llmq::CCha
                 LogPrintf("CChainLocksHandler::%s -- height of CLSIG (%s) does not match the specified block's height (%d)\n",
                         __func__, clsig.ToString(), pindex->nHeight);
                 // Note: not relaying clsig here
-                return;
+                return {};
             }
 
             bestChainLockWithKnownBlock = bestChainLock;
@@ -167,7 +167,7 @@ void CChainLocksHandler::ProcessNewChainLock(const NodeId from, const llmq::CCha
     if (pindex == nullptr) {
         // we don't know the block/header for this CLSIG yet, so bail out for now
         // when the block or the header later comes in, we will enforce the correct chain
-        return;
+        return {};
     }
 
     scheduler->scheduleFromNow([&]() {
@@ -177,6 +177,7 @@ void CChainLocksHandler::ProcessNewChainLock(const NodeId from, const llmq::CCha
 
     LogPrint(BCLog::CHAINLOCKS, "CChainLocksHandler::%s -- processed new CLSIG (%s), peer=%d\n",
               __func__, clsig.ToString(), from);
+    return {};
 }
 
 void CChainLocksHandler::AcceptedBlockHeader(gsl::not_null<const CBlockIndex*> pindexNew)

src/llmq/chainlocks.h

@@ -10,6 +10,7 @@
 #include <crypto/common.h>
 #include <llmq/signing.h>
 #include <net.h>
+#include <net_types.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <saltedhasher.h>
@@ -29,7 +30,6 @@ class CMasternodeSync;
 class CScheduler;
 class CSporkManager;
 class CTxMemPool;
-class PeerManager;
 
 namespace llmq
 {
@@ -53,7 +53,6 @@ class CChainLocksHandler : public CRecoveredSigsListener
     CSigSharesManager& shareman;
     CSporkManager& spork_manager;
     CTxMemPool& mempool;
-    const std::unique_ptr<PeerManager>& m_peerman;
 
     std::unique_ptr<CScheduler> scheduler;
     std::unique_ptr<std::thread> scheduler_thread;
@@ -89,7 +88,7 @@ class CChainLocksHandler : public CRecoveredSigsListener
 public:
     explicit CChainLocksHandler(CChainState& chainstate, CConnman& _connman, CMasternodeSync& mn_sync, CQuorumManager& _qman,
                                 CSigningManager& _sigman, CSigSharesManager& _shareman, CSporkManager& sporkManager,
-                                CTxMemPool& _mempool, const std::unique_ptr<PeerManager>& peerman);
+                                CTxMemPool& _mempool);
     ~CChainLocksHandler();
 
     void Start();
@@ -99,8 +98,9 @@ class CChainLocksHandler : public CRecoveredSigsListener
     bool GetChainLockByHash(const uint256& hash, CChainLockSig& ret) const LOCKS_EXCLUDED(cs);
     CChainLockSig GetBestChainLock() const LOCKS_EXCLUDED(cs);
 
-    void ProcessMessage(const CNode& pfrom, const std::string& msg_type, CDataStream& vRecv);
-    void ProcessNewChainLock(NodeId from, const CChainLockSig& clsig, const uint256& hash) LOCKS_EXCLUDED(cs);
+    PeerMsgRet ProcessMessage(const CNode& pfrom, const std::string& msg_type, CDataStream& vRecv);
+    PeerMsgRet ProcessNewChainLock(NodeId from, const CChainLockSig& clsig, const uint256& hash) LOCKS_EXCLUDED(cs);
+
     void AcceptedBlockHeader(gsl::not_null<const CBlockIndex*> pindexNew) LOCKS_EXCLUDED(cs);
     void UpdatedBlockTip();
     void TransactionAddedToMempool(const CTransactionRef& tx, int64_t nAcceptTime) LOCKS_EXCLUDED(cs);

src/llmq/context.cpp

@@ -39,7 +39,7 @@ LLMQContext::LLMQContext(CChainState& chainstate, CConnman& connman, CEvoDB& evo
     shareman{std::make_unique<llmq::CSigSharesManager>(connman, *llmq::quorumManager, *sigman, peerman)},
     clhandler{[&]() -> llmq::CChainLocksHandler* const {
         assert(llmq::chainLocksHandler == nullptr);
-        llmq::chainLocksHandler = std::make_unique<llmq::CChainLocksHandler>(chainstate, connman, *::masternodeSync, *llmq::quorumManager, *sigman, *shareman, sporkman, mempool, peerman);
+        llmq::chainLocksHandler = std::make_unique<llmq::CChainLocksHandler>(chainstate, connman, *::masternodeSync, *llmq::quorumManager, *sigman, *shareman, sporkman, mempool);
         return llmq::chainLocksHandler.get();
     }()},
     isman{[&]() -> llmq::CInstantSendManager* const {

src/net_processing.cpp

@@ -4357,7 +4357,7 @@ void PeerManagerImpl::ProcessMessage(
         m_llmq_ctx->qman->ProcessMessage(pfrom, msg_type, vRecv);
         m_llmq_ctx->shareman->ProcessMessage(pfrom, *sporkManager, msg_type, vRecv);
         m_llmq_ctx->sigman->ProcessMessage(pfrom, msg_type, vRecv);
-        m_llmq_ctx->clhandler->ProcessMessage(pfrom, msg_type, vRecv);
+        ProcessPeerMsgRet(m_llmq_ctx->clhandler->ProcessMessage(pfrom, msg_type, vRecv), pfrom);
         m_llmq_ctx->isman->ProcessMessage(pfrom, msg_type, vRecv);
         return;
     }