refactor: move RelayRecoveredSig() call out of CSigSharesManager

As ProcessRecoveredSig() triggers a NotifyRecoveredSig() notification,
we can stick the RelayRecoveredSig() into CSigSharesManager and have the
relay request processed through the notification interface instead, lets
us finally drop CActiveMasternodeManager from CSigSharesManager.

Author: kwvg

src/llmq/context.cpp

@@ -30,7 +30,7 @@ LLMQContext::LLMQContext(ChainstateManager& chainman, CDeterministicMNManager& d
     qman{std::make_unique<llmq::CQuorumManager>(*bls_worker, chainman.ActiveChainstate(), dmnman, *qdkgsman, evo_db,
                                                 *quorum_block_processor, *qsnapman, mn_activeman, mn_sync, sporkman,
                                                 unit_tests, wipe)},
-    sigman{std::make_unique<llmq::CSigningManager>(mn_activeman, chainman.ActiveChainstate(), *qman, unit_tests, wipe)},
+    sigman{std::make_unique<llmq::CSigningManager>(chainman.ActiveChainstate(), *qman, unit_tests, wipe)},
     clhandler{std::make_unique<llmq::CChainLocksHandler>(chainman.ActiveChainstate(), *qman, sporkman, mempool, mn_sync)},
     isman{std::make_unique<llmq::CInstantSendManager>(*clhandler, chainman.ActiveChainstate(), *qman, *sigman, sporkman,
                                                       mempool, mn_sync, unit_tests, wipe)}

src/llmq/signing.cpp

@@ -332,10 +332,8 @@ void CRecoveredSigsDb::CleanupOldVotes(int64_t maxAge)
 
 //////////////////
 
-CSigningManager::CSigningManager(const CActiveMasternodeManager* const mn_activeman, const CChainState& chainstate,
-                                 const CQuorumManager& _qman, bool fMemory, bool fWipe) :
+CSigningManager::CSigningManager(const CChainState& chainstate, const CQuorumManager& _qman, bool fMemory, bool fWipe) :
     db(fMemory, fWipe),
-    m_mn_activeman(mn_activeman),
     m_chainstate(chainstate),
     qman(_qman)
 {
@@ -615,10 +613,6 @@ void CSigningManager::ProcessRecoveredSig(const std::shared_ptr<const CRecovered
     db.WriteRecoveredSig(*recoveredSig);
     WITH_LOCK(cs_pending, pendingReconstructedRecoveredSigs.erase(recoveredSig->GetHash()));
 
-    if (m_mn_activeman != nullptr) {
-        peerman.RelayRecoveredSig(recoveredSig->GetHash());
-    }
-
     auto listeners = WITH_LOCK(cs_listeners, return recoveredSigsListeners);
     for (auto& l : listeners) {
         peerman.PostProcessMessage(l->HandleNewRecoveredSig(*recoveredSig));

src/llmq/signing.h

@@ -23,7 +23,6 @@
 #include <string_view>
 #include <unordered_map>
 
-class CActiveMasternodeManager;
 class CChainState;
 class CDataStream;
 class CDBBatch;
@@ -163,7 +162,6 @@ class CSigningManager
 private:
 
     CRecoveredSigsDb db;
-    const CActiveMasternodeManager* const m_mn_activeman;
     const CChainState& m_chainstate;
     const CQuorumManager& qman;
 
@@ -180,8 +178,7 @@ class CSigningManager
     std::vector<CRecoveredSigsListener*> recoveredSigsListeners GUARDED_BY(cs_listeners);
 
 public:
-    CSigningManager(const CActiveMasternodeManager* const mn_activeman, const CChainState& chainstate,
-                    const CQuorumManager& _qman, bool fMemory, bool fWipe);
+    CSigningManager(const CChainState& chainstate, const CQuorumManager& _qman, bool fMemory, bool fWipe);
 
     bool AlreadyHave(const CInv& inv) const EXCLUSIVE_LOCKS_REQUIRED(!cs_pending);
     bool GetRecoveredSigForGetData(const uint256& hash, CRecoveredSig& ret) const;

src/llmq/signing_shares.cpp

@@ -949,6 +949,11 @@ bool CSigSharesManager::AsyncSignIfMember(Consensus::LLMQType llmqType, CSigning
     return true;
 }
 
+void CSigSharesManager::NotifyRecoveredSig(const std::shared_ptr<const CRecoveredSig>& sig) const
+{
+    m_peerman.RelayRecoveredSig(Assert(sig)->GetHash());
+}
+
 void CSigSharesManager::CollectSigSharesToRequest(std::unordered_map<NodeId, Uint256HashMap<CSigSharesInv>>& sigSharesToRequest)
 {
     AssertLockHeld(cs);

src/llmq/signing_shares.h

@@ -445,6 +445,8 @@ class CSigSharesManager : public CRecoveredSigsListener
                            bool allowDiffMsgHashSigning = false)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_pendingSigns);
 
+    void NotifyRecoveredSig(const std::shared_ptr<const CRecoveredSig>& sig) const;
+
 private:
     // all of these return false when the currently processed message should be aborted (as each message actually contains multiple messages)
     bool ProcessMessageSigSesAnn(const CNode& pfrom, const CSigSesAnn& ann);

src/masternode/active/notificationinterface.cpp

@@ -6,6 +6,7 @@
 
 #include <governance/signing.h>
 #include <llmq/ehf_signals.h>
+#include <llmq/signing_shares.h>
 #include <masternode/active/context.h>
 #include <masternode/node.h>
 
@@ -26,4 +27,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)
+{
+    m_active_ctx.shareman->NotifyRecoveredSig(sig);
+}
+
 std::unique_ptr<ActiveNotificationInterface> g_active_notification_interface;

src/masternode/active/notificationinterface.h

@@ -7,8 +7,13 @@
 
 #include <validationinterface.h>
 
+#include <memory>
+
 class CActiveMasternodeManager;
 struct ActiveContext;
+namespace llmq {
+class CRecoveredSig;
+} // namespace llmq
 
 class ActiveNotificationInterface final : public CValidationInterface
 {
@@ -20,6 +25,7 @@ class ActiveNotificationInterface final : public CValidationInterface
 
 protected:
     // CValidationInterface
+    void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig) override;
     void UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload) override;
 
 private: