refactor: migrate CInstantSendManager::ProcessMessage()

Author: kwvg

src/instantsend/instantsend.cpp

@@ -102,53 +102,52 @@ void CInstantSendManager::Stop()
     }
 }
 
-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<instantsend::InstantSendLock>();
-        vRecv >> *islock;
-        return ProcessMessageInstantSendLock(pfrom, peerman, islock);
-    }
-    return {};
-}
-
 bool ShouldReportISLockTiming() {
     return g_stats_client->active() || LogAcceptDebug(BCLog::INSTANTSEND);
 }
 
-PeerMsgRet CInstantSendManager::ProcessMessageInstantSendLock(const CNode& pfrom, PeerManager& peerman,
-                                                              const instantsend::InstantSendLockPtr& islock)
+MessageProcessingResult CInstantSendManager::ProcessMessage(NodeId from, std::string_view msg_type, CDataStream& vRecv)
 {
+    if (!IsInstantSendEnabled() || msg_type != NetMsgType::ISDLOCK) {
+        return {};
+    }
+
+    const auto islock = std::make_shared<instantsend::InstantSendLock>();
+    vRecv >> *islock;
+
     auto hash = ::SerializeHash(*islock);
 
-    WITH_LOCK(::cs_main, peerman.EraseObjectRequest(pfrom.GetId(), CInv(MSG_ISDLOCK, hash)));
+    MessageProcessingResult ret{};
+    ret.m_to_erase = CInv{MSG_ISDLOCK, hash};
 
     if (!islock->TriviallyValid()) {
-        return tl::unexpected{100};
+        ret.m_error = MisbehavingError{100};
+        return ret;
     }
 
     const auto blockIndex = WITH_LOCK(::cs_main, return m_chainstate.m_blockman.LookupBlockIndex(islock->cycleHash));
     if (blockIndex == nullptr) {
         // Maybe we don't have the block yet or maybe some peer spams invalid values for cycleHash
-        return tl::unexpected{1};
+        ret.m_error = MisbehavingError{1};
+        return ret;
     }
 
     // Deterministic islocks MUST use rotation based llmq
     auto llmqType = Params().GetConsensus().llmqTypeDIP0024InstantSend;
     const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
     assert(llmq_params_opt);
     if (blockIndex->nHeight % llmq_params_opt->dkgInterval != 0) {
-        return tl::unexpected{100};
+        ret.m_error = MisbehavingError{100};
+        return ret;
     }
 
     if (WITH_LOCK(cs_pendingLocks, return pendingInstantSendLocks.count(hash) || pendingNoTxInstantSendLocks.count(hash)) ||
         db.KnownInstantSendLock(hash)) {
-        return {};
+        return ret;
     }
 
     LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- txid=%s, islock=%s: received islock, peer=%d\n", __func__,
-             islock->txid.ToString(), hash.ToString(), pfrom.GetId());
+             islock->txid.ToString(), hash.ToString(), from);
 
     if (ShouldReportISLockTiming()) {
         auto time_diff = [&]() -> int64_t {
@@ -168,8 +167,8 @@ PeerMsgRet CInstantSendManager::ProcessMessageInstantSendLock(const CNode& pfrom
     }
 
     LOCK(cs_pendingLocks);
-    pendingInstantSendLocks.emplace(hash, std::make_pair(pfrom.GetId(), islock));
-    return {};
+    pendingInstantSendLocks.emplace(hash, std::make_pair(from, islock));
+    return ret;
 }
 
 bool CInstantSendManager::ProcessPendingInstantSendLocks(PeerManager& peerman)

src/instantsend/instantsend.h

@@ -25,7 +25,6 @@ class CBlockIndex;
 class CChainState;
 class CDataStream;
 class CMasternodeSync;
-class CNode;
 class CSporkManager;
 class CTxMemPool;
 class PeerManager;
@@ -96,7 +95,6 @@ class CInstantSendManager final : public instantsend::InstantSendSignerParent
     void InterruptWorkerThread() { workInterrupt(); };
 
 private:
-    PeerMsgRet ProcessMessageInstantSendLock(const CNode& pfrom, PeerManager& peerman, const instantsend::InstantSendLockPtr& islock);
     bool ProcessPendingInstantSendLocks(PeerManager& peerman)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingLocks, !cs_pendingRetry);
 
@@ -131,7 +129,7 @@ class CInstantSendManager final : public instantsend::InstantSendSignerParent
     bool IsWaitingForTx(const uint256& txHash) const EXCLUSIVE_LOCKS_REQUIRED(!cs_pendingLocks);
     instantsend::InstantSendLockPtr GetConflictingLock(const CTransaction& tx) const override;
 
-    PeerMsgRet ProcessMessage(const CNode& pfrom, PeerManager& peerman, std::string_view msg_type, CDataStream& vRecv);
+    [[nodiscard]] MessageProcessingResult ProcessMessage(NodeId from, std::string_view msg_type, CDataStream& vRecv);
 
     void TransactionAddedToMempool(const CTransactionRef& tx)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_nonLocked, !cs_pendingLocks, !cs_pendingRetry);

src/net_processing.cpp

@@ -5289,7 +5289,7 @@ void PeerManagerImpl::ProcessMessage(
             return; // CLSIG
         }
 
-        ProcessPeerMsgRet(m_llmq_ctx->isman->ProcessMessage(pfrom, *this, msg_type, vRecv), pfrom);
+        PostProcessMessage(m_llmq_ctx->isman->ProcessMessage(pfrom.GetId(), msg_type, vRecv), pfrom.GetId());
         return;
     }