Merge #7247: refactor: simplify architecture of quorum observer and quorum participant

863ee6b doc: clarify masternode late InitializeCurrentBlockTip comment (UdjinM6)
dc8c6cf fix: replay startup tip into ActiveContext/ObserverContext (UdjinM6)
21fe75f fix: guard GetProTxHash() behind is_masternode check, add CQuorum safety assert (UdjinM6)
27129d9 fix: defer full InitializeCurrentBlockTip broadcast on masternodes (UdjinM6)
55d8025 refactor: safety belt to be sure that CQuorum is initialized properly and no empty qc member (Konstantin Akimov)
8bc5744 fix: review comments - missing forward declaration, protection for no valid members (Konstantin Akimov)
e2df648 refactor: drop argument request_limit_exceeded in ProcessContribQGETDATA (Konstantin Akimov)
b47de25 refactor: remove net related code ProcessContribQGETDATA and ProcessContribQDATA to NetQuorum (Konstantin Akimov)
1be8863 refactor: move out network code to new NetQuorum from CQuorumManager (Konstantin Akimov)
c86e4f6 refactor: it's always either observer_ctx or active_ctx, not both created together (Konstantin Akimov)
6a2f291 refactor: remove duplicated code between QuorumRole's UpdatedBlockTip and InitializeQuorumConnections (Konstantin Akimov)
6c99cb0 fix: parameter 'params' shadows member inherited from type 'CDKGSession' [-Werror,-Wshadow-field] (Konstantin Akimov)
0f1174a refactor: remove multiple friends of CDKGSession (Konstantin Akimov)
f4cbf92 refactor: inline QuorumParticipant to ActiveContext (Konstantin Akimov)
5ded711 refactor: rename src/llmq/observer/context to src/llmq/observer (Konstantin Akimov)
93f168a refactor: remove QuorumRoleBase by moving its functionality directly to QuorumRole (Konstantin Akimov)
9bb50db refactor: merge QuorumObserver and ObserverContext classes to the one entity to reduce amount of abstractions (Konstantin Akimov)
7978822 refactor: quorum members: remove QuorumObserverParent; participant is no more child of 'observer' (Konstantin Akimov)

Pull request description:

  ## Issue being fixed or feature implemented
  It's a follow-up for #7066 and related PRs

  This PR is reducing mental concentration when reading quorum-related code by significant simplification amount of levels of abstractions and inheritance classes from each other.

  This PR is a direct dependency of #7234 (kernel / chainstate project)

  Performance is not expected to be improved by any noticeable margin.

  Compilation time is expected to be improved marginally due to fewer files (-2) to compile and less transitive includes over `src/llmq/quorumsman.h`.

  ## What was done?

  This changes has been spotted during #7234 and extracted to own PR.

   - Remove QuorumObserverParent; decouple QuorumParticipant from QuorumObserver inheritance — they become independent implementations of a common QuorumRole interface.
   - Merge QuorumObserver and ObserverContext into a single class, then remove the transitional QuorumRoleBase by folding it into QuorumRole.
   - Rename src/llmq/observer/context.{h,cpp} to src/llmq/observer.{h,cpp} — flatten the now-single-file subdirectory.
   - Inline QuorumParticipant into ActiveContext — it only applies to active masternode mode; src/active/quorums.{h,cpp} deleted.
   - Remove four friend declarations from CDKGSession (ActiveDKGSession, ActiveDKGSessionHandler, CDKGSessionHandler, CDKGSessionManager); affected members changed from private to protected.
   - Extract network code from CQuorumManager and ActiveContext into new NetQuorum (src/llmq/net_quorum.{h,cpp}) — handles QGETDATA/QDATA processing, quorum peer connections, data recovery, and periodic cleanup.

  ###  Class hierarchy — before vs. after
   *by claude

    Before:
    QuorumObserverParent (interface, implemented by CQuorumManager)
        │
    QuorumObserver (base class with shared state)
        ├── ObserverContext  (observer mode, also CValidationInterface)
        └── QuorumParticipant (active mode, in src/active/quorums.h)

    After:
    QuorumRole (pure virtual interface in quorumsman.h)
        ├── ObserverContext  (observer mode, in src/llmq/observer.h)
        └── ActiveContext    (active mode, QuorumParticipant inlined)

  ## How Has This Been Tested?
  Run unit & functional tests

  ## Breaking Changes
  N/A

  ## Checklist:
  - [x] I have performed a self-review of my own code
  - [ ] I have commented my code, particularly in hard-to-understand areas
  - [ ] I have added or updated relevant unit/integration/functional/e2e tests
  - [ ] I have made corresponding changes to the documentation
  - [x] I have assigned this pull request to a milestone

ACKs for top commit:
  UdjinM6:
    utACK 863ee6b

Tree-SHA512: 13a3d8e533bf811fd5d438e0c2f3007b633e990b725767907d5c4b8eb2da32d06f282f3f61319ce78a17e40ca41dac1b3c791039c5672321e1b43a7174712b2d

Author: PastaPastaPasta

src/Makefile.am

@@ -155,7 +155,6 @@ BITCOIN_CORE_H = \
   active/dkgsession.h \
   active/dkgsessionhandler.h \
   active/masternode.h \
-  active/quorums.h \
   addrdb.h \
   addressindex.h \
   spentindex.h \
@@ -283,19 +282,19 @@ BITCOIN_CORE_H = \
   llmq/dkgsessionhandler.h \
   llmq/dkgsessionmgr.h \
   llmq/ehf_signals.h \
+  llmq/observer.h \
   llmq/options.h \
   llmq/params.h \
   llmq/quorums.h \
   llmq/quorumsman.h \
   llmq/signhash.h \
   llmq/signing.h \
+  llmq/net_quorum.h \
   llmq/net_signing.h \
   llmq/signing_shares.h \
   llmq/snapshot.h \
   llmq/types.h \
   llmq/utils.h \
-  llmq/observer/context.h \
-  llmq/observer/quorums.h \
   logging.h \
   logging/timer.h \
   mapport.h \
@@ -486,7 +485,6 @@ libbitcoin_node_a_SOURCES = \
   active/dkgsession.cpp \
   active/dkgsessionhandler.cpp \
   active/masternode.cpp \
-  active/quorums.cpp \
   addrdb.cpp \
   addressindex.cpp \
   addrman.cpp \
@@ -555,7 +553,9 @@ libbitcoin_node_a_SOURCES = \
   llmq/dkgsessionhandler.cpp \
   llmq/dkgsessionmgr.cpp \
   llmq/ehf_signals.cpp \
+  llmq/net_quorum.cpp \
   llmq/net_signing.cpp \
+  llmq/observer.cpp \
   llmq/options.cpp \
   llmq/quorums.cpp \
   llmq/quorumsman.cpp \
@@ -564,8 +564,6 @@ libbitcoin_node_a_SOURCES = \
   llmq/signing_shares.cpp \
   llmq/snapshot.cpp \
   llmq/utils.cpp \
-  llmq/observer/context.cpp \
-  llmq/observer/quorums.cpp \
   mapport.cpp \
   masternode/meta.cpp \
   masternode/payments.cpp \

src/active/context.cpp

@@ -6,19 +6,21 @@
 
 #include <active/dkgsessionhandler.h>
 #include <active/masternode.h>
-#include <active/quorums.h>
+#include <bls/bls_worker.h>
 #include <chainlock/handler.h>
 #include <chainlock/signing.h>
+#include <evo/deterministicmns.h>
 #include <governance/governance.h>
 #include <governance/signing.h>
 #include <instantsend/instantsend.h>
 #include <instantsend/signing.h>
-#include <llmq/context.h>
 #include <llmq/debug.h>
 #include <llmq/dkgsessionmgr.h>
 #include <llmq/ehf_signals.h>
+#include <llmq/quorums.h>
 #include <llmq/quorumsman.h>
 #include <llmq/signing_shares.h>
+#include <masternode/sync.h>
 #include <util/check.h>
 #include <validation.h>
 #include <validationinterface.h>
@@ -30,17 +32,16 @@ ActiveContext::ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman
                              llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumManager& qman,
                              llmq::CQuorumSnapshotManager& qsnapman, llmq::CSigningManager& sigman,
                              const CMasternodeSync& mn_sync, const CBLSSecretKey& operator_sk,
-                             const llmq::QvvecSyncModeMap& sync_map, const util::DbWrapperParams& db_params,
-                             bool quorums_recovery, bool quorums_watch) :
-    m_qman{qman},
+                             const util::DbWrapperParams& db_params, bool quorums_watch) :
+    llmq::QuorumRole{qman},
+    m_bls_worker{bls_worker},
+    m_quorums_watch{quorums_watch},
     nodeman{std::make_unique<CActiveMasternodeManager>(connman, dmnman, operator_sk)},
     dkgdbgman{std::make_unique<llmq::CDKGDebugManager>(dmnman, qsnapman, chainman)},
     qdkgsman{std::make_unique<llmq::CDKGSessionManager>(dmnman, qsnapman, chainman, sporkman, db_params, quorums_watch)},
     shareman{std::make_unique<llmq::CSigSharesManager>(connman, chainman, sigman, *nodeman, qman, sporkman)},
     gov_signer{std::make_unique<GovernanceSigner>(connman, dmnman, govman, *nodeman, chainman, mn_sync)},
     ehf_sighandler{std::make_unique<llmq::CEHFSignalsHandler>(chainman, sigman, *shareman, qman)},
-    qman_handler{std::make_unique<llmq::QuorumParticipant>(bls_worker, connman, dmnman, qman, qsnapman, *nodeman, chainman,
-                                                           mn_sync, sporkman, sync_map, quorums_recovery, quorums_watch)},
     cl_signer{std::make_unique<chainlock::ChainLockSigner>(chainman.ActiveChainstate(), chainlocks, clhandler, isman,
                                                            qman, sigman, *shareman, mn_sync)},
     is_signer{std::make_unique<instantsend::InstantSendSigner>(chainman.ActiveChainstate(), chainlocks, isman, sigman,
@@ -52,17 +53,16 @@ ActiveContext::ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman
                                                                qblockman, qsnapman, *nodeman, chainman, sporkman,
                                                                llmq_params, quorums_watch, quorum_idx);
     });
-    m_qman.ConnectManagers(qman_handler.get(), qdkgsman.get());
+    m_qman.ConnectManagers(this, qdkgsman.get());
 }
 
 ActiveContext::~ActiveContext()
 {
     m_qman.DisconnectManagers();
 }
 
-void ActiveContext::Start(CConnman& connman, PeerManager& peerman, int16_t worker_count)
+void ActiveContext::Start(CConnman& connman, PeerManager& peerman)
 {
-    qman_handler->Start(worker_count);
     qdkgsman->StartThreads(connman, peerman);
     cl_signer->Start();
     cl_signer->RegisterRecoveryInterface();
@@ -81,7 +81,6 @@ void ActiveContext::Stop()
     cl_signer->UnregisterRecoveryInterface();
     cl_signer->Stop();
     qdkgsman->StopThreads();
-    qman_handler->Stop();
 }
 
 CCoinJoinServer& ActiveContext::GetCJServer() const
@@ -99,9 +98,6 @@ void ActiveContext::SetCJServer(gsl::not_null<CCoinJoinServer*> cj_server)
 void ActiveContext::InitializeCurrentBlockTip(const CBlockIndex* tip, bool ibd)
 {
     UpdatedBlockTip(tip, nullptr, ibd);
-    if (tip) {
-        qman_handler->InitializeQuorumConnections(tip);
-    }
 }
 
 void ActiveContext::UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload)
@@ -113,5 +109,26 @@ void ActiveContext::UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIn
     ehf_sighandler->UpdatedBlockTip(pindexNew);
     gov_signer->UpdatedBlockTip(pindexNew);
     qdkgsman->UpdatedBlockTip(pindexNew, fInitialDownload);
-    qman_handler->UpdatedBlockTip(pindexNew, fInitialDownload);
+}
+
+bool ActiveContext::IsMasternode() const
+{
+    // We are only initialized if masternode mode is enabled
+    return true;
+}
+
+bool ActiveContext::IsWatching() const
+{
+    // Watch-only mode can co-exist with masternode mode
+    return m_quorums_watch;
+}
+
+uint256 ActiveContext::GetProTxHash() const
+{
+    return nodeman->GetProTxHash();
+}
+
+bool ActiveContext::SetQuorumSecretKeyShare(llmq::CQuorum& quorum, Span<CBLSSecretKey> skContributions) const
+{
+    return quorum.SetSecretKeyShare(m_bls_worker.AggregateSecretKeys(skContributions), nodeman->GetProTxHash());
 }

src/active/context.h

@@ -5,21 +5,19 @@
 #ifndef BITCOIN_ACTIVE_CONTEXT_H
 #define BITCOIN_ACTIVE_CONTEXT_H
 
-#include <llmq/options.h>
+#include <llmq/quorumsman.h>
 
 #include <validationinterface.h>
 
 #include <gsl/pointers.h>
+#include <span.h>
 
 #include <memory>
 
 class CActiveMasternodeManager;
-class CBLSSecretKey;
 class CBLSWorker;
-class ChainstateManager;
 class CCoinJoinServer;
 class CConnman;
-class CDeterministicMNManager;
 class CGovernanceManager;
 class CMasternodeMetaMan;
 class CMasternodeSync;
@@ -38,23 +36,19 @@ class InstantSendSigner;
 } // namespace instantsend
 namespace llmq {
 class CDKGDebugManager;
-class CDKGSessionManager;
 class CEHFSignalsHandler;
 class CInstantSendManager;
-class CQuorumBlockProcessor;
-class CQuorumManager;
-class CQuorumSnapshotManager;
 class CSigningManager;
 class CSigSharesManager;
-class QuorumParticipant;
 } // namespace llmq
 namespace util {
 struct DbWrapperParams;
 } // namespace util
 
-struct ActiveContext final : public CValidationInterface {
+struct ActiveContext final : public llmq::QuorumRole, public CValidationInterface {
 private:
-    llmq::CQuorumManager& m_qman;
+    CBLSWorker& m_bls_worker;
+    const bool m_quorums_watch{false};
 
 public:
     ActiveContext() = delete;
@@ -67,19 +61,24 @@ struct ActiveContext final : public CValidationInterface {
                            llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumManager& qman,
                            llmq::CQuorumSnapshotManager& qsnapman, llmq::CSigningManager& sigman,
                            const CMasternodeSync& mn_sync, const CBLSSecretKey& operator_sk,
-                           const llmq::QvvecSyncModeMap& sync_map, const util::DbWrapperParams& db_params,
-                           bool quorums_recovery, bool quorums_watch);
+                           const util::DbWrapperParams& db_params, bool quorums_watch);
     ~ActiveContext();
 
-    void Start(CConnman& connman, PeerManager& peerman, int16_t worker_count);
+    void Start(CConnman& connman, PeerManager& peerman);
     void Stop();
-    void InitializeCurrentBlockTip(const CBlockIndex* tip, bool ibd);
 
     CCoinJoinServer& GetCJServer() const;
     void SetCJServer(gsl::not_null<CCoinJoinServer*> cj_server);
 
+    // QuorumRole
+    bool IsMasternode() const override;
+    bool IsWatching() const override;
+    uint256 GetProTxHash() const override;
+    bool SetQuorumSecretKeyShare(llmq::CQuorum& quorum, Span<CBLSSecretKey> skContributions) const override;
+
 protected:
     // CValidationInterface
+    void InitializeCurrentBlockTip(const CBlockIndex* tip, bool ibd) override;
     void UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload) override;
 
 public:
@@ -95,7 +94,6 @@ struct ActiveContext final : public CValidationInterface {
 private:
     const std::unique_ptr<GovernanceSigner> gov_signer;
     const std::unique_ptr<llmq::CEHFSignalsHandler> ehf_sighandler;
-    const std::unique_ptr<llmq::QuorumParticipant> qman_handler;
     const std::unique_ptr<chainlock::ChainLockSigner> cl_signer;
 
 public:

src/active/dkgsession.cpp

@@ -25,8 +25,8 @@ ActiveDKGSession::ActiveDKGSession(CBLSWorker& bls_worker, CDeterministicMNManag
                                    CDKGSessionManager& qdkgsman, CMasternodeMetaMan& mn_metaman,
                                    CQuorumSnapshotManager& qsnapman, const CActiveMasternodeManager& mn_activeman,
                                    const ChainstateManager& chainman, const CSporkManager& sporkman,
-                                   const CBlockIndex* base_block_index, const Consensus::LLMQParams& params) :
-    CDKGSession(bls_worker, dmnman, dkgdbgman, qdkgsman, qsnapman, chainman, base_block_index, params),
+                                   const CBlockIndex* base_block_index, const Consensus::LLMQParams& llmq_params) :
+    CDKGSession(bls_worker, dmnman, dkgdbgman, qdkgsman, qsnapman, chainman, base_block_index, llmq_params),
     m_mn_metaman{mn_metaman},
     m_mn_activeman{mn_activeman},
     m_sporkman{sporkman},

src/active/dkgsessionhandler.cpp

@@ -106,11 +106,11 @@ bool ActiveDKGSessionHandler::InitNewQuorum(gsl::not_null<const CBlockIndex*> pQ
 
     if (!curSession->Init(m_mn_activeman.GetProTxHash(), quorumIndex)) {
         LogPrintf("ActiveDKGSessionHandler::%s -- height[%d] quorum initialization failed for %s qi[%d]\n", __func__,
-                  pQuorumBaseBlockIndex->nHeight, curSession->params.name, quorumIndex);
+                  pQuorumBaseBlockIndex->nHeight, params.name, quorumIndex);
         return false;
     }
 
-    LogPrintf("ActiveDKGSessionHandler::%s -- height[%d] quorum initialization OK for %s qi[%d]\n", __func__, pQuorumBaseBlockIndex->nHeight, curSession->params.name, quorumIndex);
+    LogPrintf("ActiveDKGSessionHandler::%s -- height[%d] quorum initialization OK for %s qi[%d]\n", __func__, pQuorumBaseBlockIndex->nHeight, params.name, quorumIndex);
     return true;
 }
 
@@ -461,11 +461,11 @@ void ActiveDKGSessionHandler::HandleDKGRound(CConnman& connman, PeerManager& pee
 
     const auto tip_mn_list = m_dmnman.GetListAtChainTip();
     utils::EnsureQuorumConnections(params, connman, m_sporkman, {m_dmnman, m_qsnapman, m_chainman, pQuorumBaseBlockIndex},
-                                   tip_mn_list, curSession->myProTxHash, /*is_masternode=*/true, m_quorums_watch);
+                                   tip_mn_list, curSession->ProTx(), /*is_masternode=*/true, m_quorums_watch);
     if (curSession->AreWeMember()) {
         utils::AddQuorumProbeConnections(params, connman, m_mn_metaman, m_sporkman,
                                          {m_dmnman, m_qsnapman, m_chainman, pQuorumBaseBlockIndex}, tip_mn_list,
-                                         curSession->myProTxHash);
+                                         curSession->ProTx());
     }
 
     WaitForNextPhase(QuorumPhase::Initialized, QuorumPhase::Contribute, curQuorumHash);
@@ -527,58 +527,22 @@ void ActiveDKGSessionHandler::PhaseHandlerThread(CConnman& connman, PeerManager&
 
 bool ActiveDKGSessionHandler::GetContribution(const uint256& hash, CDKGContribution& ret) const
 {
-    if (!curSession) {
-        return false;
-    }
-    LOCK(curSession->invCs);
-    auto it = curSession->contributions.find(hash);
-    if (it != curSession->contributions.end()) {
-        ret = it->second;
-        return true;
-    }
-    return false;
+    return curSession && curSession->GetContribution(hash, ret);
 }
 
 bool ActiveDKGSessionHandler::GetComplaint(const uint256& hash, CDKGComplaint& ret) const
 {
-    if (!curSession) {
-        return false;
-    }
-    LOCK(curSession->invCs);
-    auto it = curSession->complaints.find(hash);
-    if (it != curSession->complaints.end()) {
-        ret = it->second;
-        return true;
-    }
-    return false;
+    return curSession && curSession->GetComplaint(hash, ret);
 }
 
 bool ActiveDKGSessionHandler::GetJustification(const uint256& hash, CDKGJustification& ret) const
 {
-    if (!curSession) {
-        return false;
-    }
-    LOCK(curSession->invCs);
-    auto it = curSession->justifications.find(hash);
-    if (it != curSession->justifications.end()) {
-        ret = it->second;
-        return true;
-    }
-    return false;
+    return curSession && curSession->GetJustification(hash, ret);
 }
 
 bool ActiveDKGSessionHandler::GetPrematureCommitment(const uint256& hash, CDKGPrematureCommitment& ret) const
 {
-    if (!curSession) {
-        return false;
-    }
-    LOCK(curSession->invCs);
-    auto it = curSession->prematureCommitments.find(hash);
-    if (it != curSession->prematureCommitments.end() && curSession->validCommitments.count(hash)) {
-        ret = it->second;
-        return true;
-    }
-    return false;
+    return curSession && curSession->GetPrematureCommitment(hash, ret);
 }
 
 QuorumPhase ActiveDKGSessionHandler::GetPhase() const