From 4e0b36e5fd8a5be0e60539631aafb4ca2554e351 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Sat, 2 May 2026 02:12:31 +0700
Subject: [PATCH 1/4] refactor: simplify implementation of regression tests
 evo_trivialvalidation

This commit replaces usage of helpers GetPayload+IsTrivialValid to GetValidatedPayload
It unifies validation between regression tests and production code and
useful for the next commits in PR
---
 src/evo/specialtxman.cpp             |  4 ++--
 src/evo/specialtxman.h               |  9 +++++++++
 src/test/data/trivially_invalid.json |  2 +-
 src/test/evo_trivialvalidation.cpp   | 17 ++++++++---------
 4 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 515c1dd06dec..c4e5dec5b4b0 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -859,8 +859,8 @@ static bool CheckHashSig(const ProTx& proTx, const CBLSPublicKey& pubKey, TxVali
 }
 
 template <typename ProTx>
-static std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
-                                                const ChainstateManager& chainman, TxValidationState& state)
+std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                                         const ChainstateManager& chainman, TxValidationState& state)
 {
     if (tx.nType != ProTx::SPECIALTX_TYPE) {
         state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-type");
diff --git a/src/evo/specialtxman.h b/src/evo/specialtxman.h
index 2d5ab32096bb..ee16bad08893 100644
--- a/src/evo/specialtxman.h
+++ b/src/evo/specialtxman.h
@@ -93,6 +93,15 @@ class CSpecialTxProcessor
 };
 
 
+/**
+ * This helper does some trivial validations that doesn't depends on collateral and
+ * masternode list. Use CheckPro*Tx for the full validation of transaction,
+ * including bls signatures, list of masternodes and collateral
+ */
+template <typename ProTx>
+std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                                         const ChainstateManager& chainman, TxValidationState& state);
+
 bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
                    CDeterministicMNManager& dmnman, const CCoinsViewCache& view, const ChainstateManager& chainman,
                    TxValidationState& state, bool check_sigs);
diff --git a/src/test/data/trivially_invalid.json b/src/test/data/trivially_invalid.json
index cfc789cbee37..88489086c809 100644
--- a/src/test/data/trivially_invalid.json
+++ b/src/test/data/trivially_invalid.json
@@ -85,7 +85,7 @@
     "proupregtx",
     "legacy",
     "03000300010000000000000000000000000000000000000000000000000000000000000000ffffffff016affffffff0100f2052a01000000016a00000000e40000bfd280d22a21574ea9f568f7a729b370f4051b89eab6df3d0d74b65fde1bdb7900000a6a7fb814db71eb6ef12341749d81b5fd326eb4b9445a3be65668da9856910b378ec6427fe18fc81c39499e7c7060647618f8ec94404051e4a7ab68f1b017fd9e7f94761976a914c18e0b18e0d992e7471d8a4d4da428e8e191328788ac959ca83b61eeb3f5543973253da6da8e9ac23f9e7844453ac5543b51d0177799416666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666",
-    "gettxpayload-fail",
+    "bad-protx-payload",
     "Transaction with version set to null"
 ],
 [
diff --git a/src/test/evo_trivialvalidation.cpp b/src/test/evo_trivialvalidation.cpp
index 74da999581b2..26b6bddbb778 100644
--- a/src/test/evo_trivialvalidation.cpp
+++ b/src/test/evo_trivialvalidation.cpp
@@ -11,6 +11,7 @@
 #include <chainparams.h>
 #include <deploymentstatus.h>
 #include <evo/providertx.h>
+#include <evo/specialtxman.h>
 #include <primitives/transaction.h>
 #include <validation.h>
 
@@ -29,22 +30,20 @@ template <class T>
 void TestTxHelper(const CMutableTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
                   const std::optional<std::string>& expected_error, const ChainstateManager& chainman)
 {
-    const bool payload_to_fail = expected_error.has_value() && expected_error.value() == "gettxpayload-fail";
-    const auto opt_payload = GetTxPayload<T>(tx, false);
-    BOOST_CHECK_EQUAL(opt_payload.has_value(), !payload_to_fail);
+    TxValidationState dummy_state;
+    auto opt_payload = GetValidatedPayload<T>(CTransaction{tx}, pindexPrev, chainman, dummy_state);
 
-    // No need to check anything else if GetTxPayload() expected to fail
-    if (payload_to_fail) return;
+    BOOST_CHECK_EQUAL(opt_payload.has_value(), !expected_error.has_value());
 
-    TxValidationState dummy_state;
-    BOOST_CHECK_EQUAL(opt_payload->IsTriviallyValid(pindexPrev, chainman, dummy_state), !expected_error.has_value());
     if (expected_error.has_value()) {
         BOOST_CHECK_EQUAL(dummy_state.GetRejectReason(), expected_error.value());
     }
 }
 
-void trivialvalidation_runner(const ChainstateManager& chainman, const std::string& json)
+void trivialvalidation_runner(ChainstateManager& chainman, const std::string& json)
 {
+    LOCK(::cs_main);
+
     const UniValue vectors = read_json(json);
 
     for (size_t idx = 1; idx < vectors.size(); idx++) {
@@ -72,7 +71,7 @@ void trivialvalidation_runner(const ChainstateManager& chainman, const std::stri
             BOOST_CHECK_EQUAL(tx.nVersion, 3);
             BOOST_CHECK_EQUAL(tx.GetHash(), txHash);
             // Deserialization based on transaction nType
-            TxValidationState dummy_state;
+
             switch (tx.nType) {
             case TRANSACTION_PROVIDER_REGISTER: {
                 BOOST_CHECK_EQUAL(txType, "proregtx");

From d86d5716a126b19adec84daf6bc600b502ae045a Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Fri, 1 May 2026 02:24:52 +0700
Subject: [PATCH 2/4] fix!: use the same version along all protx special
 transactions

CProRegTx and CProUpServTx used to be the only type of protx that have
a different version. It is theoretically acceptable in assumption that
there is no new features or version will ever be introduced for protx
special transaction.

Though, for better compatibility for futher version, unification, simplicity
of documentation and to reduce user's confusions for after-v24 version
of CProUpRegTx and CProUpRevTx are allowed to be "ext addresses" even they
don't have any network related fields _at the moment_

So, since now:
 - version 1: legacy BLS, extended addresses disallowed (pre v19 fork)
 - version 2: basic BLS, extended addresses disallowed (since v19 fork)
 - version 3: basic BLS, extended addresses allowed (since v24 fork)

NOTE: there are also classes CSimplifiedMNListEntry and CDeterministicMNState
use the same enum for its version; moreover CDeterministicMNState inherits
version directly from CProRegTx. This refactoring doesn't contradict or conflict
this behavior
---
 src/evo/providertx.cpp   |  9 ++++-----
 src/evo/specialtxman.cpp | 17 +++++------------
 2 files changed, 9 insertions(+), 17 deletions(-)

diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index b2c3691aa4f5..21be463e00ac 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -20,11 +20,10 @@ template <typename T>
 [[nodiscard]] uint16_t GetMaxFromDeployment(gsl::not_null<const CBlockIndex*> pindexPrev,
                                             const ChainstateManager& chainman, std::optional<bool> is_basic_override)
 {
-    constexpr bool is_extaddr_eligible{std::is_same_v<std::decay_t<T>, CProRegTx> || std::is_same_v<std::decay_t<T>, CProUpServTx>};
-    return ProTxVersion::GetMax(
-        is_basic_override ? *is_basic_override
-                          : DeploymentActiveAfter(pindexPrev, chainman.GetConsensus(), Consensus::DEPLOYMENT_V19),
-        is_extaddr_eligible ? DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24) : false);
+    return ProTxVersion::GetMax(is_basic_override ? *is_basic_override
+                                                  : DeploymentActiveAfter(pindexPrev, chainman.GetConsensus(),
+                                                                          Consensus::DEPLOYMENT_V19),
+                                DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24));
 }
 template uint16_t GetMaxFromDeployment<CProRegTx>(gsl::not_null<const CBlockIndex*> pindexPrev,
                                                   const ChainstateManager& chainman,
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index c4e5dec5b4b0..a23472e0e9ea 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -882,15 +882,13 @@ std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not_null<c
 /**
  * Validates potential changes to masternode state version by ProTx transaction version
  * @param[in]  pindexPrev    Previous block index to validate DEPLOYMENT_V24 activation
- * @param[in]  tx_type       Special transaction type
  * @param[in]  state_version Current masternode state version
  * @param[in]  tx_version    Proposed transaction version
  * @param[out] state         This may be set to an Error state if any error occurred processing them
  * @returns                  true if version change is valid or DEPLOYMENT_V24 is not active
  */
-static bool IsVersionChangeValid(gsl::not_null<const CBlockIndex*> pindexPrev, const uint16_t tx_type,
-                                 const uint16_t state_version, const uint16_t tx_version,
-                                 const ChainstateManager& chainman, TxValidationState& state)
+static bool IsVersionChangeValid(gsl::not_null<const CBlockIndex*> pindexPrev, const uint16_t state_version,
+                                 const uint16_t tx_version, const ChainstateManager& chainman, TxValidationState& state)
 {
     if (!DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)) {
         // New restrictions only apply after v24 deployment
@@ -907,11 +905,6 @@ static bool IsVersionChangeValid(gsl::not_null<const CBlockIndex*> pindexPrev, c
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-upgrade");
     }
 
-    if (tx_type != TRANSACTION_PROVIDER_UPDATE_SERVICE && tx_version == ProTxVersion::ExtAddr) {
-        // Only new entries (ProRegTx) and service updates (ProUpServTx) can use ExtAddr versioning
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-tx-type");
-    }
-
     return true;
 }
 
@@ -1077,7 +1070,7 @@ bool CheckProUpServTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*>
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-hash");
     }
 
-    if (!IsVersionChangeValid(pindexPrev, tx.nType, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
+    if (!IsVersionChangeValid(pindexPrev, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
         // pass the state returned by the function above
         return false;
     }
@@ -1152,7 +1145,7 @@ bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-hash");
     }
 
-    if (!IsVersionChangeValid(pindexPrev, tx.nType, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
+    if (!IsVersionChangeValid(pindexPrev, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
         // pass the state returned by the function above
         return false;
     }
@@ -1219,7 +1212,7 @@ bool CheckProUpRevTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-hash");
     }
 
-    if (!IsVersionChangeValid(pindexPrev, tx.nType, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
+    if (!IsVersionChangeValid(pindexPrev, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
         // pass the state returned by the function above
         return false;
     }

From 5393e1a4735a364d90f38a3f06c1021c0a5ceb27 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Thu, 30 Apr 2026 19:35:14 +0700
Subject: [PATCH 3/4] refactor: simplify implementation of providertx
 versioning

It helps to drop multiple circular dependencies for providertx <-> validation.h as a side effect
---
 src/evo/netinfo.cpp                     |  2 +-
 src/evo/providertx.cpp                  | 45 +++--------------
 src/evo/providertx.h                    | 65 +++++++++----------------
 src/evo/specialtxman.cpp                |  6 ++-
 src/evo/types.h                         | 24 +++++++++
 src/rpc/evo.cpp                         | 15 +++---
 src/validation.cpp                      |  9 ++++
 src/validation.h                        |  7 +++
 test/lint/lint-circular-dependencies.py |  9 ++--
 9 files changed, 85 insertions(+), 97 deletions(-)

diff --git a/src/evo/netinfo.cpp b/src/evo/netinfo.cpp
index a3f53693ccaf..eab2e93a9b16 100644
--- a/src/evo/netinfo.cpp
+++ b/src/evo/netinfo.cpp
@@ -5,7 +5,7 @@
 #include <evo/netinfo.h>
 
 #include <chainparams.h>
-#include <evo/providertx.h>
+#include <evo/types.h>
 #include <netbase.h>
 #include <span.h>
 #include <util/check.h>
diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index 21be463e00ac..05803bbb3305 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -13,31 +13,6 @@
 #include <hash.h>
 #include <script/standard.h>
 #include <tinyformat.h>
-#include <validation.h>
-
-namespace ProTxVersion {
-template <typename T>
-[[nodiscard]] uint16_t GetMaxFromDeployment(gsl::not_null<const CBlockIndex*> pindexPrev,
-                                            const ChainstateManager& chainman, std::optional<bool> is_basic_override)
-{
-    return ProTxVersion::GetMax(is_basic_override ? *is_basic_override
-                                                  : DeploymentActiveAfter(pindexPrev, chainman.GetConsensus(),
-                                                                          Consensus::DEPLOYMENT_V19),
-                                DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24));
-}
-template uint16_t GetMaxFromDeployment<CProRegTx>(gsl::not_null<const CBlockIndex*> pindexPrev,
-                                                  const ChainstateManager& chainman,
-                                                  std::optional<bool> is_basic_override);
-template uint16_t GetMaxFromDeployment<CProUpServTx>(gsl::not_null<const CBlockIndex*> pindexPrev,
-                                                     const ChainstateManager& chainman,
-                                                     std::optional<bool> is_basic_override);
-template uint16_t GetMaxFromDeployment<CProUpRegTx>(gsl::not_null<const CBlockIndex*> pindexPrev,
-                                                    const ChainstateManager& chainman,
-                                                    std::optional<bool> is_basic_override);
-template uint16_t GetMaxFromDeployment<CProUpRevTx>(gsl::not_null<const CBlockIndex*> pindexPrev,
-                                                    const ChainstateManager& chainman,
-                                                    std::optional<bool> is_basic_override);
-} // namespace ProTxVersion
 
 template <typename ProTx>
 bool IsNetInfoTriviallyValid(const ProTx& proTx, TxValidationState& state)
@@ -63,10 +38,9 @@ bool IsNetInfoTriviallyValid(const ProTx& proTx, TxValidationState& state)
     return true;
 }
 
-bool CProRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                                 TxValidationState& state) const
+bool CProRegTx::IsTriviallyValid(TxValidationState& state) const
 {
-    if (nVersion == 0 || nVersion > ProTxVersion::GetMaxFromDeployment<decltype(*this)>(pindexPrev, chainman)) {
+    if (nVersion == 0 || nVersion > ProTxVersion::ExtAddr) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
     }
     if (nVersion < ProTxVersion::BasicBLS && nType == MnType::Evo) {
@@ -161,10 +135,9 @@ std::string CProRegTx::ToString() const
                           : strprintf(", platformP2PPort=%d, platformHTTPPort=%d", platformP2PPort, platformHTTPPort)));
 }
 
-bool CProUpServTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                                    TxValidationState& state) const
+bool CProUpServTx::IsTriviallyValid(TxValidationState& state) const
 {
-    if (nVersion == 0 || nVersion > ProTxVersion::GetMaxFromDeployment<decltype(*this)>(pindexPrev, chainman)) {
+    if (nVersion == 0 || nVersion > ProTxVersion::ExtAddr) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
     }
     if (nVersion < ProTxVersion::BasicBLS && nType == MnType::Evo) {
@@ -206,10 +179,9 @@ std::string CProUpServTx::ToString() const
                           : strprintf(", platformP2PPort=%d, platformHTTPPort=%d", platformP2PPort, platformHTTPPort)));
 }
 
-bool CProUpRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                                   TxValidationState& state) const
+bool CProUpRegTx::IsTriviallyValid(TxValidationState& state) const
 {
-    if (nVersion == 0 || nVersion > ProTxVersion::GetMaxFromDeployment<decltype(*this)>(pindexPrev, chainman)) {
+    if (nVersion == 0 || nVersion > ProTxVersion::ExtAddr) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
     }
     if (nMode != 0) {
@@ -240,10 +212,9 @@ std::string CProUpRegTx::ToString() const
         nVersion, proTxHash.ToString(), pubKeyOperator.ToString(), EncodeDestination(PKHash(keyIDVoting)), payee);
 }
 
-bool CProUpRevTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                                   TxValidationState& state) const
+bool CProUpRevTx::IsTriviallyValid(TxValidationState& state) const
 {
-    if (nVersion == 0 || nVersion > ProTxVersion::GetMaxFromDeployment<decltype(*this)>(pindexPrev, chainman)) {
+    if (nVersion == 0 || nVersion > ProTxVersion::ExtAddr) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
     }
 
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index 68c6fe3c7aa2..3e2fa97bd174 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -9,6 +9,7 @@
 #include <evo/dmn_types.h>
 #include <evo/netinfo.h>
 #include <evo/specialtx.h>
+#include <evo/types.h>
 #include <primitives/transaction.h>
 #include <util/std23.h>
 
@@ -17,46 +18,12 @@
 #include <netaddress.h>
 #include <pubkey.h>
 
-#include <univalue.h>
 #include <gsl/pointers.h>
+#include <univalue.h>
 
-class CBlockIndex;
-class ChainstateManager;
 class TxValidationState;
 struct RPCResult;
 
-namespace ProTxVersion {
-enum : uint16_t {
-    LegacyBLS = 1,
-    BasicBLS  = 2,
-    ExtAddr   = 3,
-};
-
-/** Get highest permissible ProTx version based on flags set. */
-[[nodiscard]] constexpr uint16_t GetMax(const bool is_basic_scheme_active, const bool is_extended_addr)
-{
-    if (is_basic_scheme_active) {
-        if (is_extended_addr) {
-            // Requires *both* forks to be active to use extended addresses. is_basic_scheme_active could
-            // be set to false due to RPC specialization, so we must evaluate is_extended_addr *last* to
-            // avoid accidentally upgrading a legacy BLS node to basic BLS due to v24 activation.
-            return ProTxVersion::ExtAddr;
-        }
-        return ProTxVersion::BasicBLS;
-    }
-    return ProTxVersion::LegacyBLS;
-}
-
-/** Get highest permissible ProTx version based on deployment status
- *  Note: The override is needed because some RPCs need to use deployment status information for everything *except*
- *        the BLS version upgrade since they are specializations for a specific BLS version. This is a one-off.
- *  TODO: Resolve this oddity. Consider deprecating legacy BLS-only RPCs so we can remove them eventually.
- */
-template <typename T>
-[[nodiscard]] uint16_t GetMaxFromDeployment(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                                            std::optional<bool> is_basic_override = std::nullopt);
-} // namespace ProTxVersion
-
 class CProRegTx
 {
 public:
@@ -125,8 +92,11 @@ class CProRegTx
     [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
     [[nodiscard]] UniValue ToJson() const;
 
-    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                          TxValidationState& state) const;
+    /**
+     * Note: this check validates only some trivial consensus rules
+     * Use `CheckProRegTx` or GetValidatedPayload<T> helper for full validation
+     */
+    bool IsTriviallyValid(TxValidationState& state) const;
 };
 
 class CProUpServTx
@@ -187,8 +157,11 @@ class CProUpServTx
     [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
     [[nodiscard]] UniValue ToJson() const;
 
-    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                          TxValidationState& state) const;
+    /**
+     * Note: this check validates only some trivial consensus rules
+     * Use `CheckProUpServTx` or GetValidatedPayload<T> helper for full validation
+     */
+    bool IsTriviallyValid(TxValidationState& state) const;
 };
 
 class CProUpRegTx
@@ -235,8 +208,11 @@ class CProUpRegTx
     [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
     [[nodiscard]] UniValue ToJson() const;
 
-    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                          TxValidationState& state) const;
+    /**
+     * Note: this check validates only some trivial consensus rules
+     * Use `CheckProUpRegTx` or GetValidatedPayload<T> helper for full validation
+     */
+    bool IsTriviallyValid(TxValidationState& state) const;
 };
 
 class CProUpRevTx
@@ -286,8 +262,11 @@ class CProUpRevTx
     [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
     [[nodiscard]] UniValue ToJson() const;
 
-    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                          TxValidationState& state) const;
+    /**
+     * Note: this check validates only some trivial consensus rules
+     * Use `CheckProUpRevTx` or GetValidatedPayload<T> helper for full validation
+     */
+    bool IsTriviallyValid(TxValidationState& state) const;
 };
 
 template <typename ProTx>
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index a23472e0e9ea..d1ce91609c1c 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -872,7 +872,11 @@ std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not_null<c
         state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-payload");
         return std::nullopt;
     }
-    if (!opt_ptx->IsTriviallyValid(pindexPrev, chainman, state)) {
+    if (opt_ptx->nVersion > DeploymentToProtxVersion(pindexPrev, chainman)) {
+        state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
+        return std::nullopt;
+    }
+    if (!opt_ptx->IsTriviallyValid(state)) {
         // pass the state returned by the function above
         return std::nullopt;
     }
diff --git a/src/evo/types.h b/src/evo/types.h
index 1bc7a47715bf..2a9f76c07d48 100644
--- a/src/evo/types.h
+++ b/src/evo/types.h
@@ -11,4 +11,28 @@ class CDeterministicMN;
 
 using CDeterministicMNCPtr = std::shared_ptr<const CDeterministicMN>;
 
+namespace ProTxVersion {
+enum : uint16_t {
+    LegacyBLS = 1,
+    BasicBLS = 2,
+    ExtAddr = 3,
+};
+
+/** Get highest permissible ProTx version based on flags set. */
+[[nodiscard]] constexpr uint16_t GetMax(const bool is_basic_scheme_active, const bool is_extended_addr)
+{
+    if (is_basic_scheme_active) {
+        if (is_extended_addr) {
+            // Requires *both* forks to be active to use extended addresses. is_basic_scheme_active could
+            // be set to false due to RPC specialization, so we must evaluate is_extended_addr *last* to
+            // avoid accidentally upgrading a legacy BLS node to basic BLS due to v24 activation.
+            return ProTxVersion::ExtAddr;
+        }
+        return ProTxVersion::BasicBLS;
+    }
+    return ProTxVersion::LegacyBLS;
+}
+
+} // namespace ProTxVersion
+
 #endif // BITCOIN_EVO_TYPES_H
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 735f524e808b..c023e5d0e1de 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -695,8 +695,8 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
 
     CProRegTx ptx;
     ptx.nType = mnType;
-    ptx.nVersion = ProTxVersion::GetMaxFromDeployment<CProRegTx>(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()),
-                                                                 chainman, /*is_basic_override=*/!use_legacy);
+    ptx.nVersion = DeploymentToProtxVersion(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()), chainman,
+                                            /*is_basic_override=*/!use_legacy);
     ptx.netInfo = NetInfoInterface::MakeNetInfo(ptx.nVersion);
 
     if (action == ProTxRegisterAction::Fund) {
@@ -1009,9 +1009,7 @@ static UniValue protx_update_service_common_wrapper(const JSONRPCRequest& reques
         throw std::runtime_error(strprintf("masternode with proTxHash %s is not a %s", ptx.proTxHash.ToString(), GetMnType(mnType).description));
     }
 
-    ptx.nVersion = ProTxVersion::GetMaxFromDeployment<CProUpServTx>(WITH_LOCK(::cs_main,
-                                                                              return chainman.ActiveChain().Tip()),
-                                                                    chainman);
+    ptx.nVersion = DeploymentToProtxVersion(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()), chainman);
 
     // Legacy masternodes must upgrade to BasicBLS before using higher versions.
     // Clamp to BasicBLS to avoid "bad-protx-version-upgrade" validation failure.
@@ -1138,8 +1136,8 @@ static RPCHelpMan protx_update_registrar_wrapper(const bool specific_legacy_bls_
     EnsureWalletIsUnlocked(*wallet);
 
     CProUpRegTx ptx;
-    ptx.nVersion = ProTxVersion::GetMaxFromDeployment<CProUpRegTx>(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()),
-                                                                   chainman, /*is_basic_override=*/!use_legacy);
+    ptx.nVersion = DeploymentToProtxVersion(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()), chainman,
+                                            /*is_basic_override=*/!use_legacy);
 
     ptx.proTxHash = ParseHashV(request.params[0], "proTxHash");
     auto dmn = dmnman.GetListAtChainTip().GetMN(ptx.proTxHash);
@@ -1265,8 +1263,7 @@ static RPCHelpMan protx_revoke()
         throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("masternode %s not found", ptx.proTxHash.ToString()));
     }
 
-    ptx.nVersion = ProTxVersion::GetMaxFromDeployment<CProUpRevTx>(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()),
-                                                                   chainman);
+    ptx.nVersion = DeploymentToProtxVersion(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()), chainman);
 
     // Legacy masternodes must upgrade to BasicBLS before using higher versions.
     // Clamp to BasicBLS to avoid "bad-protx-version-upgrade" validation failure.
diff --git a/src/validation.cpp b/src/validation.cpp
index 2a16f339b631..42fbca1f8851 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -6169,3 +6169,12 @@ bool IsBIP30Unspendable(const CBlockIndex& block_index)
     return (block_index.nHeight==91722 && block_index.GetBlockHash() == uint256S("0x00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e")) ||
            (block_index.nHeight==91812 && block_index.GetBlockHash() == uint256S("0x00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"));
 }
+
+[[nodiscard]] uint16_t DeploymentToProtxVersion(gsl::not_null<const CBlockIndex*> pindexPrev,
+                                                const ChainstateManager& chainman, std::optional<bool> is_basic_override)
+{
+    return ProTxVersion::GetMax(
+        is_basic_override ? *is_basic_override
+                          : DeploymentActiveAfter(pindexPrev, chainman.GetConsensus(), Consensus::DEPLOYMENT_V19),
+        DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24));
+}
diff --git a/src/validation.h b/src/validation.h
index 666773994265..fb78a0c43ea8 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -1103,6 +1103,13 @@ bool DeploymentEnabled(const ChainstateManager& chainman, DEP dep)
     return DeploymentEnabled(chainman.GetConsensus(), dep);
 }
 
+/** Get highest permissible ProTx version based on deployment status
+ *  Note: The override is needed because some RPCs need to use deployment status information for everything *except*
+ *        the BLS version upgrade since they are specializations for a specific BLS version. This is a one-off.
+ *  TODO: Resolve this oddity. Consider deprecating legacy BLS-only RPCs so we can remove them eventually.
+ */
+[[nodiscard]] uint16_t DeploymentToProtxVersion(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
+                                                std::optional<bool> is_basic_override = std::nullopt);
 /**
  * Return true if hash can be found in active_chain at nBlockHeight height.
  * Fills hashRet with found hash, if no nBlockHeight is specified - active_chain.Height() is used.
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 96ce0c51fa02..8f9926cfb189 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -23,7 +23,7 @@
     # Dash
     "active/context -> active/dkgsessionhandler -> llmq/dkgsessionhandler -> net_processing -> active/context",
     "banman -> common/bloom -> evo/assetlocktx -> llmq/quorumsman -> llmq/blockprocessor -> net -> banman",
-    "chainlock/chainlock -> spork -> net -> evo/deterministicmns -> evo/providertx -> validation -> chainlock/chainlock",
+    "chainlock/chainlock -> spork -> net -> evo/deterministicmns -> index/txindex -> validation -> chainlock/chainlock",
     "coinjoin/client -> coinjoin/util -> wallet/wallet -> psbt -> node/transaction -> net_processing -> coinjoin/walletman -> coinjoin/client",
     "common/bloom -> evo/assetlocktx -> llmq/commitment -> evo/deterministicmns -> evo/simplifiedmns -> merkleblock -> common/bloom",
     "common/bloom -> evo/assetlocktx -> llmq/quorumsman -> llmq/blockprocessor -> net -> common/bloom",
@@ -31,11 +31,8 @@
     "consensus/tx_verify -> evo/assetlocktx -> llmq/commitment -> validation -> txmempool -> consensus/tx_verify",
     "evo/assetlocktx -> llmq/commitment -> validation -> txmempool -> evo/assetlocktx",
     "evo/chainhelper -> evo/creditpool -> validation -> evo/chainhelper",
-    "evo/deterministicmns -> evo/providertx -> validation -> evo/deterministicmns",
-    "evo/deterministicmns -> evo/providertx -> validation -> txmempool -> evo/deterministicmns",
-    "evo/netinfo -> evo/providertx -> evo/netinfo",
-    "evo/netinfo -> evo/providertx -> validation -> txmempool -> evo/netinfo",
-    "evo/providertx -> validation -> txmempool -> evo/providertx",
+    "evo/deterministicmns -> index/txindex -> validation -> evo/deterministicmns",
+    "evo/deterministicmns -> index/txindex -> validation -> txmempool -> evo/deterministicmns",
     "evo/smldiff -> llmq/blockprocessor -> llmq/utils -> llmq/snapshot -> evo/smldiff",
     "evo/specialtxman -> validation -> evo/specialtxman",
     "governance/classes -> governance/object -> governance/governance -> governance/classes",

From f94f7ccb3b3afe2f744e5af0c75d6a831f7fd7ff Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Fri, 1 May 2026 02:37:08 +0700
Subject: [PATCH 4/4] refactor: drop various unused includes, such as
 evo/providertx

---
 src/evo/deterministicmns.h | 3 ---
 src/evo/dmnstate.h         | 1 -
 src/evo/simplifiedmns.h    | 6 +++---
 src/evo/smldiff.h          | 2 --
 src/llmq/commitment.cpp    | 1 +
 5 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/evo/deterministicmns.h b/src/evo/deterministicmns.h
index 3a684ffa78df..01faff1cd480 100644
--- a/src/evo/deterministicmns.h
+++ b/src/evo/deterministicmns.h
@@ -7,15 +7,12 @@
 
 #include <evo/dmn_types.h>
 #include <evo/dmnstate.h>
-#include <evo/providertx.h>
 #include <evo/types.h>
 
-#include <arith_uint256.h>
 #include <clientversion.h>
 #include <consensus/params.h>
 #include <crypto/common.h>
 #include <saltedhasher.h>
-#include <scheduler.h>
 #include <sync.h>
 
 #include <gsl/pointers.h>
diff --git a/src/evo/dmnstate.h b/src/evo/dmnstate.h
index bb1a23f2074c..409106839252 100644
--- a/src/evo/dmnstate.h
+++ b/src/evo/dmnstate.h
@@ -8,7 +8,6 @@
 #include <bls/bls.h>
 #include <crypto/sha256.h>
 #include <evo/providertx.h>
-#include <netaddress.h>
 #include <pubkey.h>
 #include <script/script.h>
 #include <util/helpers.h>
diff --git a/src/evo/simplifiedmns.h b/src/evo/simplifiedmns.h
index fca52d88fa03..94bf63688ca6 100644
--- a/src/evo/simplifiedmns.h
+++ b/src/evo/simplifiedmns.h
@@ -6,14 +6,14 @@
 #define BITCOIN_EVO_SIMPLIFIEDMNS_H
 
 #include <bls/bls.h>
+#include <consensus/validation.h>
 #include <evo/dmn_types.h>
 #include <evo/netinfo.h>
-#include <evo/providertx.h>
-#include <util/helpers.h>
-
+#include <evo/types.h>
 #include <merkleblock.h>
 #include <netaddress.h>
 #include <pubkey.h>
+#include <util/helpers.h>
 
 #include <gsl/pointers.h>
 
diff --git a/src/evo/smldiff.h b/src/evo/smldiff.h
index 4dfc692511fc..c7073f23ba7a 100644
--- a/src/evo/smldiff.h
+++ b/src/evo/smldiff.h
@@ -8,9 +8,7 @@
 #include <bls/bls.h>
 #include <evo/dmn_types.h>
 #include <evo/netinfo.h>
-#include <evo/providertx.h>
 #include <evo/simplifiedmns.h>
-
 #include <merkleblock.h>
 #include <netaddress.h>
 #include <pubkey.h>
diff --git a/src/llmq/commitment.cpp b/src/llmq/commitment.cpp
index b492df2e0c2d..b000fd0f6853 100644
--- a/src/llmq/commitment.cpp
+++ b/src/llmq/commitment.cpp
@@ -5,6 +5,7 @@
 #include <llmq/commitment.h>
 
 #include <evo/deterministicmns.h>
+#include <evo/dmnstate.h>
 #include <evo/specialtx.h>
 #include <llmq/options.h>
 #include <llmq/utils.h>