refactor: access llmq::CQuorumManager through arg in MNHFTx, functions

kwvg · kwvg · commit cbb6828ec781 · 2024-05-26T12:57:17.000Z
diff --git a/src/evo/chainhelper.cpp b/src/evo/chainhelper.cpp
@@ -10,9 +10,10 @@
 
 CChainstateHelper::CChainstateHelper(CCreditPoolManager& cpoolman, CDeterministicMNManager& dmnman, CMNHFManager& mnhfman, CGovernanceManager& govman,
                                      llmq::CQuorumBlockProcessor& qblockman, const Consensus::Params& consensus_params,
-                                     const CMasternodeSync& mn_sync, const CSporkManager& sporkman, const llmq::CChainLocksHandler& clhandler)
+                                     const CMasternodeSync& mn_sync, const CSporkManager& sporkman, const llmq::CChainLocksHandler& clhandler,
+                                     const llmq::CQuorumManager& qman)
     : mn_payments{std::make_unique<CMNPaymentsProcessor>(dmnman, govman, consensus_params, mn_sync, sporkman)},
-      special_tx{std::make_unique<CSpecialTxProcessor>(cpoolman, dmnman, mnhfman, qblockman, consensus_params, clhandler)}
+      special_tx{std::make_unique<CSpecialTxProcessor>(cpoolman, dmnman, mnhfman, qblockman, consensus_params, clhandler, qman)}
 {}
 
 CChainstateHelper::~CChainstateHelper() = default;
diff --git a/src/evo/chainhelper.h b/src/evo/chainhelper.h
@@ -20,14 +20,16 @@ namespace Consensus { struct Params; }
 namespace llmq {
 class CChainLocksHandler;
 class CQuorumBlockProcessor;
+class CQuorumManager;
 }
 
 class CChainstateHelper
 {
 public:
     explicit CChainstateHelper(CCreditPoolManager& cpoolman, CDeterministicMNManager& dmnman, CMNHFManager& mnhfman, CGovernanceManager& govman,
                                llmq::CQuorumBlockProcessor& qblockman, const Consensus::Params& consensus_params,
-                               const CMasternodeSync& mn_sync, const CSporkManager& sporkman, const llmq::CChainLocksHandler& clhandler);
+                               const CMasternodeSync& mn_sync, const CSporkManager& sporkman, const llmq::CChainLocksHandler& clhandler,
+                               const llmq::CQuorumManager& qman);
     ~CChainstateHelper();
 
     CChainstateHelper() = delete;
diff --git a/src/evo/mnhftx.cpp b/src/evo/mnhftx.cpp
@@ -84,14 +84,14 @@ CMNHFManager::Signals CMNHFManager::GetSignalsStage(const CBlockIndex* const pin
     return signals;
 }
 
-bool MNHFTx::Verify(const uint256& quorumHash, const uint256& requestId, const uint256& msgHash, TxValidationState& state) const
+bool MNHFTx::Verify(const llmq::CQuorumManager& qman, const uint256& quorumHash, const uint256& requestId, const uint256& msgHash, TxValidationState& state) const
 {
     if (versionBit >= VERSIONBITS_NUM_BITS) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-mnhf-nbit-out-of-bounds");
     }
 
     const Consensus::LLMQType& llmqType = Params().GetConsensus().llmqTypeMnhf;
-    const auto quorum = llmq::quorumManager->GetQuorum(llmqType, quorumHash);
+    const auto quorum = qman.GetQuorum(llmqType, quorumHash);
 
     const uint256 signHash = llmq::BuildSignHash(llmqType, quorum->qc->quorumHash, requestId, msgHash);
     if (!sig.VerifyInsecure(quorum->qc->quorumPublicKey, signHash)) {
@@ -101,7 +101,7 @@ bool MNHFTx::Verify(const uint256& quorumHash, const uint256& requestId, const u
     return true;
 }
 
-bool CheckMNHFTx(const CTransaction& tx, const CBlockIndex* pindexPrev, TxValidationState& state)
+bool CheckMNHFTx(const llmq::CQuorumManager& qman, const CTransaction& tx, const CBlockIndex* pindexPrev, TxValidationState& state)
 {
     if (!tx.IsSpecialTxVersion() || tx.nType != TRANSACTION_MNHF_SIGNAL) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-mnhf-type");
@@ -134,7 +134,7 @@ bool CheckMNHFTx(const CTransaction& tx, const CBlockIndex* pindexPrev, TxValida
     uint256 msgHash = tx_copy.GetHash();
 
 
-    if (!mnhfTx.signal.Verify(mnhfTx.signal.quorumHash, mnhfTx.GetRequestId(), msgHash, state)) {
+    if (!mnhfTx.signal.Verify(qman, mnhfTx.signal.quorumHash, mnhfTx.GetRequestId(), msgHash, state)) {
         // set up inside Verify
         return false;
     }
@@ -160,7 +160,7 @@ std::optional<uint8_t> extractEHFSignal(const CTransaction& tx)
     return opt_mnhfTx->signal.versionBit;
 }
 
-static bool extractSignals(const CBlock& block, const CBlockIndex* const pindex, std::vector<uint8_t>& new_signals, BlockValidationState& state)
+static bool extractSignals(const llmq::CQuorumManager& qman, const CBlock& block, const CBlockIndex* const pindex, std::vector<uint8_t>& new_signals, BlockValidationState& state)
 {
     // we skip the coinbase
     for (size_t i = 1; i < block.vtx.size(); ++i) {
@@ -172,7 +172,7 @@ static bool extractSignals(const CBlock& block, const CBlockIndex* const pindex,
         }
 
         TxValidationState tx_state;
-        if (!CheckMNHFTx(tx, pindex, tx_state)) {
+        if (!CheckMNHFTx(qman, tx, pindex, tx_state)) {
             return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(), tx_state.GetDebugMessage());
         }
 
@@ -194,7 +194,7 @@ std::optional<CMNHFManager::Signals> CMNHFManager::ProcessBlock(const CBlock& bl
 {
     try {
         std::vector<uint8_t> new_signals;
-        if (!extractSignals(block, pindex, new_signals, state)) {
+        if (!extractSignals(*Assert(llmq::quorumManager), block, pindex, new_signals, state)) {
             // state is set inside extractSignals
             return std::nullopt;
         }
@@ -246,7 +246,7 @@ bool CMNHFManager::UndoBlock(const CBlock& block, const CBlockIndex* const pinde
 {
     std::vector<uint8_t> excluded_signals;
     BlockValidationState state;
-    if (!extractSignals(block, pindex, excluded_signals, state)) {
+    if (!extractSignals(*Assert(llmq::quorumManager), block, pindex, excluded_signals, state)) {
         LogPrintf("CMNHFManager::%s: failed to extract signals\n", __func__);
         return false;
     }
diff --git a/src/evo/mnhftx.h b/src/evo/mnhftx.h
@@ -22,6 +22,9 @@ class CBlock;
 class CBlockIndex;
 class CEvoDB;
 class TxValidationState;
+namespace llmq {
+class CQuorumManager;
+}
 
 // mnhf signal special transaction
 class MNHFTx
@@ -32,7 +35,8 @@ class MNHFTx
     CBLSSignature sig{};
 
     MNHFTx() = default;
-    bool Verify(const uint256& quorumHash, const uint256& requestId, const uint256& msgHash, TxValidationState& state) const;
+    bool Verify(const llmq::CQuorumManager& qman, const uint256& quorumHash, const uint256& requestId, const uint256& msgHash,
+                TxValidationState& state) const;
 
     SERIALIZE_METHODS(MNHFTx, obj)
     {
@@ -148,6 +152,6 @@ class CMNHFManager : public AbstractEHFManager
 };
 
 std::optional<uint8_t> extractEHFSignal(const CTransaction& tx);
-bool CheckMNHFTx(const CTransaction& tx, const CBlockIndex* pindexPrev, TxValidationState& state);
+bool CheckMNHFTx(const llmq::CQuorumManager& qman, const CTransaction& tx, const CBlockIndex* pindexPrev, TxValidationState& state);
 
 #endif // BITCOIN_EVO_MNHFTX_H
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
@@ -18,7 +18,8 @@
 #include <llmq/commitment.h>
 #include <primitives/block.h>
 
-static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, const CTransaction& tx, const CBlockIndex* pindexPrev, const CCoinsViewCache& view, const std::optional<CRangesSet>& indexes, bool check_sigs, TxValidationState& state)
+static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, const llmq::CQuorumManager& qman, const CTransaction& tx, const CBlockIndex* pindexPrev,
+                                const CCoinsViewCache& view, const std::optional<CRangesSet>& indexes, bool check_sigs, TxValidationState& state)
 {
     AssertLockHeld(cs_main);
 
@@ -48,7 +49,7 @@ static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, const CTransact
             if (!DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_V20)) {
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "mnhf-before-v20");
             }
-            return CheckMNHFTx(tx, pindexPrev, state);
+            return CheckMNHFTx(qman, tx, pindexPrev, state);
         case TRANSACTION_ASSET_LOCK:
             if (!DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_V20)) {
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "assetlocks-before-v20");
@@ -75,7 +76,7 @@ static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, const CTransact
 bool CSpecialTxProcessor::CheckSpecialTx(const CTransaction& tx, const CBlockIndex* pindexPrev, const CCoinsViewCache& view, bool check_sigs, TxValidationState& state)
 {
     AssertLockHeld(cs_main);
-    return CheckSpecialTxInner(m_dmnman, tx, pindexPrev, view, std::nullopt, check_sigs, state);
+    return CheckSpecialTxInner(m_dmnman, m_qman, tx, pindexPrev, view, std::nullopt, check_sigs, state);
 }
 
 [[nodiscard]] bool CSpecialTxProcessor::ProcessSpecialTx(const CTransaction& tx, const CBlockIndex* pindex, TxValidationState& state)
@@ -154,7 +155,7 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(const CBlock& block, const CB
             TxValidationState tx_state;
             // At this moment CheckSpecialTx() and ProcessSpecialTx() may fail by 2 possible ways:
             // consensus failures and "TX_BAD_SPECIAL"
-            if (!CheckSpecialTxInner(m_dmnman, *ptr_tx, pindex->pprev, view, creditPool.indexes, fCheckCbTxMerkleRoots, tx_state)) {
+            if (!CheckSpecialTxInner(m_dmnman, m_qman, *ptr_tx, pindex->pprev, view, creditPool.indexes, fCheckCbTxMerkleRoots, tx_state)) {
                 assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS || tx_state.GetResult() == TxValidationResult::TX_BAD_SPECIAL);
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
                                  strprintf("Special Transaction check failed (tx hash %s) %s", ptr_tx->GetHash().ToString(), tx_state.GetDebugMessage()));
diff --git a/src/evo/specialtxman.h b/src/evo/specialtxman.h
@@ -24,6 +24,7 @@ struct MNListUpdates;
 namespace Consensus { struct Params; }
 namespace llmq {
 class CQuorumBlockProcessor;
+class CQuorumManager;
 class CChainLocksHandler;
 } // namespace llmq
 
@@ -38,15 +39,17 @@ class CSpecialTxProcessor
     llmq::CQuorumBlockProcessor& m_qblockman;
     const Consensus::Params& m_consensus_params;
     const llmq::CChainLocksHandler& m_clhandler;
+    const llmq::CQuorumManager& m_qman;
 
 private:
     [[nodiscard]] bool ProcessSpecialTx(const CTransaction& tx, const CBlockIndex* pindex, TxValidationState& state);
     [[nodiscard]] bool UndoSpecialTx(const CTransaction& tx, const CBlockIndex* pindex);
 
 public:
     explicit CSpecialTxProcessor(CCreditPoolManager& cpoolman, CDeterministicMNManager& dmnman, CMNHFManager& mnhfman, llmq::CQuorumBlockProcessor& qblockman,
-                                 const Consensus::Params& consensus_params, const llmq::CChainLocksHandler& clhandler) :
-        m_cpoolman(cpoolman), m_dmnman{dmnman}, m_mnhfman{mnhfman}, m_qblockman{qblockman}, m_consensus_params{consensus_params}, m_clhandler{clhandler} {}
+                                 const Consensus::Params& consensus_params, const llmq::CChainLocksHandler& clhandler, const llmq::CQuorumManager& qman) :
+        m_cpoolman(cpoolman), m_dmnman{dmnman}, m_mnhfman{mnhfman}, m_qblockman{qblockman}, m_consensus_params{consensus_params}, m_clhandler{clhandler},
+        m_qman{qman} {}
 
     bool CheckSpecialTx(const CTransaction& tx, const CBlockIndex* pindexPrev, const CCoinsViewCache& view, bool check_sigs, TxValidationState& state)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
diff --git a/src/init.cpp b/src/init.cpp
@@ -1978,7 +1978,7 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
 
                 node.chain_helper.reset();
                 node.chain_helper = std::make_unique<CChainstateHelper>(*node.cpoolman, *node.dmnman, *node.mnhf_manager, *node.govman, *(node.llmq_ctx->quorum_block_processor),
-                                                                        chainparams.GetConsensus(), *node.mn_sync, *node.sporkman, *(node.llmq_ctx->clhandler));
+                                                                        chainparams.GetConsensus(), *node.mn_sync, *node.sporkman, *(node.llmq_ctx->clhandler), *(node.llmq_ctx->qman));
 
                 if (fReset) {
                     pblocktree->WriteReindexing(true);
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
@@ -120,7 +120,7 @@ void DashTestSetup(NodeContext& node, const CChainParams& chainparams)
     node.llmq_ctx = std::make_unique<LLMQContext>(chainstate, *node.connman, *node.dmnman, *node.evodb, *node.mn_metaman, *node.mnhf_manager, *node.sporkman, *node.mempool,
                                                   /* mn_activeman = */ nullptr, *node.mn_sync, node.peerman, /* unit_tests = */ true, /* wipe = */ false);
     node.chain_helper = std::make_unique<CChainstateHelper>(*node.cpoolman, *node.dmnman, *node.mnhf_manager, *node.govman, *(node.llmq_ctx->quorum_block_processor),
-                                                            chainparams.GetConsensus(), *node.mn_sync, *node.sporkman, *(node.llmq_ctx->clhandler));
+                                                            chainparams.GetConsensus(), *node.mn_sync, *node.sporkman, *(node.llmq_ctx->clhandler), *(node.llmq_ctx->qman));
 }
 
 void DashTestSetupClose(NodeContext& node)

Original file line number	Diff line number	Diff line change
`@@ -84,14 +84,14 @@ CMNHFManager::Signals CMNHFManager::GetSignalsStage(const CBlockIndex* const pin`
`84`	`84`	`return signals;`
`85`	`85`	`}`
`86`	`86`
`87`		`-bool MNHFTx::Verify(const uint256& quorumHash, const uint256& requestId, const uint256& msgHash, TxValidationState& state) const`
	`87`	`+bool MNHFTx::Verify(const llmq::CQuorumManager& qman, const uint256& quorumHash, const uint256& requestId, const uint256& msgHash, TxValidationState& state) const`
`88`	`88`	`{`
`89`	`89`	`if (versionBit >= VERSIONBITS_NUM_BITS) {`
`90`	`90`	`return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-mnhf-nbit-out-of-bounds");`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`const Consensus::LLMQType& llmqType = Params().GetConsensus().llmqTypeMnhf;`
`94`		`- const auto quorum = llmq::quorumManager->GetQuorum(llmqType, quorumHash);`
	`94`	`+ const auto quorum = qman.GetQuorum(llmqType, quorumHash);`
`95`	`95`
`96`	`96`	`const uint256 signHash = llmq::BuildSignHash(llmqType, quorum->qc->quorumHash, requestId, msgHash);`
`97`	`97`	`if (!sig.VerifyInsecure(quorum->qc->quorumPublicKey, signHash)) {`
`@@ -101,7 +101,7 @@ bool MNHFTx::Verify(const uint256& quorumHash, const uint256& requestId, const u`
`101`	`101`	`return true;`
`102`	`102`	`}`
`103`	`103`
`104`		`-bool CheckMNHFTx(const CTransaction& tx, const CBlockIndex* pindexPrev, TxValidationState& state)`
	`104`	`+bool CheckMNHFTx(const llmq::CQuorumManager& qman, const CTransaction& tx, const CBlockIndex* pindexPrev, TxValidationState& state)`
`105`	`105`	`{`
`106`	`106`	`if (!tx.IsSpecialTxVersion() \|\| tx.nType != TRANSACTION_MNHF_SIGNAL) {`
`107`	`107`	`return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-mnhf-type");`
`@@ -134,7 +134,7 @@ bool CheckMNHFTx(const CTransaction& tx, const CBlockIndex* pindexPrev, TxValida`
`134`	`134`	`uint256 msgHash = tx_copy.GetHash();`
`135`	`135`
`136`	`136`
`137`		`- if (!mnhfTx.signal.Verify(mnhfTx.signal.quorumHash, mnhfTx.GetRequestId(), msgHash, state)) {`
	`137`	`+ if (!mnhfTx.signal.Verify(qman, mnhfTx.signal.quorumHash, mnhfTx.GetRequestId(), msgHash, state)) {`
`138`	`138`	`// set up inside Verify`
`139`	`139`	`return false;`
`140`	`140`	`}`
`@@ -160,7 +160,7 @@ std::optional<uint8_t> extractEHFSignal(const CTransaction& tx)`
`160`	`160`	`return opt_mnhfTx->signal.versionBit;`
`161`	`161`	`}`
`162`	`162`
`163`		`-static bool extractSignals(const CBlock& block, const CBlockIndex* const pindex, std::vector<uint8_t>& new_signals, BlockValidationState& state)`
	`163`	`+static bool extractSignals(const llmq::CQuorumManager& qman, const CBlock& block, const CBlockIndex* const pindex, std::vector<uint8_t>& new_signals, BlockValidationState& state)`
`164`	`164`	`{`
`165`	`165`	`// we skip the coinbase`
`166`	`166`	`for (size_t i = 1; i < block.vtx.size(); ++i) {`
`@@ -172,7 +172,7 @@ static bool extractSignals(const CBlock& block, const CBlockIndex* const pindex,`
`172`	`172`	`}`
`173`	`173`
`174`	`174`	`TxValidationState tx_state;`
`175`		`- if (!CheckMNHFTx(tx, pindex, tx_state)) {`
	`175`	`+ if (!CheckMNHFTx(qman, tx, pindex, tx_state)) {`
`176`	`176`	`return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(), tx_state.GetDebugMessage());`
`177`	`177`	`}`
`178`	`178`
`@@ -194,7 +194,7 @@ std::optional<CMNHFManager::Signals> CMNHFManager::ProcessBlock(const CBlock& bl`
`194`	`194`	`{`
`195`	`195`	`try {`
`196`	`196`	`std::vector<uint8_t> new_signals;`
`197`		`- if (!extractSignals(block, pindex, new_signals, state)) {`
	`197`	`+ if (!extractSignals(*Assert(llmq::quorumManager), block, pindex, new_signals, state)) {`
`198`	`198`	`// state is set inside extractSignals`
`199`	`199`	`return std::nullopt;`
`200`	`200`	`}`
`@@ -246,7 +246,7 @@ bool CMNHFManager::UndoBlock(const CBlock& block, const CBlockIndex* const pinde`
`246`	`246`	`{`
`247`	`247`	`std::vector<uint8_t> excluded_signals;`
`248`	`248`	`BlockValidationState state;`
`249`		`- if (!extractSignals(block, pindex, excluded_signals, state)) {`
	`249`	`+ if (!extractSignals(*Assert(llmq::quorumManager), block, pindex, excluded_signals, state)) {`
`250`	`250`	`LogPrintf("CMNHFManager::%s: failed to extract signals\n", __func__);`
`251`	`251`	`return false;`
`252`	`252`	`}`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ void DashTestSetup(NodeContext& node, const CChainParams& chainparams)`
`120`	`120`	`node.llmq_ctx = std::make_unique<LLMQContext>(chainstate, node.connman, node.dmnman, node.evodb, node.mn_metaman, node.mnhf_manager, node.sporkman, *node.mempool,`
`121`	`121`	`/* mn_activeman = / nullptr, node.mn_sync, node.peerman, /* unit_tests = / true, / wipe = */ false);`
`122`	`122`	`node.chain_helper = std::make_unique<CChainstateHelper>(node.cpoolman, node.dmnman, node.mnhf_manager, node.govman, *(node.llmq_ctx->quorum_block_processor),`
`123`		`- chainparams.GetConsensus(), node.mn_sync, node.sporkman, *(node.llmq_ctx->clhandler));`
	`123`	`+ chainparams.GetConsensus(), node.mn_sync, node.sporkman, (node.llmq_ctx->clhandler), (node.llmq_ctx->qman));`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`void DashTestSetupClose(NodeContext& node)`