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/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 b2c3691aa4f5..05803bbb3305 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -13,32 +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)
-{
-    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);
-}
-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)
@@ -64,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) {
@@ -162,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) {
@@ -207,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) {
@@ -241,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/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/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 515c1dd06dec..d1ce91609c1c 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");
@@ -872,7 +872,11 @@ static std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not
         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;
     }
@@ -882,15 +886,13 @@ static std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not
 /**
  * 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 +909,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 +1074,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 +1149,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 +1216,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;
     }
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/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/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>
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/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");
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",