refactor: drop dependency of EhfSignals on PeerManager

Author: knst

src/llmq/context.cpp

@@ -36,16 +36,17 @@ LLMQContext::LLMQContext(CChainState& chainstate, CConnman& connman, CDeterminis
     shareman{std::make_unique<llmq::CSigSharesManager>(connman, *sigman, mn_activeman, *qman, sporkman, peerman)},
     clhandler{[&]() -> llmq::CChainLocksHandler* const {
         assert(llmq::chainLocksHandler == nullptr);
-        llmq::chainLocksHandler = std::make_unique<llmq::CChainLocksHandler>(chainstate, *qman, *sigman, *shareman, sporkman, mempool, mn_sync, is_masternode);
+        llmq::chainLocksHandler = std::make_unique<llmq::CChainLocksHandler>(chainstate, *qman, *sigman, *shareman,
+                                                                             sporkman, mempool, mn_sync, is_masternode);
         return llmq::chainLocksHandler.get();
     }()},
     isman{[&]() -> llmq::CInstantSendManager* const {
         assert(llmq::quorumInstantSendManager == nullptr);
         llmq::quorumInstantSendManager = std::make_unique<llmq::CInstantSendManager>(*llmq::chainLocksHandler, chainstate, connman, *qman, *sigman, *shareman, sporkman, mempool, mn_sync, peerman, is_masternode, unit_tests, wipe);
         return llmq::quorumInstantSendManager.get();
     }()},
-    ehfSignalsHandler{std::make_unique<llmq::CEHFSignalsHandler>(chainstate, mnhfman, *sigman, *shareman, mempool,
-                                                                 *qman, sporkman, peerman)}
+    ehfSignalsHandler{
+        std::make_unique<llmq::CEHFSignalsHandler>(chainstate, mnhfman, *sigman, *shareman, mempool, *qman, sporkman)}
 {
 }
 

src/llmq/ehf_signals.cpp

@@ -14,7 +14,6 @@
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
 #include <index/txindex.h> // g_txindex
-#include <net_processing.h>
 #include <primitives/transaction.h>
 #include <spork.h>
 #include <txmempool.h>
@@ -25,15 +24,14 @@ namespace llmq {
 
 CEHFSignalsHandler::CEHFSignalsHandler(CChainState& chainstate, CMNHFManager& mnhfman, CSigningManager& sigman,
                                        CSigSharesManager& shareman, CTxMemPool& mempool, const CQuorumManager& qman,
-                                       const CSporkManager& sporkman, const std::unique_ptr<PeerManager>& peerman) :
+                                       const CSporkManager& sporkman) :
     chainstate(chainstate),
     mnhfman(mnhfman),
     sigman(sigman),
     shareman(shareman),
     mempool(mempool),
     qman(qman),
-    sporkman(sporkman),
-    m_peerman(peerman)
+    sporkman(sporkman)
 {
     sigman.RegisterRecoveredSigsListener(this);
 }
@@ -107,6 +105,7 @@ MessageProcessingResult CEHFSignalsHandler::HandleNewRecoveredSig(const CRecover
         return {};
     }
 
+    MessageProcessingResult ret;
     const auto ehfSignals = mnhfman.GetSignalsStage(WITH_LOCK(cs_main, return chainstate.m_chain.Tip()));
     for (const auto& deployment : Params().GetConsensus().vDeployments) {
         // skip deployments that do not use dip0023 or that have already been mined
@@ -132,12 +131,12 @@ MessageProcessingResult CEHFSignalsHandler::HandleNewRecoveredSig(const CRecover
             LOCK(cs_main);
             const MempoolAcceptResult result = AcceptToMemoryPool(chainstate, mempool, tx_to_sent, /* bypass_limits */ false);
             if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
-                Assert(m_peerman)->RelayTransaction(tx_to_sent->GetHash());
+                ret.m_transactions.push_back(tx_to_sent->GetHash());
             } else {
                 LogPrintf("CEHFSignalsHandler::HandleNewRecoveredSig -- AcceptToMemoryPool failed: %s\n", result.m_state.ToString());
             }
         }
     }
-    return {};
+    return ret;
 }
 } // namespace llmq

src/llmq/ehf_signals.h

@@ -14,7 +14,6 @@ class CChainState;
 class CMNHFManager;
 class CSporkManager;
 class CTxMemPool;
-class PeerManager;
 
 namespace llmq
 {
@@ -32,7 +31,6 @@ class CEHFSignalsHandler : public CRecoveredSigsListener
     CTxMemPool& mempool;
     const CQuorumManager& qman;
     const CSporkManager& sporkman;
-    const std::unique_ptr<PeerManager>& m_peerman;
 
     /**
      * keep freshly generated IDs for easier filter sigs in HandleNewRecoveredSig
@@ -42,7 +40,7 @@ class CEHFSignalsHandler : public CRecoveredSigsListener
 public:
     explicit CEHFSignalsHandler(CChainState& chainstate, CMNHFManager& mnhfman, CSigningManager& sigman,
                                 CSigSharesManager& shareman, CTxMemPool& mempool, const CQuorumManager& qman,
-                                const CSporkManager& sporkman, const std::unique_ptr<PeerManager>& peerman);
+                                const CSporkManager& sporkman);
     ~CEHFSignalsHandler();
 
 

src/net_processing.cpp

@@ -3318,6 +3318,9 @@ void PeerManagerImpl::PostProcessMessage(MessageProcessingResult&& result, NodeI
     if (result.m_to_erase) {
         WITH_LOCK(cs_main, EraseObjectRequest(node, result.m_to_erase.value()));
     }
+    for (const auto& tx : result.m_transactions) {
+        WITH_LOCK(cs_main, RelayTransaction(tx));
+    }
     if (result.m_inventory) {
         RelayInv(result.m_inventory.value(), MIN_PEER_PROTO_VERSION);
     }

src/protocol.h

@@ -585,6 +585,7 @@ struct MessageProcessingResult
 {
     std::optional<MisbehavingError> m_error;
     std::optional<CInv> m_inventory;
+    std::vector<uint256> m_transactions;
     std::optional<CInv> m_to_erase;
 
     MessageProcessingResult() = default;

test/lint/lint-circular-dependencies.sh

@@ -88,7 +88,7 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "coinjoin/client -> net_processing -> coinjoin/context -> coinjoin/client"
     "coinjoin/context -> coinjoin/server -> net_processing -> coinjoin/context"
     "coinjoin/server -> net_processing -> coinjoin/server"
-    "llmq/context -> llmq/ehf_signals -> net_processing -> llmq/context"
+    "llmq/context -> llmq/instantsend -> net_processing -> llmq/context"
     "llmq/chainlocks -> llmq/instantsend -> net_processing -> llmq/chainlocks"
     "net_processing -> spork -> net_processing"
     "governance/governance -> net_processing -> governance/governance"