feat: proactively relay recovered signatures when we are the member who performed recovery

PastaPastaPasta · PastaPastaPasta · commit 3bdb9ce9a8eb · 2025-11-12T18:02:30.000-06:00
diff --git a/src/llmq/signing.cpp b/src/llmq/signing.cpp
@@ -25,6 +25,8 @@
 #include <algorithm>
 #include <unordered_set>
 
+#include "options.h"
+
 namespace llmq
 {
 CRecoveredSigsDb::CRecoveredSigsDb(const util::DbWrapperParams& db_params) :
@@ -508,7 +510,7 @@ void CSigningManager::ProcessPendingReconstructedRecoveredSigs(PeerManager& peer
     WITH_LOCK(cs_pending, swap(m, pendingReconstructedRecoveredSigs));
 
     for (const auto& p : m) {
-        ProcessRecoveredSig(p.second, peerman);
+        ProcessRecoveredSig(p.second, peerman, -1);
     }
 }
 
@@ -570,15 +572,15 @@ bool CSigningManager::ProcessPendingRecoveredSigs(PeerManager& peerman)
                 continue;
             }
 
-            ProcessRecoveredSig(recSig, peerman);
+            ProcessRecoveredSig(recSig, peerman, nodeId);
         }
     }
 
     return recSigsByNode.size() >= nMaxBatchSize;
 }
 
 // signature must be verified already
-void CSigningManager::ProcessRecoveredSig(const std::shared_ptr<const CRecoveredSig>& recoveredSig, PeerManager& peerman)
+void CSigningManager::ProcessRecoveredSig(const std::shared_ptr<const CRecoveredSig>& recoveredSig, PeerManager& peerman, NodeId from)
 {
     auto llmqType = recoveredSig->getLlmqType();
 
@@ -621,7 +623,12 @@ void CSigningManager::ProcessRecoveredSig(const std::shared_ptr<const CRecovered
         peerman.PostProcessMessage(l->HandleNewRecoveredSig(*recoveredSig));
     }
 
-    GetMainSignals().NotifyRecoveredSig(recoveredSig, recoveredSig->GetHash().ToString());
+    // TODO refactor to use a better abstraction analogous to IsAllMembersConnectedEnabled
+    auto proactive_relay = from == -1 &&
+                           llmqType != Consensus::LLMQType::LLMQ_100_67 &&
+                           llmqType != Consensus::LLMQType::LLMQ_400_60 &&
+                           llmqType != Consensus::LLMQType::LLMQ_400_85;
+    GetMainSignals().NotifyRecoveredSig(recoveredSig, recoveredSig->GetHash().ToString(), proactive_relay);
 }
 
 void CSigningManager::PushReconstructedRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& recoveredSig)
diff --git a/src/llmq/signing.h b/src/llmq/signing.h
@@ -219,7 +219,7 @@ class CSigningManager
 
     // Used by CSigSharesManager
     CRecoveredSigsDb& GetDb() { return db; }
-    void ProcessRecoveredSig(const std::shared_ptr<const CRecoveredSig>& recoveredSig, PeerManager& peerman)
+    void ProcessRecoveredSig(const std::shared_ptr<const CRecoveredSig>& recoveredSig, PeerManager& peerman, NodeId pFrom)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_pending, !cs_listeners);
 
     // Needed for access to GetDb() and ProcessRecoveredSig()
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
@@ -807,7 +807,7 @@ void CSigSharesManager::TryRecoverSig(const CQuorum& quorum, const uint256& id,
 
             auto rs = std::make_shared<CRecoveredSig>(quorum.params.type, quorum.qc->quorumHash, id, msgHash,
                                                       recoveredSig);
-            sigman.ProcessRecoveredSig(rs, m_peerman);
+            sigman.ProcessRecoveredSig(rs, m_peerman, -1);
             return; // end of single-quorum processing
         }
 
@@ -853,7 +853,7 @@ void CSigSharesManager::TryRecoverSig(const CQuorum& quorum, const uint256& id,
         }
     }
 
-    sigman.ProcessRecoveredSig(rs, m_peerman);
+    sigman.ProcessRecoveredSig(rs, m_peerman, -1);
 }
 
 CDeterministicMNCPtr CSigSharesManager::SelectMemberForRecovery(const CQuorum& quorum, const uint256 &id, int attempt)
@@ -951,9 +951,9 @@ bool CSigSharesManager::AsyncSignIfMember(Consensus::LLMQType llmqType, CSigning
     return true;
 }
 
-void CSigSharesManager::NotifyRecoveredSig(const std::shared_ptr<const CRecoveredSig>& sig) const
+void CSigSharesManager::NotifyRecoveredSig(const std::shared_ptr<const CRecoveredSig>& sig, bool proactive_relay) const
 {
-    m_peerman.RelayRecoveredSig(Assert(sig)->GetHash());
+    m_peerman.RelayRecoveredSig(*Assert(sig), proactive_relay);
 }
 
 void CSigSharesManager::CollectSigSharesToRequest(std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToRequest)
diff --git a/src/llmq/signing_shares.h b/src/llmq/signing_shares.h
@@ -446,7 +446,7 @@ class CSigSharesManager : public CRecoveredSigsListener
                            bool allowDiffMsgHashSigning = false)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_pendingSigns);
 
-    void NotifyRecoveredSig(const std::shared_ptr<const CRecoveredSig>& sig) const;
+    void NotifyRecoveredSig(const std::shared_ptr<const CRecoveredSig>& sig, bool proactive_relay) const;
 
 private:
     // all of these return false when the currently processed message should be aborted (as each message actually contains multiple messages)
diff --git a/src/masternode/active/notificationinterface.cpp b/src/masternode/active/notificationinterface.cpp
@@ -29,9 +29,9 @@ void ActiveNotificationInterface::UpdatedBlockTip(const CBlockIndex* pindexNew,
     m_active_ctx.gov_signer->UpdatedBlockTip(pindexNew);
 }
 
-void ActiveNotificationInterface::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig)
+void ActiveNotificationInterface::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, bool proactive_relay)
 {
-    m_active_ctx.shareman->NotifyRecoveredSig(sig);
+    m_active_ctx.shareman->NotifyRecoveredSig(sig, proactive_relay);
 }
 
 std::unique_ptr<ActiveNotificationInterface> g_active_notification_interface;
diff --git a/src/masternode/active/notificationinterface.h b/src/masternode/active/notificationinterface.h
@@ -26,7 +26,7 @@ class ActiveNotificationInterface final : public CValidationInterface
 
 protected:
     // CValidationInterface
-    void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig) override;
+    void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, bool proactive_relay) override;
     void UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload) override;
 
 private:
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
@@ -627,7 +627,7 @@ class PeerManagerImpl final : public PeerManager
     void RelayInv(const CInv& inv) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     void RelayInv(const CInv& inv, const int minProtoVersion) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     void RelayTransaction(const uint256& txid) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
-    void RelayRecoveredSig(const uint256& sigHash) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
+    void RelayRecoveredSig(const llmq::CRecoveredSig& sig, bool proactive_relay) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     void RelayDSQ(const CCoinJoinQueue& queue) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     void SetBestHeight(int height) override { m_best_height = height; };
     void Misbehaving(const NodeId pnode, const int howmuch, const std::string& message = "") override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
@@ -2467,9 +2467,20 @@ void PeerManagerImpl::_RelayTransaction(const uint256& txid)
     };
 }
 
-void PeerManagerImpl::RelayRecoveredSig(const uint256& sigHash)
-{
-    const CInv inv{MSG_QUORUM_RECOVERED_SIG, sigHash};
+void PeerManagerImpl::RelayRecoveredSig(const llmq::CRecoveredSig& sig, bool proactive_relay) {
+    if (proactive_relay) {
+        // We were the peer that recovered this; avoid a bunch of `inv` -> `GetData` spam by proactively sending
+        m_connman.ForEachNode([this, &sig](CNode* pnode) -> bool {
+            // Skip nodes that don't want recovered signatures
+            PeerRef peer = GetPeerRef(pnode->GetId());
+            if (peer == nullptr || !peer->m_wants_recsigs) return true;
+            CNetMsgMaker msgMaker(pnode->GetCommonVersion());
+            m_connman.PushMessage(pnode, msgMaker.Make(NetMsgType::QSIGREC, sig));
+            return true;
+        });
+        return;
+    }
+    const CInv inv{MSG_QUORUM_RECOVERED_SIG, sig.GetHash()};
     READ_LOCK(m_peer_mutex);
     for (const auto& [_, peer] : m_peer_map) {
         if (peer->m_wants_recsigs) {
diff --git a/src/net_processing.h b/src/net_processing.h
@@ -104,7 +104,7 @@ class PeerManager : public CValidationInterface, public NetEventsInterface
     virtual void RelayTransaction(const uint256& txid) = 0;
 
     /** Relay recovered sigs to all interested peers */
-    virtual void RelayRecoveredSig(const uint256& sigHash) = 0;
+    virtual void RelayRecoveredSig(const llmq::CRecoveredSig& sig, bool proactive_relay) = 0;
 
     /** Set the best height */
     virtual void SetBestHeight(int height) = 0;
diff --git a/src/validationinterface.cpp b/src/validationinterface.cpp
@@ -312,9 +312,9 @@ void CMainSignals::NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& cu
             previousTx->GetHash().ToString());
 }
 
-void CMainSignals::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, const std::string& id) {
-    auto event = [sig, this] {
-        m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyRecoveredSig(sig); });
+void CMainSignals::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, const std::string& id, bool proactive_relay) {
+    auto event = [sig, proactive_relay, this] {
+        m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyRecoveredSig(sig, proactive_relay); });
     };
     ENQUEUE_AND_LOG_EVENT(event, "%s: notify recoveredsig=%s", __func__,
             id);
diff --git a/src/validationinterface.h b/src/validationinterface.h
@@ -168,7 +168,7 @@ class CValidationInterface {
     virtual void NotifyGovernanceVote(const std::shared_ptr<CDeterministicMNList>& tip_mn_list, const std::shared_ptr<const CGovernanceVote>& vote) {}
     virtual void NotifyGovernanceObject(const std::shared_ptr<const Governance::Object>& object) {}
     virtual void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx) {}
-    virtual void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig) {}
+    virtual void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, bool proactive_relay) {}
     virtual void NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff) {}
     /**
      * Notifies listeners of the new active block chain on-disk.
@@ -236,7 +236,7 @@ class CMainSignals {
     void NotifyGovernanceVote(const std::shared_ptr<CDeterministicMNList>& tip_mn_list, const std::shared_ptr<const CGovernanceVote>& vote, const std::string& id);
     void NotifyGovernanceObject(const std::shared_ptr<const Governance::Object>& object, const std::string& id);
     void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef &currentTx, const CTransactionRef &previousTx);
-    void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig> &sig, const std::string& id);
+    void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig> &sig, const std::string &id, bool proactive_relay);
     void NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff);
     void ChainStateFlushed(const CBlockLocator &);
     void BlockChecked(const CBlock&, const BlockValidationState&);
diff --git a/src/zmq/zmqabstractnotifier.cpp b/src/zmq/zmqabstractnotifier.cpp
@@ -68,7 +68,7 @@ bool CZMQAbstractNotifier::NotifyInstantSendDoubleSpendAttempt(const CTransactio
     return true;
 }
 
-bool CZMQAbstractNotifier::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig> & /*sig*/)
+bool CZMQAbstractNotifier::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig> & /*sig*/, bool /*proactive_relay*/)
 {
     return true;
 }
diff --git a/src/zmq/zmqabstractnotifier.h b/src/zmq/zmqabstractnotifier.h
@@ -75,7 +75,7 @@ class CZMQAbstractNotifier
     virtual bool NotifyGovernanceVote(const std::shared_ptr<CDeterministicMNList>& tip_mn_list, const std::shared_ptr<const CGovernanceVote>& vote);
     virtual bool NotifyGovernanceObject(const std::shared_ptr<const Governance::Object>& object);
     virtual bool NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx);
-    virtual bool NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig);
+    virtual bool NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, bool proactive_relay);
 
 protected:
     void *psocket;
diff --git a/src/zmq/zmqnotificationinterface.cpp b/src/zmq/zmqnotificationinterface.cpp
@@ -241,10 +241,10 @@ void CZMQNotificationInterface::NotifyInstantSendDoubleSpendAttempt(const CTrans
     });
 }
 
-void CZMQNotificationInterface::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig)
+void CZMQNotificationInterface::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, bool proactive_relay)
 {
-    TryForEachAndRemoveFailed(notifiers, [&sig](CZMQAbstractNotifier* notifier) {
-        return notifier->NotifyRecoveredSig(sig);
+    TryForEachAndRemoveFailed(notifiers, [&sig, proactive_relay](CZMQAbstractNotifier* notifier) {
+        return notifier->NotifyRecoveredSig(sig, proactive_relay);
     });
 }
 
diff --git a/src/zmq/zmqnotificationinterface.h b/src/zmq/zmqnotificationinterface.h
@@ -36,7 +36,7 @@ class CZMQNotificationInterface final : public CValidationInterface
     void NotifyGovernanceVote(const std::shared_ptr<CDeterministicMNList>& tip_mn_list, const std::shared_ptr<const CGovernanceVote>& vote) override;
     void NotifyGovernanceObject(const std::shared_ptr<const Governance::Object>& object) override;
     void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx) override;
-    void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig) override;
+    void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, bool proactive_relay) override;
 
 private:
     CZMQNotificationInterface();
diff --git a/src/zmq/zmqpublishnotifier.cpp b/src/zmq/zmqpublishnotifier.cpp
@@ -296,7 +296,7 @@ bool CZMQPublishHashInstantSendDoubleSpendNotifier::NotifyInstantSendDoubleSpend
         && SendZmqMessage(MSG_HASHISCON, dataPreviousHash, 32);
 }
 
-bool CZMQPublishHashRecoveredSigNotifier::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig> &sig)
+bool CZMQPublishHashRecoveredSigNotifier::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig> &sig, bool proactive_relay)
 {
     LogPrint(BCLog::ZMQ, "Publish hashrecoveredsig %s to %s\n", sig->getMsgHash().ToString(), this->address);
     char data[32];
@@ -462,7 +462,7 @@ bool CZMQPublishRawInstantSendDoubleSpendNotifier::NotifyInstantSendDoubleSpendA
         && SendZmqMessage(MSG_RAWISCON, &(*ssPrevious.begin()), ssPrevious.size());
 }
 
-bool CZMQPublishRawRecoveredSigNotifier::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig)
+bool CZMQPublishRawRecoveredSigNotifier::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, bool proactive_relay)
 {
     LogPrint(BCLog::ZMQ, "Publish rawrecoveredsig %s to %s\n", sig->getMsgHash().ToString(), this->address);
 
diff --git a/src/zmq/zmqpublishnotifier.h b/src/zmq/zmqpublishnotifier.h
@@ -81,7 +81,7 @@ class CZMQPublishHashInstantSendDoubleSpendNotifier : public CZMQAbstractPublish
 class CZMQPublishHashRecoveredSigNotifier : public CZMQAbstractPublishNotifier
 {
 public:
-    bool NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>&) override;
+    bool NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>&, bool proactive_relay) override;
 };
 
 class CZMQPublishRawBlockNotifier : public CZMQAbstractPublishNotifier
@@ -150,6 +150,6 @@ class CZMQPublishRawInstantSendDoubleSpendNotifier : public CZMQAbstractPublishN
 class CZMQPublishRawRecoveredSigNotifier : public CZMQAbstractPublishNotifier
 {
 public:
-    bool NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig> &sig) override;
+    bool NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig> &sig, bool proactive_relay) override;
 };
 #endif // BITCOIN_ZMQ_ZMQPUBLISHNOTIFIER_H

Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,8 @@`
`25`	`25`	`#include <algorithm>`
`26`	`26`	`#include <unordered_set>`
`27`	`27`
	`28`	`+#include "options.h"`
	`29`	`+`
`28`	`30`	`namespace llmq`
`29`	`31`	`{`
`30`	`32`	`CRecoveredSigsDb::CRecoveredSigsDb(const util::DbWrapperParams& db_params) :`
`@@ -508,7 +510,7 @@ void CSigningManager::ProcessPendingReconstructedRecoveredSigs(PeerManager& peer`
`508`	`510`	`WITH_LOCK(cs_pending, swap(m, pendingReconstructedRecoveredSigs));`
`509`	`511`
`510`	`512`	`for (const auto& p : m) {`
`511`		`- ProcessRecoveredSig(p.second, peerman);`
	`513`	`+ ProcessRecoveredSig(p.second, peerman, -1);`
`512`	`514`	`}`
`513`	`515`	`}`
`514`	`516`
`@@ -570,15 +572,15 @@ bool CSigningManager::ProcessPendingRecoveredSigs(PeerManager& peerman)`
`570`	`572`	`continue;`
`571`	`573`	`}`
`572`	`574`
`573`		`- ProcessRecoveredSig(recSig, peerman);`
	`575`	`+ ProcessRecoveredSig(recSig, peerman, nodeId);`
`574`	`576`	`}`
`575`	`577`	`}`
`576`	`578`
`577`	`579`	`return recSigsByNode.size() >= nMaxBatchSize;`
`578`	`580`	`}`
`579`	`581`
`580`	`582`	`// signature must be verified already`
`581`		`-void CSigningManager::ProcessRecoveredSig(const std::shared_ptr<const CRecoveredSig>& recoveredSig, PeerManager& peerman)`
	`583`	`+void CSigningManager::ProcessRecoveredSig(const std::shared_ptr<const CRecoveredSig>& recoveredSig, PeerManager& peerman, NodeId from)`
`582`	`584`	`{`
`583`	`585`	`auto llmqType = recoveredSig->getLlmqType();`
`584`	`586`
`@@ -621,7 +623,12 @@ void CSigningManager::ProcessRecoveredSig(const std::shared_ptr<const CRecovered`
`621`	`623`	`peerman.PostProcessMessage(l->HandleNewRecoveredSig(*recoveredSig));`
`622`	`624`	`}`
`623`	`625`
`624`		`- GetMainSignals().NotifyRecoveredSig(recoveredSig, recoveredSig->GetHash().ToString());`
	`626`	`+ // TODO refactor to use a better abstraction analogous to IsAllMembersConnectedEnabled`
	`627`	`+ auto proactive_relay = from == -1 &&`
	`628`	`+ llmqType != Consensus::LLMQType::LLMQ_100_67 &&`
	`629`	`+ llmqType != Consensus::LLMQType::LLMQ_400_60 &&`
	`630`	`+ llmqType != Consensus::LLMQType::LLMQ_400_85;`
	`631`	`+ GetMainSignals().NotifyRecoveredSig(recoveredSig, recoveredSig->GetHash().ToString(), proactive_relay);`
`625`	`632`	`}`
`626`	`633`
`627`	`634`	`void CSigningManager::PushReconstructedRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& recoveredSig)`
Original file line number	Diff line number	Diff line change
`@@ -807,7 +807,7 @@ void CSigSharesManager::TryRecoverSig(const CQuorum& quorum, const uint256& id,`
`807`	`807`
`808`	`808`	`auto rs = std::make_shared<CRecoveredSig>(quorum.params.type, quorum.qc->quorumHash, id, msgHash,`
`809`	`809`	`recoveredSig);`
`810`		`- sigman.ProcessRecoveredSig(rs, m_peerman);`
	`810`	`+ sigman.ProcessRecoveredSig(rs, m_peerman, -1);`
`811`	`811`	`return; // end of single-quorum processing`
`812`	`812`	`}`
`813`	`813`
`@@ -853,7 +853,7 @@ void CSigSharesManager::TryRecoverSig(const CQuorum& quorum, const uint256& id,`
`853`	`853`	`}`
`854`	`854`	`}`
`855`	`855`
`856`		`- sigman.ProcessRecoveredSig(rs, m_peerman);`
	`856`	`+ sigman.ProcessRecoveredSig(rs, m_peerman, -1);`
`857`	`857`	`}`
`858`	`858`
`859`	`859`	`CDeterministicMNCPtr CSigSharesManager::SelectMemberForRecovery(const CQuorum& quorum, const uint256 &id, int attempt)`
`@@ -951,9 +951,9 @@ bool CSigSharesManager::AsyncSignIfMember(Consensus::LLMQType llmqType, CSigning`
`951`	`951`	`return true;`
`952`	`952`	`}`
`953`	`953`
`954`		`-void CSigSharesManager::NotifyRecoveredSig(const std::shared_ptr<const CRecoveredSig>& sig) const`
	`954`	`+void CSigSharesManager::NotifyRecoveredSig(const std::shared_ptr<const CRecoveredSig>& sig, bool proactive_relay) const`
`955`	`955`	`{`
`956`		`- m_peerman.RelayRecoveredSig(Assert(sig)->GetHash());`
	`956`	`+ m_peerman.RelayRecoveredSig(*Assert(sig), proactive_relay);`
`957`	`957`	`}`
`958`	`958`
`959`	`959`	`void CSigSharesManager::CollectSigSharesToRequest(std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToRequest)`
Original file line number	Diff line number	Diff line change
`@@ -29,9 +29,9 @@ void ActiveNotificationInterface::UpdatedBlockTip(const CBlockIndex* pindexNew,`
`29`	`29`	`m_active_ctx.gov_signer->UpdatedBlockTip(pindexNew);`
`30`	`30`	`}`
`31`	`31`
`32`		`-void ActiveNotificationInterface::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig)`
	`32`	`+void ActiveNotificationInterface::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, bool proactive_relay)`
`33`	`33`	`{`
`34`		`- m_active_ctx.shareman->NotifyRecoveredSig(sig);`
	`34`	`+ m_active_ctx.shareman->NotifyRecoveredSig(sig, proactive_relay);`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`std::unique_ptr<ActiveNotificationInterface> g_active_notification_interface;`