From 68442e8dfe0854102c7e412c2f50a505dc1714bf Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Mon, 4 Dec 2023 15:03:51 +0700
Subject: [PATCH 01/34] chore: add TODO for llmq/utils.h refactoring

---
 src/llmq/utils.cpp |  1 +
 src/llmq/utils.h   | 15 +++++++++++++++
 2 files changed, 16 insertions(+)

diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index 60522a51b8..e40bc91fa5 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -25,6 +25,7 @@
 #include <atomic>
 #include <optional>
 
+// TODO remove this const
 static constexpr int TESTNET_LLMQ_25_67_ACTIVATION_HEIGHT = 847000;
 
 /**
diff --git a/src/llmq/utils.h b/src/llmq/utils.h
index 188b917336..7093f25485 100644
--- a/src/llmq/utils.h
+++ b/src/llmq/utils.h
@@ -52,7 +52,9 @@ uint256 GetHashModifier(const Consensus::LLMQParams& llmqParams, gsl::not_null<c
 uint256 BuildCommitmentHash(Consensus::LLMQType llmqType, const uint256& blockHash, const std::vector<bool>& validMembers, const CBLSPublicKey& pubKey, const uint256& vvecHash);
 uint256 BuildSignHash(Consensus::LLMQType llmqType, const uint256& quorumHash, const uint256& id, const uint256& msgHash);
 
+// TODO options
 bool IsAllMembersConnectedEnabled(Consensus::LLMQType llmqType);
+// TODO options
 bool IsQuorumPoseEnabled(Consensus::LLMQType llmqType);
 uint256 DeterministicOutboundConnection(const uint256& proTxHash1, const uint256& proTxHash2);
 std::set<uint256> GetQuorumConnections(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound);
@@ -63,23 +65,36 @@ bool EnsureQuorumConnections(const Consensus::LLMQParams& llmqParams, gsl::not_n
 void AddQuorumProbeConnections(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, CConnman& connman, const uint256& myProTxHash);
 
 bool IsQuorumActive(Consensus::LLMQType llmqType, const CQuorumManager& qman, const uint256& quorumHash);
+// TODO options maybe not
 bool IsQuorumTypeEnabled(Consensus::LLMQType llmqType, const CQuorumManager& qman, gsl::not_null<const CBlockIndex*> pindex);
+// TODO options maybe not
 bool IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CQuorumManager& qman, gsl::not_null<const CBlockIndex*> pindex, std::optional<bool> optDIP0024IsActive, std::optional<bool> optHaveDIP0024Quorums);
 
+// TODO options maybe not
 std::vector<Consensus::LLMQType> GetEnabledQuorumTypes(gsl::not_null<const CBlockIndex*> pindex);
+// TODO options maybe not
 std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuorumParams(gsl::not_null<const CBlockIndex*> pindex);
 
+// TODO options
 bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pindex);
+// TODO deployments
 bool IsDIP0024Active(gsl::not_null<const CBlockIndex*> pindex);
+// TODO deployments
 bool IsV19Active(gsl::not_null<const CBlockIndex*> pindex);
+// TODO deployments
 bool IsV20Active(gsl::not_null<const CBlockIndex*> pindex);
+// TODO deployments
 bool IsMNRewardReallocationActive(gsl::not_null<const CBlockIndex*> pindex);
+// TODO deployments
 ThresholdState GetV20State(gsl::not_null<const CBlockIndex*> pindex);
+// TODO deployments
 int GetV20Since(gsl::not_null<const CBlockIndex*> pindex);
 
 /// Returns the state of `-llmq-data-recovery`
+// TODO options
 bool QuorumDataRecoveryEnabled();
 
+// TODO options
 /// Returns the state of `-watchquorums`
 bool IsWatchQuorumsEnabled();
 

From a7ad399824b5344922312637857a371b9abeeb4d Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Mon, 4 Dec 2023 15:40:01 +0700
Subject: [PATCH 02/34] refactor: drop IsDIP0024Active and its usage of
 llmq_vbc

---
 src/llmq/utils.cpp | 25 ++++++++++---------------
 src/llmq/utils.h   |  6 ++----
 2 files changed, 12 insertions(+), 19 deletions(-)

diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index e40bc91fa5..62caee6940 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -9,6 +9,7 @@
 
 #include <bls/bls.h>
 #include <chainparams.h>
+#include <deploymentstatus.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
 #include <masternode/meta.h>
@@ -678,12 +679,7 @@ bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_n
         return false;
     }
     // It should activate at least 1 block prior to the cycle start
-    return IsDIP0024Active(pindex->GetAncestor(cycleQuorumBaseHeight - 1));
-}
-
-bool IsDIP0024Active(gsl::not_null<const CBlockIndex*> pindex)
-{
-    return pindex->nHeight + 1 >= Params().GetConsensus().DIP0024Height;
+    return DeploymentActiveAfter(pindex->GetAncestor(cycleQuorumBaseHeight - 1), Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024);
 }
 
 bool IsV19Active(gsl::not_null<const CBlockIndex*> pindex)
@@ -942,16 +938,17 @@ bool IsQuorumActive(Consensus::LLMQType llmqType, const CQuorumManager& qman, co
     return ranges::any_of(quorums, [&quorumHash](const auto& q){ return q->qc->quorumHash == quorumHash; });
 }
 
-bool IsQuorumTypeEnabled(Consensus::LLMQType llmqType, const CQuorumManager& qman, gsl::not_null<const CBlockIndex*> pindex)
+bool IsQuorumTypeEnabled(Consensus::LLMQType llmqType, const CQuorumManager& qman, gsl::not_null<const CBlockIndex*> pindexPrev)
 {
-    return IsQuorumTypeEnabledInternal(llmqType, qman, pindex, std::nullopt, std::nullopt);
+    return IsQuorumTypeEnabledInternal(llmqType, qman, pindexPrev, std::nullopt, std::nullopt);
 }
 
-bool IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CQuorumManager& qman, gsl::not_null<const CBlockIndex*> pindex,
+bool IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CQuorumManager& qman, gsl::not_null<const CBlockIndex*> pindexPrev,
                                 std::optional<bool> optDIP0024IsActive, std::optional<bool> optHaveDIP0024Quorums)
 {
     const Consensus::Params& consensusParams = Params().GetConsensus();
 
+    bool fDIP0024IsActive = optDIP0024IsActive.has_value() ? *optDIP0024IsActive : DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_DIP0024);
     switch (llmqType)
     {
         case Consensus::LLMQType::LLMQ_DEVNET:
@@ -960,12 +957,11 @@ bool IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CQuorumMana
             if (Params().NetworkIDString() == CBaseChainParams::TESTNET) return true;
             // fall through
         case Consensus::LLMQType::LLMQ_TEST_INSTANTSEND: {
-            bool fDIP0024IsActive = optDIP0024IsActive.has_value() ? *optDIP0024IsActive : IsDIP0024Active(pindex);
             if (!fDIP0024IsActive) return true;
 
             bool fHaveDIP0024Quorums = optHaveDIP0024Quorums.has_value() ? *optHaveDIP0024Quorums
                                                                          : !qman.ScanQuorums(
-                            consensusParams.llmqTypeDIP0024InstantSend, pindex, 1).empty();
+                            consensusParams.llmqTypeDIP0024InstantSend, pindexPrev, 1).empty();
             return !fHaveDIP0024Quorums;
         }
         case Consensus::LLMQType::LLMQ_TEST:
@@ -976,19 +972,18 @@ bool IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CQuorumMana
             return true;
 
         case Consensus::LLMQType::LLMQ_TEST_V17: {
-            return llmq_versionbitscache.State(pindex, consensusParams, Consensus::DEPLOYMENT_TESTDUMMY) == ThresholdState::ACTIVE;
+            return llmq_versionbitscache.State(pindexPrev, consensusParams, Consensus::DEPLOYMENT_TESTDUMMY) == ThresholdState::ACTIVE;
         }
         case Consensus::LLMQType::LLMQ_100_67:
-            return pindex->nHeight + 1 >= consensusParams.DIP0020Height;
+            return pindexPrev->nHeight + 1 >= consensusParams.DIP0020Height;
 
         case Consensus::LLMQType::LLMQ_60_75:
         case Consensus::LLMQType::LLMQ_DEVNET_DIP0024:
         case Consensus::LLMQType::LLMQ_TEST_DIP0024: {
-            bool fDIP0024IsActive = optDIP0024IsActive.has_value() ? *optDIP0024IsActive : IsDIP0024Active(pindex);
             return fDIP0024IsActive;
         }
         case Consensus::LLMQType::LLMQ_25_67:
-            return pindex->nHeight >= TESTNET_LLMQ_25_67_ACTIVATION_HEIGHT;
+            return pindexPrev->nHeight >= TESTNET_LLMQ_25_67_ACTIVATION_HEIGHT;
 
         default:
             throw std::runtime_error(strprintf("%s: Unknown LLMQ type %d", __func__, ToUnderlying(llmqType)));
diff --git a/src/llmq/utils.h b/src/llmq/utils.h
index 7093f25485..83d633088e 100644
--- a/src/llmq/utils.h
+++ b/src/llmq/utils.h
@@ -66,9 +66,9 @@ void AddQuorumProbeConnections(const Consensus::LLMQParams& llmqParams, gsl::not
 
 bool IsQuorumActive(Consensus::LLMQType llmqType, const CQuorumManager& qman, const uint256& quorumHash);
 // TODO options maybe not
-bool IsQuorumTypeEnabled(Consensus::LLMQType llmqType, const CQuorumManager& qman, gsl::not_null<const CBlockIndex*> pindex);
+bool IsQuorumTypeEnabled(Consensus::LLMQType llmqType, const CQuorumManager& qman, gsl::not_null<const CBlockIndex*> pindexPrev);
 // TODO options maybe not
-bool IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CQuorumManager& qman, gsl::not_null<const CBlockIndex*> pindex, std::optional<bool> optDIP0024IsActive, std::optional<bool> optHaveDIP0024Quorums);
+bool IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CQuorumManager& qman, gsl::not_null<const CBlockIndex*> pindexPrev, std::optional<bool> optDIP0024IsActive, std::optional<bool> optHaveDIP0024Quorums);
 
 // TODO options maybe not
 std::vector<Consensus::LLMQType> GetEnabledQuorumTypes(gsl::not_null<const CBlockIndex*> pindex);
@@ -78,8 +78,6 @@ std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuoru
 // TODO options
 bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pindex);
 // TODO deployments
-bool IsDIP0024Active(gsl::not_null<const CBlockIndex*> pindex);
-// TODO deployments
 bool IsV19Active(gsl::not_null<const CBlockIndex*> pindex);
 // TODO deployments
 bool IsV20Active(gsl::not_null<const CBlockIndex*> pindex);

From c32961558432270112c4199f0c43cfe62ee49285 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Mon, 18 Dec 2023 15:17:13 +0700
Subject: [PATCH 03/34] refactor: use value_or in std::optional

---
 src/llmq/utils.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index 62caee6940..62ce2b9d63 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -948,7 +948,7 @@ bool IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CQuorumMana
 {
     const Consensus::Params& consensusParams = Params().GetConsensus();
 
-    bool fDIP0024IsActive = optDIP0024IsActive.has_value() ? *optDIP0024IsActive : DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_DIP0024);
+    const bool fDIP0024IsActive{optDIP0024IsActive.value_or(DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_DIP0024))};
     switch (llmqType)
     {
         case Consensus::LLMQType::LLMQ_DEVNET:
@@ -959,9 +959,8 @@ bool IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CQuorumMana
         case Consensus::LLMQType::LLMQ_TEST_INSTANTSEND: {
             if (!fDIP0024IsActive) return true;
 
-            bool fHaveDIP0024Quorums = optHaveDIP0024Quorums.has_value() ? *optHaveDIP0024Quorums
-                                                                         : !qman.ScanQuorums(
-                            consensusParams.llmqTypeDIP0024InstantSend, pindexPrev, 1).empty();
+            const bool fHaveDIP0024Quorums{optHaveDIP0024Quorums.value_or(!qman.ScanQuorums(
+                            consensusParams.llmqTypeDIP0024InstantSend, pindexPrev, 1).empty())};
             return !fHaveDIP0024Quorums;
         }
         case Consensus::LLMQType::LLMQ_TEST:

From 8f3d3db9a4c2e08e25ab62281d7736aaffed417f Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Mon, 4 Dec 2023 15:48:21 +0700
Subject: [PATCH 04/34] refactor: drop dependency governance/classes on
 llmq/utils

---
 src/governance/classes.cpp |  6 +++---
 src/llmq/utils.cpp         | 10 ----------
 src/llmq/utils.h           |  4 ----
 3 files changed, 3 insertions(+), 17 deletions(-)

diff --git a/src/governance/classes.cpp b/src/governance/classes.cpp
index b8fe9b4b08..6ee0c2b7f7 100644
--- a/src/governance/classes.cpp
+++ b/src/governance/classes.cpp
@@ -7,9 +7,9 @@
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <core_io.h>
+#include <deploymentstatus.h>
 #include <governance/governance.h>
 #include <key_io.h>
-#include <llmq/utils.h>
 #include <primitives/transaction.h>
 #include <script/standard.h>
 #include <util/moneystr.h>
@@ -496,13 +496,13 @@ CAmount CSuperblock::GetPaymentsLimit(int nBlockHeight)
     const CBlockIndex* pindex = ::ChainActive().Tip();
     if (pindex->nHeight > nBlockHeight) pindex = pindex->GetAncestor(nBlockHeight);
 
-    const auto v20_state = llmq::utils::GetV20State(pindex);
+    const auto v20_state = g_versionbitscache.State(pindex, consensusParams, Consensus::DEPLOYMENT_V20);
     bool fV20Active{v20_state == ThresholdState::ACTIVE};
     if (!fV20Active && nBlockHeight > pindex->nHeight) {
         // If fV20Active isn't active yet and nBlockHeight refers to a future SuperBlock
         // then we need to check if the fork is locked_in and see if it will be active by the time of the future SuperBlock
         if (v20_state == ThresholdState::LOCKED_IN) {
-            int activation_height = llmq::utils::GetV20Since(pindex) + static_cast<int>(Params().GetConsensus().vDeployments[Consensus::DEPLOYMENT_V20].nWindowSize);
+            int activation_height = g_versionbitscache.StateSinceHeight(pindex, consensusParams, Consensus::DEPLOYMENT_V20) + static_cast<int>(Params().GetConsensus().vDeployments[Consensus::DEPLOYMENT_V20].nWindowSize);
             if (nBlockHeight >= activation_height) {
                 fV20Active = true;
             }
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index 62ce2b9d63..e45fb687ec 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -699,16 +699,6 @@ bool IsMNRewardReallocationActive(gsl::not_null<const CBlockIndex*> pindex)
     return llmq_versionbitscache.State(pindex, Params().GetConsensus(), Consensus::DEPLOYMENT_MN_RR) == ThresholdState::ACTIVE;
 }
 
-ThresholdState GetV20State(gsl::not_null<const CBlockIndex*> pindex)
-{
-    return llmq_versionbitscache.State(pindex, Params().GetConsensus(), Consensus::DEPLOYMENT_V20);
-}
-
-int GetV20Since(gsl::not_null<const CBlockIndex*> pindex)
-{
-    return llmq_versionbitscache.StateSinceHeight(pindex, Params().GetConsensus(), Consensus::DEPLOYMENT_V20);
-}
-
 uint256 DeterministicOutboundConnection(const uint256& proTxHash1, const uint256& proTxHash2)
 {
     // We need to deterministically select who is going to initiate the connection. The naive way would be to simply
diff --git a/src/llmq/utils.h b/src/llmq/utils.h
index 83d633088e..719eae085d 100644
--- a/src/llmq/utils.h
+++ b/src/llmq/utils.h
@@ -83,10 +83,6 @@ bool IsV19Active(gsl::not_null<const CBlockIndex*> pindex);
 bool IsV20Active(gsl::not_null<const CBlockIndex*> pindex);
 // TODO deployments
 bool IsMNRewardReallocationActive(gsl::not_null<const CBlockIndex*> pindex);
-// TODO deployments
-ThresholdState GetV20State(gsl::not_null<const CBlockIndex*> pindex);
-// TODO deployments
-int GetV20Since(gsl::not_null<const CBlockIndex*> pindex);
 
 /// Returns the state of `-llmq-data-recovery`
 // TODO options

From c25d336e956b2fe003ff71ca2503c1338c9da843 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Mon, 4 Dec 2023 15:56:43 +0700
Subject: [PATCH 05/34] refactor: drop dependency masternode/payments on
 llmq/utils

---
 src/masternode/payments.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/masternode/payments.cpp b/src/masternode/payments.cpp
index 8f5797950c..78d73b191d 100644
--- a/src/masternode/payments.cpp
+++ b/src/masternode/payments.cpp
@@ -7,12 +7,12 @@
 #include <amount.h>
 #include <chain.h>
 #include <chainparams.h>
+#include <deploymentstatus.h>
 #include <evo/deterministicmns.h>
 #include <governance/classes.h>
 #include <governance/governance.h>
 #include <key_io.h>
 #include <logging.h>
-#include <llmq/utils.h>
 #include <masternode/sync.h>
 #include <primitives/block.h>
 #include <script/standard.h>
@@ -29,11 +29,12 @@
     voutMasternodePaymentsRet.clear();
 
     const int nBlockHeight = pindexPrev  == nullptr ? 0 : pindexPrev->nHeight + 1;
+    const Consensus::Params& consensusParams = Params().GetConsensus();
 
-    bool fV20Active =  llmq::utils::IsV20Active(pindexPrev);
+    bool fV20Active = DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_V20);
     CAmount masternodeReward = GetMasternodePayment(nBlockHeight, blockSubsidy + feeReward, fV20Active);
 
-    if (llmq::utils::IsMNRewardReallocationActive(pindexPrev)) {
+    if (DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_MN_RR)) {
         CAmount masternodeSubsidyReward = GetMasternodePayment(nBlockHeight, blockSubsidy, fV20Active);
         const CAmount platformReward = MasternodePayments::PlatformShare(masternodeSubsidyReward);
         masternodeReward -= platformReward;

From f3d2f2da2683e0d2f51ee91fe59949d1a3437dcd Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Mon, 4 Dec 2023 16:09:23 +0700
Subject: [PATCH 06/34] refactor: drop dependency unit test
 block_reward_reallocation_tests on llmq/utils

---
 src/test/block_reward_reallocation_tests.cpp | 22 ++++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/test/block_reward_reallocation_tests.cpp b/src/test/block_reward_reallocation_tests.cpp
index 0b1a968613..95c7d47e73 100644
--- a/src/test/block_reward_reallocation_tests.cpp
+++ b/src/test/block_reward_reallocation_tests.cpp
@@ -7,6 +7,7 @@
 #include <bls/bls.h>
 #include <chainparams.h>
 #include <consensus/validation.h>
+#include <deploymentstatus.h>
 #include <messagesigner.h>
 #include <miner.h>
 #include <netbase.h>
@@ -26,7 +27,6 @@
 #include <llmq/chainlocks.h>
 #include <llmq/context.h>
 #include <llmq/instantsend.h>
-#include <llmq/utils.h>
 #include <masternode/payments.h>
 #include <util/enumerate.h>
 #include <util/irange.h>
@@ -206,7 +206,7 @@ BOOST_FIXTURE_TEST_CASE(block_reward_reallocation, TestChainBRRBeforeActivationS
         // next block should be signaling by default
         LOCK(cs_main);
         const CBlockIndex* const tip{m_node.chainman->ActiveChain().Tip()};
-        const bool isV20Active{llmq::utils::IsV20Active(tip)};
+        const bool isV20Active{DeploymentActiveAfter(tip, consensus_params, Consensus::DEPLOYMENT_V20)};
         deterministicMNManager->UpdatedBlockTip(tip);
         BOOST_ASSERT(deterministicMNManager->GetListAtChainTip().HasMN(tx.GetHash()));
         const CAmount block_subsidy = GetBlockSubsidyInner(tip->nBits, tip->nHeight, consensus_params, isV20Active);
@@ -222,7 +222,7 @@ BOOST_FIXTURE_TEST_CASE(block_reward_reallocation, TestChainBRRBeforeActivationS
     {
         LOCK(cs_main);
         const CBlockIndex* const tip{m_node.chainman->ActiveChain().Tip()};
-        const bool isV20Active{llmq::utils::IsV20Active(tip)};
+        const bool isV20Active{DeploymentActiveAfter(tip, consensus_params, Consensus::DEPLOYMENT_V20)};
         const CAmount block_subsidy = GetBlockSubsidyInner(tip->nBits, tip->nHeight, consensus_params, isV20Active);
         const CAmount masternode_payment = GetMasternodePayment(tip->nHeight, block_subsidy, isV20Active);
         const auto pblocktemplate = BlockAssembler(*sporkManager, *governance, *m_node.llmq_ctx, *m_node.evodb, m_node.chainman->ActiveChainstate(), *m_node.mempool, Params()).CreateNewBlock(coinbasePubKey);
@@ -240,20 +240,20 @@ BOOST_FIXTURE_TEST_CASE(block_reward_reallocation, TestChainBRRBeforeActivationS
             }
             LOCK(cs_main);
             const CBlockIndex* const tip{m_node.chainman->ActiveChain().Tip()};
-            const bool isV20Active{llmq::utils::IsV20Active(tip)};
+            const bool isV20Active{DeploymentActiveAfter(tip, consensus_params, Consensus::DEPLOYMENT_V20)};
             const CAmount block_subsidy = GetBlockSubsidyInner(tip->nBits, tip->nHeight, consensus_params, isV20Active);
             const CAmount masternode_payment = GetMasternodePayment(tip->nHeight, block_subsidy, isV20Active);
             const auto pblocktemplate = BlockAssembler(*sporkManager, *governance, *m_node.llmq_ctx, *m_node.evodb, m_node.chainman->ActiveChainstate(), *m_node.mempool, Params()).CreateNewBlock(coinbasePubKey);
             BOOST_CHECK_EQUAL(pblocktemplate->voutMasternodePayments[0].nValue, masternode_payment);
         }
     }
-    BOOST_CHECK(llmq::utils::IsV20Active(m_node.chainman->ActiveChain().Tip()));
+    BOOST_CHECK(DeploymentActiveAfter(m_node.chainman->ActiveChain().Tip(), consensus_params, Consensus::DEPLOYMENT_V20));
     // Allocation of block subsidy is 60% MN, 20% miners and 20% treasury
     {
         // Reward split should reach ~75/25 after reallocation is done
         LOCK(cs_main);
         const CBlockIndex* const tip{m_node.chainman->ActiveChain().Tip()};
-        const bool isV20Active{llmq::utils::IsV20Active(tip)};
+        const bool isV20Active{DeploymentActiveAfter(tip, consensus_params, Consensus::DEPLOYMENT_V20)};
         const CAmount block_subsidy = GetBlockSubsidyInner(tip->nBits, tip->nHeight, consensus_params, isV20Active);
         const CAmount block_subsidy_sb = GetSuperblockSubsidyInner(tip->nBits, tip->nHeight, consensus_params, isV20Active);
         CAmount block_subsidy_potential = block_subsidy + block_subsidy_sb;
@@ -267,7 +267,7 @@ BOOST_FIXTURE_TEST_CASE(block_reward_reallocation, TestChainBRRBeforeActivationS
         BOOST_CHECK_EQUAL(pblocktemplate->voutMasternodePayments[0].nValue, masternode_payment);
         BOOST_CHECK_EQUAL(pblocktemplate->voutMasternodePayments[0].nValue, 50662764); // 0.75
     }
-    BOOST_CHECK(!llmq::utils::IsMNRewardReallocationActive(m_node.chainman->ActiveChain().Tip()));
+    BOOST_CHECK(!DeploymentActiveAfter(m_node.chainman->ActiveChain().Tip(), consensus_params, Consensus::DEPLOYMENT_MN_RR));
 
     // Activate EHF "MN_RR"
     {
@@ -283,8 +283,8 @@ BOOST_FIXTURE_TEST_CASE(block_reward_reallocation, TestChainBRRBeforeActivationS
         }
         LOCK(cs_main);
         const CBlockIndex* const tip{m_node.chainman->ActiveChain().Tip()};
-        const bool isV20Active{llmq::utils::IsV20Active(tip)};
-        const bool isMNRewardReallocated{llmq::utils::IsMNRewardReallocationActive(tip)};
+        const bool isV20Active{DeploymentActiveAfter(tip, consensus_params, Consensus::DEPLOYMENT_V20)};
+        const bool isMNRewardReallocated{DeploymentActiveAfter(tip, consensus_params, Consensus::DEPLOYMENT_MN_RR)};
         const CAmount block_subsidy = GetBlockSubsidyInner(tip->nBits, tip->nHeight, consensus_params, isV20Active);
         CAmount masternode_payment = GetMasternodePayment(tip->nHeight, block_subsidy, isV20Active);
         const auto pblocktemplate = BlockAssembler(*sporkManager, *governance, *m_node.llmq_ctx, *m_node.evodb, m_node.chainman->ActiveChainstate(), *m_node.mempool, Params()).CreateNewBlock(coinbasePubKey);
@@ -298,12 +298,12 @@ BOOST_FIXTURE_TEST_CASE(block_reward_reallocation, TestChainBRRBeforeActivationS
         BOOST_CHECK_EQUAL(pblocktemplate->voutMasternodePayments[payment_index].nValue, masternode_payment);
     }
 
-    BOOST_CHECK(llmq::utils::IsMNRewardReallocationActive(m_node.chainman->ActiveChain().Tip()));
+    BOOST_CHECK(DeploymentActiveAfter(m_node.chainman->ActiveChain().Tip(), consensus_params, Consensus::DEPLOYMENT_MN_RR));
     { // At this moment Masternode reward should be reallocated to platform
         // Allocation of block subsidy is 60% MN, 20% miners and 20% treasury
         LOCK(cs_main);
         const CBlockIndex* const tip{m_node.chainman->ActiveChain().Tip()};
-        const bool isV20Active{llmq::utils::IsV20Active(tip)};
+        const bool isV20Active{DeploymentActiveAfter(tip, consensus_params, Consensus::DEPLOYMENT_V20)};
         const CAmount block_subsidy = GetBlockSubsidyInner(tip->nBits, tip->nHeight, consensus_params, isV20Active);
         const CAmount block_subsidy_sb = GetSuperblockSubsidyInner(tip->nBits, tip->nHeight, consensus_params, isV20Active);
         CAmount masternode_payment = GetMasternodePayment(tip->nHeight, block_subsidy, isV20Active);

From bacaa805ea33829ded4f380fe41bd6936d9d7cd3 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Mon, 4 Dec 2023 16:52:09 +0700
Subject: [PATCH 07/34] fix: use proper pindex/pindex->pprev in credit pool
 code during v20/mn_rr activations

---
 src/evo/creditpool.cpp   | 12 ++++++------
 src/evo/creditpool.h     |  4 ++--
 src/evo/specialtxman.cpp |  3 ++-
 3 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index 517adf5f9b..7731b1e418 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -218,16 +218,16 @@ CCreditPoolManager::CCreditPoolManager(CEvoDB& _evoDb)
 {
 }
 
-CCreditPoolDiff::CCreditPoolDiff(CCreditPool starter, const CBlockIndex *pindex, const Consensus::Params& consensusParams, const CAmount blockSubsidy) :
+CCreditPoolDiff::CCreditPoolDiff(CCreditPool starter, const CBlockIndex *pindexPrev, const Consensus::Params& consensusParams, const CAmount blockSubsidy) :
     pool(std::move(starter)),
-    pindex(pindex),
+    pindexPrev(pindexPrev),
     params(consensusParams)
 {
-    assert(pindex);
+    assert(pindexPrev);
 
-    if (llmq::utils::IsMNRewardReallocationActive(pindex)) {
+    if (llmq::utils::IsMNRewardReallocationActive(pindexPrev)) {
         // We consider V20 active if mn_rr is active
-        platformReward = MasternodePayments::PlatformShare(GetMasternodePayment(pindex->nHeight, blockSubsidy, /*fV20Active=*/ true));
+        platformReward = MasternodePayments::PlatformShare(GetMasternodePayment(pindexPrev->nHeight + 1, blockSubsidy, /*fV20Active=*/ true));
     }
 }
 
@@ -274,7 +274,7 @@ bool CCreditPoolDiff::ProcessLockUnlockTransaction(const CTransaction& tx, TxVal
     if (tx.nVersion != 3) return true;
     if (tx.nType != TRANSACTION_ASSET_LOCK && tx.nType != TRANSACTION_ASSET_UNLOCK) return true;
 
-    if (!CheckAssetLockUnlockTx(tx, pindex, pool.indexes, state)) {
+    if (!CheckAssetLockUnlockTx(tx, pindexPrev, pool.indexes, state)) {
         // pass the state returned by the function above
         return false;
     }
diff --git a/src/evo/creditpool.h b/src/evo/creditpool.h
index 0b3b5f31b6..eb122e4ebe 100644
--- a/src/evo/creditpool.h
+++ b/src/evo/creditpool.h
@@ -70,10 +70,10 @@ private:
     CAmount sessionUnlocked{0};
     CAmount platformReward{0};
 
-    const CBlockIndex *pindex{nullptr};
+    const CBlockIndex *pindexPrev{nullptr};
     const Consensus::Params& params;
 public:
-    explicit CCreditPoolDiff(CCreditPool starter, const CBlockIndex *pindex,
+    explicit CCreditPoolDiff(CCreditPool starter, const CBlockIndex *pindexPrev,
                              const Consensus::Params& consensusParams,
                              const CAmount blockSubsidy);
 
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 0108cc131b..ca93542204 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -6,6 +6,7 @@
 
 #include <chainparams.h>
 #include <consensus/validation.h>
+#include <deploymentstatus.h>
 #include <evo/cbtx.h>
 #include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
@@ -276,7 +277,7 @@ bool CheckCreditPoolDiffForBlock(const CBlock& block, const CBlockIndex* pindex,
                                 const CAmount blockSubsidy, BlockValidationState& state)
 {
     try {
-        if (!llmq::utils::IsV20Active(pindex)) return true;
+        if (!DeploymentActiveAt(*pindex, consensusParams, Consensus::DEPLOYMENT_V20)) return true;
 
         auto creditPoolDiff = GetCreditPoolDiffForBlock(block, pindex->pprev, consensusParams, blockSubsidy, state);
         if (!creditPoolDiff.has_value()) return false;

From e94f5753c9b63bffe8f159a24c7dcccda7e74bbe Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Mon, 4 Dec 2023 17:01:20 +0700
Subject: [PATCH 08/34] refactor: drop dependency of specialtxman on llmq/utils

---
 src/evo/specialtxman.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index ca93542204..2e1f694f7e 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -16,7 +16,6 @@
 #include <hash.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
-#include <llmq/utils.h>
 #include <primitives/block.h>
 #include <validation.h>
 
@@ -27,7 +26,8 @@ static bool CheckSpecialTxInner(const CTransaction& tx, const CBlockIndex* pinde
     if (tx.nVersion != 3 || tx.nType == TRANSACTION_NORMAL)
         return true;
 
-    if (pindexPrev && pindexPrev->nHeight + 1 < Params().GetConsensus().DIP0003Height) {
+    const auto& consensusParams = Params().GetConsensus();
+    if (!DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_DIP0003)) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-tx-type");
     }
 
@@ -46,21 +46,21 @@ static bool CheckSpecialTxInner(const CTransaction& tx, const CBlockIndex* pinde
         case TRANSACTION_QUORUM_COMMITMENT:
             return llmq::CheckLLMQCommitment(tx, pindexPrev, state);
         case TRANSACTION_MNHF_SIGNAL:
-            if (!llmq::utils::IsV20Active(pindexPrev)) {
+            if (!DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_V20)) {
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "mnhf-before-v20");
             }
             return CheckMNHFTx(tx, pindexPrev, state);
         case TRANSACTION_ASSET_LOCK:
-            if (!llmq::utils::IsV20Active(pindexPrev)) {
+            if (!DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_V20)) {
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "assetlocks-before-v20");
             }
             return CheckAssetLockUnlockTx(tx, pindexPrev, indexes, state);
         case TRANSACTION_ASSET_UNLOCK:
-            if (Params().NetworkIDString() == CBaseChainParams::REGTEST && !llmq::utils::IsV20Active(pindexPrev)) {
+            if (Params().NetworkIDString() == CBaseChainParams::REGTEST && !DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_V20)) {
                 // TODO:  adjust functional tests to make it activated by MN_RR on regtest too
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "assetunlocks-before-v20");
             }
-            if (Params().NetworkIDString() != CBaseChainParams::REGTEST && !llmq::utils::IsMNRewardReallocationActive(pindexPrev)) {
+            if (Params().NetworkIDString() != CBaseChainParams::REGTEST && !DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_MN_RR)) {
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "assetunlocks-before-mn_rr");
             }
             return CheckAssetLockUnlockTx(tx, pindexPrev, indexes, state);
@@ -149,7 +149,7 @@ bool ProcessSpecialTxsInBlock(const CBlock& block, const CBlockIndex* pindex, CM
         int64_t nTime1 = GetTimeMicros();
 
         const CCreditPool creditPool = creditPoolManager->GetCreditPool(pindex->pprev, consensusParams);
-        if (llmq::utils::IsV20Active(pindex->pprev)) {
+        if (DeploymentActiveAt(*pindex, consensusParams, Consensus::DEPLOYMENT_V20)) {
             LogPrint(BCLog::CREDITPOOL, "%s: CCreditPool is %s\n", __func__, creditPool.ToString());
         }
 

From 82c01ea6644b5932b519945e375787ad13102cfd Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Mon, 4 Dec 2023 17:13:16 +0700
Subject: [PATCH 09/34] refactor: drop dependency creditpool on llmq/utils

---
 src/evo/creditpool.cpp | 16 +++++++++-------
 src/evo/creditpool.h   |  2 +-
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index 7731b1e418..d0fc398813 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -9,8 +9,9 @@
 #include <evo/specialtx.h>
 
 #include <chain.h>
+#include <chainparams.h>
 #include <consensus/validation.h>
-#include <llmq/utils.h>
+#include <deploymentstatus.h>
 #include <logging.h>
 #include <node/blockstorage.h>
 #include <validation.h>
@@ -80,11 +81,11 @@ std::string CCreditPool::ToString() const
             locked, currentLimit);
 }
 
-std::optional<CCreditPool> CCreditPoolManager::GetFromCache(const CBlockIndex* const block_index)
+std::optional<CCreditPool> CCreditPoolManager::GetFromCache(const CBlockIndex& block_index)
 {
-    if (!llmq::utils::IsV20Active(block_index)) return CCreditPool{};
+    if (!DeploymentActiveAt(block_index, Params().GetConsensus(), Consensus::DEPLOYMENT_V20)) return CCreditPool{};
 
-    const uint256 block_hash = block_index->GetBlockHash();
+    const uint256 block_hash = block_index.GetBlockHash();
     CCreditPool pool;
     {
         LOCK(cache_mutex);
@@ -92,7 +93,7 @@ std::optional<CCreditPool> CCreditPoolManager::GetFromCache(const CBlockIndex* c
             return pool;
         }
     }
-    if (block_index->nHeight % DISK_SNAPSHOT_PERIOD == 0) {
+    if (block_index.nHeight % DISK_SNAPSHOT_PERIOD == 0) {
         if (evoDb.Read(std::make_pair(DB_CREDITPOOL_SNAPSHOT, block_hash), pool)) {
             LOCK(cache_mutex);
             creditPoolCache.insert(block_hash, pool);
@@ -202,10 +203,11 @@ CCreditPool CCreditPoolManager::GetCreditPool(const CBlockIndex* block_index, co
     std::stack<const CBlockIndex *> to_calculate;
 
     std::optional<CCreditPool> poolTmp;
-    while (!(poolTmp = GetFromCache(block_index)).has_value()) {
+    while (block_index != nullptr && !(poolTmp = GetFromCache(*block_index)).has_value()) {
         to_calculate.push(block_index);
         block_index = block_index->pprev;
     }
+    if (block_index == nullptr) poolTmp = CCreditPool{};
     while (!to_calculate.empty()) {
         poolTmp = ConstructCreditPool(to_calculate.top(), *poolTmp, consensusParams);
         to_calculate.pop();
@@ -225,7 +227,7 @@ CCreditPoolDiff::CCreditPoolDiff(CCreditPool starter, const CBlockIndex *pindexP
 {
     assert(pindexPrev);
 
-    if (llmq::utils::IsMNRewardReallocationActive(pindexPrev)) {
+    if (DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_MN_RR)) {
         // We consider V20 active if mn_rr is active
         platformReward = MasternodePayments::PlatformShare(GetMasternodePayment(pindexPrev->nHeight + 1, blockSubsidy, /*fV20Active=*/ true));
     }
diff --git a/src/evo/creditpool.h b/src/evo/creditpool.h
index eb122e4ebe..1c6993e5c2 100644
--- a/src/evo/creditpool.h
+++ b/src/evo/creditpool.h
@@ -128,7 +128,7 @@ public:
     CCreditPool GetCreditPool(const CBlockIndex* block, const Consensus::Params& consensusParams);
 
 private:
-    std::optional<CCreditPool> GetFromCache(const CBlockIndex* const block_index);
+    std::optional<CCreditPool> GetFromCache(const CBlockIndex& block_index);
     void AddToCache(const uint256& block_hash, int height, const CCreditPool& pool);
 
     CCreditPool ConstructCreditPool(const CBlockIndex* block_index, CCreditPool prev, const Consensus::Params& consensusParams);

From 251a89736d837c0805ea8db5907b2e322c35fb4c Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Mon, 4 Dec 2023 17:32:49 +0700
Subject: [PATCH 10/34] refactor: rename argument pindex to pindexPrev in
 GetMNPayee and GetProjectedMNPayees

---
 src/evo/deterministicmns.cpp | 10 +++++-----
 src/evo/deterministicmns.h   |  4 ++--
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index 2a0bc7c9ef..165ecc6012 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -178,14 +178,14 @@ static bool CompareByLastPaid(const CDeterministicMN* _a, const CDeterministicMN
     return CompareByLastPaid(*_a, *_b);
 }
 
-CDeterministicMNCPtr CDeterministicMNList::GetMNPayee(gsl::not_null<const CBlockIndex*> pIndex) const
+CDeterministicMNCPtr CDeterministicMNList::GetMNPayee(gsl::not_null<const CBlockIndex*> pindexPrev) const
 {
     if (mnMap.size() == 0) {
         return nullptr;
     }
 
-    bool isv19Active = llmq::utils::IsV19Active(pIndex);
-    bool isMNRewardReallocation = llmq::utils::IsMNRewardReallocationActive(pIndex);
+    bool isv19Active = llmq::utils::IsV19Active(pindexPrev);
+    bool isMNRewardReallocation = llmq::utils::IsMNRewardReallocationActive(pindexPrev);
     // Starting from v19 and until MNRewardReallocation (Platform release), EvoNodes will be rewarded 4 blocks in a row
     CDeterministicMNCPtr best = nullptr;
     if (isv19Active && !isMNRewardReallocation) {
@@ -214,7 +214,7 @@ CDeterministicMNCPtr CDeterministicMNList::GetMNPayee(gsl::not_null<const CBlock
     return best;
 }
 
-std::vector<CDeterministicMNCPtr> CDeterministicMNList::GetProjectedMNPayees(gsl::not_null<const CBlockIndex* const> pindex, int nCount) const
+std::vector<CDeterministicMNCPtr> CDeterministicMNList::GetProjectedMNPayees(gsl::not_null<const CBlockIndex* const> pindexPrev, int nCount) const
 {
     if (nCount < 0 ) {
         return {};
@@ -227,7 +227,7 @@ std::vector<CDeterministicMNCPtr> CDeterministicMNList::GetProjectedMNPayees(gsl
 
     int remaining_evo_payments{0};
     CDeterministicMNCPtr evo_to_be_skipped{nullptr};
-    const bool isMNRewardReallocation = llmq::utils::IsMNRewardReallocationActive(pindex);
+    const bool isMNRewardReallocation = llmq::utils::IsMNRewardReallocationActive(pindexPrev);
     if (!isMNRewardReallocation) {
         ForEachMNShared(true, [&](const CDeterministicMNCPtr& dmn) {
             if (dmn->pdmnState->nLastPaidHeight == nHeight) {
diff --git a/src/evo/deterministicmns.h b/src/evo/deterministicmns.h
index 96e9e5ef42..6767ebbd2d 100644
--- a/src/evo/deterministicmns.h
+++ b/src/evo/deterministicmns.h
@@ -340,7 +340,7 @@ public:
     [[nodiscard]] CDeterministicMNCPtr GetValidMNByCollateral(const COutPoint& collateralOutpoint) const;
     [[nodiscard]] CDeterministicMNCPtr GetMNByService(const CService& service) const;
     [[nodiscard]] CDeterministicMNCPtr GetMNByInternalId(uint64_t internalId) const;
-    [[nodiscard]] CDeterministicMNCPtr GetMNPayee(gsl::not_null<const CBlockIndex*> pIndex) const;
+    [[nodiscard]] CDeterministicMNCPtr GetMNPayee(gsl::not_null<const CBlockIndex*> pindexPrev) const;
 
     /**
      * Calculates the projected MN payees for the next *count* blocks. The result is not guaranteed to be correct
@@ -348,7 +348,7 @@ public:
      * @param nCount the number of payees to return. "nCount = max()"" means "all", use it to avoid calling GetValidWeightedMNsCount twice.
      * @return
      */
-    [[nodiscard]] std::vector<CDeterministicMNCPtr> GetProjectedMNPayees(gsl::not_null<const CBlockIndex* const> pindex, int nCount = std::numeric_limits<int>::max()) const;
+    [[nodiscard]] std::vector<CDeterministicMNCPtr> GetProjectedMNPayees(gsl::not_null<const CBlockIndex* const> pindexPrev, int nCount = std::numeric_limits<int>::max()) const;
 
     /**
      * Calculate a quorum based on the modifier. The resulting list is deterministically sorted by score

From 13adedb423b51a05bbd8391cb11b86daf44d2105 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Mon, 4 Dec 2023 18:03:50 +0700
Subject: [PATCH 11/34] refactor: move common code in deterministicmns to the
 helper

---
 src/evo/deterministicmns.cpp | 64 ++++++++++++++++--------------------
 1 file changed, 29 insertions(+), 35 deletions(-)

diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index 165ecc6012..a2a736f79b 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -21,6 +21,7 @@
 #include <messagesigner.h>
 #include <uint256.h>
 
+#include <optional>
 #include <memory>
 
 static const std::string DB_LIST_SNAPSHOT = "dmn_S3";
@@ -1509,21 +1510,35 @@ static bool CheckHashSig(const ProTx& proTx, const CBLSPublicKey& pubKey, TxVali
     return true;
 }
 
-bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state, const CCoinsViewCache& view, bool check_sigs)
+template<typename ProTx>
+static std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state)
 {
-    if (tx.nType != TRANSACTION_PROVIDER_REGISTER) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-type");
+    if (tx.nType != ProTx::SPECIALTX_TYPE) {
+        state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-type");
+        return std::nullopt;
     }
 
-    CProRegTx ptx;
+    ProTx ptx;
     if (!GetTxPayload(tx, ptx)) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-payload");
+        state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-payload");
+        return std::nullopt;
     }
 
     if (!ptx.IsTriviallyValid(llmq::utils::IsV19Active(pindexPrev), state)) {
+        // pass the state returned by the function above
+        return std::nullopt;
+    }
+    return ptx;
+}
+
+bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state, const CCoinsViewCache& view, bool check_sigs)
+{
+    const auto opt_ptx = GetValidatedPayload<CProRegTx>(tx, pindexPrev, state);
+    if (!opt_ptx) {
         // pass the state returned by the function above
         return false;
     }
+    const auto& ptx{*opt_ptx};
 
     // It's allowed to set addr to 0, which will put the MN into PoSe-banned state and require a ProUpServTx to be issues later
     // If any of both is set, it must be valid however
@@ -1633,19 +1648,12 @@ bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pin
 
 bool CheckProUpServTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state, bool check_sigs)
 {
-    if (tx.nType != TRANSACTION_PROVIDER_UPDATE_SERVICE) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-type");
-    }
-
-    CProUpServTx ptx;
-    if (!GetTxPayload(tx, ptx)) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-payload");
-    }
-
-    if (!ptx.IsTriviallyValid(llmq::utils::IsV19Active(pindexPrev), state)) {
+    const auto opt_ptx = GetValidatedPayload<CProUpServTx>(tx, pindexPrev, state);
+    if (!opt_ptx) {
         // pass the state returned by the function above
         return false;
     }
+    const auto& ptx{*opt_ptx};
 
     if (!CheckService(ptx, state)) {
         // pass the state returned by the function above
@@ -1701,19 +1709,12 @@ bool CheckProUpServTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*>
 
 bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state, const CCoinsViewCache& view, bool check_sigs)
 {
-    if (tx.nType != TRANSACTION_PROVIDER_UPDATE_REGISTRAR) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-type");
-    }
-
-    CProUpRegTx ptx;
-    if (!GetTxPayload(tx, ptx)) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-payload");
-    }
-
-    if (!ptx.IsTriviallyValid(llmq::utils::IsV19Active(pindexPrev), state)) {
+    const auto opt_ptx = GetValidatedPayload<CProUpRegTx>(tx, pindexPrev, state);
+    if (!opt_ptx) {
         // pass the state returned by the function above
         return false;
     }
+    const auto& ptx{*opt_ptx};
 
     CTxDestination payoutDest;
     if (!ExtractDestination(ptx.scriptPayout, payoutDest)) {
@@ -1774,19 +1775,12 @@ bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
 
 bool CheckProUpRevTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state, bool check_sigs)
 {
-    if (tx.nType != TRANSACTION_PROVIDER_UPDATE_REVOKE) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-type");
-    }
-
-    CProUpRevTx ptx;
-    if (!GetTxPayload(tx, ptx)) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-payload");
-    }
-
-    if (!ptx.IsTriviallyValid(llmq::utils::IsV19Active(pindexPrev), state)) {
+    const auto opt_ptx = GetValidatedPayload<CProUpRevTx>(tx, pindexPrev, state);
+    if (!opt_ptx) {
         // pass the state returned by the function above
         return false;
     }
+    const auto& ptx{*opt_ptx};
 
     auto mnList = deterministicMNManager->GetListForBlock(pindexPrev);
     auto dmn = mnList.GetMN(ptx.proTxHash);

From f7274c450bd2e3928a440929f6b93d185a987a97 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Mon, 4 Dec 2023 17:52:08 +0700
Subject: [PATCH 12/34] refactor: use deployment status in deterministicmns
 instead llmq's helpers

---
 src/evo/deterministicmns.cpp | 34 +++++++++++++++++++---------------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index a2a736f79b..490ad15d9e 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -13,6 +13,7 @@
 #include <base58.h>
 #include <chainparams.h>
 #include <consensus/validation.h>
+#include <deploymentstatus.h>
 #include <script/standard.h>
 #include <ui_interface.h>
 #include <validation.h>
@@ -185,9 +186,10 @@ CDeterministicMNCPtr CDeterministicMNList::GetMNPayee(gsl::not_null<const CBlock
         return nullptr;
     }
 
-    bool isv19Active = llmq::utils::IsV19Active(pindexPrev);
-    bool isMNRewardReallocation = llmq::utils::IsMNRewardReallocationActive(pindexPrev);
-    // Starting from v19 and until MNRewardReallocation (Platform release), EvoNodes will be rewarded 4 blocks in a row
+    const bool isv19Active{DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
+    const bool isMNRewardReallocation{DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_MN_RR)};
+    // EvoNodes are rewarded 4 blocks in a row until MNRewardReallocation (Platform release)
+    // For optimization purposes we also check if v19 active to avoid loop over all masternodes
     CDeterministicMNCPtr best = nullptr;
     if (isv19Active && !isMNRewardReallocation) {
         ForEachMNShared(true, [&](const CDeterministicMNCPtr& dmn) {
@@ -228,7 +230,7 @@ std::vector<CDeterministicMNCPtr> CDeterministicMNList::GetProjectedMNPayees(gsl
 
     int remaining_evo_payments{0};
     CDeterministicMNCPtr evo_to_be_skipped{nullptr};
-    const bool isMNRewardReallocation = llmq::utils::IsMNRewardReallocationActive(pindexPrev);
+    const bool isMNRewardReallocation{DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_MN_RR)};
     if (!isMNRewardReallocation) {
         ForEachMNShared(true, [&](const CDeterministicMNCPtr& dmn) {
             if (dmn->pdmnState->nLastPaidHeight == nHeight) {
@@ -600,8 +602,7 @@ bool CDeterministicMNManager::ProcessBlock(const CBlock& block, gsl::not_null<co
     AssertLockHeld(cs_main);
 
     const auto& consensusParams = Params().GetConsensus();
-    bool fDIP0003Active = pindex->nHeight >= consensusParams.DIP0003Height;
-    if (!fDIP0003Active) {
+    if (!DeploymentActiveAt(*pindex, consensusParams, Consensus::DEPLOYMENT_DIP0003)) {
         return true;
     }
 
@@ -732,7 +733,8 @@ bool CDeterministicMNManager::BuildNewListFromBlock(const CBlock& block, gsl::no
 
     newList.DecreaseScores();
 
-    bool isMNRewardReallocation = llmq::utils::IsMNRewardReallocationActive(pindexPrev);
+    const bool isV19Active{DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
+    const bool isMNRewardReallocation{DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_MN_RR)};
 
     // we skip the coinbase
     for (int i = 1; i < (int)block.vtx.size(); i++) {
@@ -749,7 +751,7 @@ bool CDeterministicMNManager::BuildNewListFromBlock(const CBlock& block, gsl::no
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-payload");
             }
 
-            if (proTx.nType == MnType::Evo && !llmq::utils::IsV19Active(pindexPrev)) {
+            if (proTx.nType == MnType::Evo && !isV19Active) {
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-payload");
             }
 
@@ -812,7 +814,7 @@ bool CDeterministicMNManager::BuildNewListFromBlock(const CBlock& block, gsl::no
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-payload");
             }
 
-            if (proTx.nType == MnType::Evo && !llmq::utils::IsV19Active(pindexPrev)) {
+            if (proTx.nType == MnType::Evo && !DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_V19)) {
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-payload");
             }
 
@@ -1204,6 +1206,7 @@ bool CDeterministicMNManager::MigrateDBIfNeeded()
     static const std::string DB_OLD_LIST_DIFF = "dmn_D";
     static const std::string DB_OLD_BEST_BLOCK = "b_b2";
     static const std::string DB_OLD_BEST_BLOCK2 = "b_b3";
+    const auto& consensusParams = Params().GetConsensus();
 
     LOCK(cs_main);
 
@@ -1232,7 +1235,7 @@ bool CDeterministicMNManager::MigrateDBIfNeeded()
         return true;
     }
 
-    if (m_chainstate.m_chain.Tip()->pprev != nullptr && llmq::utils::IsV19Active(m_chainstate.m_chain.Tip()->pprev)) {
+    if (DeploymentActiveAt(*m_chainstate.m_chain.Tip(), consensusParams, Consensus::DEPLOYMENT_V19)) {
         // too late
         LogPrintf("CDeterministicMNManager::%s -- migration is not possible\n", __func__);
         return false;
@@ -1247,7 +1250,7 @@ bool CDeterministicMNManager::MigrateDBIfNeeded()
     }
     m_evoDb.GetRawDB().Erase(DB_OLD_BEST_BLOCK);
 
-    if (m_chainstate.m_chain.Height() < Params().GetConsensus().DIP0003Height) {
+    if (!DeploymentActiveAt(*m_chainstate.m_chain.Tip(), consensusParams, Consensus::DEPLOYMENT_DIP0003)) {
         // not reached DIP3 height yet, so no upgrade needed
         LogPrintf("CDeterministicMNManager::%s -- migration not needed. dip3 not reached\n", __func__);
         auto dbTx = m_evoDb.BeginTransaction();
@@ -1314,6 +1317,7 @@ bool CDeterministicMNManager::MigrateDBIfNeeded2()
     static const std::string DB_OLD_LIST_SNAPSHOT = "dmn_S2";
     static const std::string DB_OLD_LIST_DIFF = "dmn_D2";
     static const std::string DB_OLD_BEST_BLOCK = "b_b3";
+    const auto& consensusParams = Params().GetConsensus();
 
     LOCK(cs_main);
 
@@ -1342,7 +1346,7 @@ bool CDeterministicMNManager::MigrateDBIfNeeded2()
         return true;
     }
 
-    if (m_chainstate.m_chain.Tip()->pprev != nullptr && llmq::utils::IsV19Active(m_chainstate.m_chain.Tip()->pprev)) {
+    if (DeploymentActiveAt(*m_chainstate.m_chain.Tip(), consensusParams, Consensus::DEPLOYMENT_V19)) {
         // too late
         LogPrintf("CDeterministicMNManager::%s -- migration is not possible\n", __func__);
         return false;
@@ -1357,7 +1361,7 @@ bool CDeterministicMNManager::MigrateDBIfNeeded2()
     }
     m_evoDb.GetRawDB().Erase(DB_OLD_BEST_BLOCK);
 
-    if (m_chainstate.m_chain.Height() < Params().GetConsensus().DIP0003Height) {
+    if (!DeploymentActiveAt(*m_chainstate.m_chain.Tip(), consensusParams, Consensus::DEPLOYMENT_DIP0003)) {
         // not reached DIP3 height yet, so no upgrade needed
         LogPrintf("CDeterministicMNManager::%s -- migration not needed. dip3 not reached\n", __func__);
         auto dbTx = m_evoDb.BeginTransaction();
@@ -1523,8 +1527,8 @@ static std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not
         state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-payload");
         return std::nullopt;
     }
-
-    if (!ptx.IsTriviallyValid(llmq::utils::IsV19Active(pindexPrev), state)) {
+    const bool is_basic_scheme_active{DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
+    if (!ptx.IsTriviallyValid(is_basic_scheme_active, state)) {
         // pass the state returned by the function above
         return std::nullopt;
     }

From 5a84eb0f0a2a0642e85ee30ad397b05ca37282d0 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Mon, 4 Dec 2023 18:33:23 +0700
Subject: [PATCH 13/34] refactor: drop default value from IsDIP3Enforced()

---
 src/evo/deterministicmns.cpp | 10 ----------
 src/evo/deterministicmns.h   |  2 +-
 2 files changed, 1 insertion(+), 11 deletions(-)

diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index 490ad15d9e..ccef28e82c 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -1120,16 +1120,6 @@ bool CDeterministicMNManager::IsProTxWithCollateral(const CTransactionRef& tx, u
 
 bool CDeterministicMNManager::IsDIP3Enforced(int nHeight)
 {
-    if (nHeight == -1) {
-        LOCK(cs);
-        if (tipIndex == nullptr) {
-            // Since EnforcementHeight can be set to block 1, we shouldn't just return false here
-            nHeight = 1;
-        } else {
-            nHeight = tipIndex->nHeight;
-        }
-    }
-
     return nHeight >= Params().GetConsensus().DIP0003EnforcementHeight;
 }
 
diff --git a/src/evo/deterministicmns.h b/src/evo/deterministicmns.h
index 6767ebbd2d..96241b463c 100644
--- a/src/evo/deterministicmns.h
+++ b/src/evo/deterministicmns.h
@@ -622,7 +622,7 @@ public:
     // Test if given TX is a ProRegTx which also contains the collateral at index n
     static bool IsProTxWithCollateral(const CTransactionRef& tx, uint32_t n);
 
-    bool IsDIP3Enforced(int nHeight = -1) LOCKS_EXCLUDED(cs);
+    bool IsDIP3Enforced(int nHeight);
 
     bool MigrateDBIfNeeded();
     bool MigrateDBIfNeeded2();

From a79aa56d9b56ae8a0a38f1dd74e88df259865972 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 00:58:13 +0700
Subject: [PATCH 14/34] refactor: move out helper IsDIP3Enforced from
 deterministicmns

---
 src/deploymentstatus.h                       | 6 ++++++
 src/evo/deterministicmns.cpp                 | 9 ++-------
 src/evo/deterministicmns.h                   | 2 --
 src/governance/governance.cpp                | 3 ++-
 src/llmq/dkgsessionhandler.cpp               | 3 ++-
 src/llmq/dkgsessionmgr.cpp                   | 6 +++---
 src/masternode/node.cpp                      | 5 +++--
 src/masternode/payments.cpp                  | 2 +-
 src/test/block_reward_reallocation_tests.cpp | 2 +-
 9 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/src/deploymentstatus.h b/src/deploymentstatus.h
index 84c5e54698..84ce46375e 100644
--- a/src/deploymentstatus.h
+++ b/src/deploymentstatus.h
@@ -52,4 +52,10 @@ inline bool DeploymentEnabled(const Consensus::Params& params, Consensus::Deploy
     return params.vDeployments[dep].nTimeout != 0;
 }
 
+/** this function is convenient helper for DIP0003 because 'active' and 'enforced' are different statuses for DIP0003 */
+constexpr bool DeploymentDIP0003Enforced(const int nHeight, const Consensus::Params& params)
+{
+    return nHeight >= params.DIP0003EnforcementHeight;
+}
+
 #endif // BITCOIN_DEPLOYMENTSTATUS_H
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index ccef28e82c..73d72b2be6 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -1118,11 +1118,6 @@ bool CDeterministicMNManager::IsProTxWithCollateral(const CTransactionRef& tx, u
     return true;
 }
 
-bool CDeterministicMNManager::IsDIP3Enforced(int nHeight)
-{
-    return nHeight >= Params().GetConsensus().DIP0003EnforcementHeight;
-}
-
 void CDeterministicMNManager::CleanupCache(int nHeight)
 {
     AssertLockHeld(cs);
@@ -1612,7 +1607,7 @@ bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pin
             }
         }
 
-        if (!deterministicMNManager->IsDIP3Enforced(pindexPrev->nHeight)) {
+        if (!DeploymentDIP0003Enforced(pindexPrev->nHeight, Params().GetConsensus())) {
             if (ptx.keyIDOwner != ptx.keyIDVoting) {
                 return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-key-not-same");
             }
@@ -1749,7 +1744,7 @@ bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
         }
     }
 
-    if (!deterministicMNManager->IsDIP3Enforced(pindexPrev->nHeight)) {
+    if (!DeploymentDIP0003Enforced(pindexPrev->nHeight, Params().GetConsensus())) {
         if (dmn->pdmnState->keyIDOwner != ptx.keyIDVoting) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-key-not-same");
         }
diff --git a/src/evo/deterministicmns.h b/src/evo/deterministicmns.h
index 96241b463c..95bf68432f 100644
--- a/src/evo/deterministicmns.h
+++ b/src/evo/deterministicmns.h
@@ -622,8 +622,6 @@ public:
     // Test if given TX is a ProRegTx which also contains the collateral at index n
     static bool IsProTxWithCollateral(const CTransactionRef& tx, uint32_t n);
 
-    bool IsDIP3Enforced(int nHeight);
-
     bool MigrateDBIfNeeded();
     bool MigrateDBIfNeeded2();
 
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
index 7ad5cb32c9..e4ed643552 100644
--- a/src/governance/governance.cpp
+++ b/src/governance/governance.cpp
@@ -8,6 +8,7 @@
 #include <chain.h>
 #include <chainparams.h>
 #include <consensus/validation.h>
+#include <deploymentstatus.h>
 #include <evo/deterministicmns.h>
 #include <flat-database.h>
 #include <governance/classes.h>
@@ -1461,7 +1462,7 @@ void CGovernanceManager::UpdatedBlockTip(const CBlockIndex* pindex, CConnman& co
     nCachedBlockHeight = pindex->nHeight;
     LogPrint(BCLog::GOBJECT, "CGovernanceManager::UpdatedBlockTip -- nCachedBlockHeight: %d\n", nCachedBlockHeight);
 
-    if (deterministicMNManager->IsDIP3Enforced(pindex->nHeight)) {
+    if (DeploymentDIP0003Enforced(pindex->nHeight, Params().GetConsensus())) {
         RemoveInvalidVotes();
     }
 
diff --git a/src/llmq/dkgsessionhandler.cpp b/src/llmq/dkgsessionhandler.cpp
index 4f3ba6d65d..3acc3539e1 100644
--- a/src/llmq/dkgsessionhandler.cpp
+++ b/src/llmq/dkgsessionhandler.cpp
@@ -12,6 +12,7 @@
 
 #include <evo/deterministicmns.h>
 
+#include <deploymentstatus.h>
 #include <masternode/node.h>
 #include <chainparams.h>
 #include <net_processing.h>
@@ -168,7 +169,7 @@ bool CDKGSessionHandler::InitNewQuorum(const CBlockIndex* pQuorumBaseBlockIndex)
 {
     curSession = std::make_unique<CDKGSession>(params, blsWorker, dkgManager, dkgDebugManager, connman);
 
-    if (!deterministicMNManager->IsDIP3Enforced(pQuorumBaseBlockIndex->nHeight)) {
+    if (!DeploymentDIP0003Enforced(pQuorumBaseBlockIndex->nHeight, Params().GetConsensus())) {
         return false;
     }
 
diff --git a/src/llmq/dkgsessionmgr.cpp b/src/llmq/dkgsessionmgr.cpp
index fabf48b2f3..a4c9578037 100644
--- a/src/llmq/dkgsessionmgr.cpp
+++ b/src/llmq/dkgsessionmgr.cpp
@@ -7,10 +7,10 @@
 #include <llmq/quorums.h>
 #include <llmq/utils.h>
 
-#include <evo/deterministicmns.h>
-
 #include <chainparams.h>
 #include <dbwrapper.h>
+#include <deploymentstatus.h>
+#include <evo/deterministicmns.h>
 #include <net_processing.h>
 #include <spork.h>
 #include <util/irange.h>
@@ -162,7 +162,7 @@ void CDKGSessionManager::UpdatedBlockTip(const CBlockIndex* pindexNew, bool fIni
 
     if (fInitialDownload)
         return;
-    if (!deterministicMNManager->IsDIP3Enforced(pindexNew->nHeight))
+    if (!DeploymentDIP0003Enforced(pindexNew->nHeight, Params().GetConsensus()))
         return;
     if (!IsQuorumDKGEnabled(spork_manager))
         return;
diff --git a/src/masternode/node.cpp b/src/masternode/node.cpp
index 84a2005293..055fa0430c 100644
--- a/src/masternode/node.cpp
+++ b/src/masternode/node.cpp
@@ -7,6 +7,7 @@
 #include <evo/deterministicmns.h>
 
 #include <chainparams.h>
+#include <deploymentstatus.h>
 #include <net.h>
 #include <netbase.h>
 #include <protocol.h>
@@ -68,7 +69,7 @@ void CActiveMasternodeManager::Init(const CBlockIndex* pindex)
 
     if (!fMasternodeMode) return;
 
-    if (!deterministicMNManager->IsDIP3Enforced(pindex->nHeight)) return;
+    if (!DeploymentDIP0003Enforced(pindex->nHeight, Params().GetConsensus())) return;
 
     // Check that our local network configuration is correct
     if (!fListen && Params().RequireRoutableExternalIP()) {
@@ -141,7 +142,7 @@ void CActiveMasternodeManager::UpdatedBlockTip(const CBlockIndex* pindexNew, con
 
     if (!fMasternodeMode) return;
 
-    if (!deterministicMNManager->IsDIP3Enforced(pindexNew->nHeight)) return;
+    if (!DeploymentDIP0003Enforced(pindexNew->nHeight, Params().GetConsensus())) return;
 
     if (state == MASTERNODE_READY) {
         auto oldMNList = deterministicMNManager->GetListForBlock(pindexNew->pprev);
diff --git a/src/masternode/payments.cpp b/src/masternode/payments.cpp
index 78d73b191d..2bf94d213d 100644
--- a/src/masternode/payments.cpp
+++ b/src/masternode/payments.cpp
@@ -98,7 +98,7 @@
 [[nodiscard]] static bool IsTransactionValid(const CTransaction& txNew, const CBlockIndex* const pindexPrev, const CAmount blockSubsidy, const CAmount feeReward)
 {
     const int nBlockHeight = pindexPrev  == nullptr ? 0 : pindexPrev->nHeight + 1;
-    if (!deterministicMNManager->IsDIP3Enforced(nBlockHeight)) {
+    if (!DeploymentDIP0003Enforced(nBlockHeight, Params().GetConsensus())) {
         // can't verify historical blocks here
         return true;
     }
diff --git a/src/test/block_reward_reallocation_tests.cpp b/src/test/block_reward_reallocation_tests.cpp
index 95c7d47e73..3563a2d1aa 100644
--- a/src/test/block_reward_reallocation_tests.cpp
+++ b/src/test/block_reward_reallocation_tests.cpp
@@ -150,7 +150,7 @@ BOOST_FIXTURE_TEST_CASE(block_reward_reallocation, TestChainBRRBeforeActivationS
 
     CScript coinbasePubKey = CScript() <<  ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
 
-    BOOST_ASSERT(deterministicMNManager->IsDIP3Enforced(WITH_LOCK(cs_main, return m_node.chainman->ActiveChain().Height())));
+    BOOST_ASSERT(DeploymentDIP0003Enforced(WITH_LOCK(cs_main, return m_node.chainman->ActiveChain().Height()), consensus_params));
 
     // Register one MN
     CKey ownerKey;

From c742b9acf506e4ad4fa7a91b5c9d1002c89b21f0 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 01:00:59 +0700
Subject: [PATCH 15/34] refactor: drop unused
 llmq::utils::IsMNRewardReallocationActive

---
 src/llmq/utils.cpp | 7 -------
 src/llmq/utils.h   | 2 --
 2 files changed, 9 deletions(-)

diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index e45fb687ec..9980efbfaf 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -692,13 +692,6 @@ bool IsV20Active(gsl::not_null<const CBlockIndex*> pindex)
     return llmq_versionbitscache.State(pindex, Params().GetConsensus(), Consensus::DEPLOYMENT_V20) == ThresholdState::ACTIVE;
 }
 
-bool IsMNRewardReallocationActive(gsl::not_null<const CBlockIndex*> pindex)
-{
-    if (!IsV20Active(pindex)) return false;
-
-    return llmq_versionbitscache.State(pindex, Params().GetConsensus(), Consensus::DEPLOYMENT_MN_RR) == ThresholdState::ACTIVE;
-}
-
 uint256 DeterministicOutboundConnection(const uint256& proTxHash1, const uint256& proTxHash2)
 {
     // We need to deterministically select who is going to initiate the connection. The naive way would be to simply
diff --git a/src/llmq/utils.h b/src/llmq/utils.h
index 719eae085d..55c59b8b06 100644
--- a/src/llmq/utils.h
+++ b/src/llmq/utils.h
@@ -81,8 +81,6 @@ bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_n
 bool IsV19Active(gsl::not_null<const CBlockIndex*> pindex);
 // TODO deployments
 bool IsV20Active(gsl::not_null<const CBlockIndex*> pindex);
-// TODO deployments
-bool IsMNRewardReallocationActive(gsl::not_null<const CBlockIndex*> pindex);
 
 /// Returns the state of `-llmq-data-recovery`
 // TODO options

From 377d929edc0ef3b976d580e763f769147fdaba79 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 01:04:51 +0700
Subject: [PATCH 16/34] refactor: drop dependency evo/simplifiedmns on
 llmq/utils

---
 src/evo/simplifiedmns.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/evo/simplifiedmns.cpp b/src/evo/simplifiedmns.cpp
index e87ba39cb0..9ced1bb0d2 100644
--- a/src/evo/simplifiedmns.cpp
+++ b/src/evo/simplifiedmns.cpp
@@ -6,11 +6,11 @@
 
 #include <evo/cbtx.h>
 #include <core_io.h>
+#include <deploymentstatus.h>
 #include <evo/deterministicmns.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
 #include <llmq/quorums.h>
-#include <llmq/utils.h>
 #include <node/blockstorage.h>
 #include <evo/specialtx.h>
 
@@ -363,7 +363,7 @@ bool BuildSimplifiedMNListDiff(const uint256& baseBlockHash, const uint256& bloc
         return false;
     }
 
-    if (llmq::utils::IsV20Active(blockIndex)) {
+    if (DeploymentActiveAfter(blockIndex, Params().GetConsensus(), Consensus::DEPLOYMENT_V20)) {
         if (!mnListDiffRet.BuildQuorumChainlockInfo(blockIndex)) {
             errorRet = strprintf("failed to build quorums chainlocks info");
             return false;

From 488c895a6597c80f57585108e2f02e916111c44c Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 01:37:39 +0700
Subject: [PATCH 17/34] refactor: use DeploymentActiveAfter in ehf_signals

---
 src/llmq/ehf_signals.cpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/llmq/ehf_signals.cpp b/src/llmq/ehf_signals.cpp
index 92f6afa6a1..697b6a9d07 100644
--- a/src/llmq/ehf_signals.cpp
+++ b/src/llmq/ehf_signals.cpp
@@ -3,15 +3,16 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <llmq/ehf_signals.h>
-#include <llmq/utils.h>
 #include <llmq/quorums.h>
 #include <llmq/signing_shares.h>
 #include <llmq/commitment.h>
+#include <llmq/utils.h>
 
 #include <evo/mnhftx.h>
 #include <evo/specialtx.h>
 
 #include <consensus/validation.h>
+#include <deploymentstatus.h>
 #include <index/txindex.h> // g_txindex
 #include <primitives/transaction.h>
 #include <spork.h>
@@ -43,7 +44,9 @@ CEHFSignalsHandler::~CEHFSignalsHandler()
 
 void CEHFSignalsHandler::UpdatedBlockTip(const CBlockIndex* const pindexNew)
 {
-    if (!fMasternodeMode || !llmq::utils::IsV20Active(pindexNew) || (Params().IsTestChain() && !sporkman.IsSporkActive(SPORK_24_TEST_EHF))) {
+    if (!DeploymentActiveAfter(pindexNew, Params().GetConsensus(), Consensus::DEPLOYMENT_V20)) return;
+
+    if (!fMasternodeMode || (Params().IsTestChain() && !sporkman.IsSporkActive(SPORK_24_TEST_EHF))) {
         return;
     }
 

From 2128d58b4fa1cdc1478a6072c8411bc711823149 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 01:51:45 +0700
Subject: [PATCH 18/34] refactor: use DeploymentActiveAfter in cbtx

---
 src/evo/cbtx.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/evo/cbtx.cpp b/src/evo/cbtx.cpp
index 66ff72683f..8bfe14ab50 100644
--- a/src/evo/cbtx.cpp
+++ b/src/evo/cbtx.cpp
@@ -16,6 +16,7 @@
 #include <chain.h>
 #include <chainparams.h>
 #include <consensus/merkle.h>
+#include <deploymentstatus.h>
 #include <validation.h>
 
 bool CheckCbTx(const CTransaction& tx, const CBlockIndex* pindexPrev, TxValidationState& state)
@@ -42,12 +43,12 @@ bool CheckCbTx(const CTransaction& tx, const CBlockIndex* pindexPrev, TxValidati
             return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-height");
         }
 
-        bool fDIP0008Active = pindexPrev->nHeight >= Params().GetConsensus().DIP0008Height;
+        const bool fDIP0008Active{DeploymentActiveAt(*pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0008)};
         if (fDIP0008Active && cbTx.nVersion < CCbTx::Version::MERKLE_ROOT_QUORUMS) {
             return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-version");
         }
 
-        bool isV20 = llmq::utils::IsV20Active(pindexPrev);
+        const bool isV20{DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_V20)};
         if ((isV20 && cbTx.nVersion < CCbTx::Version::CLSIG_AND_BALANCE) || (!isV20 && cbTx.nVersion >= CCbTx::Version::CLSIG_AND_BALANCE)) {
             return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-version");
         }

From 9aa437115ac650b5cd6017854365648a95526769 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 01:53:36 +0700
Subject: [PATCH 19/34] refactor: use DeploymentActiveAfter in evo/mnauth

---
 src/evo/mnauth.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/evo/mnauth.cpp b/src/evo/mnauth.cpp
index 8162371a06..48f4821896 100644
--- a/src/evo/mnauth.cpp
+++ b/src/evo/mnauth.cpp
@@ -7,6 +7,7 @@
 #include <bls/bls.h>
 #include <chain.h>
 #include <chainparams.h>
+#include <deploymentstatus.h>
 #include <evo/deterministicmns.h>
 #include <llmq/utils.h>
 #include <masternode/meta.h>
@@ -40,8 +41,8 @@ void CMNAuth::PushMNAUTH(CNode& peer, CConnman& connman, const CBlockIndex* tip)
     if (Params().NetworkIDString() != CBaseChainParams::MAIN && gArgs.IsArgSet("-pushversion")) {
         nOurNodeVersion = gArgs.GetArg("-pushversion", PROTOCOL_VERSION);
     }
-    bool isV19active = llmq::utils::IsV19Active(tip);
-    const CBLSPublicKeyVersionWrapper pubKey(*activeMasternodeInfo.blsPubKeyOperator, !isV19active);
+    const bool is_basic_scheme_active{DeploymentActiveAfter(tip, Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
+    const CBLSPublicKeyVersionWrapper pubKey(*activeMasternodeInfo.blsPubKeyOperator, !is_basic_scheme_active);
     if (peer.nVersion < MNAUTH_NODE_VER_VERSION || nOurNodeVersion < MNAUTH_NODE_VER_VERSION) {
         signHash = ::SerializeHash(std::make_tuple(pubKey, receivedMNAuthChallenge, peer.fInbound));
     } else {
@@ -106,8 +107,8 @@ void CMNAuth::ProcessMessage(CNode& peer, PeerManager& peerman, CConnman& connma
         nOurNodeVersion = gArgs.GetArg("-pushversion", PROTOCOL_VERSION);
     }
     const CBlockIndex* tip = ::ChainActive().Tip();
-    bool isV19active = llmq::utils::IsV19Active(tip);
-    ConstCBLSPublicKeyVersionWrapper pubKey(dmn->pdmnState->pubKeyOperator.Get(), !isV19active);
+    const bool is_basic_scheme_active{DeploymentActiveAfter(tip, Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
+    ConstCBLSPublicKeyVersionWrapper pubKey(dmn->pdmnState->pubKeyOperator.Get(), !is_basic_scheme_active);
     // See comment in PushMNAUTH (fInbound is negated here as we're on the other side of the connection)
     if (peer.nVersion < MNAUTH_NODE_VER_VERSION || nOurNodeVersion < MNAUTH_NODE_VER_VERSION) {
         signHash = ::SerializeHash(std::make_tuple(pubKey, peer.GetSentMNAuthChallenge(), !peer.fInbound));

From 7bce9d820994a32f0e4f645b3a00c0dc90b57dd7 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 02:14:27 +0700
Subject: [PATCH 20/34] refactor: use CFinalCommitment::GetVersion in
 llmq/{commitment,dkgsession}

---
 src/llmq/commitment.cpp | 10 +++-------
 src/llmq/dkgsession.cpp | 11 ++++-------
 2 files changed, 7 insertions(+), 14 deletions(-)

diff --git a/src/llmq/commitment.cpp b/src/llmq/commitment.cpp
index 967b4a4927..f9a90a0532 100644
--- a/src/llmq/commitment.cpp
+++ b/src/llmq/commitment.cpp
@@ -9,6 +9,7 @@
 
 #include <chainparams.h>
 #include <consensus/validation.h>
+#include <deploymentstatus.h>
 #include <llmq/utils.h>
 #include <logging.h>
 #include <validation.h>
@@ -41,13 +42,8 @@ bool CFinalCommitment::Verify(gsl::not_null<const CBlockIndex*> pQuorumBaseBlock
     }
     const auto& llmq_params = llmq_params_opt.value();
 
-    uint16_t expected_nversion{CFinalCommitment::LEGACY_BLS_NON_INDEXED_QUORUM_VERSION};
-    if (utils::IsQuorumRotationEnabled(llmq_params, pQuorumBaseBlockIndex)) {
-        expected_nversion = utils::IsV19Active(pQuorumBaseBlockIndex) ? CFinalCommitment::BASIC_BLS_INDEXED_QUORUM_VERSION : CFinalCommitment::LEGACY_BLS_INDEXED_QUORUM_VERSION;
-    }
-    else {
-        expected_nversion = utils::IsV19Active(pQuorumBaseBlockIndex) ? CFinalCommitment::BASIC_BLS_NON_INDEXED_QUORUM_VERSION : CFinalCommitment::LEGACY_BLS_NON_INDEXED_QUORUM_VERSION;
-    }
+    const uint16_t expected_nversion{CFinalCommitment::GetVersion(utils::IsQuorumRotationEnabled(llmq_params, pQuorumBaseBlockIndex),
+            DeploymentActiveAfter(pQuorumBaseBlockIndex, Params().GetConsensus(), Consensus::DEPLOYMENT_V19))};
     if (nVersion == 0 || nVersion != expected_nversion) {
         LogPrintfFinalCommitment("q[%s] invalid nVersion=%d expectednVersion\n", quorumHash.ToString(), nVersion, expected_nversion);
         return false;
diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
index 10950b5903..2a0b888f20 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -14,6 +14,7 @@
 #include <batchedlogger.h>
 #include <chainparams.h>
 #include <cxxtimer.hpp>
+#include <deploymentstatus.h>
 #include <logging.h>
 #include <masternode/meta.h>
 #include <masternode/node.h>
@@ -1223,13 +1224,9 @@ std::vector<CFinalCommitment> CDKGSession::FinalizeCommitments()
         fqc.quorumPublicKey = first.quorumPublicKey;
         fqc.quorumVvecHash = first.quorumVvecHash;
 
-        if (utils::IsQuorumRotationEnabled(params, m_quorum_base_block_index)) {
-            fqc.nVersion = utils::IsV19Active(m_quorum_base_block_index) ? CFinalCommitment::BASIC_BLS_INDEXED_QUORUM_VERSION : CFinalCommitment::LEGACY_BLS_INDEXED_QUORUM_VERSION;
-            fqc.quorumIndex = quorumIndex;
-        } else {
-            fqc.nVersion = utils::IsV19Active(m_quorum_base_block_index) ? CFinalCommitment::BASIC_BLS_NON_INDEXED_QUORUM_VERSION : CFinalCommitment::LEGACY_BLS_NON_INDEXED_QUORUM_VERSION;
-            fqc.quorumIndex = 0;
-        }
+        const bool isQuorumRotationEnabled{utils::IsQuorumRotationEnabled(params, m_quorum_base_block_index)};
+        fqc.nVersion = CFinalCommitment::GetVersion(isQuorumRotationEnabled, DeploymentActiveAfter(m_quorum_base_block_index, Params().GetConsensus(), Consensus::DEPLOYMENT_V19));
+        fqc.quorumIndex = isQuorumRotationEnabled ? quorumIndex : 0;
 
         uint256 commitmentHash = utils::BuildCommitmentHash(fqc.llmqType, fqc.quorumHash, fqc.validMembers, fqc.quorumPublicKey, fqc.quorumVvecHash);
 

From c4d634c051ef67eedac9a16df53a76b6a8799e20 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 02:21:28 +0700
Subject: [PATCH 21/34] refactor: use DeploymentActiveAfter in init.cpp

---
 src/init.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index f38f8cfd24..a1b8b85844 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -18,6 +18,7 @@
 #include <chain.h>
 #include <chainparams.h>
 #include <context.h>
+#include <deploymentstatus.h>
 #include <node/coinstats.h>
 #include <fs.h>
 #include <hash.h>
@@ -2109,9 +2110,8 @@ bool AppInitMain(const CoreContext& context, NodeContext& node, interfaces::Bloc
                             failed_verification = true;
                             break;
                         }
-
-                        bool v19active = llmq::utils::IsV19Active(tip);
-                        if (llmq::utils::IsV19Active(tip)) {
+                        const bool v19active{DeploymentActiveAfter(tip, chainparams.GetConsensus(), Consensus::DEPLOYMENT_V19)};
+                        if (v19active) {
                             bls::bls_legacy_scheme.store(false);
                             LogPrintf("%s: bls_legacy_scheme=%d\n", __func__, bls::bls_legacy_scheme.load());
                         }

From 39dc612eee2a7c3f4dac03eb7bb9fb4edbef3a64 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 02:25:57 +0700
Subject: [PATCH 22/34] refactor: drop dependency test/util/setup_common on
 llmq/utils

---
 src/test/util/setup_common.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 677e4b0e4e..8ce8fe760b 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -10,6 +10,7 @@
 #include <consensus/consensus.h>
 #include <consensus/params.h>
 #include <consensus/validation.h>
+#include <deploymentstatus.h>
 #include <crypto/sha256.h>
 #include <flat-database.h>
 #include <governance/governance.h>
@@ -27,7 +28,6 @@
 #include <llmq/signing.h>
 #include <llmq/signing_shares.h>
 #include <llmq/snapshot.h>
-#include <llmq/utils.h>
 #include <masternode/sync.h>
 #include <miner.h>
 #include <net.h>
@@ -464,14 +464,14 @@ CBlock getBlock13b8a()
 
 TestChainV19Setup::TestChainV19Setup() : TestChainSetup(899)
 {
-    bool v19_just_activated = llmq::utils::IsV19Active(::ChainActive().Tip()) &&
-                              !llmq::utils::IsV19Active(::ChainActive().Tip()->pprev);
+    bool v19_just_activated{DeploymentActiveAfter(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_V19) &&
+                            !DeploymentActiveAt(*::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
     assert(v19_just_activated);
 }
 
 // 5 blocks earlier
 TestChainV19BeforeActivationSetup::TestChainV19BeforeActivationSetup() : TestChainSetup(894)
 {
-    bool v19_active = llmq::utils::IsV19Active(::ChainActive().Tip());
+    bool v19_active{DeploymentActiveAfter(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
     assert(!v19_active);
 }

From 1ed7f0cca45b3c081e583c94e364b64e6c43d1b2 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 02:43:18 +0700
Subject: [PATCH 23/34] refactor: use DeploymentActiveAfter instead llmq::utils
 in rpc/

---
 src/rpc/evo.cpp     | 15 ++++++++-------
 src/rpc/misc.cpp    |  4 ++--
 src/rpc/quorums.cpp |  5 +++--
 3 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index bd3ddaaf66..87c59e5c02 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -7,6 +7,7 @@
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <core_io.h>
+#include <deploymentstatus.h>
 #include <evo/deterministicmns.h>
 #include <evo/dmn_types.h>
 #include <evo/providertx.h>
@@ -16,7 +17,6 @@
 #include <index/txindex.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/context.h>
-#include <llmq/utils.h>
 #include <masternode/meta.h>
 #include <messagesigner.h>
 #include <netbase.h>
@@ -611,7 +611,7 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
         EnsureWalletIsUnlocked(wallet.get());
     }
 
-    bool isV19active = llmq::utils::IsV19Active(WITH_LOCK(cs_main, return chainman.ActiveChain().Tip();));
+    const bool isV19active{DeploymentActiveAfter(WITH_LOCK(cs_main, return chainman.ActiveChain().Tip();), Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
     if (isEvoRequested && !isV19active) {
         throw JSONRPCError(RPC_INVALID_REQUEST, "EvoNodes aren't allowed yet");
     }
@@ -915,7 +915,7 @@ static UniValue protx_update_service_common_wrapper(const JSONRPCRequest& reques
 
     EnsureWalletIsUnlocked(wallet.get());
 
-    const bool isV19active = llmq::utils::IsV19Active(WITH_LOCK(cs_main, return chainman.ActiveChain().Tip();));
+    const bool isV19active{DeploymentActiveAfter(WITH_LOCK(cs_main, return chainman.ActiveChain().Tip();), Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
     const bool is_bls_legacy = !isV19active;
     if (isEvoRequested && !isV19active) {
         throw JSONRPCError(RPC_INVALID_REQUEST, "EvoNodes aren't allowed yet");
@@ -1056,7 +1056,8 @@ static UniValue protx_update_registrar_wrapper(const JSONRPCRequest& request, co
     ptx.keyIDVoting = dmn->pdmnState->keyIDVoting;
     ptx.scriptPayout = dmn->pdmnState->scriptPayout;
 
-    const bool use_legacy = llmq::utils::IsV19Active(chainman.ActiveChain().Tip()) ? specific_legacy_bls_scheme : true;
+    const bool isV19Active{DeploymentActiveAfter(WITH_LOCK(cs_main, return chainman.ActiveChain().Tip();), Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
+    const bool use_legacy = isV19Active ? specific_legacy_bls_scheme : true;
 
     if (request.params[1].get_str() != "") {
         // new pubkey
@@ -1156,7 +1157,7 @@ static UniValue protx_revoke(const JSONRPCRequest& request, const ChainstateMana
 
     EnsureWalletIsUnlocked(wallet.get());
 
-    const bool isV19active = llmq::utils::IsV19Active(WITH_LOCK(cs_main, return chainman.ActiveChain().Tip();));
+    const bool isV19active{DeploymentActiveAfter(WITH_LOCK(cs_main, return chainman.ActiveChain().Tip();), Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
     const bool is_bls_legacy = !isV19active;
     CProUpRevTx ptx;
     ptx.nVersion = CProUpRevTx::GetVersion(isV19active);
@@ -1678,7 +1679,7 @@ static UniValue bls_generate(const JSONRPCRequest& request, const ChainstateMana
 
     CBLSSecretKey sk;
     sk.MakeNewKey();
-    bool bls_legacy_scheme = !llmq::utils::IsV19Active(chainman.ActiveChain().Tip());
+    bool bls_legacy_scheme{!DeploymentActiveAfter(WITH_LOCK(cs_main, return chainman.ActiveChain().Tip();), Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
     if (!request.params[0].isNull()) {
         bls_legacy_scheme = ParseBoolV(request.params[0], "bls_legacy_scheme");
     }
@@ -1715,7 +1716,7 @@ static UniValue bls_fromsecret(const JSONRPCRequest& request, const ChainstateMa
 {
     bls_fromsecret_help(request);
 
-    bool bls_legacy_scheme = !llmq::utils::IsV19Active(chainman.ActiveChain().Tip());
+    bool bls_legacy_scheme{!DeploymentActiveAfter(WITH_LOCK(cs_main, return chainman.ActiveChain().Tip();), Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
     if (!request.params[1].isNull()) {
         bls_legacy_scheme = ParseBoolV(request.params[1], "bls_legacy_scheme");
     }
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index fcab8d4b1b..84515dc3ae 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -7,6 +7,7 @@
 #include <addressindex.h>
 #include <chainparams.h>
 #include <consensus/consensus.h>
+#include <deploymentstatus.h>
 #include <evo/mnauth.h>
 #include <httpserver.h>
 #include <index/blockfilterindex.h>
@@ -15,7 +16,6 @@
 #include <init.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
-#include <llmq/utils.h>
 #include <net.h>
 #include <node/context.h>
 #include <rpc/blockchain.h>
@@ -581,7 +581,7 @@ static UniValue mnauth(const JSONRPCRequest& request)
     ChainstateManager& chainman = EnsureAnyChainman(request.context);
 
     CBLSPublicKey publicKey;
-    bool bls_legacy_scheme = !llmq::utils::IsV19Active(chainman.ActiveChain().Tip());
+    const bool bls_legacy_scheme{!DeploymentActiveAfter(chainman.ActiveChain().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
     publicKey.SetHexStr(request.params[2].get_str(), bls_legacy_scheme);
     if (!publicKey.IsValid()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "publicKey invalid");
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index f3c7f7a63f..40b80142b4 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -3,6 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
+#include <deploymentstatus.h>
 #include <index/txindex.h>
 #include <node/context.h>
 #include <rpc/blockchain.h>
@@ -896,7 +897,7 @@ static UniValue verifychainlock(const JSONRPCRequest& request)
 
     CBLSSignature sig;
     if (pIndex) {
-        bool use_legacy_signature = !llmq::utils::IsV19Active(pIndex);
+        const bool use_legacy_signature{!DeploymentActiveAfter(pIndex, Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
         if (!sig.SetHexStr(request.params[1].get_str(), use_legacy_signature)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid signature format");
         }
@@ -976,7 +977,7 @@ static UniValue verifyislock(const JSONRPCRequest& request)
     CHECK_NONFATAL(pBlockIndex != nullptr);
 
     CBLSSignature sig;
-    const bool use_bls_legacy = !llmq::utils::IsV19Active(pBlockIndex);
+    const bool use_bls_legacy{!DeploymentActiveAfter(pBlockIndex, Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
     if (!sig.SetHexStr(request.params[2].get_str(), use_bls_legacy)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid signature format");
     }

From ad4d753bd75bf5d0da5b41cafc78901925426abd Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 02:47:04 +0700
Subject: [PATCH 24/34] refactor: use DeploymentActiveAfter in
 llmq/blockprocessor

---
 src/llmq/blockprocessor.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
index b951d6e083..9018934404 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -13,6 +13,7 @@
 #include <chainparams.h>
 #include <consensus/params.h>
 #include <consensus/validation.h>
+#include <deploymentstatus.h>
 #include <net.h>
 #include <net_processing.h>
 #include <primitives/block.h>
@@ -708,7 +709,7 @@ std::optional<std::vector<CFinalCommitment>> CQuorumBlockProcessor::GetMineableC
     const auto *const pindex = m_chainstate.m_chain.Height() < nHeight ? m_chainstate.m_chain.Tip() : m_chainstate.m_chain.Tip()->GetAncestor(nHeight);
 
     bool rotation_enabled = utils::IsQuorumRotationEnabled(llmqParams, pindex);
-    bool basic_bls_enabled = utils::IsV19Active(pindex);
+    bool basic_bls_enabled{DeploymentActiveAfter(pindex, Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
     size_t quorums_num = rotation_enabled ? llmqParams.signingActiveQuorumCount : 1;
 
     std::stringstream ss;

From 55abf7fa8d3f54c3d435b284e27d104158f0a6df Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 02:50:22 +0700
Subject: [PATCH 25/34] refactor: drop dependency
 test/evo_deterministicmns_tests on llmq::utils

---
 src/test/evo_deterministicmns_tests.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/test/evo_deterministicmns_tests.cpp b/src/test/evo_deterministicmns_tests.cpp
index 22428f4288..fb7adcaff8 100644
--- a/src/test/evo_deterministicmns_tests.cpp
+++ b/src/test/evo_deterministicmns_tests.cpp
@@ -7,6 +7,7 @@
 #include <base58.h>
 #include <chainparams.h>
 #include <consensus/validation.h>
+#include <deploymentstatus.h>
 #include <messagesigner.h>
 #include <netbase.h>
 #include <policy/policy.h>
@@ -21,7 +22,6 @@
 #include <evo/deterministicmns.h>
 #include <evo/providertx.h>
 #include <evo/specialtx.h>
-#include <llmq/utils.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -267,7 +267,7 @@ void FuncDIP3Activation(TestChainSetup& setup)
 
 void FuncV19Activation(TestChainSetup& setup)
 {
-    BOOST_ASSERT(!llmq::utils::IsV19Active(::ChainActive().Tip()));
+    BOOST_ASSERT(!DeploymentActiveAfter(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_V19));
 
     // create
     auto utxos = BuildSimpleUtxoMap(setup.m_coinbase_txns);
@@ -283,7 +283,7 @@ void FuncV19Activation(TestChainSetup& setup)
 
     auto block = std::make_shared<CBlock>(setup.CreateBlock({tx_reg}, setup.coinbaseKey));
     BOOST_ASSERT(Assert(setup.m_node.chainman)->ProcessNewBlock(Params(), block, true, nullptr));
-    BOOST_ASSERT(!llmq::utils::IsV19Active(::ChainActive().Tip()));
+    BOOST_ASSERT(!DeploymentActiveAfter(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_V19));
     ++nHeight;
     BOOST_CHECK_EQUAL(::ChainActive().Height(), nHeight);
     deterministicMNManager->UpdatedBlockTip(::ChainActive().Tip());
@@ -301,7 +301,7 @@ void FuncV19Activation(TestChainSetup& setup)
 
     block = std::make_shared<CBlock>(setup.CreateBlock({tx_upreg}, setup.coinbaseKey));
     BOOST_ASSERT(Assert(setup.m_node.chainman)->ProcessNewBlock(Params(), block, true, nullptr));
-    BOOST_ASSERT(!llmq::utils::IsV19Active(::ChainActive().Tip()));
+    BOOST_ASSERT(!DeploymentActiveAfter(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_V19));
     ++nHeight;
     BOOST_CHECK_EQUAL(::ChainActive().Height(), nHeight);
     deterministicMNManager->UpdatedBlockTip(::ChainActive().Tip());
@@ -321,7 +321,7 @@ void FuncV19Activation(TestChainSetup& setup)
     BOOST_ASSERT(SignSignature(signing_provider, CTransaction(tx_reg), tx_spend, 0, SIGHASH_ALL));
     block = std::make_shared<CBlock>(setup.CreateBlock({tx_spend}, setup.coinbaseKey));
     BOOST_ASSERT(Assert(setup.m_node.chainman)->ProcessNewBlock(Params(), block, true, nullptr));
-    BOOST_ASSERT(!llmq::utils::IsV19Active(::ChainActive().Tip()));
+    BOOST_ASSERT(!DeploymentActiveAfter(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_V19));
     ++nHeight;
     BOOST_CHECK_EQUAL(::ChainActive().Height(), nHeight);
     deterministicMNManager->UpdatedBlockTip(::ChainActive().Tip());
@@ -333,7 +333,7 @@ void FuncV19Activation(TestChainSetup& setup)
 
     // mine another block so that it's not the last one before V19
     setup.CreateAndProcessBlock({}, setup.coinbaseKey);
-    BOOST_ASSERT(!llmq::utils::IsV19Active(::ChainActive().Tip()));
+    BOOST_ASSERT(!DeploymentActiveAfter(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_V19));
     ++nHeight;
     BOOST_CHECK_EQUAL(::ChainActive().Height(), nHeight);
     deterministicMNManager->UpdatedBlockTip(::ChainActive().Tip());
@@ -345,7 +345,7 @@ void FuncV19Activation(TestChainSetup& setup)
 
     // this block should activate V19
     setup.CreateAndProcessBlock({}, setup.coinbaseKey);
-    BOOST_ASSERT(llmq::utils::IsV19Active(::ChainActive().Tip()));
+    BOOST_ASSERT(DeploymentActiveAfter(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_V19));
     ++nHeight;
     BOOST_CHECK_EQUAL(::ChainActive().Height(), nHeight);
     deterministicMNManager->UpdatedBlockTip(::ChainActive().Tip());
@@ -365,7 +365,7 @@ void FuncV19Activation(TestChainSetup& setup)
     for (int i = 0; i < 10; ++i)
     {
         setup.CreateAndProcessBlock({}, setup.coinbaseKey);
-        BOOST_ASSERT(llmq::utils::IsV19Active(::ChainActive().Tip()));
+        BOOST_ASSERT(DeploymentActiveAfter(::ChainActive().Tip(), Params().GetConsensus(), Consensus::DEPLOYMENT_V19));
         BOOST_CHECK_EQUAL(::ChainActive().Height(), nHeight + 1 + i);
         deterministicMNManager->UpdatedBlockTip(::ChainActive().Tip());
         deterministicMNManager->DoMaintenance();

From 5d4b16a78390b4f80583b8a59cb325fd9aefd688 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 02:55:08 +0700
Subject: [PATCH 26/34] refactor: drop public method llmq::utils::IsV19Active

---
 src/llmq/utils.cpp | 10 +++++-----
 src/llmq/utils.h   |  2 --
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index 9980efbfaf..058021af93 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -34,6 +34,11 @@ static constexpr int TESTNET_LLMQ_25_67_ACTIVATION_HEIGHT = 847000;
  */
 std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(const CBlockIndex* pindex);
 
+static bool IsV19Active(gsl::not_null<const CBlockIndex*> pindexPrev)
+{
+    return DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_V19);
+}
+
 namespace llmq
 {
 
@@ -682,11 +687,6 @@ bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_n
     return DeploymentActiveAfter(pindex->GetAncestor(cycleQuorumBaseHeight - 1), Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024);
 }
 
-bool IsV19Active(gsl::not_null<const CBlockIndex*> pindex)
-{
-    return pindex->nHeight + 1 >= Params().GetConsensus().V19Height;
-}
-
 bool IsV20Active(gsl::not_null<const CBlockIndex*> pindex)
 {
     return llmq_versionbitscache.State(pindex, Params().GetConsensus(), Consensus::DEPLOYMENT_V20) == ThresholdState::ACTIVE;
diff --git a/src/llmq/utils.h b/src/llmq/utils.h
index 55c59b8b06..b0bcdc1ca4 100644
--- a/src/llmq/utils.h
+++ b/src/llmq/utils.h
@@ -78,8 +78,6 @@ std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuoru
 // TODO options
 bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pindex);
 // TODO deployments
-bool IsV19Active(gsl::not_null<const CBlockIndex*> pindex);
-// TODO deployments
 bool IsV20Active(gsl::not_null<const CBlockIndex*> pindex);
 
 /// Returns the state of `-llmq-data-recovery`

From db4379348c43bd0cfead018b8bd08d432b916946 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 03:06:32 +0700
Subject: [PATCH 27/34] refactor: drop dependency miner on
 llmq::utils::IsV20Active

---
 src/miner.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/miner.cpp b/src/miner.cpp
index 9f18d94689..cdd0b038d6 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -135,7 +135,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
 
     bool fDIP0003Active_context = DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_DIP0003);
     bool fDIP0008Active_context = DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_DIP0008);
-    bool fV20Active_context = llmq::utils::IsV20Active(pindexPrev);
+    const bool fV20Active_context{DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_V20)};
 
     pblock->nVersion = g_versionbitscache.ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
     // Non-mainnet only: allow overriding block.nVersion with
@@ -402,7 +402,7 @@ void BlockAssembler::addPackageTxs(int &nPackagesSelected, int &nDescendantsUpda
     // This credit pool is used only to check withdrawal limits and to find
     // duplicates of indexes. There's used `BlockSubsidy` equaled to 0
     std::optional<CCreditPoolDiff> creditPoolDiff;
-    if (llmq::utils::IsV20Active(pindexPrev)) {
+    if (DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_V20)) {
         CCreditPool creditPool = creditPoolManager->GetCreditPool(pindexPrev, chainparams.GetConsensus());
         creditPoolDiff.emplace(std::move(creditPool), pindexPrev, chainparams.GetConsensus(), 0);
     }

From 70fa6263814dce4c0d65a35b56443cbdbca9102d Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 03:08:42 +0700
Subject: [PATCH 28/34] refactor: drop dependency validation on llmq/utils

---
 src/validation.cpp                      | 3 +--
 test/lint/lint-circular-dependencies.sh | 1 -
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/validation.cpp b/src/validation.cpp
index d05bed342e..0c720c9e01 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -61,7 +61,6 @@
 
 #include <llmq/instantsend.h>
 #include <llmq/chainlocks.h>
-#include <llmq/utils.h>
 
 #include <statsd_client.h>
 
@@ -1171,7 +1170,7 @@ CAmount GetBlockSubsidyInner(int nPrevBits, int nPrevHeight, const Consensus::Pa
 CAmount GetBlockSubsidy(const CBlockIndex* const pindex, const Consensus::Params& consensusParams)
 {
     if (pindex->pprev == nullptr) return Params().GenesisBlock().vtx[0]->GetValueOut();
-    bool isV20Active = llmq::utils::IsV20Active(pindex->pprev);
+    const bool isV20Active{DeploymentActiveAt(*pindex, consensusParams, Consensus::DEPLOYMENT_V20)};
     return GetBlockSubsidyInner(pindex->pprev->nBits, pindex->pprev->nHeight, consensusParams, isV20Active);
 }
 
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index 7536677682..3f91423783 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -100,7 +100,6 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "governance/object -> validationinterface -> governance/object"
     "governance/vote -> validation -> validationinterface -> governance/vote"
     "llmq/signing -> masternode/node -> validationinterface -> llmq/signing"
-    "llmq/utils -> validation -> llmq/utils"
     "evo/mnhftx -> validation -> evo/mnhftx"
     "evo/deterministicmns -> validation -> evo/deterministicmns"
 )

From bc0f0bf85207b9bd870b1f6719d235f72880fdb4 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 03:16:45 +0700
Subject: [PATCH 29/34] chore: removed TODO for
 TESTNET_LLMQ_25_67_ACTIVATION_HEIGHT so far as have no idea why it is not
 matching with v19 activation

---
 src/llmq/utils.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index 058021af93..b7006331c6 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -26,7 +26,6 @@
 #include <atomic>
 #include <optional>
 
-// TODO remove this const
 static constexpr int TESTNET_LLMQ_25_67_ACTIVATION_HEIGHT = 847000;
 
 /**

From 917089d542e7e5b1767918d945f4cdfb05d00dde Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 03:18:43 +0700
Subject: [PATCH 30/34] refactor: drop public llmq::utils::IsV20Active method

---
 src/llmq/utils.cpp | 10 +++++-----
 src/llmq/utils.h   |  2 --
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index b7006331c6..f4549563c1 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -38,6 +38,11 @@ static bool IsV19Active(gsl::not_null<const CBlockIndex*> pindexPrev)
     return DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_V19);
 }
 
+static bool IsV20Active(gsl::not_null<const CBlockIndex*> pindexPrev)
+{
+    return llmq_versionbitscache.State(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_V20) == ThresholdState::ACTIVE;
+}
+
 namespace llmq
 {
 
@@ -686,11 +691,6 @@ bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_n
     return DeploymentActiveAfter(pindex->GetAncestor(cycleQuorumBaseHeight - 1), Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024);
 }
 
-bool IsV20Active(gsl::not_null<const CBlockIndex*> pindex)
-{
-    return llmq_versionbitscache.State(pindex, Params().GetConsensus(), Consensus::DEPLOYMENT_V20) == ThresholdState::ACTIVE;
-}
-
 uint256 DeterministicOutboundConnection(const uint256& proTxHash1, const uint256& proTxHash2)
 {
     // We need to deterministically select who is going to initiate the connection. The naive way would be to simply
diff --git a/src/llmq/utils.h b/src/llmq/utils.h
index b0bcdc1ca4..8a09a58ae0 100644
--- a/src/llmq/utils.h
+++ b/src/llmq/utils.h
@@ -77,8 +77,6 @@ std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuoru
 
 // TODO options
 bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pindex);
-// TODO deployments
-bool IsV20Active(gsl::not_null<const CBlockIndex*> pindex);
 
 /// Returns the state of `-llmq-data-recovery`
 // TODO options

From f57859f777b7a59788af3ced51e5a99e179e2c39 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 03:23:35 +0700
Subject: [PATCH 31/34] refactor: drop llmq_versionbitscache in favor of
 g_versionbitscache

Note: g_versionbitscache is reset in UnloadBlockIndex()
---
 src/llmq/context.cpp | 1 -
 src/llmq/utils.cpp   | 8 +++-----
 src/llmq/utils.h     | 5 -----
 3 files changed, 3 insertions(+), 11 deletions(-)

diff --git a/src/llmq/context.cpp b/src/llmq/context.cpp
index 3583675561..a7f77c2fb0 100644
--- a/src/llmq/context.cpp
+++ b/src/llmq/context.cpp
@@ -60,7 +60,6 @@ LLMQContext::~LLMQContext() {
     llmq::chainLocksHandler.reset();
     llmq::quorumManager.reset();
     llmq::quorumBlockProcessor.reset();
-    llmq::llmq_versionbitscache.Clear();
 }
 
 void LLMQContext::Interrupt() {
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index f4549563c1..b6dfb92de7 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -40,14 +40,12 @@ static bool IsV19Active(gsl::not_null<const CBlockIndex*> pindexPrev)
 
 static bool IsV20Active(gsl::not_null<const CBlockIndex*> pindexPrev)
 {
-    return llmq_versionbitscache.State(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_V20) == ThresholdState::ACTIVE;
+    return DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_V20);
 }
 
 namespace llmq
 {
 
-VersionBitsCache llmq_versionbitscache;
-
 namespace utils
 
 {
@@ -953,10 +951,10 @@ bool IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CQuorumMana
             return true;
 
         case Consensus::LLMQType::LLMQ_TEST_V17: {
-            return llmq_versionbitscache.State(pindexPrev, consensusParams, Consensus::DEPLOYMENT_TESTDUMMY) == ThresholdState::ACTIVE;
+            return DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_TESTDUMMY);
         }
         case Consensus::LLMQType::LLMQ_100_67:
-            return pindexPrev->nHeight + 1 >= consensusParams.DIP0020Height;
+            return DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_DIP0020);
 
         case Consensus::LLMQType::LLMQ_60_75:
         case Consensus::LLMQType::LLMQ_DEVNET_DIP0024:
diff --git a/src/llmq/utils.h b/src/llmq/utils.h
index 8a09a58ae0..9f2e8bd229 100644
--- a/src/llmq/utils.h
+++ b/src/llmq/utils.h
@@ -29,11 +29,6 @@ namespace llmq
 class CQuorumManager;
 class CQuorumSnapshot;
 
-// A separate cache instance instead of versionbitscache has been introduced to avoid locking cs_main
-// and dealing with all kinds of deadlocks.
-// TODO: drop llmq_versionbitscache completely so far as VersionBitsCache do not uses anymore cs_main
-extern VersionBitsCache llmq_versionbitscache;
-
 static const bool DEFAULT_ENABLE_QUORUM_DATA_RECOVERY = true;
 
 enum class QvvecSyncMode {

From 1b3237d14789a4a61346ff47c56f7a125706ce51 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 14:48:03 +0700
Subject: [PATCH 32/34] fix: remove unused cs_main lock from src/miner.cpp -
 it's not used by EHF logic anymore

---
 src/miner.cpp    | 5 ++---
 src/validation.h | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/miner.cpp b/src/miner.cpp
index cdd0b038d6..90348da9cd 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -133,8 +133,8 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     assert(pindexPrev != nullptr);
     nHeight = pindexPrev->nHeight + 1;
 
-    bool fDIP0003Active_context = DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_DIP0003);
-    bool fDIP0008Active_context = DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_DIP0008);
+    const bool fDIP0003Active_context{DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_DIP0003)};
+    const bool fDIP0008Active_context{DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_DIP0008)};
     const bool fV20Active_context{DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_V20)};
 
     pblock->nVersion = g_versionbitscache.ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
@@ -396,7 +396,6 @@ void BlockAssembler::SortForBlock(const CTxMemPool::setEntries& package, std::ve
 // transaction package to work on next.
 void BlockAssembler::addPackageTxs(int &nPackagesSelected, int &nDescendantsUpdated, const CBlockIndex* const pindexPrev)
 {
-    AssertLockHeld(cs_main); // for GetMNHFSignalsStage()
     AssertLockHeld(m_mempool.cs);
 
     // This credit pool is used only to check withdrawal limits and to find
diff --git a/src/validation.h b/src/validation.h
index 1695be3073..d73fdedc57 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -766,7 +766,7 @@ public:
         size_t max_mempool_size_bytes) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     /** Return list of MN EHF signals for current Tip() */
-    std::unordered_map<uint8_t, int> GetMNHFSignalsStage(const CBlockIndex* pindex) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    std::unordered_map<uint8_t, int> GetMNHFSignalsStage(const CBlockIndex* pindex);
 
     std::string ToString() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 private:

From c3c9ccf26120c1e7510d745a8a68fe6828c02648 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 15:32:18 +0700
Subject: [PATCH 33/34] refactor: drop global variable fDIP0001ActiveAtTip -
 partial implementation

Impossible to drop it completelly right now because:
 - net doesn't know any details about chain - can't check status of fork
 - the functional test feature_maxuploadtarget.py assume block size 1Mb
 - DIP0001 can't be activated from regtest early block2 because big txes are
 not allowed after DIP0001

refactor: drop global variable fDIP0001ActiveAtTip - attempt 2
---
 src/miner.cpp      | 11 ++++++++---
 src/miner.h        |  3 ++-
 src/net.cpp        |  2 +-
 src/rpc/mining.cpp |  5 +++--
 src/validation.cpp |  2 +-
 5 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/src/miner.cpp b/src/miner.cpp
index 90348da9cd..54f629fe92 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -35,6 +35,7 @@
 #include <llmq/utils.h>
 #include <masternode/payments.h>
 #include <spork.h>
+#include <validation.h>
 
 #include <algorithm>
 #include <utility>
@@ -72,8 +73,7 @@ BlockAssembler::BlockAssembler(const CSporkManager& sporkManager, CGovernanceMan
       m_evoDb(evoDb)
 {
     blockMinFeeRate = options.blockMinFeeRate;
-    // Limit size to between 1K and MaxBlockSize()-1K for sanity:
-    nBlockMaxSize = std::max((unsigned int)1000, std::min((unsigned int)(MaxBlockSize(fDIP0001ActiveAtTip) - 1000), (unsigned int)options.nBlockMaxSize));
+    nBlockMaxSize = options.nBlockMaxSize;
 }
 
 static BlockAssembler::Options DefaultOptions()
@@ -133,10 +133,15 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     assert(pindexPrev != nullptr);
     nHeight = pindexPrev->nHeight + 1;
 
+    const bool fDIP0001Active_context{DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_DIP0001)};
     const bool fDIP0003Active_context{DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_DIP0003)};
     const bool fDIP0008Active_context{DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_DIP0008)};
     const bool fV20Active_context{DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_V20)};
 
+    // Limit size to between 1K and MaxBlockSize()-1K for sanity:
+    nBlockMaxSize = std::max<unsigned int>(1000, std::min<unsigned int>(MaxBlockSize(fDIP0001Active_context) - 1000, nBlockMaxSize));
+    nBlockMaxSigOps = MaxBlockSigOps(fDIP0001Active_context);
+
     pblock->nVersion = g_versionbitscache.ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
     // Non-mainnet only: allow overriding block.nVersion with
     // -blockversion=N to test forking scenarios
@@ -284,7 +289,7 @@ bool BlockAssembler::TestPackage(uint64_t packageSize, unsigned int packageSigOp
 {
     if (nBlockSize + packageSize >= nBlockMaxSize)
         return false;
-    if (nBlockSigOps + packageSigOps >= MaxBlockSigOps(fDIP0001ActiveAtTip))
+    if (nBlockSigOps + packageSigOps >= nBlockMaxSigOps)
         return false;
     return true;
 }
diff --git a/src/miner.h b/src/miner.h
index d2e7b2f919..f8ddbbbad0 100644
--- a/src/miner.h
+++ b/src/miner.h
@@ -8,7 +8,6 @@
 
 #include <primitives/block.h>
 #include <txmempool.h>
-#include <validation.h>
 
 #include <memory>
 #include <optional>
@@ -20,6 +19,7 @@
 class CBlockIndex;
 class CChainParams;
 class CConnman;
+class CEvoDB;
 class CGovernanceManager;
 class CScript;
 class CSporkManager;
@@ -142,6 +142,7 @@ private:
 
     // Configuration parameters for the block size
     unsigned int nBlockMaxSize;
+    unsigned int nBlockMaxSigOps;
     CFeeRate blockMinFeeRate;
 
     // Information on the current status of the block
diff --git a/src/net.cpp b/src/net.cpp
index e221974652..06429ba0dd 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -29,7 +29,7 @@
 #include <util/thread.h>
 #include <util/time.h>
 #include <util/translation.h>
-#include <validation.h>
+#include <validation.h> // for fDIP0001ActiveAtTip
 
 #include <masternode/meta.h>
 #include <masternode/sync.h>
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 02057ce65a..9d4415275c 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -903,6 +903,7 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
         aMutable.push_back("version/force");
     }
 
+    const bool fDIP0001Active_context{DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_DIP0001)};
     result.pushKV("previousblockhash", pblock->hashPrevBlock.GetHex());
     result.pushKV("transactions", transactions);
     result.pushKV("coinbaseaux", aux);
@@ -912,8 +913,8 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
     result.pushKV("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1);
     result.pushKV("mutable", aMutable);
     result.pushKV("noncerange", "00000000ffffffff");
-    result.pushKV("sigoplimit", (int64_t)MaxBlockSigOps(fDIP0001ActiveAtTip));
-    result.pushKV("sizelimit", (int64_t)MaxBlockSize(fDIP0001ActiveAtTip));
+    result.pushKV("sigoplimit", (int64_t)MaxBlockSigOps(fDIP0001Active_context));
+    result.pushKV("sizelimit", (int64_t)MaxBlockSize(fDIP0001Active_context));
     result.pushKV("curtime", pblock->GetBlockTime());
     result.pushKV("bits", strprintf("%08x", pblock->nBits));
     result.pushKV("previousbits", strprintf("%08x", pblocktemplate->nPrevBits));
diff --git a/src/validation.cpp b/src/validation.cpp
index 0c720c9e01..c89e5904ed 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -156,7 +156,7 @@ bool fCheckpointsEnabled = DEFAULT_CHECKPOINTS_ENABLED;
 uint64_t nPruneTarget = 0;
 int64_t nMaxTipAge = DEFAULT_MAX_TIP_AGE;
 
-// TODO: drop this global variable
+// TODO: drop this global variable. Used by net.cpp module only
 std::atomic<bool> fDIP0001ActiveAtTip{false};
 
 uint256 hashAssumeValid;

From 42e65f45410480f88f9d08ad1527039f5b21aa47 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <knstqq@gmail.com>
Date: Tue, 5 Dec 2023 16:02:11 +0700
Subject: [PATCH 34/34] chore: remaining TODO goes to other PRs

---
 src/llmq/utils.h | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/src/llmq/utils.h b/src/llmq/utils.h
index 9f2e8bd229..a19e1981d7 100644
--- a/src/llmq/utils.h
+++ b/src/llmq/utils.h
@@ -47,9 +47,7 @@ uint256 GetHashModifier(const Consensus::LLMQParams& llmqParams, gsl::not_null<c
 uint256 BuildCommitmentHash(Consensus::LLMQType llmqType, const uint256& blockHash, const std::vector<bool>& validMembers, const CBLSPublicKey& pubKey, const uint256& vvecHash);
 uint256 BuildSignHash(Consensus::LLMQType llmqType, const uint256& quorumHash, const uint256& id, const uint256& msgHash);
 
-// TODO options
 bool IsAllMembersConnectedEnabled(Consensus::LLMQType llmqType);
-// TODO options
 bool IsQuorumPoseEnabled(Consensus::LLMQType llmqType);
 uint256 DeterministicOutboundConnection(const uint256& proTxHash1, const uint256& proTxHash2);
 std::set<uint256> GetQuorumConnections(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound);
@@ -60,24 +58,17 @@ bool EnsureQuorumConnections(const Consensus::LLMQParams& llmqParams, gsl::not_n
 void AddQuorumProbeConnections(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex, CConnman& connman, const uint256& myProTxHash);
 
 bool IsQuorumActive(Consensus::LLMQType llmqType, const CQuorumManager& qman, const uint256& quorumHash);
-// TODO options maybe not
 bool IsQuorumTypeEnabled(Consensus::LLMQType llmqType, const CQuorumManager& qman, gsl::not_null<const CBlockIndex*> pindexPrev);
-// TODO options maybe not
 bool IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CQuorumManager& qman, gsl::not_null<const CBlockIndex*> pindexPrev, std::optional<bool> optDIP0024IsActive, std::optional<bool> optHaveDIP0024Quorums);
 
-// TODO options maybe not
 std::vector<Consensus::LLMQType> GetEnabledQuorumTypes(gsl::not_null<const CBlockIndex*> pindex);
-// TODO options maybe not
 std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuorumParams(gsl::not_null<const CBlockIndex*> pindex);
 
-// TODO options
 bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pindex);
 
 /// Returns the state of `-llmq-data-recovery`
-// TODO options
 bool QuorumDataRecoveryEnabled();
 
-// TODO options
 /// Returns the state of `-watchquorums`
 bool IsWatchQuorumsEnabled();