From d54ba447a7243862e5384e5b045b2e02eeb68496 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Fri, 5 Apr 2024 22:22:34 +0000
Subject: [PATCH 1/7] net: use ForEachNode instead of manually iterating
 through vNodes

ForEachNode is publicly available, which will help us extract the
functions from CConnman in a subsequent commit
---
 src/net.cpp | 29 +++++++++++++----------------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/src/net.cpp b/src/net.cpp
index d39a891f8b07b..0326d4fd78a51 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -3934,52 +3934,49 @@ void CConnman::RelayTransaction(const CTransaction& tx, const bool is_dstx)
 }
 
 void CConnman::RelayInv(CInv &inv, const int minProtoVersion) {
-    LOCK(cs_vNodes);
-    for (const auto& pnode : vNodes) {
+    ForEachNode([&](CNode* pnode) {
         if (pnode->nVersion < minProtoVersion || !pnode->CanRelay())
-            continue;
+            return;
         pnode->PushInventory(inv);
-    }
+    });
 }
 
 void CConnman::RelayInvFiltered(CInv &inv, const CTransaction& relatedTx, const int minProtoVersion)
 {
-    LOCK(cs_vNodes);
-    for (const auto& pnode : vNodes) {
+    ForEachNode([&](CNode* pnode) {
         if (pnode->nVersion < minProtoVersion || !pnode->CanRelay() || pnode->IsBlockOnlyConn()) {
-            continue;
+            return;
         }
         {
             LOCK(pnode->m_tx_relay->cs_filter);
             if (!pnode->m_tx_relay->fRelayTxes) {
-                continue;
+                return;
             }
             if (pnode->m_tx_relay->pfilter && !pnode->m_tx_relay->pfilter->IsRelevantAndUpdate(relatedTx)) {
-                continue;
+                return;
             }
         }
         pnode->PushInventory(inv);
-    }
+    });
 }
 
 void CConnman::RelayInvFiltered(CInv &inv, const uint256& relatedTxHash, const int minProtoVersion)
 {
-    LOCK(cs_vNodes);
-    for (const auto& pnode : vNodes) {
+    ForEachNode([&](CNode* pnode) {
         if (pnode->nVersion < minProtoVersion || !pnode->CanRelay() || pnode->IsBlockOnlyConn()) {
-            continue;
+            return;
         }
         {
             LOCK(pnode->m_tx_relay->cs_filter);
             if (!pnode->m_tx_relay->fRelayTxes) {
-                continue;
+                return;
             }
             if (pnode->m_tx_relay->pfilter && !pnode->m_tx_relay->pfilter->contains(relatedTxHash)) {
-                continue;
+                return;
             }
         }
         pnode->PushInventory(inv);
-    }
+    });
 }
 
 void CConnman::RecordBytesRecv(uint64_t bytes)

From 0323c6ca174bdda5926d90a775b848abb2af74f8 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Fri, 5 Apr 2024 22:31:52 +0000
Subject: [PATCH 2/7] net: move Relay{Inv, InvFiltered, Transaction} out of
 CConnman

---
 src/coinjoin/server.cpp     |  4 ++--
 src/governance/object.cpp   |  2 +-
 src/governance/vote.cpp     |  2 +-
 src/llmq/blockprocessor.cpp |  2 +-
 src/llmq/chainlocks.cpp     |  2 +-
 src/llmq/ehf_signals.cpp    |  2 +-
 src/llmq/instantsend.cpp    |  4 ++--
 src/net.cpp                 | 26 +++++++++++++-------------
 src/net.h                   | 17 +++++++++++------
 src/spork.cpp               |  2 +-
 10 files changed, 34 insertions(+), 29 deletions(-)

diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
index 250e965c61920..77731c77d0c1f 100644
--- a/src/coinjoin/server.cpp
+++ b/src/coinjoin/server.cpp
@@ -348,7 +348,7 @@ void CCoinJoinServer::CommitFinalTransaction()
     LogPrint(BCLog::COINJOIN, "CCoinJoinServer::CommitFinalTransaction -- TRANSMITTING DSTX\n");
 
     CInv inv(MSG_DSTX, hashTx);
-    connman.RelayInv(inv);
+    RelayInv(connman, inv);
 
     // Tell the clients it was successful
     RelayCompletedTransaction(MSG_SUCCESS);
@@ -459,7 +459,7 @@ void CCoinJoinServer::ConsumeCollateral(const CTransactionRef& txref) const
     if (!ATMPIfSaneFee(m_chainstate, mempool, txref, false /* bypass_limits */)) {
         LogPrint(BCLog::COINJOIN, "%s -- AcceptToMemoryPool failed\n", __func__);
     } else {
-        connman.RelayTransaction(*txref, static_cast<bool>(m_dstxman.GetDSTX(txref->GetHash())));
+        RelayTransaction(connman, *txref, static_cast<bool>(m_dstxman.GetDSTX(txref->GetHash())));
         LogPrint(BCLog::COINJOIN, "%s -- Collateral was consumed\n", __func__);
     }
 }
diff --git a/src/governance/object.cpp b/src/governance/object.cpp
index dfd28b3879ee8..109c2bb2bd49c 100644
--- a/src/governance/object.cpp
+++ b/src/governance/object.cpp
@@ -651,7 +651,7 @@ void CGovernanceObject::Relay(CConnman& connman, const CMasternodeSync& mn_sync)
     }
 
     CInv inv(MSG_GOVERNANCE_OBJECT, GetHash());
-    connman.RelayInv(inv, minProtoVersion);
+    RelayInv(connman, inv, minProtoVersion);
 }
 
 void CGovernanceObject::UpdateSentinelVariables(const CDeterministicMNList& tip_mn_list)
diff --git a/src/governance/vote.cpp b/src/governance/vote.cpp
index 859aee529c089..a1000426cae62 100644
--- a/src/governance/vote.cpp
+++ b/src/governance/vote.cpp
@@ -136,7 +136,7 @@ void CGovernanceVote::Relay(CConnman& connman, const CMasternodeSync& mn_sync, c
     }
 
     CInv inv(MSG_GOVERNANCE_OBJECT_VOTE, GetHash());
-    connman.RelayInv(inv);
+    RelayInv(connman, inv);
 }
 
 void CGovernanceVote::UpdateHash() const
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
index a1f75e7ce28c8..4f118f24331e1 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -666,7 +666,7 @@ void CQuorumBlockProcessor::AddMineableCommitment(const CFinalCommitment& fqc)
     // We only relay the new commitment if it's new or better then the old one
     if (relay) {
         CInv inv(MSG_QUORUM_FINAL_COMMITMENT, commitmentHash);
-        connman.RelayInv(inv);
+        RelayInv(connman, inv);
     }
 }
 
diff --git a/src/llmq/chainlocks.cpp b/src/llmq/chainlocks.cpp
index c5f3b0f525ab3..e55a4c9e98651 100644
--- a/src/llmq/chainlocks.cpp
+++ b/src/llmq/chainlocks.cpp
@@ -161,7 +161,7 @@ PeerMsgRet CChainLocksHandler::ProcessNewChainLock(const NodeId from, const llmq
 
     // Note: do not hold cs while calling RelayInv
     AssertLockNotHeld(cs);
-    connman.RelayInv(clsigInv);
+    RelayInv(connman, clsigInv);
 
     if (pindex == nullptr) {
         // we don't know the block/header for this CLSIG yet, so bail out for now
diff --git a/src/llmq/ehf_signals.cpp b/src/llmq/ehf_signals.cpp
index 178254af4b398..70703c36a0b9e 100644
--- a/src/llmq/ehf_signals.cpp
+++ b/src/llmq/ehf_signals.cpp
@@ -139,7 +139,7 @@ void CEHFSignalsHandler::HandleNewRecoveredSig(const CRecoveredSig& recoveredSig
             LOCK(cs_main);
             const MempoolAcceptResult result = AcceptToMemoryPool(chainstate, mempool, tx_to_sent, /* bypass_limits */ false);
             if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
-                connman.RelayTransaction(*tx_to_sent, /*is_dstx=*/ false);
+                RelayTransaction(connman, *tx_to_sent, /*is_dstx=*/ false);
             } else {
                 LogPrintf("CEHFSignalsHandler::HandleNewRecoveredSig -- AcceptToMemoryPool failed: %s\n", result.m_state.ToString());
             }
diff --git a/src/llmq/instantsend.cpp b/src/llmq/instantsend.cpp
index c0ba51d3bd617..06020ff275a4d 100644
--- a/src/llmq/instantsend.cpp
+++ b/src/llmq/instantsend.cpp
@@ -1051,11 +1051,11 @@ void CInstantSendManager::ProcessInstantSendLock(NodeId from, const uint256& has
 
     CInv inv(MSG_ISDLOCK, hash);
     if (tx != nullptr) {
-        connman.RelayInvFiltered(inv, *tx, ISDLOCK_PROTO_VERSION);
+        RelayInvFiltered(connman, inv, *tx, ISDLOCK_PROTO_VERSION);
     } else {
         // we don't have the TX yet, so we only filter based on txid. Later when that TX arrives, we will re-announce
         // with the TX taken into account.
-        connman.RelayInvFiltered(inv, islock->txid, ISDLOCK_PROTO_VERSION);
+        RelayInvFiltered(connman, inv, islock->txid, ISDLOCK_PROTO_VERSION);
     }
 
     ResolveBlockConflicts(hash, *islock);
diff --git a/src/net.cpp b/src/net.cpp
index 0326d4fd78a51..94a656214ec3d 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -3926,24 +3926,17 @@ bool CConnman::DisconnectNode(NodeId id)
     return false;
 }
 
-void CConnman::RelayTransaction(const CTransaction& tx, const bool is_dstx)
-{
-    uint256 hash = tx.GetHash();
-    CInv inv(is_dstx ? MSG_DSTX : MSG_TX, hash);
-    RelayInv(inv);
-}
-
-void CConnman::RelayInv(CInv &inv, const int minProtoVersion) {
-    ForEachNode([&](CNode* pnode) {
+void RelayInv(CConnman& connman, CInv &inv, const int minProtoVersion) {
+    connman.ForEachNode([&](CNode* pnode) {
         if (pnode->nVersion < minProtoVersion || !pnode->CanRelay())
             return;
         pnode->PushInventory(inv);
     });
 }
 
-void CConnman::RelayInvFiltered(CInv &inv, const CTransaction& relatedTx, const int minProtoVersion)
+void RelayInvFiltered(CConnman& connman, CInv &inv, const CTransaction& relatedTx, const int minProtoVersion)
 {
-    ForEachNode([&](CNode* pnode) {
+    connman.ForEachNode([&](CNode* pnode) {
         if (pnode->nVersion < minProtoVersion || !pnode->CanRelay() || pnode->IsBlockOnlyConn()) {
             return;
         }
@@ -3960,9 +3953,9 @@ void CConnman::RelayInvFiltered(CInv &inv, const CTransaction& relatedTx, const
     });
 }
 
-void CConnman::RelayInvFiltered(CInv &inv, const uint256& relatedTxHash, const int minProtoVersion)
+void RelayInvFiltered(CConnman& connman, CInv &inv, const uint256& relatedTxHash, const int minProtoVersion)
 {
-    ForEachNode([&](CNode* pnode) {
+    connman.ForEachNode([&](CNode* pnode) {
         if (pnode->nVersion < minProtoVersion || !pnode->CanRelay() || pnode->IsBlockOnlyConn()) {
             return;
         }
@@ -3979,6 +3972,13 @@ void CConnman::RelayInvFiltered(CInv &inv, const uint256& relatedTxHash, const i
     });
 }
 
+void RelayTransaction(CConnman& connman, const CTransaction& tx, const bool is_dstx)
+{
+    uint256 hash = tx.GetHash();
+    CInv inv(is_dstx ? MSG_DSTX : MSG_TX, hash);
+    RelayInv(connman, inv);
+}
+
 void CConnman::RecordBytesRecv(uint64_t bytes)
 {
     LOCK(cs_totalBytesRecv);
diff --git a/src/net.h b/src/net.h
index a2a11b346c20e..58a0432e86d09 100644
--- a/src/net.h
+++ b/src/net.h
@@ -1116,12 +1116,6 @@ friend class CNode;
     std::vector<CNode*> CopyNodeVector(std::function<bool(const CNode* pnode)> cond = AllNodes);
     void ReleaseNodeVector(const std::vector<CNode*>& vecNodes);
 
-    void RelayTransaction(const CTransaction& tx, const bool is_dstx);
-    void RelayInv(CInv &inv, const int minProtoVersion = MIN_PEER_PROTO_VERSION);
-    void RelayInvFiltered(CInv &inv, const CTransaction &relatedTx, const int minProtoVersion = MIN_PEER_PROTO_VERSION);
-    // This overload will not update node filters,  so use it only for the cases when other messages will update related transaction data in filters
-    void RelayInvFiltered(CInv &inv, const uint256 &relatedTxHash, const int minProtoVersion = MIN_PEER_PROTO_VERSION);
-
     // Addrman functions
     /**
      * Return all or many randomly selected addresses, optionally by network.
@@ -1530,6 +1524,17 @@ friend class CNode;
     friend struct ConnmanTestMsg;
 };
 
+void RelayInv(CConnman& connman, CInv &inv, const int minProtoVersion = MIN_PEER_PROTO_VERSION);
+void RelayInvFiltered(CConnman& connman, CInv &inv, const CTransaction &relatedTx,
+                      const int minProtoVersion = MIN_PEER_PROTO_VERSION);
+/**
+ * This overload will not update node filters,  so use it only for the cases
+ * when other messages will update related transaction data in filters
+ */
+void RelayInvFiltered(CConnman& connman, CInv &inv, const uint256 &relatedTxHash,
+                      const int minProtoVersion = MIN_PEER_PROTO_VERSION);
+void RelayTransaction(CConnman& connman, const CTransaction& tx, const bool is_dstx);
+
 /** Return a timestamp in the future (in microseconds) for exponentially distributed events. */
 std::chrono::microseconds PoissonNextSend(std::chrono::microseconds now, std::chrono::seconds average_interval);
 
diff --git a/src/spork.cpp b/src/spork.cpp
index 2a27e6821fca6..19896e1081fa7 100644
--- a/src/spork.cpp
+++ b/src/spork.cpp
@@ -454,5 +454,5 @@ std::optional<CKeyID> CSporkMessage::GetSignerKeyID() const
 void CSporkMessage::Relay(CConnman& connman) const
 {
     CInv inv(MSG_SPORK, GetHash());
-    connman.RelayInv(inv);
+    RelayInv(connman, inv);
 }

From c3f1ac22913615282ef9a74bebca57fa37df3b5b Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Thu, 18 Apr 2024 10:45:13 +0000
Subject: [PATCH 3/7] net: retire CConnman::RelayTransaction, use
 PeerManager::RelayTransaction

---
 src/coinjoin/context.cpp                |  4 ++--
 src/coinjoin/context.h                  |  3 ++-
 src/coinjoin/server.cpp                 |  3 ++-
 src/coinjoin/server.h                   |  5 ++++-
 src/init.cpp                            |  2 +-
 src/llmq/context.cpp                    |  2 +-
 src/llmq/ehf_signals.cpp                | 15 ++++++++-------
 src/llmq/ehf_signals.h                  | 13 +++++++------
 src/net.cpp                             |  7 -------
 src/net.h                               |  1 -
 src/test/util/setup_common.cpp          |  2 +-
 test/lint/lint-circular-dependencies.sh | 10 +++++-----
 12 files changed, 33 insertions(+), 34 deletions(-)

diff --git a/src/coinjoin/context.cpp b/src/coinjoin/context.cpp
index 46ec89a156c12..3a0dd047af6c3 100644
--- a/src/coinjoin/context.cpp
+++ b/src/coinjoin/context.cpp
@@ -15,13 +15,13 @@
 
 CJContext::CJContext(CChainState& chainstate, CConnman& connman, CDeterministicMNManager& dmnman, CMasternodeMetaMan& mn_metaman,
                      CTxMemPool& mempool, const CActiveMasternodeManager* const mn_activeman, const CMasternodeSync& mn_sync,
-                     bool relay_txes) :
+                     const std::unique_ptr<PeerManager>& peerman, bool relay_txes) :
     dstxman{std::make_unique<CDSTXManager>()},
 #ifdef ENABLE_WALLET
     walletman{std::make_unique<CoinJoinWalletManager>(connman, dmnman, mn_metaman, mempool, mn_sync, queueman)},
     queueman {relay_txes ? std::make_unique<CCoinJoinClientQueueManager>(connman, *walletman, dmnman, mn_metaman, mn_sync) : nullptr},
 #endif // ENABLE_WALLET
-    server{std::make_unique<CCoinJoinServer>(chainstate, connman, dmnman, *dstxman, mn_metaman, mempool, mn_activeman, mn_sync)}
+    server{std::make_unique<CCoinJoinServer>(chainstate, connman, dmnman, *dstxman, mn_metaman, mempool, mn_activeman, mn_sync, peerman)}
 {}
 
 CJContext::~CJContext() {}
diff --git a/src/coinjoin/context.h b/src/coinjoin/context.h
index 881daed6d0cd8..e3a7432cf99ca 100644
--- a/src/coinjoin/context.h
+++ b/src/coinjoin/context.h
@@ -21,6 +21,7 @@ class CDSTXManager;
 class CMasternodeMetaMan;
 class CMasternodeSync;
 class CTxMemPool;
+class PeerManager;
 
 #ifdef ENABLE_WALLET
 class CCoinJoinClientQueueManager;
@@ -32,7 +33,7 @@ struct CJContext {
     CJContext(const CJContext&) = delete;
     CJContext(CChainState& chainstate, CConnman& connman, CDeterministicMNManager& dmnman, CMasternodeMetaMan& mn_metaman,
               CTxMemPool& mempool, const CActiveMasternodeManager* const mn_activeman, const CMasternodeSync& mn_sync,
-              bool relay_txes);
+              const std::unique_ptr<PeerManager>& peerman, bool relay_txes);
     ~CJContext();
 
     const std::unique_ptr<CDSTXManager> dstxman;
diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
index 77731c77d0c1f..868786de38ce2 100644
--- a/src/coinjoin/server.cpp
+++ b/src/coinjoin/server.cpp
@@ -12,6 +12,7 @@
 #include <masternode/sync.h>
 #include <net.h>
 #include <netmessagemaker.h>
+#include <net_processing.h>
 #include <script/interpreter.h>
 #include <shutdown.h>
 #include <streams.h>
@@ -459,7 +460,7 @@ void CCoinJoinServer::ConsumeCollateral(const CTransactionRef& txref) const
     if (!ATMPIfSaneFee(m_chainstate, mempool, txref, false /* bypass_limits */)) {
         LogPrint(BCLog::COINJOIN, "%s -- AcceptToMemoryPool failed\n", __func__);
     } else {
-        RelayTransaction(connman, *txref, static_cast<bool>(m_dstxman.GetDSTX(txref->GetHash())));
+        m_peerman->RelayTransaction(txref->GetHash());
         LogPrint(BCLog::COINJOIN, "%s -- Collateral was consumed\n", __func__);
     }
 }
diff --git a/src/coinjoin/server.h b/src/coinjoin/server.h
index 9913224c28f4b..9ce4a993cc70f 100644
--- a/src/coinjoin/server.h
+++ b/src/coinjoin/server.h
@@ -18,6 +18,7 @@ class CDSTXManager;
 class CMasternodeMetaMan;
 class CNode;
 class CTxMemPool;
+class PeerManager;
 
 class UniValue;
 
@@ -34,6 +35,7 @@ class CCoinJoinServer : public CCoinJoinBaseSession, public CCoinJoinBaseManager
     CTxMemPool& mempool;
     const CActiveMasternodeManager* const m_mn_activeman;
     const CMasternodeSync& m_mn_sync;
+    const std::unique_ptr<PeerManager>& m_peerman;
 
     // Mixing uses collateral transactions to trust parties entering the pool
     // to behave honestly. If they don't it takes their money.
@@ -90,7 +92,7 @@ class CCoinJoinServer : public CCoinJoinBaseSession, public CCoinJoinBaseManager
 public:
     explicit CCoinJoinServer(CChainState& chainstate, CConnman& _connman, CDeterministicMNManager& dmnman, CDSTXManager& dstxman,
                              CMasternodeMetaMan& mn_metaman, CTxMemPool& mempool, const CActiveMasternodeManager* const mn_activeman,
-                             const CMasternodeSync& mn_sync) :
+                             const CMasternodeSync& mn_sync, const std::unique_ptr<PeerManager>& peerman) :
         m_chainstate(chainstate),
         connman(_connman),
         m_dmnman(dmnman),
@@ -99,6 +101,7 @@ class CCoinJoinServer : public CCoinJoinBaseSession, public CCoinJoinBaseManager
         mempool(mempool),
         m_mn_activeman(mn_activeman),
         m_mn_sync(mn_sync),
+        m_peerman(peerman),
         vecSessionCollaterals(),
         fUnitTest(false)
     {}
diff --git a/src/init.cpp b/src/init.cpp
index ac051755a1d12..833303f8f0d16 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -2207,7 +2207,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
     // ********************************************************* Step 7c: Setup CoinJoin
 
     node.cj_ctx = std::make_unique<CJContext>(chainman.ActiveChainstate(), *node.connman, *node.dmnman, *node.mn_metaman, *node.mempool,
-                                              node.mn_activeman.get(), *node.mn_sync, !ignores_incoming_txs);
+                                              node.mn_activeman.get(), *node.mn_sync, node.peerman, !ignores_incoming_txs);
 
 #ifdef ENABLE_WALLET
     node.coinjoin_loader = interfaces::MakeCoinJoinLoader(*node.cj_ctx->walletman);
diff --git a/src/llmq/context.cpp b/src/llmq/context.cpp
index cc32e7a0dd783..8514ca16970b4 100644
--- a/src/llmq/context.cpp
+++ b/src/llmq/context.cpp
@@ -48,7 +48,7 @@ LLMQContext::LLMQContext(CChainState& chainstate, CConnman& connman, CDeterminis
         llmq::quorumInstantSendManager = std::make_unique<llmq::CInstantSendManager>(*llmq::chainLocksHandler, chainstate, connman, *llmq::quorumManager, *sigman, *shareman, sporkman, mempool, mn_sync, unit_tests, wipe);
         return llmq::quorumInstantSendManager.get();
     }()},
-    ehfSignalsHandler{std::make_unique<llmq::CEHFSignalsHandler>(chainstate, connman, mnhfman, *sigman, *shareman, sporkman, *llmq::quorumManager, mempool)}
+    ehfSignalsHandler{std::make_unique<llmq::CEHFSignalsHandler>(chainstate, mnhfman, *sigman, *shareman, mempool, *llmq::quorumManager, sporkman, peerman)}
 {
     // NOTE: we use this only to wipe the old db, do NOT use it for anything else
     // TODO: remove it in some future version
diff --git a/src/llmq/ehf_signals.cpp b/src/llmq/ehf_signals.cpp
index 70703c36a0b9e..a07342f262c99 100644
--- a/src/llmq/ehf_signals.cpp
+++ b/src/llmq/ehf_signals.cpp
@@ -14,6 +14,7 @@
 #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>
@@ -22,17 +23,17 @@
 namespace llmq {
 
 
-CEHFSignalsHandler::CEHFSignalsHandler(CChainState& chainstate, CConnman& connman,
-                                       CMNHFManager& mnhfman, CSigningManager& sigman, CSigSharesManager& shareman,
-                                       const CSporkManager& sporkman, const CQuorumManager& qman, CTxMemPool& mempool) :
+CEHFSignalsHandler::CEHFSignalsHandler(CChainState& chainstate, CMNHFManager& mnhfman, CSigningManager& sigman,
+                                       CSigSharesManager& shareman, CTxMemPool& mempool, const CQuorumManager& qman,
+                                       const CSporkManager& sporkman, const std::unique_ptr<PeerManager>& peerman) :
     chainstate(chainstate),
-    connman(connman),
     mnhfman(mnhfman),
     sigman(sigman),
     shareman(shareman),
-    sporkman(sporkman),
+    mempool(mempool),
     qman(qman),
-    mempool(mempool)
+    sporkman(sporkman),
+    m_peerman(peerman)
 {
     sigman.RegisterRecoveredSigsListener(this);
 }
@@ -139,7 +140,7 @@ void CEHFSignalsHandler::HandleNewRecoveredSig(const CRecoveredSig& recoveredSig
             LOCK(cs_main);
             const MempoolAcceptResult result = AcceptToMemoryPool(chainstate, mempool, tx_to_sent, /* bypass_limits */ false);
             if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
-                RelayTransaction(connman, *tx_to_sent, /*is_dstx=*/ false);
+                m_peerman->RelayTransaction(tx_to_sent->GetHash());
             } else {
                 LogPrintf("CEHFSignalsHandler::HandleNewRecoveredSig -- AcceptToMemoryPool failed: %s\n", result.m_state.ToString());
             }
diff --git a/src/llmq/ehf_signals.h b/src/llmq/ehf_signals.h
index 3c9b99b8d3ea9..675b90d833ca9 100644
--- a/src/llmq/ehf_signals.h
+++ b/src/llmq/ehf_signals.h
@@ -15,6 +15,7 @@ class CConnman;
 class CMNHFManager;
 class CSporkManager;
 class CTxMemPool;
+class PeerManager;
 
 namespace llmq
 {
@@ -26,13 +27,13 @@ class CEHFSignalsHandler : public CRecoveredSigsListener
 {
 private:
     CChainState& chainstate;
-    CConnman& connman;
     CMNHFManager& mnhfman;
     CSigningManager& sigman;
     CSigSharesManager& shareman;
-    const CSporkManager& sporkman;
-    const CQuorumManager& qman;
     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
@@ -40,9 +41,9 @@ class CEHFSignalsHandler : public CRecoveredSigsListener
     mutable Mutex cs;
     std::set<uint256> ids GUARDED_BY(cs);
 public:
-    explicit CEHFSignalsHandler(CChainState& chainstate, CConnman& connman,
-                                CMNHFManager& mnhfman, CSigningManager& sigman, CSigSharesManager& shareman,
-                                const CSporkManager& sporkman, const CQuorumManager& qman, CTxMemPool& mempool);
+    explicit CEHFSignalsHandler(CChainState& chainstate, CMNHFManager& mnhfman, CSigningManager& sigman,
+                                CSigSharesManager& shareman, CTxMemPool& mempool, const CQuorumManager& qman,
+                                const CSporkManager& sporkman, const std::unique_ptr<PeerManager>& peerman);
     ~CEHFSignalsHandler();
 
 
diff --git a/src/net.cpp b/src/net.cpp
index 94a656214ec3d..390b7fa7db3df 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -3972,13 +3972,6 @@ void RelayInvFiltered(CConnman& connman, CInv &inv, const uint256& relatedTxHash
     });
 }
 
-void RelayTransaction(CConnman& connman, const CTransaction& tx, const bool is_dstx)
-{
-    uint256 hash = tx.GetHash();
-    CInv inv(is_dstx ? MSG_DSTX : MSG_TX, hash);
-    RelayInv(connman, inv);
-}
-
 void CConnman::RecordBytesRecv(uint64_t bytes)
 {
     LOCK(cs_totalBytesRecv);
diff --git a/src/net.h b/src/net.h
index 58a0432e86d09..b7d105322a547 100644
--- a/src/net.h
+++ b/src/net.h
@@ -1533,7 +1533,6 @@ void RelayInvFiltered(CConnman& connman, CInv &inv, const CTransaction &relatedT
  */
 void RelayInvFiltered(CConnman& connman, CInv &inv, const uint256 &relatedTxHash,
                       const int minProtoVersion = MIN_PEER_PROTO_VERSION);
-void RelayTransaction(CConnman& connman, const CTransaction& tx, const bool is_dstx);
 
 /** Return a timestamp in the future (in microseconds) for exponentially distributed events. */
 std::chrono::microseconds PoissonNextSend(std::chrono::microseconds now, std::chrono::seconds average_interval);
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 4f601dc6c7ff2..dfb0068932c73 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -113,7 +113,7 @@ void DashTestSetup(NodeContext& node, const CChainParams& chainparams)
     node.mempool->ConnectManagers(node.dmnman.get());
 
     node.cj_ctx = std::make_unique<CJContext>(chainstate, *node.connman, *node.dmnman, *node.mn_metaman, *node.mempool,
-                                              /* mn_activeman = */ nullptr, *node.mn_sync, /* relay_txes = */ true);
+                                              /* mn_activeman = */ nullptr, *node.mn_sync, node.peerman, /* relay_txes = */ true);
 #ifdef ENABLE_WALLET
     node.coinjoin_loader = interfaces::MakeCoinJoinLoader(*node.cj_ctx->walletman);
 #endif // ENABLE_WALLET
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index 227f7f3e85b53..a036c3229f146 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -24,8 +24,6 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "wallet/wallet -> wallet/walletdb -> wallet/wallet"
     "node/coinstats -> validation -> node/coinstats"
     # Dash
-    "coinjoin/server -> core_io -> evo/assetlocktx -> llmq/signing -> net_processing -> coinjoin/server"
-    "coinjoin/coinjoin -> llmq/instantsend -> net_processing -> coinjoin/server -> coinjoin/coinjoin"
     "dsnotificationinterface -> llmq/chainlocks -> node/blockstorage -> dsnotificationinterface"
     "evo/cbtx -> evo/simplifiedmns -> evo/cbtx"
     "evo/deterministicmns -> llmq/commitment -> evo/deterministicmns"
@@ -58,7 +56,6 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "logging -> util/system -> sync -> logging"
     "logging -> util/system -> stacktraces -> logging"
     "logging -> util/system -> util/getuniquepath -> random -> logging"
-    "coinjoin/context -> coinjoin/server -> core_io -> evo/assetlocktx -> llmq/signing -> net_processing -> coinjoin/context"
     "qt/appearancewidget -> qt/guiutil -> qt/optionsdialog -> qt/appearancewidget"
     "qt/guiutil -> qt/optionsdialog -> qt/optionsmodel -> qt/guiutil"
 
@@ -69,7 +66,6 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "banman -> bloom -> evo/assetlocktx -> llmq/signing -> net_processing -> banman"
 
     "coinjoin/client -> coinjoin/coinjoin -> llmq/instantsend -> net_processing -> coinjoin/client"
-    "coinjoin/client -> coinjoin/coinjoin -> llmq/instantsend -> net_processing -> coinjoin/context -> coinjoin/client"
     "llmq/dkgsession -> llmq/dkgsessionmgr -> llmq/dkgsession"
     "llmq/chainlocks -> validation -> llmq/chainlocks"
     "coinjoin/coinjoin -> llmq/chainlocks -> net -> coinjoin/coinjoin"
@@ -88,7 +84,6 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
 
     "evo/simplifiedmns -> llmq/blockprocessor -> llmq/utils -> llmq/snapshot -> evo/simplifiedmns"
     "llmq/blockprocessor -> llmq/utils -> llmq/snapshot -> llmq/blockprocessor"
-    "llmq/context -> llmq/instantsend -> net_processing -> llmq/context"
     "llmq/commitment -> llmq/utils -> llmq/snapshot -> llmq/commitment"
     "spork -> validation -> spork"
     "governance/governance -> validation -> governance/governance"
@@ -100,6 +95,11 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "evo/chainhelper -> masternode/payments -> validation -> evo/chainhelper"
     "evo/deterministicmns -> validationinterface -> evo/deterministicmns"
     "logging -> util/system -> sync -> logging/timer -> logging"
+
+    "coinjoin/context -> net_processing -> coinjoin/context"
+    "coinjoin/server -> net_processing -> coinjoin/server"
+    "llmq/context -> llmq/ehf_signals -> net_processing -> llmq/context"
+    "coinjoin/client -> coinjoin/util -> wallet/wallet -> psbt -> node/transaction -> node/context -> coinjoin/context -> coinjoin/client"
 )
 
 EXIT_CODE=0

From 313a7e9a501e84a38743edce2ba47ecf2c999a09 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Thu, 18 Apr 2024 10:54:57 +0000
Subject: [PATCH 4/7] trivial: cleanup unnecessary headers in context files

---
 src/coinjoin/context.cpp                | 4 ----
 src/llmq/context.cpp                    | 2 --
 test/lint/lint-circular-dependencies.sh | 2 +-
 3 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/coinjoin/context.cpp b/src/coinjoin/context.cpp
index 3a0dd047af6c3..2b974cdf6cd43 100644
--- a/src/coinjoin/context.cpp
+++ b/src/coinjoin/context.cpp
@@ -4,10 +4,6 @@
 
 #include <coinjoin/context.h>
 
-#include <net.h>
-#include <txmempool.h>
-#include <validation.h>
-
 #ifdef ENABLE_WALLET
 #include <coinjoin/client.h>
 #endif // ENABLE_WALLET
diff --git a/src/llmq/context.cpp b/src/llmq/context.cpp
index 8514ca16970b4..ea182a90b55e1 100644
--- a/src/llmq/context.cpp
+++ b/src/llmq/context.cpp
@@ -4,7 +4,6 @@
 
 #include <llmq/context.h>
 
-#include <consensus/validation.h>
 #include <dbwrapper.h>
 
 #include <llmq/blockprocessor.h>
@@ -17,7 +16,6 @@
 #include <llmq/quorums.h>
 #include <llmq/signing.h>
 #include <llmq/signing_shares.h>
-#include <masternode/sync.h>
 
 LLMQContext::LLMQContext(CChainState& chainstate, CConnman& connman, CDeterministicMNManager& dmnman, CEvoDB& evo_db,
                          CMasternodeMetaMan& mn_metaman, CMNHFManager& mnhfman, CSporkManager& sporkman, CTxMemPool& mempool,
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index a036c3229f146..6eef8b94721ff 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -96,7 +96,7 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "evo/deterministicmns -> validationinterface -> evo/deterministicmns"
     "logging -> util/system -> sync -> logging/timer -> logging"
 
-    "coinjoin/context -> net_processing -> coinjoin/context"
+    "coinjoin/context -> coinjoin/server -> net_processing -> coinjoin/context"
     "coinjoin/server -> net_processing -> coinjoin/server"
     "llmq/context -> llmq/ehf_signals -> net_processing -> llmq/context"
     "coinjoin/client -> coinjoin/util -> wallet/wallet -> psbt -> node/transaction -> node/context -> coinjoin/context -> coinjoin/client"

From bfd33cd2b4dcc331b2cb2b96395eb94e5c3122db Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Tue, 9 Apr 2024 19:51:13 +0000
Subject: [PATCH 5/7] net: move CConnman::RelayInv{Filtered} into PeerManager

---
 src/coinjoin/server.cpp                 |  2 +-
 src/dsnotificationinterface.cpp         |  5 ++-
 src/dsnotificationinterface.h           |  5 ++-
 src/governance/governance.cpp           | 48 +++++++++++-----------
 src/governance/governance.h             | 20 +++++-----
 src/governance/object.cpp               |  6 +--
 src/governance/object.h                 |  3 +-
 src/governance/vote.cpp                 |  6 +--
 src/governance/vote.h                   |  4 +-
 src/init.cpp                            |  2 +-
 src/llmq/blockprocessor.cpp             |  8 ++--
 src/llmq/blockprocessor.h               |  6 ++-
 src/llmq/chainlocks.cpp                 | 11 ++---
 src/llmq/chainlocks.h                   | 10 ++---
 src/llmq/context.cpp                    |  4 +-
 src/llmq/ehf_signals.h                  |  1 -
 src/llmq/instantsend.cpp                |  4 +-
 src/net.cpp                             | 46 ---------------------
 src/net.h                               | 10 -----
 src/net_processing.cpp                  | 53 ++++++++++++++++++++++++-
 src/net_processing.h                    | 15 +++++++
 src/rpc/governance.cpp                  |  8 ++--
 src/rpc/misc.cpp                        |  4 +-
 src/spork.cpp                           | 17 ++++----
 src/spork.h                             |  9 +++--
 test/lint/lint-circular-dependencies.sh | 13 ++++--
 26 files changed, 173 insertions(+), 147 deletions(-)

diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
index 868786de38ce2..50c256665b12d 100644
--- a/src/coinjoin/server.cpp
+++ b/src/coinjoin/server.cpp
@@ -349,7 +349,7 @@ void CCoinJoinServer::CommitFinalTransaction()
     LogPrint(BCLog::COINJOIN, "CCoinJoinServer::CommitFinalTransaction -- TRANSMITTING DSTX\n");
 
     CInv inv(MSG_DSTX, hashTx);
-    RelayInv(connman, inv);
+    m_peerman->RelayInv(inv);
 
     // Tell the clients it was successful
     RelayCompletedTransaction(MSG_SUCCESS);
diff --git a/src/dsnotificationinterface.cpp b/src/dsnotificationinterface.cpp
index ac0f116da857e..f540b151145be 100644
--- a/src/dsnotificationinterface.cpp
+++ b/src/dsnotificationinterface.cpp
@@ -11,6 +11,7 @@
 #include <dsnotificationinterface.h>
 #include <governance/governance.h>
 #include <masternode/sync.h>
+#include <net_processing.h>
 #include <validation.h>
 
 #include <evo/deterministicmns.h>
@@ -26,6 +27,7 @@
 CDSNotificationInterface::CDSNotificationInterface(CConnman& connman,
                                                    CMasternodeSync& mn_sync,
                                                    CGovernanceManager& govman,
+                                                   PeerManager& peerman,
                                                    const CActiveMasternodeManager* const mn_activeman,
                                                    const std::unique_ptr<CDeterministicMNManager>& dmnman,
                                                    const std::unique_ptr<LLMQContext>& llmq_ctx,
@@ -33,6 +35,7 @@ CDSNotificationInterface::CDSNotificationInterface(CConnman& connman,
   : m_connman(connman),
     m_mn_sync(mn_sync),
     m_govman(govman),
+    m_peerman(peerman),
     m_mn_activeman(mn_activeman),
     m_dmnman(dmnman),
     m_llmq_ctx(llmq_ctx),
@@ -96,7 +99,7 @@ void CDSNotificationInterface::UpdatedBlockTip(const CBlockIndex *pindexNew, con
     m_llmq_ctx->qdkgsman->UpdatedBlockTip(pindexNew, fInitialDownload);
     m_llmq_ctx->ehfSignalsHandler->UpdatedBlockTip(pindexNew);
 
-    if (!fDisableGovernance) m_govman.UpdatedBlockTip(pindexNew, m_connman, m_mn_activeman);
+    if (!fDisableGovernance) m_govman.UpdatedBlockTip(pindexNew, m_connman, m_peerman, m_mn_activeman);
 }
 
 void CDSNotificationInterface::TransactionAddedToMempool(const CTransactionRef& ptx, int64_t nAcceptTime)
diff --git a/src/dsnotificationinterface.h b/src/dsnotificationinterface.h
index 35092ea11a1c8..b715217ac118e 100644
--- a/src/dsnotificationinterface.h
+++ b/src/dsnotificationinterface.h
@@ -12,6 +12,7 @@ class CConnman;
 class CDeterministicMNManager;
 class CGovernanceManager;
 class CMasternodeSync;
+class PeerManager;
 struct CJContext;
 struct LLMQContext;
 
@@ -21,6 +22,7 @@ class CDSNotificationInterface : public CValidationInterface
     explicit CDSNotificationInterface(CConnman& connman,
                                       CMasternodeSync& mn_sync,
                                       CGovernanceManager& govman,
+                                      PeerManager& peerman,
                                       const CActiveMasternodeManager* const mn_activeman,
                                       const std::unique_ptr<CDeterministicMNManager>& dmnman,
                                       const std::unique_ptr<LLMQContext>& llmq_ctx,
@@ -45,10 +47,9 @@ class CDSNotificationInterface : public CValidationInterface
 
 private:
     CConnman& m_connman;
-
     CMasternodeSync& m_mn_sync;
     CGovernanceManager& m_govman;
-
+    PeerManager& m_peerman;
     const CActiveMasternodeManager* const m_mn_activeman;
     const std::unique_ptr<CDeterministicMNManager>& m_dmnman;
     const std::unique_ptr<LLMQContext>& m_llmq_ctx;
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
index 021411112768c..7b8ad1532a04a 100644
--- a/src/governance/governance.cpp
+++ b/src/governance/governance.cpp
@@ -119,7 +119,7 @@ bool CGovernanceManager::SerializeVoteForHash(const uint256& nHash, CDataStream&
     return cmapVoteToObject.Get(nHash, pGovobj) && pGovobj->GetVoteFile().SerializeVoteToStream(nHash, ss);
 }
 
-PeerMsgRet CGovernanceManager::ProcessMessage(CNode& peer, CConnman& connman, std::string_view msg_type, CDataStream& vRecv)
+PeerMsgRet CGovernanceManager::ProcessMessage(CNode& peer, CConnman& connman, PeerManager& peerman, std::string_view msg_type, CDataStream& vRecv)
 {
     if (fDisableGovernance) return {};
     if (m_mn_sync == nullptr || !m_mn_sync->IsBlockchainSynced()) return {};
@@ -213,7 +213,7 @@ PeerMsgRet CGovernanceManager::ProcessMessage(CNode& peer, CConnman& connman, st
             return {};
         }
 
-        AddGovernanceObject(govobj, connman, &peer);
+        AddGovernanceObject(govobj, peerman, &peer);
     }
 
     // A NEW GOVERNANCE OBJECT VOTE HAS ARRIVED
@@ -248,7 +248,7 @@ PeerMsgRet CGovernanceManager::ProcessMessage(CNode& peer, CConnman& connman, st
         if (ProcessVote(&peer, vote, exception, connman)) {
             LogPrint(BCLog::GOBJECT, "MNGOVERNANCEOBJECTVOTE -- %s new\n", strHash);
             m_mn_sync->BumpAssetLastTime("MNGOVERNANCEOBJECTVOTE");
-            vote.Relay(connman, *m_mn_sync, tip_mn_list);
+            vote.Relay(peerman, *m_mn_sync, tip_mn_list);
         } else {
             LogPrint(BCLog::GOBJECT, "MNGOVERNANCEOBJECTVOTE -- Rejected vote, error = %s\n", exception.what());
             if ((exception.GetNodePenalty() != 0) && m_mn_sync->IsSynced()) {
@@ -260,7 +260,7 @@ PeerMsgRet CGovernanceManager::ProcessMessage(CNode& peer, CConnman& connman, st
     return {};
 }
 
-void CGovernanceManager::CheckOrphanVotes(CGovernanceObject& govobj, CConnman& connman)
+void CGovernanceManager::CheckOrphanVotes(CGovernanceObject& govobj, PeerManager& peerman)
 {
     uint256 nHash = govobj.GetHash();
     std::vector<vote_time_pair_t> vecVotePairs;
@@ -277,7 +277,7 @@ void CGovernanceManager::CheckOrphanVotes(CGovernanceObject& govobj, CConnman& c
         if (pairVote.second < nNow) {
             fRemove = true;
         } else if (govobj.ProcessVote(m_mn_metaman, *this, tip_mn_list, vote, e)) {
-            vote.Relay(connman, *Assert(m_mn_sync), tip_mn_list);
+            vote.Relay(peerman, *Assert(m_mn_sync), tip_mn_list);
             fRemove = true;
         }
         if (fRemove) {
@@ -286,7 +286,7 @@ void CGovernanceManager::CheckOrphanVotes(CGovernanceObject& govobj, CConnman& c
     }
 }
 
-void CGovernanceManager::AddGovernanceObject(CGovernanceObject& govobj, CConnman& connman, const CNode* pfrom)
+void CGovernanceManager::AddGovernanceObject(CGovernanceObject& govobj, PeerManager& peerman, const CNode* pfrom)
 {
     uint256 nHash = govobj.GetHash();
     std::string strHash = nHash.ToString();
@@ -331,7 +331,7 @@ void CGovernanceManager::AddGovernanceObject(CGovernanceObject& govobj, CConnman
     }
 
     LogPrint(BCLog::GOBJECT, "CGovernanceManager::AddGovernanceObject -- %s new, received from peer %s\n", strHash, pfrom ? pfrom->GetLogString() : "nullptr");
-    govobj.Relay(connman, *Assert(m_mn_sync));
+    govobj.Relay(peerman, *Assert(m_mn_sync));
 
     // Update the rate buffer
     MasternodeRateUpdate(govobj);
@@ -340,7 +340,7 @@ void CGovernanceManager::AddGovernanceObject(CGovernanceObject& govobj, CConnman
 
     // WE MIGHT HAVE PENDING/ORPHAN VOTES FOR THIS OBJECT
 
-    CheckOrphanVotes(govobj, connman);
+    CheckOrphanVotes(govobj, peerman);
 
     // SEND NOTIFICATION TO SCRIPT/ZMQ
     GetMainSignals().NotifyGovernanceObject(std::make_shared<const Governance::Object>(govobj.Object()));
@@ -672,7 +672,7 @@ std::optional<const CSuperblock> CGovernanceManager::CreateSuperblockCandidate(i
     return CSuperblock(nNextSuperblock, std::move(payments));
 }
 
-std::optional<const CGovernanceObject> CGovernanceManager::CreateGovernanceTrigger(const std::optional<const CSuperblock>& sb_opt, CConnman& connman,
+std::optional<const CGovernanceObject> CGovernanceManager::CreateGovernanceTrigger(const std::optional<const CSuperblock>& sb_opt, PeerManager& peerman,
                                                                                    const CActiveMasternodeManager* const mn_activeman)
 {
     if (!fMasternodeMode) return std::nullopt;
@@ -718,11 +718,11 @@ std::optional<const CGovernanceObject> CGovernanceManager::CreateGovernanceTrigg
     }
 
     // The trigger we just created looks good, submit it
-    AddGovernanceObject(gov_sb, connman);
+    AddGovernanceObject(gov_sb, peerman);
     return std::make_optional<CGovernanceObject>(gov_sb);
 }
 
-void CGovernanceManager::VoteGovernanceTriggers(const std::optional<const CGovernanceObject>& trigger_opt, CConnman& connman,
+void CGovernanceManager::VoteGovernanceTriggers(const std::optional<const CGovernanceObject>& trigger_opt, CConnman& connman, PeerManager& peerman,
                                                 const CActiveMasternodeManager* const mn_activeman)
 {
     // only active masternodes can vote on triggers
@@ -736,7 +736,7 @@ void CGovernanceManager::VoteGovernanceTriggers(const std::optional<const CGover
         assert(!votedFundingYesTriggerHash.has_value());
         // Vote YES-FUNDING for the trigger we like
         const uint256 gov_sb_hash = trigger_opt.value().GetHash();
-        if (!VoteFundingTrigger(gov_sb_hash, VOTE_OUTCOME_YES, connman, mn_activeman)) {
+        if (!VoteFundingTrigger(gov_sb_hash, VOTE_OUTCOME_YES, connman, peerman, mn_activeman)) {
             LogPrint(BCLog::GOBJECT, "CGovernanceManager::%s Voting YES-FUNDING for new trigger:%s failed\n", __func__, gov_sb_hash.ToString());
             // this should never happen, bail out
             return;
@@ -759,7 +759,7 @@ void CGovernanceManager::VoteGovernanceTriggers(const std::optional<const CGover
             LogPrint(BCLog::GOBJECT, "CGovernanceManager::%s Not voting NO-FUNDING for trigger:%s, we voted yes for it already\n", __func__, trigger_hash.ToString());
             continue;
         }
-        if (!VoteFundingTrigger(trigger_hash, VOTE_OUTCOME_NO, connman, mn_activeman)) {
+        if (!VoteFundingTrigger(trigger_hash, VOTE_OUTCOME_NO, connman, peerman, mn_activeman)) {
             LogPrint(BCLog::GOBJECT, "CGovernanceManager::%s Voting NO-FUNDING for trigger:%s failed\n", __func__, trigger_hash.ToString());
             // failing here is ok-ish
             continue;
@@ -768,7 +768,7 @@ void CGovernanceManager::VoteGovernanceTriggers(const std::optional<const CGover
     }
 }
 
-bool CGovernanceManager::VoteFundingTrigger(const uint256& nHash, const vote_outcome_enum_t outcome, CConnman& connman,
+bool CGovernanceManager::VoteFundingTrigger(const uint256& nHash, const vote_outcome_enum_t outcome, CConnman& connman, PeerManager& peerman,
                                             const CActiveMasternodeManager* const mn_activeman)
 {
     if (!fMasternodeMode) return false;
@@ -778,7 +778,7 @@ bool CGovernanceManager::VoteFundingTrigger(const uint256& nHash, const vote_out
     vote.Sign(*mn_activeman);
 
     CGovernanceException exception;
-    if (!ProcessVoteAndRelay(vote, exception, connman)) {
+    if (!ProcessVoteAndRelay(vote, exception, connman, peerman)) {
         LogPrint(BCLog::GOBJECT, "CGovernanceManager::%s Vote FUNDING %d for trigger:%s failed:%s\n", __func__, outcome, nHash.ToString(), exception.what());
         return false;
     }
@@ -1066,11 +1066,11 @@ bool CGovernanceManager::MasternodeRateCheck(const CGovernanceObject& govobj, bo
     return false;
 }
 
-bool CGovernanceManager::ProcessVoteAndRelay(const CGovernanceVote& vote, CGovernanceException& exception, CConnman& connman)
+bool CGovernanceManager::ProcessVoteAndRelay(const CGovernanceVote& vote, CGovernanceException& exception, CConnman& connman, PeerManager& peerman)
 {
     bool fOK = ProcessVote(/* pfrom = */ nullptr, vote, exception, connman);
     if (fOK) {
-        vote.Relay(connman, *Assert(m_mn_sync), Assert(m_dmnman)->GetListAtChainTip());
+        vote.Relay(peerman, *Assert(m_mn_sync), Assert(m_dmnman)->GetListAtChainTip());
     }
     return fOK;
 }
@@ -1129,7 +1129,7 @@ bool CGovernanceManager::ProcessVote(CNode* pfrom, const CGovernanceVote& vote,
     return fOk;
 }
 
-void CGovernanceManager::CheckPostponedObjects(CConnman& connman)
+void CGovernanceManager::CheckPostponedObjects(PeerManager& peerman)
 {
     if (!Assert(m_mn_sync)->IsSynced()) return;
 
@@ -1146,7 +1146,7 @@ void CGovernanceManager::CheckPostponedObjects(CConnman& connman)
         bool fMissingConfirmations;
         if (govobj.IsCollateralValid(strError, fMissingConfirmations)) {
             if (govobj.IsValidLocally(Assert(m_dmnman)->GetListAtChainTip(), strError, false)) {
-                AddGovernanceObject(govobj, connman);
+                AddGovernanceObject(govobj, peerman);
             } else {
                 LogPrint(BCLog::GOBJECT, "CGovernanceManager::CheckPostponedObjects -- %s invalid\n", nHash.ToString());
             }
@@ -1179,7 +1179,7 @@ void CGovernanceManager::CheckPostponedObjects(CConnman& connman)
             if (fValid) {
                 if (fReady) {
                     LogPrint(BCLog::GOBJECT, "CGovernanceManager::CheckPostponedObjects -- additional relay: hash = %s\n", govobj.GetHash().ToString());
-                    govobj.Relay(connman, *m_mn_sync);
+                    govobj.Relay(peerman, *m_mn_sync);
                 } else {
                     it++;
                     continue;
@@ -1474,7 +1474,7 @@ UniValue CGovernanceManager::ToJson() const
     return jsonObj;
 }
 
-void CGovernanceManager::UpdatedBlockTip(const CBlockIndex* pindex, CConnman& connman, const CActiveMasternodeManager* const mn_activeman)
+void CGovernanceManager::UpdatedBlockTip(const CBlockIndex* pindex, CConnman& connman, PeerManager& peerman, const CActiveMasternodeManager* const mn_activeman)
 {
     // Note this gets called from ActivateBestChain without cs_main being held
     // so it should be safe to lock our mutex here without risking a deadlock
@@ -1486,8 +1486,8 @@ void CGovernanceManager::UpdatedBlockTip(const CBlockIndex* pindex, CConnman& co
     }
 
     const auto sb_opt = CreateSuperblockCandidate(pindex->nHeight);
-    const auto trigger_opt = CreateGovernanceTrigger(sb_opt, connman, mn_activeman);
-    VoteGovernanceTriggers(trigger_opt, connman, mn_activeman);
+    const auto trigger_opt = CreateGovernanceTrigger(sb_opt, peerman, mn_activeman);
+    VoteGovernanceTriggers(trigger_opt, connman, peerman, mn_activeman);
 
     nCachedBlockHeight = pindex->nHeight;
     LogPrint(BCLog::GOBJECT, "CGovernanceManager::UpdatedBlockTip -- nCachedBlockHeight: %d\n", nCachedBlockHeight);
@@ -1496,7 +1496,7 @@ void CGovernanceManager::UpdatedBlockTip(const CBlockIndex* pindex, CConnman& co
         RemoveInvalidVotes();
     }
 
-    CheckPostponedObjects(connman);
+    CheckPostponedObjects(peerman);
 
     CSuperblockManager::ExecuteBestSuperblock(*this, Assert(m_dmnman)->GetListAtChainTip(), pindex->nHeight);
 }
diff --git a/src/governance/governance.h b/src/governance/governance.h
index cad15d52aa37d..9cfe0a0a7c20f 100644
--- a/src/governance/governance.h
+++ b/src/governance/governance.h
@@ -17,9 +17,11 @@
 
 class CBloomFilter;
 class CBlockIndex;
+class CConnman;
 template<typename T>
 class CFlatDB;
 class CInv;
+class PeerManager;
 
 class CDeterministicMNManager;
 class CGovernanceManager;
@@ -292,7 +294,7 @@ class CGovernanceManager : public GovernanceStore
     void SyncSingleObjVotes(CNode& peer, const uint256& nProp, const CBloomFilter& filter, CConnman& connman);
     PeerMsgRet SyncObjects(CNode& peer, CConnman& connman) const;
 
-    PeerMsgRet ProcessMessage(CNode& peer, CConnman& connman, std::string_view msg_type, CDataStream& vRecv);
+    PeerMsgRet ProcessMessage(CNode& peer, CConnman& connman, PeerManager& peerman, std::string_view msg_type, CDataStream& vRecv);
 
     void ResetVotedFundingTrigger();
 
@@ -307,13 +309,13 @@ class CGovernanceManager : public GovernanceStore
     std::vector<CGovernanceVote> GetCurrentVotes(const uint256& nParentHash, const COutPoint& mnCollateralOutpointFilter) const;
     void GetAllNewerThan(std::vector<CGovernanceObject>& objs, int64_t nMoreThanTime) const;
 
-    void AddGovernanceObject(CGovernanceObject& govobj, CConnman& connman, const CNode* pfrom = nullptr);
+    void AddGovernanceObject(CGovernanceObject& govobj, PeerManager& peerman, const CNode* pfrom = nullptr);
 
     void CheckAndRemove();
 
     UniValue ToJson() const;
 
-    void UpdatedBlockTip(const CBlockIndex* pindex, CConnman& connman, const CActiveMasternodeManager* const mn_activeman);
+    void UpdatedBlockTip(const CBlockIndex* pindex, CConnman& connman, PeerManager& peerman, const CActiveMasternodeManager* const mn_activeman);
     int64_t GetLastDiffTime() const { return nTimeLastDiff; }
     void UpdateLastDiffTime(int64_t nTimeIn) { nTimeLastDiff = nTimeIn; }
 
@@ -342,9 +344,9 @@ class CGovernanceManager : public GovernanceStore
 
     bool MasternodeRateCheck(const CGovernanceObject& govobj, bool fUpdateFailStatus, bool fForce, bool& fRateCheckBypassed);
 
-    bool ProcessVoteAndRelay(const CGovernanceVote& vote, CGovernanceException& exception, CConnman& connman);
+    bool ProcessVoteAndRelay(const CGovernanceVote& vote, CGovernanceException& exception, CConnman& connman, PeerManager& peerman);
 
-    void CheckPostponedObjects(CConnman& connman);
+    void CheckPostponedObjects(PeerManager& peerman);
 
     bool AreRateChecksEnabled() const
     {
@@ -368,11 +370,11 @@ class CGovernanceManager : public GovernanceStore
 
 private:
     std::optional<const CSuperblock> CreateSuperblockCandidate(int nHeight) const;
-    std::optional<const CGovernanceObject> CreateGovernanceTrigger(const std::optional<const CSuperblock>& sb_opt, CConnman& connman,
+    std::optional<const CGovernanceObject> CreateGovernanceTrigger(const std::optional<const CSuperblock>& sb_opt, PeerManager& peerman,
                                                                    const CActiveMasternodeManager* const mn_activeman);
-    void VoteGovernanceTriggers(const std::optional<const CGovernanceObject>& trigger_opt, CConnman& connman,
+    void VoteGovernanceTriggers(const std::optional<const CGovernanceObject>& trigger_opt, CConnman& connman, PeerManager& peerman,
                                 const CActiveMasternodeManager* const mn_activeman);
-    bool VoteFundingTrigger(const uint256& nHash, const vote_outcome_enum_t outcome, CConnman& connman,
+    bool VoteFundingTrigger(const uint256& nHash, const vote_outcome_enum_t outcome, CConnman& connman, PeerManager& peerman,
                             const CActiveMasternodeManager* const mn_activeman);
     bool HasAlreadyVotedFundingTrigger() const;
 
@@ -393,7 +395,7 @@ class CGovernanceManager : public GovernanceStore
 
     static bool AcceptMessage(const uint256& nHash, hash_s_t& setHash);
 
-    void CheckOrphanVotes(CGovernanceObject& govobj, CConnman& connman);
+    void CheckOrphanVotes(CGovernanceObject& govobj, PeerManager& peerman);
 
     void RebuildIndexes();
 
diff --git a/src/governance/object.cpp b/src/governance/object.cpp
index 109c2bb2bd49c..9b147325ef192 100644
--- a/src/governance/object.cpp
+++ b/src/governance/object.cpp
@@ -14,7 +14,7 @@
 #include <masternode/node.h>
 #include <masternode/sync.h>
 #include <messagesigner.h>
-#include <net.h>
+#include <net_processing.h>
 #include <timedata.h>
 #include <util/time.h>
 #include <validation.h>
@@ -629,7 +629,7 @@ bool CGovernanceObject::GetCurrentMNVotes(const COutPoint& mnCollateralOutpoint,
     return true;
 }
 
-void CGovernanceObject::Relay(CConnman& connman, const CMasternodeSync& mn_sync) const
+void CGovernanceObject::Relay(PeerManager& peerman, const CMasternodeSync& mn_sync) const
 {
     // Do not relay until fully synced
     if (!mn_sync.IsSynced()) {
@@ -651,7 +651,7 @@ void CGovernanceObject::Relay(CConnman& connman, const CMasternodeSync& mn_sync)
     }
 
     CInv inv(MSG_GOVERNANCE_OBJECT, GetHash());
-    RelayInv(connman, inv, minProtoVersion);
+    peerman.RelayInv(inv, minProtoVersion);
 }
 
 void CGovernanceObject::UpdateSentinelVariables(const CDeterministicMNList& tip_mn_list)
diff --git a/src/governance/object.h b/src/governance/object.h
index d7f22bad9bf90..b427fe2c21226 100644
--- a/src/governance/object.h
+++ b/src/governance/object.h
@@ -22,6 +22,7 @@ class CGovernanceVote;
 class CMasternodeMetaMan;
 class CMasternodeSync;
 class CNode;
+class PeerManager;
 
 extern RecursiveMutex cs_main;
 
@@ -249,7 +250,7 @@ class CGovernanceObject
 
     UniValue GetJSONObject() const;
 
-    void Relay(CConnman& connman, const CMasternodeSync& mn_sync) const;
+    void Relay(PeerManager& peerman, const CMasternodeSync& mn_sync) const;
 
     uint256 GetHash() const;
     uint256 GetDataHash() const;
diff --git a/src/governance/vote.cpp b/src/governance/vote.cpp
index a1000426cae62..62f9a763aa59c 100644
--- a/src/governance/vote.cpp
+++ b/src/governance/vote.cpp
@@ -11,7 +11,7 @@
 #include <masternode/node.h>
 #include <masternode/sync.h>
 #include <messagesigner.h>
-#include <net.h>
+#include <net_processing.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <validation.h>
@@ -122,7 +122,7 @@ std::string CGovernanceVote::ToString(const CDeterministicMNList& tip_mn_list) c
     return ostr.str();
 }
 
-void CGovernanceVote::Relay(CConnman& connman, const CMasternodeSync& mn_sync, const CDeterministicMNList& tip_mn_list) const
+void CGovernanceVote::Relay(PeerManager& peerman, const CMasternodeSync& mn_sync, const CDeterministicMNList& tip_mn_list) const
 {
     // Do not relay until fully synced
     if (!mn_sync.IsSynced()) {
@@ -136,7 +136,7 @@ void CGovernanceVote::Relay(CConnman& connman, const CMasternodeSync& mn_sync, c
     }
 
     CInv inv(MSG_GOVERNANCE_OBJECT_VOTE, GetHash());
-    RelayInv(connman, inv);
+    peerman.RelayInv(inv);
 }
 
 void CGovernanceVote::UpdateHash() const
diff --git a/src/governance/vote.h b/src/governance/vote.h
index bb2c0a510b278..5662ac839cba8 100644
--- a/src/governance/vote.h
+++ b/src/governance/vote.h
@@ -10,12 +10,12 @@
 
 class CActiveMasternodeManager;
 class CBLSPublicKey;
-class CConnman;
 class CDeterministicMNList;
 class CGovernanceVote;
 class CMasternodeSync;
 class CKey;
 class CKeyID;
+class PeerManager;
 
 // INTENTION OF MASTERNODES REGARDING ITEM
 enum vote_outcome_enum_t : uint8_t {
@@ -105,7 +105,7 @@ class CGovernanceVote
     bool Sign(const CActiveMasternodeManager& mn_activeman);
     bool CheckSignature(const CBLSPublicKey& pubKey) const;
     bool IsValid(const CDeterministicMNList& tip_mn_list, bool useVotingKey) const;
-    void Relay(CConnman& connman, const CMasternodeSync& mn_sync, const CDeterministicMNList& tip_mn_list) const;
+    void Relay(PeerManager& peerman, const CMasternodeSync& mn_sync, const CDeterministicMNList& tip_mn_list) const;
 
     const COutPoint& GetMasternodeOutpoint() const { return masternodeOutpoint; }
 
diff --git a/src/init.cpp b/src/init.cpp
index 833303f8f0d16..37c5383d49378 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1860,7 +1860,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
 #endif
 
     pdsNotificationInterface = new CDSNotificationInterface(
-        *node.connman, *node.mn_sync, *node.govman, node.mn_activeman.get(), node.dmnman, node.llmq_ctx, node.cj_ctx
+        *node.connman, *node.mn_sync, *node.govman, *node.peerman, node.mn_activeman.get(), node.dmnman, node.llmq_ctx, node.cj_ctx
     );
     RegisterValidationInterface(pdsNotificationInterface);
 
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
index 4f118f24331e1..0604ec747527b 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -16,6 +16,7 @@
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
 #include <net.h>
+#include <net_processing.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <saltedhasher.h>
@@ -46,8 +47,9 @@ static const std::string DB_MINED_COMMITMENT_BY_INVERSED_HEIGHT_Q_INDEXED = "q_m
 
 static const std::string DB_BEST_BLOCK_UPGRADE = "q_bbu2";
 
-CQuorumBlockProcessor::CQuorumBlockProcessor(CChainState& chainstate, CConnman& _connman, CDeterministicMNManager& dmnman, CEvoDB& evoDb) :
-    m_chainstate(chainstate), connman(_connman), m_dmnman(dmnman), m_evoDb(evoDb)
+CQuorumBlockProcessor::CQuorumBlockProcessor(CChainState& chainstate, CDeterministicMNManager& dmnman, CEvoDB& evoDb,
+                                             const std::unique_ptr<PeerManager>& peerman) :
+    m_chainstate(chainstate), m_dmnman(dmnman), m_evoDb(evoDb), m_peerman(peerman)
 {
     utils::InitQuorumsCache(mapHasMinedCommitmentCache);
 }
@@ -666,7 +668,7 @@ void CQuorumBlockProcessor::AddMineableCommitment(const CFinalCommitment& fqc)
     // We only relay the new commitment if it's new or better then the old one
     if (relay) {
         CInv inv(MSG_QUORUM_FINAL_COMMITMENT, commitmentHash);
-        RelayInv(connman, inv);
+        m_peerman->RelayInv(inv);
     }
 }
 
diff --git a/src/llmq/blockprocessor.h b/src/llmq/blockprocessor.h
index 62e27ed43cf01..b77f125233a3f 100644
--- a/src/llmq/blockprocessor.h
+++ b/src/llmq/blockprocessor.h
@@ -25,6 +25,7 @@ class CDataStream;
 class CDeterministicMNManager;
 class CEvoDB;
 class CNode;
+class PeerManager;
 
 extern RecursiveMutex cs_main;
 
@@ -38,9 +39,9 @@ class CQuorumBlockProcessor
 {
 private:
     CChainState& m_chainstate;
-    CConnman& connman;
     CDeterministicMNManager& m_dmnman;
     CEvoDB& m_evoDb;
+    const std::unique_ptr<PeerManager>& m_peerman;
 
     mutable Mutex minableCommitmentsCs;
     std::map<std::pair<Consensus::LLMQType, uint256>, uint256> minableCommitmentsByQuorum GUARDED_BY(minableCommitmentsCs);
@@ -49,7 +50,8 @@ class CQuorumBlockProcessor
     mutable std::map<Consensus::LLMQType, unordered_lru_cache<uint256, bool, StaticSaltedHasher>> mapHasMinedCommitmentCache GUARDED_BY(minableCommitmentsCs);
 
 public:
-    explicit CQuorumBlockProcessor(CChainState& chainstate, CConnman& _connman, CDeterministicMNManager& dmnman, CEvoDB& evoDb);
+    explicit CQuorumBlockProcessor(CChainState& chainstate, CDeterministicMNManager& dmnman, CEvoDB& evoDb,
+                                   const std::unique_ptr<PeerManager>& peerman);
 
     PeerMsgRet ProcessMessage(const CNode& peer, std::string_view msg_type, CDataStream& vRecv);
 
diff --git a/src/llmq/chainlocks.cpp b/src/llmq/chainlocks.cpp
index e55a4c9e98651..a22a8dc44f8c6 100644
--- a/src/llmq/chainlocks.cpp
+++ b/src/llmq/chainlocks.cpp
@@ -11,6 +11,7 @@
 #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>
@@ -25,17 +26,17 @@ namespace llmq
 {
 std::unique_ptr<CChainLocksHandler> chainLocksHandler;
 
-CChainLocksHandler::CChainLocksHandler(CChainState& chainstate, CConnman& _connman, CQuorumManager& _qman,
-                                       CSigningManager& _sigman, CSigSharesManager& _shareman, CSporkManager& sporkman,
-                                       CTxMemPool& _mempool, const CMasternodeSync& mn_sync) :
+CChainLocksHandler::CChainLocksHandler(CChainState& chainstate, CQuorumManager& _qman, CSigningManager& _sigman,
+                                       CSigSharesManager& _shareman, CSporkManager& sporkman, CTxMemPool& _mempool,
+                                       const CMasternodeSync& mn_sync, const std::unique_ptr<PeerManager>& peerman) :
     m_chainstate(chainstate),
-    connman(_connman),
     qman(_qman),
     sigman(_sigman),
     shareman(_shareman),
     spork_manager(sporkman),
     mempool(_mempool),
     m_mn_sync(mn_sync),
+    m_peerman(peerman),
     scheduler(std::make_unique<CScheduler>()),
     scheduler_thread(std::make_unique<std::thread>(std::thread(util::TraceThread, "cl-schdlr", [&] { scheduler->serviceQueue(); })))
 {
@@ -161,7 +162,7 @@ PeerMsgRet CChainLocksHandler::ProcessNewChainLock(const NodeId from, const llmq
 
     // Note: do not hold cs while calling RelayInv
     AssertLockNotHeld(cs);
-    RelayInv(connman, clsigInv);
+    m_peerman->RelayInv(clsigInv);
 
     if (pindex == nullptr) {
         // we don't know the block/header for this CLSIG yet, so bail out for now
diff --git a/src/llmq/chainlocks.h b/src/llmq/chainlocks.h
index e9041d5442534..9ac83669dd7f9 100644
--- a/src/llmq/chainlocks.h
+++ b/src/llmq/chainlocks.h
@@ -24,12 +24,12 @@
 #include <unordered_set>
 
 class CChainState;
-class CConnman;
 class CBlockIndex;
 class CMasternodeSync;
 class CScheduler;
 class CSporkManager;
 class CTxMemPool;
+class PeerManager;
 
 namespace llmq
 {
@@ -46,13 +46,13 @@ class CChainLocksHandler : public CRecoveredSigsListener
 
 private:
     CChainState& m_chainstate;
-    CConnman& connman;
     CQuorumManager& qman;
     CSigningManager& sigman;
     CSigSharesManager& shareman;
     CSporkManager& spork_manager;
     CTxMemPool& mempool;
     const CMasternodeSync& m_mn_sync;
+    const std::unique_ptr<PeerManager>& m_peerman;
 
     std::unique_ptr<CScheduler> scheduler;
     std::unique_ptr<std::thread> scheduler_thread;
@@ -85,9 +85,9 @@ class CChainLocksHandler : public CRecoveredSigsListener
     std::atomic<int64_t> lastCleanupTime{0};
 
 public:
-    explicit CChainLocksHandler(CChainState& chainstate, CConnman& _connman, CQuorumManager& _qman,
-                                CSigningManager& _sigman, CSigSharesManager& _shareman, CSporkManager& sporkman,
-                                CTxMemPool& _mempool, const CMasternodeSync& mn_sync);
+    explicit CChainLocksHandler(CChainState& chainstate, CQuorumManager& _qman, CSigningManager& _sigman,
+                                CSigSharesManager& _shareman, CSporkManager& sporkman, CTxMemPool& _mempool,
+                                const CMasternodeSync& mn_sync, const std::unique_ptr<PeerManager>& peerman);
     ~CChainLocksHandler();
 
     void Start();
diff --git a/src/llmq/context.cpp b/src/llmq/context.cpp
index ea182a90b55e1..ceb3949787207 100644
--- a/src/llmq/context.cpp
+++ b/src/llmq/context.cpp
@@ -25,7 +25,7 @@ LLMQContext::LLMQContext(CChainState& chainstate, CConnman& connman, CDeterminis
     dkg_debugman{std::make_unique<llmq::CDKGDebugManager>()},
     quorum_block_processor{[&]() -> llmq::CQuorumBlockProcessor* const {
         assert(llmq::quorumBlockProcessor == nullptr);
-        llmq::quorumBlockProcessor = std::make_unique<llmq::CQuorumBlockProcessor>(chainstate, connman, dmnman, evo_db);
+        llmq::quorumBlockProcessor = std::make_unique<llmq::CQuorumBlockProcessor>(chainstate, dmnman, evo_db, peerman);
         return llmq::quorumBlockProcessor.get();
     }()},
     qdkgsman{std::make_unique<llmq::CDKGSessionManager>(*bls_worker, chainstate, connman, dmnman, *dkg_debugman, mn_metaman, *quorum_block_processor, mn_activeman, sporkman, unit_tests, wipe)},
@@ -38,7 +38,7 @@ LLMQContext::LLMQContext(CChainState& chainstate, CConnman& connman, CDeterminis
     shareman{std::make_unique<llmq::CSigSharesManager>(connman, *sigman, mn_activeman, *llmq::quorumManager, sporkman, peerman)},
     clhandler{[&]() -> llmq::CChainLocksHandler* const {
         assert(llmq::chainLocksHandler == nullptr);
-        llmq::chainLocksHandler = std::make_unique<llmq::CChainLocksHandler>(chainstate, connman, *llmq::quorumManager, *sigman, *shareman, sporkman, mempool, mn_sync);
+        llmq::chainLocksHandler = std::make_unique<llmq::CChainLocksHandler>(chainstate, *llmq::quorumManager, *sigman, *shareman, sporkman, mempool, mn_sync, peerman);
         return llmq::chainLocksHandler.get();
     }()},
     isman{[&]() -> llmq::CInstantSendManager* const {
diff --git a/src/llmq/ehf_signals.h b/src/llmq/ehf_signals.h
index 675b90d833ca9..b29828ebd288d 100644
--- a/src/llmq/ehf_signals.h
+++ b/src/llmq/ehf_signals.h
@@ -11,7 +11,6 @@
 
 class CBlockIndex;
 class CChainState;
-class CConnman;
 class CMNHFManager;
 class CSporkManager;
 class CTxMemPool;
diff --git a/src/llmq/instantsend.cpp b/src/llmq/instantsend.cpp
index 06020ff275a4d..8278b156739e1 100644
--- a/src/llmq/instantsend.cpp
+++ b/src/llmq/instantsend.cpp
@@ -1051,11 +1051,11 @@ void CInstantSendManager::ProcessInstantSendLock(NodeId from, const uint256& has
 
     CInv inv(MSG_ISDLOCK, hash);
     if (tx != nullptr) {
-        RelayInvFiltered(connman, inv, *tx, ISDLOCK_PROTO_VERSION);
+        m_peerman.load()->RelayInvFiltered(inv, *tx, ISDLOCK_PROTO_VERSION);
     } else {
         // we don't have the TX yet, so we only filter based on txid. Later when that TX arrives, we will re-announce
         // with the TX taken into account.
-        RelayInvFiltered(connman, inv, islock->txid, ISDLOCK_PROTO_VERSION);
+        m_peerman.load()->RelayInvFiltered(inv, islock->txid, ISDLOCK_PROTO_VERSION);
     }
 
     ResolveBlockConflicts(hash, *islock);
diff --git a/src/net.cpp b/src/net.cpp
index 390b7fa7db3df..499fd05f91818 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -3926,52 +3926,6 @@ bool CConnman::DisconnectNode(NodeId id)
     return false;
 }
 
-void RelayInv(CConnman& connman, CInv &inv, const int minProtoVersion) {
-    connman.ForEachNode([&](CNode* pnode) {
-        if (pnode->nVersion < minProtoVersion || !pnode->CanRelay())
-            return;
-        pnode->PushInventory(inv);
-    });
-}
-
-void RelayInvFiltered(CConnman& connman, CInv &inv, const CTransaction& relatedTx, const int minProtoVersion)
-{
-    connman.ForEachNode([&](CNode* pnode) {
-        if (pnode->nVersion < minProtoVersion || !pnode->CanRelay() || pnode->IsBlockOnlyConn()) {
-            return;
-        }
-        {
-            LOCK(pnode->m_tx_relay->cs_filter);
-            if (!pnode->m_tx_relay->fRelayTxes) {
-                return;
-            }
-            if (pnode->m_tx_relay->pfilter && !pnode->m_tx_relay->pfilter->IsRelevantAndUpdate(relatedTx)) {
-                return;
-            }
-        }
-        pnode->PushInventory(inv);
-    });
-}
-
-void RelayInvFiltered(CConnman& connman, CInv &inv, const uint256& relatedTxHash, const int minProtoVersion)
-{
-    connman.ForEachNode([&](CNode* pnode) {
-        if (pnode->nVersion < minProtoVersion || !pnode->CanRelay() || pnode->IsBlockOnlyConn()) {
-            return;
-        }
-        {
-            LOCK(pnode->m_tx_relay->cs_filter);
-            if (!pnode->m_tx_relay->fRelayTxes) {
-                return;
-            }
-            if (pnode->m_tx_relay->pfilter && !pnode->m_tx_relay->pfilter->contains(relatedTxHash)) {
-                return;
-            }
-        }
-        pnode->PushInventory(inv);
-    });
-}
-
 void CConnman::RecordBytesRecv(uint64_t bytes)
 {
     LOCK(cs_totalBytesRecv);
diff --git a/src/net.h b/src/net.h
index b7d105322a547..1c5f5f8c9415d 100644
--- a/src/net.h
+++ b/src/net.h
@@ -1524,16 +1524,6 @@ friend class CNode;
     friend struct ConnmanTestMsg;
 };
 
-void RelayInv(CConnman& connman, CInv &inv, const int minProtoVersion = MIN_PEER_PROTO_VERSION);
-void RelayInvFiltered(CConnman& connman, CInv &inv, const CTransaction &relatedTx,
-                      const int minProtoVersion = MIN_PEER_PROTO_VERSION);
-/**
- * This overload will not update node filters,  so use it only for the cases
- * when other messages will update related transaction data in filters
- */
-void RelayInvFiltered(CConnman& connman, CInv &inv, const uint256 &relatedTxHash,
-                      const int minProtoVersion = MIN_PEER_PROTO_VERSION);
-
 /** Return a timestamp in the future (in microseconds) for exponentially distributed events. */
 std::chrono::microseconds PoissonNextSend(std::chrono::microseconds now, std::chrono::seconds average_interval);
 
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 7a6b5c23921de..ca2e16a1c6ed4 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -358,6 +358,9 @@ class PeerManagerImpl final : public PeerManager
     bool GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) const override;
     bool IgnoresIncomingTxs() override { return m_ignore_incoming_txs; }
     void SendPings() override;
+    void RelayInv(CInv &inv, const int minProtoVersion) override;
+    void RelayInvFiltered(CInv &inv, const CTransaction &relatedTx, const int minProtoVersion) override;
+    void RelayInvFiltered(CInv &inv, const uint256 &relatedTxHash, const int minProtoVersion) override;
     void RelayTransaction(const uint256& txid) override;
     void SetBestHeight(int height) override { m_best_height = height; };
     void Misbehaving(const NodeId pnode, const int howmuch, const std::string& message = "") override;
@@ -2109,6 +2112,52 @@ void PeerManagerImpl::SendPings()
     for(auto& it : m_peer_map) it.second->m_ping_queued = true;
 }
 
+void PeerManagerImpl::RelayInv(CInv &inv, const int minProtoVersion) {
+    m_connman.ForEachNode([&](CNode* pnode) {
+        if (pnode->nVersion < minProtoVersion || !pnode->CanRelay())
+            return;
+        pnode->PushInventory(inv);
+    });
+}
+
+void PeerManagerImpl::RelayInvFiltered(CInv &inv, const CTransaction& relatedTx, const int minProtoVersion)
+{
+    m_connman.ForEachNode([&](CNode* pnode) {
+        if (pnode->nVersion < minProtoVersion || !pnode->CanRelay() || pnode->IsBlockOnlyConn()) {
+            return;
+        }
+        {
+            LOCK(pnode->m_tx_relay->cs_filter);
+            if (!pnode->m_tx_relay->fRelayTxes) {
+                return;
+            }
+            if (pnode->m_tx_relay->pfilter && !pnode->m_tx_relay->pfilter->IsRelevantAndUpdate(relatedTx)) {
+                return;
+            }
+        }
+        pnode->PushInventory(inv);
+    });
+}
+
+void PeerManagerImpl::RelayInvFiltered(CInv &inv, const uint256& relatedTxHash, const int minProtoVersion)
+{
+    m_connman.ForEachNode([&](CNode* pnode) {
+        if (pnode->nVersion < minProtoVersion || !pnode->CanRelay() || pnode->IsBlockOnlyConn()) {
+            return;
+        }
+        {
+            LOCK(pnode->m_tx_relay->cs_filter);
+            if (!pnode->m_tx_relay->fRelayTxes) {
+                return;
+            }
+            if (pnode->m_tx_relay->pfilter && !pnode->m_tx_relay->pfilter->contains(relatedTxHash)) {
+                return;
+            }
+        }
+        pnode->PushInventory(inv);
+    });
+}
+
 void PeerManagerImpl::RelayTransaction(const uint256& txid)
 {
     CInv inv(m_cj_ctx->dstxman->GetDSTX(txid) ? MSG_DSTX : MSG_TX, txid);
@@ -4689,9 +4738,9 @@ void PeerManagerImpl::ProcessMessage(
         }
 #endif // ENABLE_WALLET
         ProcessPeerMsgRet(m_cj_ctx->server->ProcessMessage(pfrom, msg_type, vRecv), pfrom);
-        ProcessPeerMsgRet(m_sporkman.ProcessMessage(pfrom, m_connman, msg_type, vRecv), pfrom);
+        ProcessPeerMsgRet(m_sporkman.ProcessMessage(pfrom, m_connman, *this, msg_type, vRecv), pfrom);
         m_mn_sync.ProcessMessage(pfrom, msg_type, vRecv);
-        ProcessPeerMsgRet(m_govman.ProcessMessage(pfrom, m_connman, msg_type, vRecv), pfrom);
+        ProcessPeerMsgRet(m_govman.ProcessMessage(pfrom, m_connman, *this, msg_type, vRecv), pfrom);
         ProcessPeerMsgRet(CMNAuth::ProcessMessage(pfrom, m_connman, m_mn_metaman, m_mn_activeman, m_mn_sync, m_dmnman->GetListAtChainTip(), msg_type, vRecv), pfrom);
         ProcessPeerMsgRet(m_llmq_ctx->quorum_block_processor->ProcessMessage(pfrom, msg_type, vRecv), pfrom);
         ProcessPeerMsgRet(m_llmq_ctx->qdkgsman->ProcessMessage(pfrom, this, msg_type, vRecv), pfrom);
diff --git a/src/net_processing.h b/src/net_processing.h
index 6b29d2e8ff735..f5826dd40d21f 100644
--- a/src/net_processing.h
+++ b/src/net_processing.h
@@ -9,6 +9,7 @@
 #include <net.h>
 #include <sync.h>
 #include <validationinterface.h>
+#include <version.h>
 
 #include <atomic>
 
@@ -21,7 +22,9 @@ class CMasternodeSync;
 class ChainstateManager;
 class CCoinJoinServer;
 class CGovernanceManager;
+class CInv;
 class CSporkManager;
+class CTransaction;
 struct CJContext;
 struct LLMQContext;
 
@@ -71,6 +74,18 @@ class PeerManager : public CValidationInterface, public NetEventsInterface
     /** Send ping message to all peers */
     virtual void SendPings() = 0;
 
+    /** Relay inventories to all peers */
+    virtual void RelayInv(CInv &inv, const int minProtoVersion = MIN_PEER_PROTO_VERSION) = 0;
+    virtual void RelayInvFiltered(CInv &inv, const CTransaction &relatedTx,
+                                  const int minProtoVersion = MIN_PEER_PROTO_VERSION) = 0;
+
+    /**
+     * This overload will not update node filters, use it only for the cases
+     * when other messages will update related transaction data in filters
+     */
+    virtual void RelayInvFiltered(CInv &inv, const uint256 &relatedTxHash,
+                                  const int minProtoVersion = MIN_PEER_PROTO_VERSION) = 0;
+
     /** Relay transaction to all peers. */
     virtual void RelayTransaction(const uint256& txid)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main) = 0;
diff --git a/src/rpc/governance.cpp b/src/rpc/governance.cpp
index b91261fb69637..9d173a1f96f9a 100644
--- a/src/rpc/governance.cpp
+++ b/src/rpc/governance.cpp
@@ -399,9 +399,9 @@ static UniValue gobject_submit(const JSONRPCRequest& request)
 
     if (fMissingConfirmations) {
         node.govman->AddPostponedObject(govobj);
-        govobj.Relay(*node.connman, *node.mn_sync);
+        govobj.Relay(*node.peerman, *node.mn_sync);
     } else {
-        node.govman->AddGovernanceObject(govobj, *node.connman);
+        node.govman->AddGovernanceObject(govobj, *node.peerman);
     }
 
     return govobj.GetHash().ToString();
@@ -452,7 +452,7 @@ static UniValue VoteWithMasternodes(const JSONRPCRequest& request, const std::ma
         }
 
         CGovernanceException exception;
-        if (node.govman->ProcessVoteAndRelay(vote, exception, *node.connman)) {
+        if (node.govman->ProcessVoteAndRelay(vote, exception, *node.connman, *node.peerman)) {
             nSuccessful++;
             statusObj.pushKV("result", "success");
         } else {
@@ -1035,7 +1035,7 @@ static UniValue voteraw(const JSONRPCRequest& request)
     }
 
     CGovernanceException exception;
-    if (node.govman->ProcessVoteAndRelay(vote, exception, *node.connman)) {
+    if (node.govman->ProcessVoteAndRelay(vote, exception, *node.connman, *node.peerman)) {
         return "Voted successfully";
     } else {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Error voting : " + exception.GetMessage());
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index bbc2e4eec242f..d011bb60f147c 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -214,13 +214,13 @@ static RPCHelpMan sporkupdate()
     }
 
     const NodeContext& node = EnsureAnyNodeContext(request.context);
-    CConnman& connman = EnsureConnman(node);
+    PeerManager& peerman = EnsurePeerman(node);
 
     // SPORK VALUE
     int64_t nValue = request.params[1].get_int64();
 
     // broadcast new spork
-    if (node.sporkman->UpdateSpork(nSporkID, nValue, connman)) {
+    if (node.sporkman->UpdateSpork(peerman, nSporkID, nValue)) {
         return "success";
     }
 
diff --git a/src/spork.cpp b/src/spork.cpp
index 19896e1081fa7..798dddac77e81 100644
--- a/src/spork.cpp
+++ b/src/spork.cpp
@@ -11,6 +11,7 @@
 #include <logging.h>
 #include <messagesigner.h>
 #include <net.h>
+#include <net_processing.h>
 #include <netmessagemaker.h>
 #include <primitives/block.h>
 #include <protocol.h>
@@ -127,17 +128,17 @@ void CSporkManager::CheckAndRemove()
     }
 }
 
-PeerMsgRet CSporkManager::ProcessMessage(CNode& peer, CConnman& connman, std::string_view msg_type, CDataStream& vRecv)
+PeerMsgRet CSporkManager::ProcessMessage(CNode& peer, CConnman& connman, PeerManager& peerman, std::string_view msg_type, CDataStream& vRecv)
 {
     if (msg_type == NetMsgType::SPORK) {
-        return ProcessSpork(peer, connman, vRecv);
+        return ProcessSpork(peer, peerman, vRecv);
     } else if (msg_type == NetMsgType::GETSPORKS) {
         ProcessGetSporks(peer, connman);
     }
     return {};
 }
 
-PeerMsgRet CSporkManager::ProcessSpork(const CNode& peer, CConnman& connman, CDataStream& vRecv)
+PeerMsgRet CSporkManager::ProcessSpork(const CNode& peer, PeerManager& peerman, CDataStream& vRecv)
 {
     CSporkMessage spork;
     vRecv >> spork;
@@ -193,7 +194,7 @@ PeerMsgRet CSporkManager::ProcessSpork(const CNode& peer, CConnman& connman, CDa
         WITH_LOCK(cs_mapSporksCachedActive, mapSporksCachedActive.erase(spork.nSporkID));
         WITH_LOCK(cs_mapSporksCachedValues, mapSporksCachedValues.erase(spork.nSporkID));
     }
-    spork.Relay(connman);
+    spork.Relay(peerman);
     return {};
 }
 
@@ -208,7 +209,7 @@ void CSporkManager::ProcessGetSporks(CNode& peer, CConnman& connman)
 }
 
 
-bool CSporkManager::UpdateSpork(SporkId nSporkID, SporkValue nValue, CConnman& connman)
+bool CSporkManager::UpdateSpork(PeerManager& peerman, SporkId nSporkID, SporkValue nValue)
 {
     CSporkMessage spork(nSporkID, nValue, GetAdjustedTime());
 
@@ -235,7 +236,7 @@ bool CSporkManager::UpdateSpork(SporkId nSporkID, SporkValue nValue, CConnman& c
         WITH_LOCK(cs_mapSporksCachedValues, mapSporksCachedValues.erase(spork.nSporkID));
     }
 
-    spork.Relay(connman);
+    spork.Relay(peerman);
     return true;
 }
 
@@ -451,8 +452,8 @@ std::optional<CKeyID> CSporkMessage::GetSignerKeyID() const
     return {pubkeyFromSig.GetID()};
 }
 
-void CSporkMessage::Relay(CConnman& connman) const
+void CSporkMessage::Relay(PeerManager& peerman) const
 {
     CInv inv(MSG_SPORK, GetHash());
-    RelayInv(connman, inv);
+    peerman.RelayInv(inv);
 }
diff --git a/src/spork.h b/src/spork.h
index effc9d75309ce..02e9eeecd3d58 100644
--- a/src/spork.h
+++ b/src/spork.h
@@ -25,6 +25,7 @@ template<typename T>
 class CFlatDB;
 class CNode;
 class CDataStream;
+class PeerManager;
 
 class CSporkMessage;
 class CSporkManager;
@@ -155,7 +156,7 @@ class CSporkMessage
     /**
      * Relay is used to send this spork message to other peers.
      */
-    void Relay(CConnman& connman) const;
+    void Relay(PeerManager& peerman) const;
 };
 
 class SporkStore
@@ -257,7 +258,7 @@ class CSporkManager : public SporkStore
     /**
      * ProcessMessage is used to call ProcessSpork and ProcessGetSporks. See below
      */
-    PeerMsgRet ProcessMessage(CNode& peer, CConnman& connman, std::string_view msg_type, CDataStream& vRecv);
+    PeerMsgRet ProcessMessage(CNode& peer, CConnman& connman, PeerManager& peerman, std::string_view msg_type, CDataStream& vRecv);
 
     /**
      * ProcessSpork is used to handle the 'spork' p2p message.
@@ -265,7 +266,7 @@ class CSporkManager : public SporkStore
      * For 'spork', it validates the spork and adds it to the internal spork storage and
      * performs any necessary processing.
      */
-    PeerMsgRet ProcessSpork(const CNode& peer, CConnman& connman, CDataStream& vRecv) LOCKS_EXCLUDED(cs);
+    PeerMsgRet ProcessSpork(const CNode& peer, PeerManager& peerman, CDataStream& vRecv) LOCKS_EXCLUDED(cs);
 
     /**
      * ProcessGetSporks is used to handle the 'getsporks' p2p message.
@@ -278,7 +279,7 @@ class CSporkManager : public SporkStore
      * UpdateSpork is used by the spork RPC command to set a new spork value, sign
      * and broadcast the spork message.
      */
-    bool UpdateSpork(SporkId nSporkID, SporkValue nValue, CConnman& connman) LOCKS_EXCLUDED(cs);
+    bool UpdateSpork(PeerManager& peerman, SporkId nSporkID, SporkValue nValue) LOCKS_EXCLUDED(cs);
 
     /**
      * IsSporkActive returns a bool for time-based sporks, and should be used
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index 6eef8b94721ff..5fc193b53bed0 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -32,7 +32,6 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "governance/governance -> governance/object -> governance/governance"
     "governance/governance -> masternode/sync -> governance/governance"
     "llmq/chainlocks -> llmq/instantsend -> llmq/chainlocks"
-    "llmq/chainlocks -> llmq/instantsend -> net_processing -> llmq/chainlocks"
     "llmq/dkgsessionhandler -> net_processing -> llmq/dkgsessionmgr -> llmq/dkgsessionhandler"
     "llmq/instantsend -> net_processing -> llmq/instantsend"
     "llmq/instantsend -> txmempool -> llmq/instantsend"
@@ -51,7 +50,6 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "qt/guiutil -> qt/optionsdialog -> qt/guiutil"
     "qt/guiutil -> qt/qvalidatedlineedit -> qt/guiutil"
     "core_io -> evo/cbtx -> evo/simplifiedmns -> core_io"
-    "core_io -> evo/assetlocktx -> llmq/signing -> net_processing -> governance/governance -> governance/object -> core_io"
     "llmq/dkgsession -> llmq/dkgsessionmgr -> llmq/dkgsessionhandler -> llmq/dkgsession"
     "logging -> util/system -> sync -> logging"
     "logging -> util/system -> stacktraces -> logging"
@@ -60,12 +58,10 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "qt/guiutil -> qt/optionsdialog -> qt/optionsmodel -> qt/guiutil"
 
     "bloom -> evo/assetlocktx -> llmq/quorums -> net -> bloom"
-    "bloom -> evo/assetlocktx -> llmq/signing -> net_processing -> governance/governance -> bloom"
     "bloom -> evo/assetlocktx -> llmq/signing -> net_processing -> merkleblock -> bloom"
     "banman -> bloom -> evo/assetlocktx -> llmq/quorums -> net -> banman"
     "banman -> bloom -> evo/assetlocktx -> llmq/signing -> net_processing -> banman"
 
-    "coinjoin/client -> coinjoin/coinjoin -> llmq/instantsend -> net_processing -> coinjoin/client"
     "llmq/dkgsession -> llmq/dkgsessionmgr -> llmq/dkgsession"
     "llmq/chainlocks -> validation -> llmq/chainlocks"
     "coinjoin/coinjoin -> llmq/chainlocks -> net -> coinjoin/coinjoin"
@@ -100,6 +96,15 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "coinjoin/server -> net_processing -> coinjoin/server"
     "llmq/context -> llmq/ehf_signals -> net_processing -> llmq/context"
     "coinjoin/client -> coinjoin/util -> wallet/wallet -> psbt -> node/transaction -> node/context -> coinjoin/context -> coinjoin/client"
+    "llmq/blockprocessor -> net_processing -> llmq/blockprocessor"
+    "llmq/chainlocks -> net_processing -> llmq/chainlocks"
+    "net_processing -> spork -> net_processing"
+    "evo/simplifiedmns -> llmq/blockprocessor -> net_processing -> evo/simplifiedmns"
+    "governance/governance -> governance/object -> net_processing -> governance/governance"
+    "llmq/blockprocessor -> net_processing -> llmq/context -> llmq/blockprocessor"
+    "llmq/blockprocessor -> net_processing -> llmq/quorums -> llmq/blockprocessor"
+    "llmq/chainlocks -> net_processing -> llmq/context -> llmq/chainlocks"
+    "coinjoin/client -> coinjoin/coinjoin -> llmq/chainlocks -> net_processing -> coinjoin/client"
 )
 
 EXIT_CODE=0

From 35be4e2ebecd9db740412ede10a67f2933d4215c Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Tue, 9 Apr 2024 17:43:08 +0000
Subject: [PATCH 6/7] llmq: pass PeerManager to llmq::CInstantSendManager
 constructor

Required to avoid crashes when calling RelayInvFiltered in situations
where the PeerManager* atomic hasn't been set (possible when ProcessMessage
isn't called, leaving the value unset, while a separate thread traverses
the ProcessPendingInstantSendLocks > ProcessPendingInstantSendLocks[1] >
ProcessInstantSendLock > RelayInvFiltered call chain).

[1] - There is a function with the exact same name but with multiple
      arguments
---
 src/llmq/context.cpp     |  2 +-
 src/llmq/instantsend.cpp | 18 ++++++------------
 src/llmq/instantsend.h   |  8 ++++----
 src/net_processing.cpp   |  2 +-
 4 files changed, 12 insertions(+), 18 deletions(-)

diff --git a/src/llmq/context.cpp b/src/llmq/context.cpp
index ceb3949787207..ee1f723d2997c 100644
--- a/src/llmq/context.cpp
+++ b/src/llmq/context.cpp
@@ -43,7 +43,7 @@ LLMQContext::LLMQContext(CChainState& chainstate, CConnman& connman, CDeterminis
     }()},
     isman{[&]() -> llmq::CInstantSendManager* const {
         assert(llmq::quorumInstantSendManager == nullptr);
-        llmq::quorumInstantSendManager = std::make_unique<llmq::CInstantSendManager>(*llmq::chainLocksHandler, chainstate, connman, *llmq::quorumManager, *sigman, *shareman, sporkman, mempool, mn_sync, unit_tests, wipe);
+        llmq::quorumInstantSendManager = std::make_unique<llmq::CInstantSendManager>(*llmq::chainLocksHandler, chainstate, connman, *llmq::quorumManager, *sigman, *shareman, sporkman, mempool, mn_sync, peerman, unit_tests, wipe);
         return llmq::quorumInstantSendManager.get();
     }()},
     ehfSignalsHandler{std::make_unique<llmq::CEHFSignalsHandler>(chainstate, mnhfman, *sigman, *shareman, mempool, *llmq::quorumManager, sporkman, peerman)}
diff --git a/src/llmq/instantsend.cpp b/src/llmq/instantsend.cpp
index 8278b156739e1..46bb829ab750d 100644
--- a/src/llmq/instantsend.cpp
+++ b/src/llmq/instantsend.cpp
@@ -747,15 +747,9 @@ void CInstantSendManager::HandleNewInstantSendLockRecoveredSig(const llmq::CReco
     pendingInstantSendLocks.emplace(hash, std::make_pair(-1, islock));
 }
 
-PeerMsgRet CInstantSendManager::ProcessMessage(const CNode& pfrom, gsl::not_null<PeerManager*> peerman, std::string_view msg_type, CDataStream& vRecv)
+PeerMsgRet CInstantSendManager::ProcessMessage(const CNode& pfrom, std::string_view msg_type, CDataStream& vRecv)
 {
     if (IsInstantSendEnabled() && msg_type == NetMsgType::ISDLOCK) {
-        if (m_peerman == nullptr) {
-            m_peerman = peerman;
-        }
-        // we should never use one CInstantSendManager with different PeerManager
-        assert(m_peerman == peerman);
-
         const auto islock = std::make_shared<CInstantSendLock>();
         vRecv >> *islock;
         return ProcessMessageInstantSendLock(pfrom, islock);
@@ -957,7 +951,7 @@ std::unordered_set<uint256, StaticSaltedHasher> CInstantSendManager::ProcessPend
         for (const auto& nodeId : batchVerifier.badSources) {
             // Let's not be too harsh, as the peer might simply be unlucky and might have sent us an old lock which
             // does not validate anymore due to changed quorums
-            m_peerman.load()->Misbehaving(nodeId, 20);
+            m_peerman->Misbehaving(nodeId, 20);
         }
     }
     for (const auto& p : pend) {
@@ -1051,11 +1045,11 @@ void CInstantSendManager::ProcessInstantSendLock(NodeId from, const uint256& has
 
     CInv inv(MSG_ISDLOCK, hash);
     if (tx != nullptr) {
-        m_peerman.load()->RelayInvFiltered(inv, *tx, ISDLOCK_PROTO_VERSION);
+        m_peerman->RelayInvFiltered(inv, *tx, ISDLOCK_PROTO_VERSION);
     } else {
         // we don't have the TX yet, so we only filter based on txid. Later when that TX arrives, we will re-announce
         // with the TX taken into account.
-        m_peerman.load()->RelayInvFiltered(inv, islock->txid, ISDLOCK_PROTO_VERSION);
+        m_peerman->RelayInvFiltered(inv, islock->txid, ISDLOCK_PROTO_VERSION);
     }
 
     ResolveBlockConflicts(hash, *islock);
@@ -1068,7 +1062,7 @@ void CInstantSendManager::ProcessInstantSendLock(NodeId from, const uint256& has
         // bump mempool counter to make sure newly locked txes are picked up by getblocktemplate
         mempool.AddTransactionsUpdated(1);
     } else {
-        AskNodesForLockedTx(islock->txid, connman, *m_peerman.load());
+        AskNodesForLockedTx(islock->txid, connman, *m_peerman);
     }
 }
 
@@ -1344,7 +1338,7 @@ void CInstantSendManager::RemoveMempoolConflictsForLock(const uint256& hash, con
         for (const auto& p : toDelete) {
             RemoveConflictedTx(*p.second);
         }
-        AskNodesForLockedTx(islock.txid, connman, *m_peerman.load());
+        AskNodesForLockedTx(islock.txid, connman, *m_peerman);
     }
 }
 
diff --git a/src/llmq/instantsend.h b/src/llmq/instantsend.h
index cd141b65b5867..4f4167b7ade53 100644
--- a/src/llmq/instantsend.h
+++ b/src/llmq/instantsend.h
@@ -206,7 +206,7 @@ class CInstantSendManager : public CRecoveredSigsListener
     CSporkManager& spork_manager;
     CTxMemPool& mempool;
     const CMasternodeSync& m_mn_sync;
-    std::atomic<PeerManager*> m_peerman{nullptr};
+    const std::unique_ptr<PeerManager>& m_peerman;
 
     std::atomic<bool> fUpgradedDB{false};
 
@@ -257,10 +257,10 @@ class CInstantSendManager : public CRecoveredSigsListener
     explicit CInstantSendManager(CChainLocksHandler& _clhandler, CChainState& chainstate, CConnman& _connman,
                                  CQuorumManager& _qman, CSigningManager& _sigman, CSigSharesManager& _shareman,
                                  CSporkManager& sporkman, CTxMemPool& _mempool, const CMasternodeSync& mn_sync,
-                                 bool unitTests, bool fWipe) :
+                                 const std::unique_ptr<PeerManager>& peerman, bool unitTests, bool fWipe) :
         db(unitTests, fWipe),
         clhandler(_clhandler), m_chainstate(chainstate), connman(_connman), qman(_qman), sigman(_sigman),
-        shareman(_shareman), spork_manager(sporkman), mempool(_mempool), m_mn_sync(mn_sync)
+        shareman(_shareman), spork_manager(sporkman), mempool(_mempool), m_mn_sync(mn_sync), m_peerman(peerman)
     {
         workInterrupt.reset();
     }
@@ -313,7 +313,7 @@ class CInstantSendManager : public CRecoveredSigsListener
 
     void HandleNewRecoveredSig(const CRecoveredSig& recoveredSig) override LOCKS_EXCLUDED(cs_inputReqests, cs_creating);
 
-    PeerMsgRet ProcessMessage(const CNode& pfrom, gsl::not_null<PeerManager*> peerman, std::string_view msg_type, CDataStream& vRecv);
+    PeerMsgRet ProcessMessage(const CNode& pfrom, std::string_view msg_type, CDataStream& vRecv);
 
     void TransactionAddedToMempool(const CTransactionRef& tx) LOCKS_EXCLUDED(cs_pendingLocks);
     void TransactionRemovedFromMempool(const CTransactionRef& tx);
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index ca2e16a1c6ed4..4860aaf0b75b9 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -4748,7 +4748,7 @@ void PeerManagerImpl::ProcessMessage(
         m_llmq_ctx->shareman->ProcessMessage(pfrom, m_sporkman, msg_type, vRecv);
         ProcessPeerMsgRet(m_llmq_ctx->sigman->ProcessMessage(pfrom, this, msg_type, vRecv), pfrom);
         ProcessPeerMsgRet(m_llmq_ctx->clhandler->ProcessMessage(pfrom, msg_type, vRecv), pfrom);
-        ProcessPeerMsgRet(m_llmq_ctx->isman->ProcessMessage(pfrom, this, msg_type, vRecv), pfrom);
+        ProcessPeerMsgRet(m_llmq_ctx->isman->ProcessMessage(pfrom, msg_type, vRecv), pfrom);
         return;
     }
 

From f2fe39fadc96327cf0a93d018860a26a46ff57c1 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Tue, 9 Apr 2024 19:42:55 +0000
Subject: [PATCH 7/7] trivial: add `Asserts` for `m_peerman` pointer container
 uses

---
 src/coinjoin/server.cpp     | 4 ++--
 src/llmq/blockprocessor.cpp | 2 +-
 src/llmq/chainlocks.cpp     | 2 +-
 src/llmq/ehf_signals.cpp    | 2 +-
 src/llmq/instantsend.cpp    | 6 +++---
 src/llmq/signing_shares.cpp | 4 ++--
 6 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
index 50c256665b12d..3c3e312a77736 100644
--- a/src/coinjoin/server.cpp
+++ b/src/coinjoin/server.cpp
@@ -349,7 +349,7 @@ void CCoinJoinServer::CommitFinalTransaction()
     LogPrint(BCLog::COINJOIN, "CCoinJoinServer::CommitFinalTransaction -- TRANSMITTING DSTX\n");
 
     CInv inv(MSG_DSTX, hashTx);
-    m_peerman->RelayInv(inv);
+    Assert(m_peerman)->RelayInv(inv);
 
     // Tell the clients it was successful
     RelayCompletedTransaction(MSG_SUCCESS);
@@ -460,7 +460,7 @@ void CCoinJoinServer::ConsumeCollateral(const CTransactionRef& txref) const
     if (!ATMPIfSaneFee(m_chainstate, mempool, txref, false /* bypass_limits */)) {
         LogPrint(BCLog::COINJOIN, "%s -- AcceptToMemoryPool failed\n", __func__);
     } else {
-        m_peerman->RelayTransaction(txref->GetHash());
+        Assert(m_peerman)->RelayTransaction(txref->GetHash());
         LogPrint(BCLog::COINJOIN, "%s -- Collateral was consumed\n", __func__);
     }
 }
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
index 0604ec747527b..f3c6c9f9709bb 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -668,7 +668,7 @@ void CQuorumBlockProcessor::AddMineableCommitment(const CFinalCommitment& fqc)
     // We only relay the new commitment if it's new or better then the old one
     if (relay) {
         CInv inv(MSG_QUORUM_FINAL_COMMITMENT, commitmentHash);
-        m_peerman->RelayInv(inv);
+        Assert(m_peerman)->RelayInv(inv);
     }
 }
 
diff --git a/src/llmq/chainlocks.cpp b/src/llmq/chainlocks.cpp
index a22a8dc44f8c6..72a0771a3ae7d 100644
--- a/src/llmq/chainlocks.cpp
+++ b/src/llmq/chainlocks.cpp
@@ -162,7 +162,7 @@ PeerMsgRet CChainLocksHandler::ProcessNewChainLock(const NodeId from, const llmq
 
     // Note: do not hold cs while calling RelayInv
     AssertLockNotHeld(cs);
-    m_peerman->RelayInv(clsigInv);
+    Assert(m_peerman)->RelayInv(clsigInv);
 
     if (pindex == nullptr) {
         // we don't know the block/header for this CLSIG yet, so bail out for now
diff --git a/src/llmq/ehf_signals.cpp b/src/llmq/ehf_signals.cpp
index a07342f262c99..8c69d7fb4c5cb 100644
--- a/src/llmq/ehf_signals.cpp
+++ b/src/llmq/ehf_signals.cpp
@@ -140,7 +140,7 @@ void CEHFSignalsHandler::HandleNewRecoveredSig(const CRecoveredSig& recoveredSig
             LOCK(cs_main);
             const MempoolAcceptResult result = AcceptToMemoryPool(chainstate, mempool, tx_to_sent, /* bypass_limits */ false);
             if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
-                m_peerman->RelayTransaction(tx_to_sent->GetHash());
+                Assert(m_peerman)->RelayTransaction(tx_to_sent->GetHash());
             } else {
                 LogPrintf("CEHFSignalsHandler::HandleNewRecoveredSig -- AcceptToMemoryPool failed: %s\n", result.m_state.ToString());
             }
diff --git a/src/llmq/instantsend.cpp b/src/llmq/instantsend.cpp
index 46bb829ab750d..f558c9151549d 100644
--- a/src/llmq/instantsend.cpp
+++ b/src/llmq/instantsend.cpp
@@ -951,7 +951,7 @@ std::unordered_set<uint256, StaticSaltedHasher> CInstantSendManager::ProcessPend
         for (const auto& nodeId : batchVerifier.badSources) {
             // Let's not be too harsh, as the peer might simply be unlucky and might have sent us an old lock which
             // does not validate anymore due to changed quorums
-            m_peerman->Misbehaving(nodeId, 20);
+            Assert(m_peerman)->Misbehaving(nodeId, 20);
         }
     }
     for (const auto& p : pend) {
@@ -1045,11 +1045,11 @@ void CInstantSendManager::ProcessInstantSendLock(NodeId from, const uint256& has
 
     CInv inv(MSG_ISDLOCK, hash);
     if (tx != nullptr) {
-        m_peerman->RelayInvFiltered(inv, *tx, ISDLOCK_PROTO_VERSION);
+        Assert(m_peerman)->RelayInvFiltered(inv, *tx, ISDLOCK_PROTO_VERSION);
     } else {
         // we don't have the TX yet, so we only filter based on txid. Later when that TX arrives, we will re-announce
         // with the TX taken into account.
-        m_peerman->RelayInvFiltered(inv, islock->txid, ISDLOCK_PROTO_VERSION);
+        Assert(m_peerman)->RelayInvFiltered(inv, islock->txid, ISDLOCK_PROTO_VERSION);
     }
 
     ResolveBlockConflicts(hash, *islock);
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
index 50cb75e8321c0..fb8541fd32768 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -1394,7 +1394,7 @@ void CSigSharesManager::RemoveBannedNodeStates()
 
     LOCK(cs);
     for (auto it = nodeStates.begin(); it != nodeStates.end();) {
-        if (m_peerman->IsBanned(it->first)) {
+        if (Assert(m_peerman)->IsBanned(it->first)) {
             // re-request sigshares from other nodes
             it->second.requestedSigShares.ForEach([this](const SigShareKey& k, int64_t) {
                 AssertLockHeld(cs);
@@ -1414,7 +1414,7 @@ void CSigSharesManager::BanNode(NodeId nodeId)
     }
 
     {
-        m_peerman->Misbehaving(nodeId, 100);
+        Assert(m_peerman)->Misbehaving(nodeId, 100);
     }
 
     LOCK(cs);