From eeb84cb2bec16776d12941c60b7ea1bd41db2f40 Mon Sep 17 00:00:00 2001 From: Konstantin Akimov Date: Mon, 16 Mar 2026 02:41:02 +0700 Subject: [PATCH] refactor: replace usages of MessageProcessingResult in HandleNewRecoveredSig to variant It could return only CInv or CTransaction; MessageProcessingResult is misused there --- src/chainlock/signing.cpp | 16 +++++++++++----- src/chainlock/signing.h | 3 +-- src/instantsend/signing.cpp | 8 ++++---- src/instantsend/signing.h | 3 +-- src/llmq/ehf_signals.cpp | 12 +++++------- src/llmq/ehf_signals.h | 3 +-- src/llmq/net_signing.cpp | 7 ++++++- src/llmq/signing.h | 10 +++++++--- src/llmq/signing_shares.cpp | 8 +++----- src/llmq/signing_shares.h | 3 +-- 10 files changed, 40 insertions(+), 33 deletions(-) diff --git a/src/chainlock/signing.cpp b/src/chainlock/signing.cpp index ca0f1f75e9c7..9a63ee387ae2 100644 --- a/src/chainlock/signing.cpp +++ b/src/chainlock/signing.cpp @@ -260,10 +260,10 @@ ChainLockSigner::BlockTxs::mapped_type ChainLockSigner::GetBlockTxs(const uint25 return ret; } -MessageProcessingResult ChainLockSigner::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig) +llmq::RecoveredSigResult ChainLockSigner::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig) { if (!m_chainlocks.IsEnabled()) { - return {}; + return std::monostate{}; } ChainLockSig clsig; @@ -272,16 +272,22 @@ MessageProcessingResult ChainLockSigner::HandleNewRecoveredSig(const llmq::CReco if (recoveredSig.getId() != lastSignedRequestId || recoveredSig.getMsgHash() != lastSignedMsgHash) { // this is not what we signed, so lets not create a CLSIG for it - return {}; + return std::monostate{}; } if (m_chainlocks.GetBestChainLockHeight() >= lastSignedHeight) { // already got the same or a better CLSIG through the CLSIG message - return {}; + return std::monostate{}; } clsig = ChainLockSig(lastSignedHeight, lastSignedMsgHash, recoveredSig.sig.Get()); } - return m_clhandler.ProcessNewChainLock(-1, clsig, m_qman, ::SerializeHash(clsig)); + // TODO: split ProcessNewChainLock into network and non-network variants; when no peer + // is specified (node == -1), only m_inventory is ever populated + auto clresult = m_clhandler.ProcessNewChainLock(-1, clsig, m_qman, ::SerializeHash(clsig)); + if (!clresult.m_inventory.empty()) { + return clresult.m_inventory.front(); + } + return std::monostate{}; } void ChainLockSigner::Cleanup() diff --git a/src/chainlock/signing.h b/src/chainlock/signing.h index 33b0c4469839..f19659727f72 100644 --- a/src/chainlock/signing.h +++ b/src/chainlock/signing.h @@ -13,7 +13,6 @@ class CScheduler; class CMasternodeSync; -struct MessageProcessingResult; namespace llmq { class CInstantSendManager; class CRecoveredSig; @@ -80,7 +79,7 @@ class ChainLockSigner final : public llmq::CRecoveredSigsListener, public CValid void UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload) override EXCLUSIVE_LOCKS_REQUIRED(!cs_try_sign, !cs_signer); - [[nodiscard]] MessageProcessingResult HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig) override + [[nodiscard]] llmq::RecoveredSigResult HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig) override EXCLUSIVE_LOCKS_REQUIRED(!cs_signer); void Cleanup() EXCLUSIVE_LOCKS_REQUIRED(!cs_signer); diff --git a/src/instantsend/signing.cpp b/src/instantsend/signing.cpp index 2bd953e1c1ee..97e767b3d86f 100644 --- a/src/instantsend/signing.cpp +++ b/src/instantsend/signing.cpp @@ -73,14 +73,14 @@ void InstantSendSigner::ClearLockFromQueue(const InstantSendLockPtr& islock) txToCreatingInstantSendLocks.erase(islock->txid); } -MessageProcessingResult InstantSendSigner::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig) +llmq::RecoveredSigResult InstantSendSigner::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig) { if (!m_isman.IsInstantSendEnabled()) { - return {}; + return std::monostate{}; } if (Params().GetConsensus().llmqTypeDIP0024InstantSend == Consensus::LLMQType::LLMQ_NONE) { - return {}; + return std::monostate{}; } uint256 txid; @@ -92,7 +92,7 @@ MessageProcessingResult InstantSendSigner::HandleNewRecoveredSig(const llmq::CRe } else if (/*isInstantSendLock=*/WITH_LOCK(cs_creating, return creatingInstantSendLocks.count(recoveredSig.getId()))) { HandleNewInstantSendLockRecoveredSig(recoveredSig); } - return {}; + return std::monostate{}; } bool InstantSendSigner::IsInstantSendMempoolSigningEnabled() const diff --git a/src/instantsend/signing.h b/src/instantsend/signing.h index 7ae867bdf1da..0f22006f0d8c 100644 --- a/src/instantsend/signing.h +++ b/src/instantsend/signing.h @@ -14,7 +14,6 @@ class CMasternodeSync; class CSporkManager; class CTxMemPool; -struct MessageProcessingResult; namespace Consensus { struct Params; @@ -93,7 +92,7 @@ class InstantSendSigner final : public llmq::CRecoveredSigsListener void ClearLockFromQueue(const InstantSendLockPtr& islock) EXCLUSIVE_LOCKS_REQUIRED(!cs_creating); - [[nodiscard]] MessageProcessingResult HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig) override + [[nodiscard]] llmq::RecoveredSigResult HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig) override EXCLUSIVE_LOCKS_REQUIRED(!cs_creating, !cs_input_requests); void ProcessPendingRetryLockTxs(const std::vector& retryTxs) diff --git a/src/llmq/ehf_signals.cpp b/src/llmq/ehf_signals.cpp index 5dd65c9e1c9e..c9f89b6bc131 100644 --- a/src/llmq/ehf_signals.cpp +++ b/src/llmq/ehf_signals.cpp @@ -81,7 +81,7 @@ void CEHFSignalsHandler::trySignEHFSignal(int bit, const CBlockIndex* const pind shareman.AsyncSignIfMember(llmqType, sigman, requestId, msgHash, quorum->qc->quorumHash, false, true); } -MessageProcessingResult CEHFSignalsHandler::HandleNewRecoveredSig(const CRecoveredSig& recoveredSig) +RecoveredSigResult CEHFSignalsHandler::HandleNewRecoveredSig(const CRecoveredSig& recoveredSig) { if (g_txindex) { g_txindex->BlockUntilSyncedToCurrentChain(); @@ -89,7 +89,7 @@ MessageProcessingResult CEHFSignalsHandler::HandleNewRecoveredSig(const CRecover if (WITH_LOCK(cs, return ids.find(recoveredSig.getId()) == ids.end())) { // Do nothing, it's not for this handler - return {}; + return std::monostate{}; } const auto ehfSignals = m_chainman.ActiveChainstate().ChainHelper().ehf_manager->GetSignalsStage( @@ -118,14 +118,12 @@ MessageProcessingResult CEHFSignalsHandler::HandleNewRecoveredSig(const CRecover LOCK(::cs_main); const MempoolAcceptResult result = m_chainman.ProcessTransaction(tx_to_sent); if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) { - MessageProcessingResult ret; - ret.m_transactions.push_back(tx_to_sent->GetHash()); - return ret; + return tx_to_sent; } LogPrintf("CEHFSignalsHandler::HandleNewRecoveredSig -- AcceptToMemoryPool failed: %s\n", result.m_state.ToString()); - return {}; + return std::monostate{}; } - return {}; + return std::monostate{}; } } // namespace llmq diff --git a/src/llmq/ehf_signals.h b/src/llmq/ehf_signals.h index 022a1d48bed4..e6247c0c21d8 100644 --- a/src/llmq/ehf_signals.h +++ b/src/llmq/ehf_signals.h @@ -6,7 +6,6 @@ #define BITCOIN_LLMQ_EHF_SIGNALS_H #include -#include #include #include @@ -44,7 +43,7 @@ class CEHFSignalsHandler : public CRecoveredSigsListener */ void UpdatedBlockTip(const CBlockIndex* const pindexNew) EXCLUSIVE_LOCKS_REQUIRED(!cs); - [[nodiscard]] MessageProcessingResult HandleNewRecoveredSig(const CRecoveredSig& recoveredSig) override + [[nodiscard]] RecoveredSigResult HandleNewRecoveredSig(const CRecoveredSig& recoveredSig) override EXCLUSIVE_LOCKS_REQUIRED(!cs); private: diff --git a/src/llmq/net_signing.cpp b/src/llmq/net_signing.cpp index 01881ca59d65..f49aa5cb2e46 100644 --- a/src/llmq/net_signing.cpp +++ b/src/llmq/net_signing.cpp @@ -166,7 +166,12 @@ void NetSigning::ProcessRecoveredSig(std::shared_ptr recove auto listeners = m_sig_manager.GetListeners(); for (auto& l : listeners) { - m_peer_manager->PeerPostProcessMessage(l->HandleNewRecoveredSig(*recovered_sig)); + auto result = l->HandleNewRecoveredSig(*recovered_sig); + if (const auto* inv = std::get_if(&result)) { + m_peer_manager->PeerRelayInv(*inv); + } else if (const auto* tx_ref = std::get_if(&result)) { + m_peer_manager->PeerRelayTransaction((*tx_ref)->GetHash()); + } } // TODO refactor to use a better abstraction analogous to IsAllMembersConnectedEnabled diff --git a/src/llmq/signing.h b/src/llmq/signing.h index d48319bc618c..0d9cc71bf7a4 100644 --- a/src/llmq/signing.h +++ b/src/llmq/signing.h @@ -8,7 +8,6 @@ #include #include #include -#include #include #include #include @@ -18,20 +17,26 @@ #include #include #include +#include class CChainState; class CDataStream; class CDBBatch; class CDBWrapper; class CInv; +class CTransaction; struct RPCResult; namespace util { struct DbWrapperParams; } // namespace util class UniValue; +using CTransactionRef = std::shared_ptr; namespace llmq { + +using RecoveredSigResult = std::variant; + class CQuorumManager; class CSigSharesManager; class SignHash; @@ -151,8 +156,7 @@ class CRecoveredSigsListener public: virtual ~CRecoveredSigsListener() = default; - // TODO: simplify returned type to std::variant - [[nodiscard]] virtual MessageProcessingResult HandleNewRecoveredSig(const CRecoveredSig& recoveredSig) = 0; + [[nodiscard]] virtual RecoveredSigResult HandleNewRecoveredSig(const CRecoveredSig& recoveredSig) = 0; }; class CSigningManager diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp index 388102061394..f337d63ff19e 100644 --- a/src/llmq/signing_shares.cpp +++ b/src/llmq/signing_shares.cpp @@ -13,11 +13,9 @@ #include #include #include -#include +#include #include #include - -#include #include #include #include @@ -1535,11 +1533,11 @@ void CSigSharesManager::ForceReAnnouncement(const CQuorum& quorum, Consensus::LL } } -MessageProcessingResult CSigSharesManager::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig) +RecoveredSigResult CSigSharesManager::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig) { auto signHash = recoveredSig.buildSignHash().Get(); LOCK(cs); RemoveSigSharesForSession(signHash); - return {}; + return std::monostate{}; } } // namespace llmq diff --git a/src/llmq/signing_shares.h b/src/llmq/signing_shares.h index a143eaa8371c..82c1e88de585 100644 --- a/src/llmq/signing_shares.h +++ b/src/llmq/signing_shares.h @@ -33,7 +33,6 @@ class ChainstateManager; class CNode; class CConnman; class CSporkManager; -struct MessageProcessingResult; namespace llmq { @@ -434,7 +433,7 @@ class CSigSharesManager : public llmq::CRecoveredSigsListener void ForceReAnnouncement(const CQuorum& quorum, Consensus::LLMQType llmqType, const uint256& id, const uint256& msgHash) EXCLUSIVE_LOCKS_REQUIRED(!cs); - [[nodiscard]] MessageProcessingResult HandleNewRecoveredSig(const CRecoveredSig& recoveredSig) override + [[nodiscard]] RecoveredSigResult HandleNewRecoveredSig(const CRecoveredSig& recoveredSig) override EXCLUSIVE_LOCKS_REQUIRED(!cs); static CDeterministicMNCPtr SelectMemberForRecovery(const CQuorum& quorum, const uint256& id, int attempt);