refactor: drop usage of chainstate globals in llmq logic

kwvg · kwvg · commit 303c6bb4db85 · 2024-06-26T13:50:49.000Z
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
@@ -46,7 +46,7 @@ static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, const Chainstat
         case TRANSACTION_COINBASE:
             return CheckCbTx(tx, pindexPrev, state);
         case TRANSACTION_QUORUM_COMMITMENT:
-            return llmq::CheckLLMQCommitment(dmnman, tx, pindexPrev, state);
+            return llmq::CheckLLMQCommitment(dmnman, chainman, tx, pindexPrev, state);
         case TRANSACTION_MNHF_SIGNAL:
             if (!DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_V20)) {
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "mnhf-before-v20");
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
@@ -257,7 +257,7 @@ bool CQuorumBlockProcessor::ProcessCommitment(int nHeight, const uint256& blockH
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-qc-dup");
     }
 
-    if (!IsMiningPhase(llmq_params, nHeight)) {
+    if (!IsMiningPhase(llmq_params, m_chainstate.m_chain, nHeight)) {
         // should not happen as it's already handled in ProcessBlock
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-qc-height");
     }
@@ -385,12 +385,12 @@ bool CQuorumBlockProcessor::GetCommitmentsFromBlock(const CBlock& block, gsl::no
     return true;
 }
 
-bool CQuorumBlockProcessor::IsMiningPhase(const Consensus::LLMQParams& llmqParams, int nHeight)
+bool CQuorumBlockProcessor::IsMiningPhase(const Consensus::LLMQParams& llmqParams, const CChain& active_chain, int nHeight)
 {
     AssertLockHeld(cs_main);
 
     // Note: This function can be called for new blocks
-    assert(nHeight <= ::ChainActive().Height() + 1);
+    assert(nHeight <= active_chain.Height() + 1);
 
     int quorumCycleStartHeight = nHeight - (nHeight % llmqParams.dkgInterval);
     int quorumCycleMiningStartHeight = quorumCycleStartHeight + llmqParams.dkgMiningWindowStart;
@@ -409,7 +409,7 @@ size_t CQuorumBlockProcessor::GetNumCommitmentsRequired(const Consensus::LLMQPar
 {
     AssertLockHeld(cs_main);
 
-    if (!IsMiningPhase(llmqParams, nHeight)) return 0;
+    if (!IsMiningPhase(llmqParams, m_chainstate.m_chain, nHeight)) return 0;
 
     // Note: This function can be called for new blocks
     assert(nHeight <= m_chainstate.m_chain.Height() + 1);
diff --git a/src/llmq/blockprocessor.h b/src/llmq/blockprocessor.h
@@ -76,7 +76,7 @@ class CQuorumBlockProcessor
 private:
     static bool GetCommitmentsFromBlock(const CBlock& block, gsl::not_null<const CBlockIndex*> pindex, std::multimap<Consensus::LLMQType, CFinalCommitment>& ret, BlockValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     bool ProcessCommitment(int nHeight, const uint256& blockHash, const CFinalCommitment& qc, BlockValidationState& state, bool fJustCheck, bool fBLSChecks) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-    static bool IsMiningPhase(const Consensus::LLMQParams& llmqParams, int nHeight) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    static bool IsMiningPhase(const Consensus::LLMQParams& llmqParams, const CChain& active_chain, int nHeight) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     size_t GetNumCommitmentsRequired(const Consensus::LLMQParams& llmqParams, int nHeight) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     static uint256 GetQuorumBlockHash(const Consensus::LLMQParams& llmqParams, const CChain& active_chain, int nHeight, int quorumIndex) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 };
diff --git a/src/llmq/chainlocks.cpp b/src/llmq/chainlocks.cpp
@@ -555,7 +555,7 @@ bool CChainLocksHandler::VerifyChainLock(const CChainLockSig& clsig) const
 {
     const auto llmqType = Params().GetConsensus().llmqTypeChainLocks;
     const uint256 nRequestId = ::SerializeHash(std::make_pair(llmq::CLSIG_REQUESTID_PREFIX, clsig.getHeight()));
-    return llmq::VerifyRecoveredSig(llmqType, qman, clsig.getHeight(), nRequestId, clsig.getBlockHash(), clsig.getSig());
+    return llmq::VerifyRecoveredSig(llmqType, m_chainstate.m_chain, qman, clsig.getHeight(), nRequestId, clsig.getBlockHash(), clsig.getSig());
 }
 
 bool CChainLocksHandler::InternalHasChainLock(int nHeight, const uint256& blockHash) const
diff --git a/src/llmq/commitment.cpp b/src/llmq/commitment.cpp
@@ -166,7 +166,7 @@ bool CFinalCommitment::VerifySizes(const Consensus::LLMQParams& params) const
     return true;
 }
 
-bool CheckLLMQCommitment(CDeterministicMNManager& dmnman, const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state)
+bool CheckLLMQCommitment(CDeterministicMNManager& dmnman, const ChainstateManager& chainman, const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state)
 {
     const auto opt_qcTx = GetTxPayload<CFinalCommitmentTxPayload>(tx);
     if (!opt_qcTx) {
@@ -200,7 +200,7 @@ bool CheckLLMQCommitment(CDeterministicMNManager& dmnman, const CTransaction& tx
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-qc-height");
     }
 
-    const CBlockIndex* pQuorumBaseBlockIndex = WITH_LOCK(cs_main, return g_chainman.m_blockman.LookupBlockIndex(qcTx.commitment.quorumHash));
+    const CBlockIndex* pQuorumBaseBlockIndex = WITH_LOCK(cs_main, return chainman.m_blockman.LookupBlockIndex(qcTx.commitment.quorumHash));
     if (pQuorumBaseBlockIndex == nullptr) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-qc-quorum-hash");
     }
diff --git a/src/llmq/commitment.h b/src/llmq/commitment.h
@@ -18,6 +18,7 @@
 
 class CBlockIndex;
 class CDeterministicMNManager;
+class ChainstateManager;
 class TxValidationState;
 
 namespace llmq
@@ -172,7 +173,7 @@ class CFinalCommitmentTxPayload
     }
 };
 
-bool CheckLLMQCommitment(CDeterministicMNManager& dmnman, const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state);
+bool CheckLLMQCommitment(CDeterministicMNManager& dmnman, const ChainstateManager& chainman, const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state);
 
 uint256 BuildCommitmentHash(Consensus::LLMQType llmqType, const uint256& blockHash, const std::vector<bool>& validMembers, const CBLSPublicKey& pubKey, const uint256& vvecHash);
 
diff --git a/src/llmq/context.cpp b/src/llmq/context.cpp
@@ -27,7 +27,7 @@ LLMQContext::LLMQContext(CChainState& chainstate, CConnman& connman, CDeterminis
     quorum_block_processor{std::make_unique<llmq::CQuorumBlockProcessor>(chainstate, dmnman, evo_db, peerman)},
     qdkgsman{std::make_unique<llmq::CDKGSessionManager>(*bls_worker, chainstate, connman, dmnman, *dkg_debugman, mn_metaman, *quorum_block_processor, mn_activeman, sporkman, peerman, unit_tests, wipe)},
     qman{std::make_unique<llmq::CQuorumManager>(*bls_worker, chainstate, connman, dmnman, *qdkgsman, evo_db, *quorum_block_processor, mn_activeman, mn_sync, sporkman)},
-    sigman{std::make_unique<llmq::CSigningManager>(connman, mn_activeman, *qman, peerman, unit_tests, wipe)},
+    sigman{std::make_unique<llmq::CSigningManager>(connman, mn_activeman, chainstate, *qman, peerman, unit_tests, wipe)},
     shareman{std::make_unique<llmq::CSigSharesManager>(connman, *sigman, mn_activeman, *qman, sporkman, peerman)},
     clhandler{[&]() -> llmq::CChainLocksHandler* const {
         assert(llmq::chainLocksHandler == nullptr);
diff --git a/src/llmq/ehf_signals.cpp b/src/llmq/ehf_signals.cpp
@@ -86,7 +86,7 @@ void CEHFSignalsHandler::trySignEHFSignal(int bit, const CBlockIndex* const pind
         return;
     }
 
-    const auto quorum = llmq::SelectQuorumForSigning(llmq_params_opt.value(), qman, requestId);
+    const auto quorum = llmq::SelectQuorumForSigning(llmq_params_opt.value(), chainstate.m_chain, qman, requestId);
     if (!quorum) {
         LogPrintf("CEHFSignalsHandler::trySignEHFSignal no quorum for id=%s\n", requestId.ToString());
         return;
diff --git a/src/llmq/instantsend.cpp b/src/llmq/instantsend.cpp
@@ -920,7 +920,7 @@ std::unordered_set<uint256, StaticSaltedHasher> CInstantSendManager::ProcessPend
             nSignHeight = blockIndex->nHeight + dkgInterval - 1;
         }
 
-        auto quorum = llmq::SelectQuorumForSigning(llmq_params, qman, id, nSignHeight, signOffset);
+        auto quorum = llmq::SelectQuorumForSigning(llmq_params, m_chainstate.m_chain, qman, id, nSignHeight, signOffset);
         if (!quorum) {
             // should not happen, but if one fails to select, all others will also fail to select
             return {};
diff --git a/src/llmq/quorums.cpp b/src/llmq/quorums.cpp
@@ -1107,25 +1107,26 @@ void CQuorumManager::StartCleanupOldQuorumDataThread(const CBlockIndex* pIndex)
     });
 }
 
-CQuorumCPtr SelectQuorumForSigning(const Consensus::LLMQParams& llmq_params, const CQuorumManager& quorum_manager, const uint256& selectionHash, int signHeight, int signOffset)
+CQuorumCPtr SelectQuorumForSigning(const Consensus::LLMQParams& llmq_params, const CChain& active_chain, const CQuorumManager& qman,
+                                   const uint256& selectionHash, int signHeight, int signOffset)
 {
     size_t poolSize = llmq_params.signingActiveQuorumCount;
 
     CBlockIndex* pindexStart;
     {
         LOCK(cs_main);
         if (signHeight == -1) {
-            signHeight = ::ChainActive().Height();
+            signHeight = active_chain.Height();
         }
         int startBlockHeight = signHeight - signOffset;
-        if (startBlockHeight > ::ChainActive().Height() || startBlockHeight < 0) {
+        if (startBlockHeight > active_chain.Height() || startBlockHeight < 0) {
             return {};
         }
-        pindexStart = ::ChainActive()[startBlockHeight];
+        pindexStart = active_chain[startBlockHeight];
     }
 
     if (IsQuorumRotationEnabled(llmq_params, pindexStart)) {
-        auto quorums = quorum_manager.ScanQuorums(llmq_params.type, pindexStart, poolSize);
+        auto quorums = qman.ScanQuorums(llmq_params.type, pindexStart, poolSize);
         if (quorums.empty()) {
             return nullptr;
         }
@@ -1149,7 +1150,7 @@ CQuorumCPtr SelectQuorumForSigning(const Consensus::LLMQParams& llmq_params, con
         }
         return *itQuorum;
     } else {
-        auto quorums = quorum_manager.ScanQuorums(llmq_params.type, pindexStart, poolSize);
+        auto quorums = qman.ScanQuorums(llmq_params.type, pindexStart, poolSize);
         if (quorums.empty()) {
             return nullptr;
         }
@@ -1168,11 +1169,13 @@ CQuorumCPtr SelectQuorumForSigning(const Consensus::LLMQParams& llmq_params, con
     }
 }
 
-bool VerifyRecoveredSig(Consensus::LLMQType llmqType, const CQuorumManager& quorum_manager, int signedAtHeight, const uint256& id, const uint256& msgHash, const CBLSSignature& sig, const int signOffset)
+bool VerifyRecoveredSig(Consensus::LLMQType llmqType, const CChain& active_chain, const CQuorumManager& qman,
+                        int signedAtHeight, const uint256& id, const uint256& msgHash, const CBLSSignature& sig,
+                        const int signOffset)
 {
     const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
     assert(llmq_params_opt.has_value());
-    auto quorum = SelectQuorumForSigning(llmq_params_opt.value(), quorum_manager, id, signedAtHeight, signOffset);
+    auto quorum = SelectQuorumForSigning(llmq_params_opt.value(), active_chain, qman, id, signedAtHeight, signOffset);
     if (!quorum) {
         return false;
     }
diff --git a/src/llmq/quorums.h b/src/llmq/quorums.h
@@ -294,11 +294,13 @@ class CQuorumManager
 // which are not 100% at the chain tip.
 static constexpr int SIGN_HEIGHT_OFFSET{8};
 
-CQuorumCPtr SelectQuorumForSigning(const Consensus::LLMQParams& llmq_params, const CQuorumManager& quorum_manager, const uint256& selectionHash, int signHeight = -1 /*chain tip*/, int signOffset = SIGN_HEIGHT_OFFSET);
+CQuorumCPtr SelectQuorumForSigning(const Consensus::LLMQParams& llmq_params, const CChain& active_chain, const CQuorumManager& qman,
+                                   const uint256& selectionHash, int signHeight = -1 /*chain tip*/, int signOffset = SIGN_HEIGHT_OFFSET);
 
 // Verifies a recovered sig that was signed while the chain tip was at signedAtTip
-bool VerifyRecoveredSig(Consensus::LLMQType llmqType, const CQuorumManager& quorum_manager, int signedAtHeight, const uint256& id, const uint256& msgHash, const CBLSSignature& sig, int signOffset = SIGN_HEIGHT_OFFSET);
-
+bool VerifyRecoveredSig(Consensus::LLMQType llmqType, const CChain& active_chain, const CQuorumManager& qman,
+                        int signedAtHeight, const uint256& id, const uint256& msgHash, const CBLSSignature& sig,
+                        int signOffset = SIGN_HEIGHT_OFFSET);
 } // namespace llmq
 
 template<typename T> struct SaltedHasherImpl;
diff --git a/src/llmq/signing.cpp b/src/llmq/signing.cpp
@@ -534,9 +534,9 @@ void CRecoveredSigsDb::CleanupOldVotes(int64_t maxAge)
 
 //////////////////
 
-CSigningManager::CSigningManager(CConnman& _connman, const CActiveMasternodeManager* const mn_activeman, const CQuorumManager& _qman,
-                                 const std::unique_ptr<PeerManager>& peerman, bool fMemory, bool fWipe) :
-    db(fMemory, fWipe), connman(_connman), m_mn_activeman(mn_activeman), qman(_qman), m_peerman(peerman)
+CSigningManager::CSigningManager(CConnman& _connman, const CActiveMasternodeManager* const mn_activeman, const CChainState& chainstate,
+                                 const CQuorumManager& _qman, const std::unique_ptr<PeerManager>& peerman, bool fMemory, bool fWipe) :
+    db(fMemory, fWipe), connman(_connman), m_mn_activeman(mn_activeman), m_chainstate(chainstate), qman(_qman), m_peerman(peerman)
 {
 }
 
@@ -890,7 +890,7 @@ bool CSigningManager::AsyncSignIfMember(Consensus::LLMQType llmqType, CSigShares
             // TODO fix this by re-signing when the next block arrives, but only when that block results in a change of the quorum list and no recovered signature has been created in the mean time
             const auto &llmq_params_opt = Params().GetLLMQ(llmqType);
             assert(llmq_params_opt.has_value());
-            return SelectQuorumForSigning(llmq_params_opt.value(), qman, id);
+            return SelectQuorumForSigning(llmq_params_opt.value(), m_chainstate.m_chain, qman, id);
         } else {
             return qman.GetQuorum(llmqType, quorumHash);
         }
diff --git a/src/llmq/signing.h b/src/llmq/signing.h
@@ -19,6 +19,7 @@
 #include <unordered_map>
 
 class CActiveMasternodeManager;
+class CChainState;
 class CConnman;
 class CDataStream;
 class CDBBatch;
@@ -163,6 +164,7 @@ class CSigningManager
     CRecoveredSigsDb db;
     CConnman& connman;
     const CActiveMasternodeManager* const m_mn_activeman;
+    const CChainState& m_chainstate;
     const CQuorumManager& qman;
     const std::unique_ptr<PeerManager>& m_peerman;
 
@@ -179,8 +181,8 @@ class CSigningManager
     std::vector<CRecoveredSigsListener*> recoveredSigsListeners GUARDED_BY(cs_listeners);
 
 public:
-    CSigningManager(CConnman& _connman, const CActiveMasternodeManager* const mn_activeman, const CQuorumManager& _qman,
-                    const std::unique_ptr<PeerManager>& peerman, bool fMemory, bool fWipe);
+    CSigningManager(CConnman& _connman, const CActiveMasternodeManager* const mn_activeman, const CChainState& chainstate,
+                    const CQuorumManager& _qman, const std::unique_ptr<PeerManager>& peerman, bool fMemory, bool fWipe);
 
     bool AlreadyHave(const CInv& inv) const;
     bool GetRecoveredSigForGetData(const uint256& hash, CRecoveredSig& ret) const;
diff --git a/src/llmq/snapshot.cpp b/src/llmq/snapshot.cpp
@@ -86,27 +86,27 @@ UniValue CQuorumRotationInfo::ToJson() const
 }
 
 bool BuildQuorumRotationInfo(const CGetQuorumRotationInfo& request, CQuorumRotationInfo& response,
-                             CDeterministicMNManager& dmnman, const CQuorumManager& qman,
+                             CDeterministicMNManager& dmnman, const ChainstateManager& chainman, const CQuorumManager& qman,
                              const CQuorumBlockProcessor& quorum_block_processor, std::string& errorRet)
 {
     AssertLockHeld(cs_main);
 
     std::vector<const CBlockIndex*> baseBlockIndexes;
     if (request.baseBlockHashes.size() == 0) {
-        const CBlockIndex* blockIndex = ::ChainActive().Genesis();
+        const CBlockIndex* blockIndex = chainman.ActiveChain().Genesis();
         if (!blockIndex) {
             errorRet = strprintf("genesis block not found");
             return false;
         }
         baseBlockIndexes.push_back(blockIndex);
     } else {
         for (const auto& blockHash : request.baseBlockHashes) {
-            const CBlockIndex* blockIndex = g_chainman.m_blockman.LookupBlockIndex(blockHash);
+            const CBlockIndex* blockIndex = chainman.m_blockman.LookupBlockIndex(blockHash);
             if (!blockIndex) {
                 errorRet = strprintf("block %s not found", blockHash.ToString());
                 return false;
             }
-            if (!::ChainActive().Contains(blockIndex)) {
+            if (!chainman.ActiveChain().Contains(blockIndex)) {
                 errorRet = strprintf("block %s is not in the active chain", blockHash.ToString());
                 return false;
             }
@@ -117,7 +117,7 @@ bool BuildQuorumRotationInfo(const CGetQuorumRotationInfo& request, CQuorumRotat
         });
     }
 
-    const CBlockIndex* tipBlockIndex = ::ChainActive().Tip();
+    const CBlockIndex* tipBlockIndex = chainman.ActiveChain().Tip();
     if (!tipBlockIndex) {
         errorRet = strprintf("tip block not found");
         return false;
@@ -127,7 +127,7 @@ bool BuildQuorumRotationInfo(const CGetQuorumRotationInfo& request, CQuorumRotat
         return false;
     }
 
-    const CBlockIndex* blockIndex = g_chainman.m_blockman.LookupBlockIndex(request.blockRequestHash);
+    const CBlockIndex* blockIndex = chainman.m_blockman.LookupBlockIndex(request.blockRequestHash);
     if (!blockIndex) {
         errorRet = strprintf("block not found");
         return false;
diff --git a/src/llmq/snapshot.h b/src/llmq/snapshot.h
@@ -208,7 +208,7 @@ class CQuorumRotationInfo
 };
 
 bool BuildQuorumRotationInfo(const CGetQuorumRotationInfo& request, CQuorumRotationInfo& response,
-                             CDeterministicMNManager& dmnman, const CQuorumManager& qman,
+                             CDeterministicMNManager& dmnman, const ChainstateManager& chainman, const CQuorumManager& qman,
                              const CQuorumBlockProcessor& quorumBlockProcessor, std::string& errorRet);
 uint256 GetLastBaseBlockHash(Span<const CBlockIndex*> baseBlockIndexes, const CBlockIndex* blockIndex);
 
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
@@ -4842,7 +4842,7 @@ void PeerManagerImpl::ProcessMessage(
 
         llmq::CQuorumRotationInfo quorumRotationInfoRet;
         std::string strError;
-        if (BuildQuorumRotationInfo(cmd, quorumRotationInfoRet, *m_dmnman, *m_llmq_ctx->qman, *m_llmq_ctx->quorum_block_processor, strError)) {
+        if (BuildQuorumRotationInfo(cmd, quorumRotationInfoRet, *m_dmnman, m_chainman, *m_llmq_ctx->qman, *m_llmq_ctx->quorum_block_processor, strError)) {
             m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::QUORUMROTATIONINFO, quorumRotationInfoRet));
         } else {
             strError = strprintf("getquorumrotationinfo failed for size(baseBlockHashes)=%d, blockRequestHash=%s. error=%s", cmd.baseBlockHashes.size(), cmd.blockRequestHash.ToString(), strError);
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp

Original file line number	Diff line number	Diff line change
`@@ -257,7 +257,7 @@ bool CQuorumBlockProcessor::ProcessCommitment(int nHeight, const uint256& blockH`
`257`	`257`	`return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-qc-dup");`
`258`	`258`	`}`
`259`	`259`
`260`		`- if (!IsMiningPhase(llmq_params, nHeight)) {`
	`260`	`+ if (!IsMiningPhase(llmq_params, m_chainstate.m_chain, nHeight)) {`
`261`	`261`	`// should not happen as it's already handled in ProcessBlock`
`262`	`262`	`return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-qc-height");`
`263`	`263`	`}`
`@@ -385,12 +385,12 @@ bool CQuorumBlockProcessor::GetCommitmentsFromBlock(const CBlock& block, gsl::no`
`385`	`385`	`return true;`
`386`	`386`	`}`
`387`	`387`
`388`		`-bool CQuorumBlockProcessor::IsMiningPhase(const Consensus::LLMQParams& llmqParams, int nHeight)`
	`388`	`+bool CQuorumBlockProcessor::IsMiningPhase(const Consensus::LLMQParams& llmqParams, const CChain& active_chain, int nHeight)`
`389`	`389`	`{`
`390`	`390`	`AssertLockHeld(cs_main);`
`391`	`391`
`392`	`392`	`// Note: This function can be called for new blocks`
`393`		`- assert(nHeight <= ::ChainActive().Height() + 1);`
	`393`	`+ assert(nHeight <= active_chain.Height() + 1);`
`394`	`394`
`395`	`395`	`int quorumCycleStartHeight = nHeight - (nHeight % llmqParams.dkgInterval);`
`396`	`396`	`int quorumCycleMiningStartHeight = quorumCycleStartHeight + llmqParams.dkgMiningWindowStart;`
`@@ -409,7 +409,7 @@ size_t CQuorumBlockProcessor::GetNumCommitmentsRequired(const Consensus::LLMQPar`
`409`	`409`	`{`
`410`	`410`	`AssertLockHeld(cs_main);`
`411`	`411`
`412`		`- if (!IsMiningPhase(llmqParams, nHeight)) return 0;`
	`412`	`+ if (!IsMiningPhase(llmqParams, m_chainstate.m_chain, nHeight)) return 0;`
`413`	`413`
`414`	`414`	`// Note: This function can be called for new blocks`
`415`	`415`	`assert(nHeight <= m_chainstate.m_chain.Height() + 1);`
Original file line number	Diff line number	Diff line change
`@@ -555,7 +555,7 @@ bool CChainLocksHandler::VerifyChainLock(const CChainLockSig& clsig) const`
`555`	`555`	`{`
`556`	`556`	`const auto llmqType = Params().GetConsensus().llmqTypeChainLocks;`
`557`	`557`	`const uint256 nRequestId = ::SerializeHash(std::make_pair(llmq::CLSIG_REQUESTID_PREFIX, clsig.getHeight()));`
`558`		`- return llmq::VerifyRecoveredSig(llmqType, qman, clsig.getHeight(), nRequestId, clsig.getBlockHash(), clsig.getSig());`
	`558`	`+ return llmq::VerifyRecoveredSig(llmqType, m_chainstate.m_chain, qman, clsig.getHeight(), nRequestId, clsig.getBlockHash(), clsig.getSig());`
`559`	`559`	`}`
`560`	`560`
`561`	`561`	`bool CChainLocksHandler::InternalHasChainLock(int nHeight, const uint256& blockHash) const`
Original file line number	Diff line number	Diff line change
`@@ -166,7 +166,7 @@ bool CFinalCommitment::VerifySizes(const Consensus::LLMQParams& params) const`
`166`	`166`	`return true;`
`167`	`167`	`}`
`168`	`168`
`169`		`-bool CheckLLMQCommitment(CDeterministicMNManager& dmnman, const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state)`
	`169`	`+bool CheckLLMQCommitment(CDeterministicMNManager& dmnman, const ChainstateManager& chainman, const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state)`
`170`	`170`	`{`
`171`	`171`	`const auto opt_qcTx = GetTxPayload<CFinalCommitmentTxPayload>(tx);`
`172`	`172`	`if (!opt_qcTx) {`
`@@ -200,7 +200,7 @@ bool CheckLLMQCommitment(CDeterministicMNManager& dmnman, const CTransaction& tx`
`200`	`200`	`return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-qc-height");`
`201`	`201`	`}`
`202`	`202`
`203`		`- const CBlockIndex* pQuorumBaseBlockIndex = WITH_LOCK(cs_main, return g_chainman.m_blockman.LookupBlockIndex(qcTx.commitment.quorumHash));`
	`203`	`+ const CBlockIndex* pQuorumBaseBlockIndex = WITH_LOCK(cs_main, return chainman.m_blockman.LookupBlockIndex(qcTx.commitment.quorumHash));`
`204`	`204`	`if (pQuorumBaseBlockIndex == nullptr) {`
`205`	`205`	`return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-qc-quorum-hash");`
`206`	`206`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ void CEHFSignalsHandler::trySignEHFSignal(int bit, const CBlockIndex* const pind`
`86`	`86`	`return;`
`87`	`87`	`}`
`88`	`88`
`89`		`- const auto quorum = llmq::SelectQuorumForSigning(llmq_params_opt.value(), qman, requestId);`
	`89`	`+ const auto quorum = llmq::SelectQuorumForSigning(llmq_params_opt.value(), chainstate.m_chain, qman, requestId);`
`90`	`90`	`if (!quorum) {`
`91`	`91`	`LogPrintf("CEHFSignalsHandler::trySignEHFSignal no quorum for id=%s\n", requestId.ToString());`
`92`	`92`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -920,7 +920,7 @@ std::unordered_set<uint256, StaticSaltedHasher> CInstantSendManager::ProcessPend`
`920`	`920`	`nSignHeight = blockIndex->nHeight + dkgInterval - 1;`
`921`	`921`	`}`
`922`	`922`
`923`		`- auto quorum = llmq::SelectQuorumForSigning(llmq_params, qman, id, nSignHeight, signOffset);`
	`923`	`+ auto quorum = llmq::SelectQuorumForSigning(llmq_params, m_chainstate.m_chain, qman, id, nSignHeight, signOffset);`
`924`	`924`	`if (!quorum) {`
`925`	`925`	`// should not happen, but if one fails to select, all others will also fail to select`
`926`	`926`	`return {};`
Original file line number	Diff line number	Diff line change
`@@ -1107,25 +1107,26 @@ void CQuorumManager::StartCleanupOldQuorumDataThread(const CBlockIndex* pIndex)`
`1107`	`1107`	`});`
`1108`	`1108`	`}`
`1109`	`1109`
`1110`		`-CQuorumCPtr SelectQuorumForSigning(const Consensus::LLMQParams& llmq_params, const CQuorumManager& quorum_manager, const uint256& selectionHash, int signHeight, int signOffset)`
	`1110`	`+CQuorumCPtr SelectQuorumForSigning(const Consensus::LLMQParams& llmq_params, const CChain& active_chain, const CQuorumManager& qman,`
	`1111`	`+ const uint256& selectionHash, int signHeight, int signOffset)`
`1111`	`1112`	`{`
`1112`	`1113`	`size_t poolSize = llmq_params.signingActiveQuorumCount;`
`1113`	`1114`
`1114`	`1115`	`CBlockIndex* pindexStart;`
`1115`	`1116`	`{`
`1116`	`1117`	`LOCK(cs_main);`
`1117`	`1118`	`if (signHeight == -1) {`
`1118`		`- signHeight = ::ChainActive().Height();`
	`1119`	`+ signHeight = active_chain.Height();`
`1119`	`1120`	`}`
`1120`	`1121`	`int startBlockHeight = signHeight - signOffset;`
`1121`		`- if (startBlockHeight > ::ChainActive().Height() \|\| startBlockHeight < 0) {`
	`1122`	`+ if (startBlockHeight > active_chain.Height() \|\| startBlockHeight < 0) {`
`1122`	`1123`	`return {};`
`1123`	`1124`	`}`
`1124`		`- pindexStart = ::ChainActive()[startBlockHeight];`
	`1125`	`+ pindexStart = active_chain[startBlockHeight];`
`1125`	`1126`	`}`
`1126`	`1127`
`1127`	`1128`	`if (IsQuorumRotationEnabled(llmq_params, pindexStart)) {`
`1128`		`- auto quorums = quorum_manager.ScanQuorums(llmq_params.type, pindexStart, poolSize);`
	`1129`	`+ auto quorums = qman.ScanQuorums(llmq_params.type, pindexStart, poolSize);`
`1129`	`1130`	`if (quorums.empty()) {`
`1130`	`1131`	`return nullptr;`
`1131`	`1132`	`}`
`@@ -1149,7 +1150,7 @@ CQuorumCPtr SelectQuorumForSigning(const Consensus::LLMQParams& llmq_params, con`
`1149`	`1150`	`}`
`1150`	`1151`	`return *itQuorum;`
`1151`	`1152`	`} else {`
`1152`		`- auto quorums = quorum_manager.ScanQuorums(llmq_params.type, pindexStart, poolSize);`
	`1153`	`+ auto quorums = qman.ScanQuorums(llmq_params.type, pindexStart, poolSize);`
`1153`	`1154`	`if (quorums.empty()) {`
`1154`	`1155`	`return nullptr;`
`1155`	`1156`	`}`
`@@ -1168,11 +1169,13 @@ CQuorumCPtr SelectQuorumForSigning(const Consensus::LLMQParams& llmq_params, con`
`1168`	`1169`	`}`
`1169`	`1170`	`}`
`1170`	`1171`
`1171`		`-bool VerifyRecoveredSig(Consensus::LLMQType llmqType, const CQuorumManager& quorum_manager, int signedAtHeight, const uint256& id, const uint256& msgHash, const CBLSSignature& sig, const int signOffset)`
	`1172`	`+bool VerifyRecoveredSig(Consensus::LLMQType llmqType, const CChain& active_chain, const CQuorumManager& qman,`
	`1173`	`+ int signedAtHeight, const uint256& id, const uint256& msgHash, const CBLSSignature& sig,`
	`1174`	`+ const int signOffset)`
`1172`	`1175`	`{`
`1173`	`1176`	`const auto& llmq_params_opt = Params().GetLLMQ(llmqType);`
`1174`	`1177`	`assert(llmq_params_opt.has_value());`
`1175`		`- auto quorum = SelectQuorumForSigning(llmq_params_opt.value(), quorum_manager, id, signedAtHeight, signOffset);`
	`1178`	`+ auto quorum = SelectQuorumForSigning(llmq_params_opt.value(), active_chain, qman, id, signedAtHeight, signOffset);`
`1176`	`1179`	`if (!quorum) {`
`1177`	`1180`	`return false;`
`1178`	`1181`	`}`