refactor: move PeerManager out of CInstantSendManager ctor

kwvg · kwvg · commit d9e5cc7c9adc · 2024-12-05T22:42:15.000Z
diff --git a/src/dsnotificationinterface.cpp b/src/dsnotificationinterface.cpp
@@ -107,7 +107,7 @@ void CDSNotificationInterface::TransactionAddedToMempool(const CTransactionRef&
 {
     assert(m_cj_ctx && m_llmq_ctx);
 
-    m_llmq_ctx->isman->TransactionAddedToMempool(ptx);
+    m_llmq_ctx->isman->TransactionAddedToMempool(m_peerman, ptx);
     m_llmq_ctx->clhandler->TransactionAddedToMempool(ptx, nAcceptTime);
     m_cj_ctx->dstxman->TransactionAddedToMempool(ptx);
 }
diff --git a/src/llmq/context.cpp b/src/llmq/context.cpp
@@ -47,8 +47,8 @@ LLMQContext::LLMQContext(ChainstateManager& chainman, CConnman& connman, CDeterm
         llmq::quorumInstantSendManager = std::make_unique<llmq::CInstantSendManager>(*llmq::chainLocksHandler,
                                                                                      chainman.ActiveChainstate(), *qman,
                                                                                      *sigman, *shareman, sporkman,
-                                                                                     mempool, mn_sync, peerman,
-                                                                                     is_masternode, unit_tests, wipe);
+                                                                                     mempool, mn_sync, is_masternode,
+                                                                                     unit_tests, wipe);
         return llmq::quorumInstantSendManager.get();
     }()},
     ehfSignalsHandler{std::make_unique<llmq::CEHFSignalsHandler>(chainman, mnhfman, *sigman, *shareman, *qman)}
@@ -87,7 +87,7 @@ void LLMQContext::Start(CConnman& connman, PeerManager& peerman)
     sigman->StartWorkerThread(peerman);
 
     llmq::chainLocksHandler->Start();
-    llmq::quorumInstantSendManager->Start();
+    llmq::quorumInstantSendManager->Start(peerman);
 }
 
 void LLMQContext::Stop() {
diff --git a/src/llmq/instantsend.cpp b/src/llmq/instantsend.cpp
@@ -430,14 +430,14 @@ std::vector<uint256> CInstantSendDb::RemoveChainedInstantSendLocks(const uint256
 ////////////////
 
 
-void CInstantSendManager::Start()
+void CInstantSendManager::Start(PeerManager& peerman)
 {
     // can't start new thread if we have one running already
     if (workThread.joinable()) {
         assert(false);
     }
 
-    workThread = std::thread(&util::TraceThread, "isman", [this] { WorkThreadMain(); });
+    workThread = std::thread(&util::TraceThread, "isman", [this, &peerman] { WorkThreadMain(peerman); });
 
     sigman.RegisterRecoveredSigsListener(this);
 }
@@ -732,21 +732,23 @@ void CInstantSendManager::HandleNewInstantSendLockRecoveredSig(const llmq::CReco
     pendingInstantSendLocks.emplace(hash, std::make_pair(-1, islock));
 }
 
-PeerMsgRet CInstantSendManager::ProcessMessage(const CNode& pfrom, std::string_view msg_type, CDataStream& vRecv)
+PeerMsgRet CInstantSendManager::ProcessMessage(const CNode& pfrom, PeerManager& peerman, std::string_view msg_type,
+                                               CDataStream& vRecv)
 {
     if (IsInstantSendEnabled() && msg_type == NetMsgType::ISDLOCK) {
         const auto islock = std::make_shared<CInstantSendLock>();
         vRecv >> *islock;
-        return ProcessMessageInstantSendLock(pfrom, islock);
+        return ProcessMessageInstantSendLock(pfrom, peerman, islock);
     }
     return {};
 }
 
-PeerMsgRet CInstantSendManager::ProcessMessageInstantSendLock(const CNode& pfrom, const llmq::CInstantSendLockPtr& islock)
+PeerMsgRet CInstantSendManager::ProcessMessageInstantSendLock(const CNode& pfrom, PeerManager& peerman,
+                                                              const llmq::CInstantSendLockPtr& islock)
 {
     auto hash = ::SerializeHash(*islock);
 
-    WITH_LOCK(::cs_main, Assert(m_peerman)->EraseObjectRequest(pfrom.GetId(), CInv(MSG_ISDLOCK, hash)));
+    WITH_LOCK(::cs_main, peerman.EraseObjectRequest(pfrom.GetId(), CInv(MSG_ISDLOCK, hash)));
 
     if (!islock->TriviallyValid()) {
         return tl::unexpected{100};
@@ -800,7 +802,7 @@ bool CInstantSendLock::TriviallyValid() const
     return true;
 }
 
-bool CInstantSendManager::ProcessPendingInstantSendLocks()
+bool CInstantSendManager::ProcessPendingInstantSendLocks(PeerManager& peerman)
 {
     decltype(pendingInstantSendLocks) pend;
     bool fMoreWork{false};
@@ -845,7 +847,7 @@ bool CInstantSendManager::ProcessPendingInstantSendLocks()
     auto dkgInterval = llmq_params.dkgInterval;
 
     // First check against the current active set and don't ban
-    auto badISLocks = ProcessPendingInstantSendLocks(llmq_params, 0, pend, false);
+    auto badISLocks = ProcessPendingInstantSendLocks(llmq_params, peerman, /*signOffset=*/0, pend, false);
     if (!badISLocks.empty()) {
         LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- doing verification on old active set\n", __func__);
 
@@ -858,13 +860,15 @@ bool CInstantSendManager::ProcessPendingInstantSendLocks()
             }
         }
         // Now check against the previous active set and perform banning if this fails
-        ProcessPendingInstantSendLocks(llmq_params, dkgInterval, pend, true);
+        ProcessPendingInstantSendLocks(llmq_params, peerman, dkgInterval, pend, true);
     }
 
     return fMoreWork;
 }
 
-std::unordered_set<uint256, StaticSaltedHasher> CInstantSendManager::ProcessPendingInstantSendLocks(const Consensus::LLMQParams& llmq_params, int signOffset, const std::unordered_map<uint256, std::pair<NodeId, CInstantSendLockPtr>, StaticSaltedHasher>& pend, bool ban)
+std::unordered_set<uint256, StaticSaltedHasher> CInstantSendManager::ProcessPendingInstantSendLocks(
+    const Consensus::LLMQParams& llmq_params, PeerManager& peerman, int signOffset,
+    const std::unordered_map<uint256, std::pair<NodeId, CInstantSendLockPtr>, StaticSaltedHasher>& pend, bool ban)
 {
     CBLSBatchVerifier<NodeId, uint256> batchVerifier(false, true, 8);
     std::unordered_map<uint256, CRecoveredSig, StaticSaltedHasher> recSigs;
@@ -936,7 +940,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
-            Assert(m_peerman)->Misbehaving(nodeId, 20);
+            peerman.Misbehaving(nodeId, 20);
         }
     }
     for (const auto& p : pend) {
@@ -951,7 +955,7 @@ std::unordered_set<uint256, StaticSaltedHasher> CInstantSendManager::ProcessPend
             continue;
         }
 
-        ProcessInstantSendLock(nodeId, hash, islock);
+        ProcessInstantSendLock(nodeId, peerman, hash, islock);
 
         // See comment further on top. We pass a reconstructed recovered sig to the signing manager to avoid
         // double-verification of the sig.
@@ -969,7 +973,8 @@ std::unordered_set<uint256, StaticSaltedHasher> CInstantSendManager::ProcessPend
     return badISLocks;
 }
 
-void CInstantSendManager::ProcessInstantSendLock(NodeId from, const uint256& hash, const CInstantSendLockPtr& islock)
+void CInstantSendManager::ProcessInstantSendLock(NodeId from, PeerManager& peerman, const uint256& hash,
+                                                 const CInstantSendLockPtr& islock)
 {
     LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- txid=%s, islock=%s: processing islock, peer=%d\n", __func__,
              islock->txid.ToString(), hash.ToString(), from);
@@ -1030,28 +1035,28 @@ void CInstantSendManager::ProcessInstantSendLock(NodeId from, const uint256& has
 
     CInv inv(MSG_ISDLOCK, hash);
     if (tx != nullptr) {
-        Assert(m_peerman)->RelayInvFiltered(inv, *tx, ISDLOCK_PROTO_VERSION);
+        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.
-        Assert(m_peerman)->RelayInvFiltered(inv, islock->txid, ISDLOCK_PROTO_VERSION);
+        peerman.RelayInvFiltered(inv, islock->txid, ISDLOCK_PROTO_VERSION);
     }
 
     ResolveBlockConflicts(hash, *islock);
 
     if (tx != nullptr) {
-        RemoveMempoolConflictsForLock(hash, *islock);
+        RemoveMempoolConflictsForLock(peerman, hash, *islock);
         LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- notify about lock %s for tx %s\n", __func__,
                 hash.ToString(), tx->GetHash().ToString());
         GetMainSignals().NotifyTransactionLock(tx, islock);
         // bump mempool counter to make sure newly locked txes are picked up by getblocktemplate
         mempool.AddTransactionsUpdated(1);
     } else {
-        m_peerman->AskPeersForTransaction(islock->txid, m_is_masternode);
+        peerman.AskPeersForTransaction(islock->txid, m_is_masternode);
     }
 }
 
-void CInstantSendManager::TransactionAddedToMempool(const CTransactionRef& tx)
+void CInstantSendManager::TransactionAddedToMempool(PeerManager& peerman, const CTransactionRef& tx)
 {
     if (!IsInstantSendEnabled() || !m_mn_sync.IsBlockchainSynced() || tx->vin.empty()) {
         return;
@@ -1080,7 +1085,7 @@ void CInstantSendManager::TransactionAddedToMempool(const CTransactionRef& tx)
         // TX is not locked, so make sure it is tracked
         AddNonLockedTx(tx, nullptr);
     } else {
-        RemoveMempoolConflictsForLock(::SerializeHash(*islock), *islock);
+        RemoveMempoolConflictsForLock(peerman, ::SerializeHash(*islock), *islock);
     }
 }
 
@@ -1292,7 +1297,8 @@ void CInstantSendManager::HandleFullyConfirmedBlock(const CBlockIndex* pindex)
     }
 }
 
-void CInstantSendManager::RemoveMempoolConflictsForLock(const uint256& hash, const CInstantSendLock& islock)
+void CInstantSendManager::RemoveMempoolConflictsForLock(PeerManager& peerman, const uint256& hash,
+                                                        const CInstantSendLock& islock)
 {
     std::unordered_map<uint256, CTransactionRef, StaticSaltedHasher> toDelete;
 
@@ -1321,7 +1327,7 @@ void CInstantSendManager::RemoveMempoolConflictsForLock(const uint256& hash, con
         for (const auto& p : toDelete) {
             RemoveConflictedTx(*p.second);
         }
-        m_peerman->AskPeersForTransaction(islock.txid, m_is_masternode);
+        peerman.AskPeersForTransaction(islock.txid, m_is_masternode);
     }
 }
 
@@ -1583,10 +1589,10 @@ size_t CInstantSendManager::GetInstantSendLockCount() const
     return db.GetInstantSendLockCount();
 }
 
-void CInstantSendManager::WorkThreadMain()
+void CInstantSendManager::WorkThreadMain(PeerManager& peerman)
 {
     while (!workInterrupt) {
-        bool fMoreWork = ProcessPendingInstantSendLocks();
+        bool fMoreWork = ProcessPendingInstantSendLocks(peerman);
         ProcessPendingRetryLockTxs();
 
         if (!fMoreWork && !workInterrupt.sleep_for(std::chrono::milliseconds(100))) {
diff --git a/src/llmq/instantsend.h b/src/llmq/instantsend.h
@@ -206,7 +206,6 @@ class CInstantSendManager : public CRecoveredSigsListener
     CSporkManager& spork_manager;
     CTxMemPool& mempool;
     const CMasternodeSync& m_mn_sync;
-    const std::unique_ptr<PeerManager>& m_peerman;
 
     const bool m_is_masternode;
 
@@ -256,9 +255,8 @@ class CInstantSendManager : public CRecoveredSigsListener
 public:
     explicit CInstantSendManager(CChainLocksHandler& _clhandler, CChainState& chainstate, CQuorumManager& _qman,
                                  CSigningManager& _sigman, CSigSharesManager& _shareman, CSporkManager& sporkman,
-                                 CTxMemPool& _mempool, const CMasternodeSync& mn_sync,
-                                 const std::unique_ptr<PeerManager>& peerman, bool is_masternode, bool unitTests,
-                                 bool fWipe) :
+                                 CTxMemPool& _mempool, const CMasternodeSync& mn_sync, bool is_masternode,
+                                 bool unitTests, bool fWipe) :
         db(unitTests, fWipe),
         clhandler(_clhandler),
         m_chainstate(chainstate),
@@ -268,14 +266,13 @@ class CInstantSendManager : public CRecoveredSigsListener
         spork_manager(sporkman),
         mempool(_mempool),
         m_mn_sync(mn_sync),
-        m_peerman(peerman),
         m_is_masternode{is_masternode}
     {
         workInterrupt.reset();
     }
     ~CInstantSendManager() = default;
 
-    void Start();
+    void Start(PeerManager& peerman);
     void Stop();
     void InterruptWorkerThread() { workInterrupt(); };
 
@@ -295,18 +292,15 @@ class CInstantSendManager : public CRecoveredSigsListener
                            const Consensus::Params& params) EXCLUSIVE_LOCKS_REQUIRED(!cs_inputReqests);
     void TrySignInstantSendLock(const CTransaction& tx) EXCLUSIVE_LOCKS_REQUIRED(!cs_creating);
 
-    PeerMsgRet ProcessMessageInstantSendLock(const CNode& pfrom, const CInstantSendLockPtr& islock);
-    bool ProcessPendingInstantSendLocks()
+    PeerMsgRet ProcessMessageInstantSendLock(const CNode& pfrom, PeerManager& peerman, const CInstantSendLockPtr& islock);
+    bool ProcessPendingInstantSendLocks(PeerManager& peerman)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_creating, !cs_inputReqests, !cs_nonLocked, !cs_pendingLocks, !cs_pendingRetry);
 
-    std::unordered_set<uint256, StaticSaltedHasher> ProcessPendingInstantSendLocks(const Consensus::LLMQParams& llmq_params,
-                                                                                   int signOffset,
-                                                                                   const std::unordered_map<uint256,
-                                                                                   std::pair<NodeId, CInstantSendLockPtr>,
-                                                                                   StaticSaltedHasher>& pend,
-                                                                                   bool ban)
+    std::unordered_set<uint256, StaticSaltedHasher> ProcessPendingInstantSendLocks(
+        const Consensus::LLMQParams& llmq_params, PeerManager& peerman, int signOffset,
+        const std::unordered_map<uint256, std::pair<NodeId, CInstantSendLockPtr>, StaticSaltedHasher>& pend, bool ban)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_creating, !cs_inputReqests, !cs_nonLocked, !cs_pendingLocks, !cs_pendingRetry);
-    void ProcessInstantSendLock(NodeId from, const uint256& hash, const CInstantSendLockPtr& islock)
+    void ProcessInstantSendLock(NodeId from, PeerManager& peerman, const uint256& hash, const CInstantSendLockPtr& islock)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_creating, !cs_inputReqests, !cs_nonLocked, !cs_pendingLocks, !cs_pendingRetry);
 
     void AddNonLockedTx(const CTransactionRef& tx, const CBlockIndex* pindexMined)
@@ -318,14 +312,14 @@ class CInstantSendManager : public CRecoveredSigsListener
     void TruncateRecoveredSigsForInputs(const CInstantSendLock& islock)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_inputReqests);
 
-    void RemoveMempoolConflictsForLock(const uint256& hash, const CInstantSendLock& islock)
+    void RemoveMempoolConflictsForLock(PeerManager& peerman, const uint256& hash, const CInstantSendLock& islock)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_inputReqests, !cs_nonLocked, !cs_pendingRetry);
     void ResolveBlockConflicts(const uint256& islockHash, const CInstantSendLock& islock)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_inputReqests, !cs_nonLocked, !cs_pendingLocks, !cs_pendingRetry);
     void ProcessPendingRetryLockTxs()
         EXCLUSIVE_LOCKS_REQUIRED(!cs_creating, !cs_inputReqests, !cs_nonLocked, !cs_pendingRetry);
 
-    void WorkThreadMain()
+    void WorkThreadMain(PeerManager& peerman)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_creating, !cs_inputReqests, !cs_nonLocked, !cs_pendingLocks, !cs_pendingRetry);
 
     void HandleFullyConfirmedBlock(const CBlockIndex* pindex)
@@ -339,9 +333,9 @@ class CInstantSendManager : public CRecoveredSigsListener
     [[nodiscard]] MessageProcessingResult HandleNewRecoveredSig(const CRecoveredSig& recoveredSig) override
         EXCLUSIVE_LOCKS_REQUIRED(!cs_creating, !cs_inputReqests, !cs_pendingLocks);
 
-    PeerMsgRet ProcessMessage(const CNode& pfrom, std::string_view msg_type, CDataStream& vRecv);
+    PeerMsgRet ProcessMessage(const CNode& pfrom, PeerManager& peerman, std::string_view msg_type, CDataStream& vRecv);
 
-    void TransactionAddedToMempool(const CTransactionRef& tx)
+    void TransactionAddedToMempool(PeerManager& peerman, const CTransactionRef& tx)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_creating, !cs_inputReqests, !cs_nonLocked, !cs_pendingLocks, !cs_pendingRetry);
     void TransactionRemovedFromMempool(const CTransactionRef& tx);
     void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
@@ -5278,7 +5278,7 @@ void PeerManagerImpl::ProcessMessage(
             return; // CLSIG
         }
 
-        ProcessPeerMsgRet(m_llmq_ctx->isman->ProcessMessage(pfrom, msg_type, vRecv), pfrom);
+        ProcessPeerMsgRet(m_llmq_ctx->isman->ProcessMessage(pfrom, *this, msg_type, vRecv), pfrom);
         return;
     }
 

Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ void CDSNotificationInterface::TransactionAddedToMempool(const CTransactionRef&`
`107`	`107`	`{`
`108`	`108`	`assert(m_cj_ctx && m_llmq_ctx);`
`109`	`109`
`110`		`- m_llmq_ctx->isman->TransactionAddedToMempool(ptx);`
	`110`	`+ m_llmq_ctx->isman->TransactionAddedToMempool(m_peerman, ptx);`
`111`	`111`	`m_llmq_ctx->clhandler->TransactionAddedToMempool(ptx, nAcceptTime);`
`112`	`112`	`m_cj_ctx->dstxman->TransactionAddedToMempool(ptx);`
`113`	`113`	`}`
Original file line number	Diff line number	Diff line change
`@@ -430,14 +430,14 @@ std::vector<uint256> CInstantSendDb::RemoveChainedInstantSendLocks(const uint256`
`430`	`430`	`////////////////`
`431`	`431`
`432`	`432`
`433`		`-void CInstantSendManager::Start()`
	`433`	`+void CInstantSendManager::Start(PeerManager& peerman)`
`434`	`434`	`{`
`435`	`435`	`// can't start new thread if we have one running already`
`436`	`436`	`if (workThread.joinable()) {`
`437`	`437`	`assert(false);`
`438`	`438`	`}`
`439`	`439`
`440`		`- workThread = std::thread(&util::TraceThread, "isman", [this] { WorkThreadMain(); });`
	`440`	`+ workThread = std::thread(&util::TraceThread, "isman", [this, &peerman] { WorkThreadMain(peerman); });`
`441`	`441`
`442`	`442`	`sigman.RegisterRecoveredSigsListener(this);`
`443`	`443`	`}`
`@@ -732,21 +732,23 @@ void CInstantSendManager::HandleNewInstantSendLockRecoveredSig(const llmq::CReco`
`732`	`732`	`pendingInstantSendLocks.emplace(hash, std::make_pair(-1, islock));`
`733`	`733`	`}`
`734`	`734`
`735`		`-PeerMsgRet CInstantSendManager::ProcessMessage(const CNode& pfrom, std::string_view msg_type, CDataStream& vRecv)`
	`735`	`+PeerMsgRet CInstantSendManager::ProcessMessage(const CNode& pfrom, PeerManager& peerman, std::string_view msg_type,`
	`736`	`+ CDataStream& vRecv)`
`736`	`737`	`{`
`737`	`738`	`if (IsInstantSendEnabled() && msg_type == NetMsgType::ISDLOCK) {`
`738`	`739`	`const auto islock = std::make_shared<CInstantSendLock>();`
`739`	`740`	`vRecv >> *islock;`
`740`		`- return ProcessMessageInstantSendLock(pfrom, islock);`
	`741`	`+ return ProcessMessageInstantSendLock(pfrom, peerman, islock);`
`741`	`742`	`}`
`742`	`743`	`return {};`
`743`	`744`	`}`
`744`	`745`
`745`		`-PeerMsgRet CInstantSendManager::ProcessMessageInstantSendLock(const CNode& pfrom, const llmq::CInstantSendLockPtr& islock)`
	`746`	`+PeerMsgRet CInstantSendManager::ProcessMessageInstantSendLock(const CNode& pfrom, PeerManager& peerman,`
	`747`	`+ const llmq::CInstantSendLockPtr& islock)`
`746`	`748`	`{`
`747`	`749`	`auto hash = ::SerializeHash(*islock);`
`748`	`750`
`749`		`- WITH_LOCK(::cs_main, Assert(m_peerman)->EraseObjectRequest(pfrom.GetId(), CInv(MSG_ISDLOCK, hash)));`
	`751`	`+ WITH_LOCK(::cs_main, peerman.EraseObjectRequest(pfrom.GetId(), CInv(MSG_ISDLOCK, hash)));`
`750`	`752`
`751`	`753`	`if (!islock->TriviallyValid()) {`
`752`	`754`	`return tl::unexpected{100};`
`@@ -800,7 +802,7 @@ bool CInstantSendLock::TriviallyValid() const`
`800`	`802`	`return true;`
`801`	`803`	`}`
`802`	`804`
`803`		`-bool CInstantSendManager::ProcessPendingInstantSendLocks()`
	`805`	`+bool CInstantSendManager::ProcessPendingInstantSendLocks(PeerManager& peerman)`
`804`	`806`	`{`
`805`	`807`	`decltype(pendingInstantSendLocks) pend;`
`806`	`808`	`bool fMoreWork{false};`
`@@ -845,7 +847,7 @@ bool CInstantSendManager::ProcessPendingInstantSendLocks()`
`845`	`847`	`auto dkgInterval = llmq_params.dkgInterval;`
`846`	`848`
`847`	`849`	`// First check against the current active set and don't ban`
`848`		`- auto badISLocks = ProcessPendingInstantSendLocks(llmq_params, 0, pend, false);`
	`850`	`+ auto badISLocks = ProcessPendingInstantSendLocks(llmq_params, peerman, /signOffset=/0, pend, false);`
`849`	`851`	`if (!badISLocks.empty()) {`
`850`	`852`	`LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- doing verification on old active set\n", __func__);`
`851`	`853`
`@@ -858,13 +860,15 @@ bool CInstantSendManager::ProcessPendingInstantSendLocks()`
`858`	`860`	`}`
`859`	`861`	`}`
`860`	`862`	`// Now check against the previous active set and perform banning if this fails`
`861`		`- ProcessPendingInstantSendLocks(llmq_params, dkgInterval, pend, true);`
	`863`	`+ ProcessPendingInstantSendLocks(llmq_params, peerman, dkgInterval, pend, true);`
`862`	`864`	`}`
`863`	`865`
`864`	`866`	`return fMoreWork;`
`865`	`867`	`}`
`866`	`868`
`867`		`-std::unordered_set<uint256, StaticSaltedHasher> CInstantSendManager::ProcessPendingInstantSendLocks(const Consensus::LLMQParams& llmq_params, int signOffset, const std::unordered_map<uint256, std::pair<NodeId, CInstantSendLockPtr>, StaticSaltedHasher>& pend, bool ban)`
	`869`	`+std::unordered_set<uint256, StaticSaltedHasher> CInstantSendManager::ProcessPendingInstantSendLocks(`
	`870`	`+ const Consensus::LLMQParams& llmq_params, PeerManager& peerman, int signOffset,`
	`871`	`+ const std::unordered_map<uint256, std::pair<NodeId, CInstantSendLockPtr>, StaticSaltedHasher>& pend, bool ban)`
`868`	`872`	`{`
`869`	`873`	`CBLSBatchVerifier<NodeId, uint256> batchVerifier(false, true, 8);`
`870`	`874`	`std::unordered_map<uint256, CRecoveredSig, StaticSaltedHasher> recSigs;`
`@@ -936,7 +940,7 @@ std::unordered_set<uint256, StaticSaltedHasher> CInstantSendManager::ProcessPend`
`936`	`940`	`for (const auto& nodeId : batchVerifier.badSources) {`
`937`	`941`	`// Let's not be too harsh, as the peer might simply be unlucky and might have sent us an old lock which`
`938`	`942`	`// does not validate anymore due to changed quorums`
`939`		`- Assert(m_peerman)->Misbehaving(nodeId, 20);`
	`943`	`+ peerman.Misbehaving(nodeId, 20);`
`940`	`944`	`}`
`941`	`945`	`}`
`942`	`946`	`for (const auto& p : pend) {`
`@@ -951,7 +955,7 @@ std::unordered_set<uint256, StaticSaltedHasher> CInstantSendManager::ProcessPend`
`951`	`955`	`continue;`
`952`	`956`	`}`
`953`	`957`
`954`		`- ProcessInstantSendLock(nodeId, hash, islock);`
	`958`	`+ ProcessInstantSendLock(nodeId, peerman, hash, islock);`
`955`	`959`
`956`	`960`	`// See comment further on top. We pass a reconstructed recovered sig to the signing manager to avoid`
`957`	`961`	`// double-verification of the sig.`
`@@ -969,7 +973,8 @@ std::unordered_set<uint256, StaticSaltedHasher> CInstantSendManager::ProcessPend`
`969`	`973`	`return badISLocks;`
`970`	`974`	`}`
`971`	`975`
`972`		`-void CInstantSendManager::ProcessInstantSendLock(NodeId from, const uint256& hash, const CInstantSendLockPtr& islock)`
	`976`	`+void CInstantSendManager::ProcessInstantSendLock(NodeId from, PeerManager& peerman, const uint256& hash,`
	`977`	`+ const CInstantSendLockPtr& islock)`
`973`	`978`	`{`
`974`	`979`	`LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- txid=%s, islock=%s: processing islock, peer=%d\n", __func__,`
`975`	`980`	`islock->txid.ToString(), hash.ToString(), from);`
`@@ -1030,28 +1035,28 @@ void CInstantSendManager::ProcessInstantSendLock(NodeId from, const uint256& has`
`1030`	`1035`
`1031`	`1036`	`CInv inv(MSG_ISDLOCK, hash);`
`1032`	`1037`	`if (tx != nullptr) {`
`1033`		`- Assert(m_peerman)->RelayInvFiltered(inv, *tx, ISDLOCK_PROTO_VERSION);`
	`1038`	`+ peerman.RelayInvFiltered(inv, *tx, ISDLOCK_PROTO_VERSION);`
`1034`	`1039`	`} else {`
`1035`	`1040`	`// we don't have the TX yet, so we only filter based on txid. Later when that TX arrives, we will re-announce`
`1036`	`1041`	`// with the TX taken into account.`
`1037`		`- Assert(m_peerman)->RelayInvFiltered(inv, islock->txid, ISDLOCK_PROTO_VERSION);`
	`1042`	`+ peerman.RelayInvFiltered(inv, islock->txid, ISDLOCK_PROTO_VERSION);`
`1038`	`1043`	`}`
`1039`	`1044`
`1040`	`1045`	`ResolveBlockConflicts(hash, *islock);`
`1041`	`1046`
`1042`	`1047`	`if (tx != nullptr) {`
`1043`		`- RemoveMempoolConflictsForLock(hash, *islock);`
	`1048`	`+ RemoveMempoolConflictsForLock(peerman, hash, *islock);`
`1044`	`1049`	`LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- notify about lock %s for tx %s\n", __func__,`
`1045`	`1050`	`hash.ToString(), tx->GetHash().ToString());`
`1046`	`1051`	`GetMainSignals().NotifyTransactionLock(tx, islock);`
`1047`	`1052`	`// bump mempool counter to make sure newly locked txes are picked up by getblocktemplate`
`1048`	`1053`	`mempool.AddTransactionsUpdated(1);`
`1049`	`1054`	`} else {`
`1050`		`- m_peerman->AskPeersForTransaction(islock->txid, m_is_masternode);`
	`1055`	`+ peerman.AskPeersForTransaction(islock->txid, m_is_masternode);`
`1051`	`1056`	`}`
`1052`	`1057`	`}`
`1053`	`1058`
`1054`		`-void CInstantSendManager::TransactionAddedToMempool(const CTransactionRef& tx)`
	`1059`	`+void CInstantSendManager::TransactionAddedToMempool(PeerManager& peerman, const CTransactionRef& tx)`
`1055`	`1060`	`{`
`1056`	`1061`	`if (!IsInstantSendEnabled() \|\| !m_mn_sync.IsBlockchainSynced() \|\| tx->vin.empty()) {`
`1057`	`1062`	`return;`
`@@ -1080,7 +1085,7 @@ void CInstantSendManager::TransactionAddedToMempool(const CTransactionRef& tx)`
`1080`	`1085`	`// TX is not locked, so make sure it is tracked`
`1081`	`1086`	`AddNonLockedTx(tx, nullptr);`
`1082`	`1087`	`} else {`
`1083`		`- RemoveMempoolConflictsForLock(::SerializeHash(islock), islock);`
	`1088`	`+ RemoveMempoolConflictsForLock(peerman, ::SerializeHash(islock), islock);`
`1084`	`1089`	`}`
`1085`	`1090`	`}`
`1086`	`1091`
`@@ -1292,7 +1297,8 @@ void CInstantSendManager::HandleFullyConfirmedBlock(const CBlockIndex* pindex)`
`1292`	`1297`	`}`
`1293`	`1298`	`}`
`1294`	`1299`
`1295`		`-void CInstantSendManager::RemoveMempoolConflictsForLock(const uint256& hash, const CInstantSendLock& islock)`
	`1300`	`+void CInstantSendManager::RemoveMempoolConflictsForLock(PeerManager& peerman, const uint256& hash,`
	`1301`	`+ const CInstantSendLock& islock)`
`1296`	`1302`	`{`
`1297`	`1303`	`std::unordered_map<uint256, CTransactionRef, StaticSaltedHasher> toDelete;`
`1298`	`1304`
`@@ -1321,7 +1327,7 @@ void CInstantSendManager::RemoveMempoolConflictsForLock(const uint256& hash, con`
`1321`	`1327`	`for (const auto& p : toDelete) {`
`1322`	`1328`	`RemoveConflictedTx(*p.second);`
`1323`	`1329`	`}`
`1324`		`- m_peerman->AskPeersForTransaction(islock.txid, m_is_masternode);`
	`1330`	`+ peerman.AskPeersForTransaction(islock.txid, m_is_masternode);`
`1325`	`1331`	`}`
`1326`	`1332`	`}`
`1327`	`1333`
`@@ -1583,10 +1589,10 @@ size_t CInstantSendManager::GetInstantSendLockCount() const`
`1583`	`1589`	`return db.GetInstantSendLockCount();`
`1584`	`1590`	`}`
`1585`	`1591`
`1586`		`-void CInstantSendManager::WorkThreadMain()`
	`1592`	`+void CInstantSendManager::WorkThreadMain(PeerManager& peerman)`
`1587`	`1593`	`{`
`1588`	`1594`	`while (!workInterrupt) {`
`1589`		`- bool fMoreWork = ProcessPendingInstantSendLocks();`
	`1595`	`+ bool fMoreWork = ProcessPendingInstantSendLocks(peerman);`
`1590`	`1596`	`ProcessPendingRetryLockTxs();`
`1591`	`1597`
`1592`	`1598`	`if (!fMoreWork && !workInterrupt.sleep_for(std::chrono::milliseconds(100))) {`
Original file line number	Diff line number	Diff line change
`@@ -5278,7 +5278,7 @@ void PeerManagerImpl::ProcessMessage(`
`5278`	`5278`	`return; // CLSIG`
`5279`	`5279`	`}`
`5280`	`5280`
`5281`		`- ProcessPeerMsgRet(m_llmq_ctx->isman->ProcessMessage(pfrom, msg_type, vRecv), pfrom);`
	`5281`	`+ ProcessPeerMsgRet(m_llmq_ctx->isman->ProcessMessage(pfrom, *this, msg_type, vRecv), pfrom);`
`5282`	`5282`	`return;`
`5283`	`5283`	`}`
`5284`	`5284`