diff --git a/doc/release-notes-7600.md b/doc/release-notes-7600.md
new file mode 100644
index 000000000000..323608c15252
--- /dev/null
+++ b/doc/release-notes-7600.md
@@ -0,0 +1,16 @@
+RPC changes
+-----------
+
+- Normal and Evo `protx` registration and maintenance commands now share a
+  typed provider-transaction implementation with other wallet frontends. RPC
+  names and successful result formats are unchanged. Fixed: when a wallet
+  cannot completely sign the inputs it selected (e.g. `protx register_submit`
+  run in a different wallet than the one that prepared the registration),
+  the command now fails with a clear wallet error naming the problem instead
+  of reporting success with a partially signed transaction or attempting a
+  broadcast that failed mempool acceptance with a bare `-26` error. The
+  external-signing workflow (`protx register_prepare` followed by
+  `protx register_submit`) is unchanged.
+  `protx update_service` on a masternode whose state does not yield a usable
+  default fee source now returns an explicit "specify feeSourceAddress"
+  parameter error instead of an internal error. (#7600)
diff --git a/src/Makefile.am b/src/Makefile.am
index fb1ffde2529a..0cf8ce802fdb 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -232,6 +232,7 @@ BITCOIN_CORE_H = \
   evo/mnhftx.h \
   evo/netinfo.h \
   evo/providertx.h \
+  evo/providertx_service.h \
   evo/simplifiedmns.h \
   evo/smldiff.h \
   evo/specialtx.h \
@@ -281,6 +282,7 @@ BITCOIN_CORE_H = \
   interfaces/init.h \
   interfaces/ipc.h \
   interfaces/node.h \
+  interfaces/providertx.h \
   interfaces/wallet.h \
   kernel/blockmanager_opts.h \
   kernel/chain.h \
@@ -539,6 +541,7 @@ libbitcoin_node_a_SOURCES = \
   evo/mnauth.cpp \
   evo/mnhftx.cpp \
   evo/providertx.cpp \
+  evo/providertx_service.cpp \
   evo/simplifiedmns.cpp \
   evo/smldiff.cpp \
   evo/specialtx.cpp \
diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index 9ccf89abfc61..ef133a9a5cb5 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -79,30 +79,105 @@ bool IsPayoutListKeySafe(const MasternodePayoutShares& payouts, const CTxDestina
     return true;
 }
 
-template <typename ProTx>
-bool IsNetInfoTriviallyValid(const ProTx& proTx, TxValidationState& state)
+static bool IsNetInfoTriviallyValid(const std::shared_ptr<NetInfoInterface>& net_info, MnType type, TxValidationState& state)
 {
-    if (!proTx.netInfo->HasEntries(NetInfoPurpose::CORE_P2P)) {
+    if (!net_info->HasEntries(NetInfoPurpose::CORE_P2P)) {
         // Mandatory for all nodes
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-empty");
     }
-    if (proTx.nType == MnType::Regular) {
+    if (type == MnType::Regular) {
         // Regular nodes shouldn't populate Platform-specific fields
-        if (proTx.netInfo->HasEntries(NetInfoPurpose::PLATFORM_HTTPS) ||
-            proTx.netInfo->HasEntries(NetInfoPurpose::PLATFORM_P2P)) {
+        if (net_info->HasEntries(NetInfoPurpose::PLATFORM_HTTPS) || net_info->HasEntries(NetInfoPurpose::PLATFORM_P2P)) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-bad");
         }
     }
-    if (proTx.netInfo->CanStorePlatform() && proTx.nType == MnType::Evo) {
+    if (net_info->CanStorePlatform() && type == MnType::Evo) {
         // Platform fields are mandatory for EvoNodes
-        if (!proTx.netInfo->HasEntries(NetInfoPurpose::PLATFORM_HTTPS) ||
-            !proTx.netInfo->HasEntries(NetInfoPurpose::PLATFORM_P2P)) {
+        if (!net_info->HasEntries(NetInfoPurpose::PLATFORM_HTTPS) || !net_info->HasEntries(NetInfoPurpose::PLATFORM_P2P)) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-empty");
         }
     }
     return true;
 }
 
+static bool CheckNetInfo(const NetInfoInterface& net_info, TxValidationState& state)
+{
+    switch (net_info.Validate()) {
+    case NetInfoStatus::BadAddress:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr");
+    case NetInfoStatus::BadPort:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-port");
+    case NetInfoStatus::BadType:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr-type");
+    case NetInfoStatus::NotRoutable:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr-unroutable");
+    case NetInfoStatus::Malformed:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-bad");
+    case NetInfoStatus::Success:
+        return true;
+    case NetInfoStatus::BadInput:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-entry");
+    case NetInfoStatus::Duplicate:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-netinfo-entry");
+    case NetInfoStatus::MaxLimit:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-maxlimit");
+    }
+    assert(false);
+}
+
+bool CheckProviderNetworkFields(const std::shared_ptr<NetInfoInterface>& net_info, MnType type, uint16_t version,
+                                const uint160* platform_node_id, uint16_t platform_p2p_port,
+                                uint16_t platform_http_port, bool allow_empty, TxValidationState& state)
+{
+    if (!net_info || net_info->CanStorePlatform() != (version >= ProTxVersion::ExtAddr)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-netinfo-version");
+    }
+    if (net_info->IsEmpty()) {
+        if (!allow_empty) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-empty");
+        }
+    } else {
+        if (!IsNetInfoTriviallyValid(net_info, type, state) || !CheckNetInfo(*net_info, state)) {
+            return false;
+        }
+    }
+
+    if (type != MnType::Evo) return true;
+    if (platform_node_id && platform_node_id->IsNull()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-nodeid");
+    }
+    if (version >= ProTxVersion::ExtAddr) {
+        if (platform_p2p_port != 0) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
+        }
+        if (platform_http_port != 0) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
+        }
+        return true;
+    }
+
+    if (::IsNodeOnMainnet()) {
+        if (platform_p2p_port != ::MainParams().GetDefaultPlatformP2PPort()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
+        }
+        if (platform_http_port != ::MainParams().GetDefaultPlatformHTTPPort()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
+        }
+    }
+    if (platform_p2p_port == ::MainParams().GetDefaultPort()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
+    }
+    if (platform_http_port == ::MainParams().GetDefaultPort()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
+    }
+
+    const uint16_t core_port{net_info->GetPrimary().GetPort()};
+    if (platform_p2p_port == platform_http_port || platform_p2p_port == core_port || platform_http_port == core_port) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-dup-ports");
+    }
+    return true;
+}
+
 bool CProRegTx::IsTriviallyValid(TxValidationState& state) const
 {
     if (nVersion == 0 || nVersion > ProTxVersion::ExtAddr) {
@@ -129,7 +204,7 @@ bool CProRegTx::IsTriviallyValid(TxValidationState& state) const
     if (netInfo->CanStorePlatform() != (nVersion >= ProTxVersion::ExtAddr)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-netinfo-version");
     }
-    if (!netInfo->IsEmpty() && !IsNetInfoTriviallyValid(*this, state)) {
+    if (!netInfo->IsEmpty() && !IsNetInfoTriviallyValid(netInfo, nType, state)) {
         // pass the state returned by the function above
         return false;
     }
@@ -199,7 +274,7 @@ bool CProUpServTx::IsTriviallyValid(TxValidationState& state) const
     if (netInfo->IsEmpty()) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-empty");
     }
-    if (!IsNetInfoTriviallyValid(*this, state)) {
+    if (!IsNetInfoTriviallyValid(netInfo, nType, state)) {
         // pass the state returned by the function above
         return false;
     }
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index d27713e74ca7..f38c3bacc059 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -58,6 +58,12 @@ template<class T>
 [[nodiscard]] std::string PayoutListToString(const MasternodePayoutShares& payouts);
 [[nodiscard]] UniValue PayoutListToJson(const MasternodePayoutShares& payouts);
 
+/** Validate all provider network fields using the same rules as special transaction validation.
+ *  Pass nullptr for platform_node_id when validating endpoint input separately from the rest of a payload. */
+[[nodiscard]] bool CheckProviderNetworkFields(const std::shared_ptr<NetInfoInterface>& net_info, MnType type,
+                                              uint16_t version, const uint160* platform_node_id, uint16_t platform_p2p_port,
+                                              uint16_t platform_http_port, bool allow_empty, TxValidationState& state);
+
 class CProRegTx
 {
 public:
diff --git a/src/evo/providertx_service.cpp b/src/evo/providertx_service.cpp
new file mode 100644
index 000000000000..accdb7d25be3
--- /dev/null
+++ b/src/evo/providertx_service.cpp
@@ -0,0 +1,824 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <evo/providertx_service.h>
+
+#include <consensus/validation.h>
+#include <deploymentstatus.h>
+#include <evo/chainhelper.h>
+#include <evo/deterministicmns.h>
+#include <evo/netinfo.h>
+#include <evo/providertx.h>
+#include <evo/specialtx.h>
+#include <evo/specialtxman.h>
+#include <interfaces/wallet.h>
+#include <key_io.h>
+#include <node/context.h>
+#include <node/transaction.h>
+#include <policy/policy.h>
+#include <script/standard.h>
+#include <sync.h>
+#include <util/check.h>
+#include <util/message.h>
+#include <util/result.h>
+#include <util/strencodings.h>
+#include <util/translation.h>
+#include <validation.h>
+
+#include <algorithm>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <variant>
+#include <vector>
+
+namespace evo::provider {
+namespace {
+
+using interfaces::CoinLockResult;
+using interfaces::ExistingProviderCollateral;
+using interfaces::FundProviderCollateral;
+using interfaces::PreparedProviderRegistration;
+using interfaces::ProviderNetInfo;
+using interfaces::ProviderPayout;
+using interfaces::ProviderPlatformEndpoints;
+using interfaces::ProviderRegistrationRequest;
+using interfaces::ProviderRevokeRequest;
+using interfaces::ProviderTxError;
+using interfaces::ProviderTxErrorCode;
+using interfaces::ProviderTxResult;
+using interfaces::ProviderTxSubmission;
+using interfaces::ProviderUpdateRegistrarRequest;
+using interfaces::ProviderUpdateServiceRequest;
+using interfaces::Wallet;
+
+ProviderTxError Error(ProviderTxErrorCode code, std::string message, std::string reject_reason = {},
+                      std::optional<TransactionError> transaction_error = std::nullopt)
+{
+    return ProviderTxError{code, Untranslated(std::move(message)), std::move(reject_reason), transaction_error};
+}
+
+std::optional<ProviderTxError> CheckDestination(const std::optional<CTxDestination>& destination, std::string_view field_name)
+{
+    if (destination && !IsValidDestination(*destination)) {
+        return Error(ProviderTxErrorCode::INVALID_ADDRESS_OR_KEY, strprintf("invalid %s address", field_name));
+    }
+    return std::nullopt;
+}
+
+std::optional<ProviderTxError> CheckWallet(Wallet& wallet)
+{
+    AssertLockNotHeld(::cs_main);
+    if (wallet.isLocked()) {
+        return Error(ProviderTxErrorCode::WALLET_UNLOCK_NEEDED,
+                     "Please enter the wallet passphrase with walletpassphrase first.");
+    }
+    return std::nullopt;
+}
+
+uint16_t CurrentProviderTxVersion(node::NodeContext& node, std::optional<bool> basic_override = std::nullopt)
+{
+    AssertLockNotHeld(::cs_main);
+    auto& chainman{*Assert(node.chainman)};
+    LOCK(::cs_main);
+    return DeploymentToProtxVersion(chainman.ActiveChain().Tip(), chainman, basic_override);
+}
+
+struct ChainSnapshot {
+    uint16_t provider_tx_version{0};
+    CDeterministicMNCPtr dmn;
+    std::optional<Coin> collateral_coin;
+};
+
+ChainSnapshot SnapshotChain(node::NodeContext& node, std::optional<uint256> pro_tx_hash,
+                            std::optional<COutPoint> collateral_outpoint, std::optional<bool> basic_override = std::nullopt)
+{
+    AssertLockNotHeld(::cs_main);
+    auto& chainman{*Assert(node.chainman)};
+    LOCK(::cs_main);
+
+    ChainSnapshot snapshot;
+    snapshot.provider_tx_version = DeploymentToProtxVersion(chainman.ActiveChain().Tip(), chainman, basic_override);
+    if (pro_tx_hash) snapshot.dmn = Assert(node.dmnman)->GetListAtChainTip().GetMN(*pro_tx_hash);
+    if (collateral_outpoint) {
+        Coin coin;
+        if (chainman.ActiveChainstate().CoinsTip().GetCoin(*collateral_outpoint, coin) && !coin.IsSpent()) {
+            snapshot.collateral_coin = std::move(coin);
+        }
+    }
+    return snapshot;
+}
+
+template <typename ProTx>
+std::optional<ProviderTxError> ApplyCoreNetInfo(ProTx& payload, const std::vector<std::string>& entries, bool optional)
+{
+    CHECK_NONFATAL(payload.netInfo);
+    if (!optional && entries.empty()) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "Invalid param for coreP2PAddrs, cannot be empty");
+    }
+    for (size_t index{0}; index < entries.size(); ++index) {
+        if (entries[index].empty()) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                         strprintf("Invalid param for coreP2PAddrs[%zu], cannot be empty", index));
+        }
+        if (const auto status{payload.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, entries[index])};
+            status != NetInfoStatus::Success) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                         strprintf("Error setting coreP2PAddrs[%zu] to '%s' (%s)", index, entries[index],
+                                   NISToString(status)));
+        }
+    }
+    return std::nullopt;
+}
+
+bool IsNumeric(std::string_view input)
+{
+    return !input.empty() && input.find_first_not_of("0123456789") == std::string_view::npos;
+}
+
+bool HasPlatformEndpoints(const ProviderPlatformEndpoints& input)
+{
+    if (std::holds_alternative<uint16_t>(input)) return true;
+    const auto* entries{std::get_if<std::vector<std::string>>(&input)};
+    return entries && !entries->empty();
+}
+
+template <typename ProTx>
+std::optional<ProviderTxError> ApplyPlatformField(ProTx& payload, const ProviderPlatformEndpoints& input,
+                                                  NetInfoPurpose purpose, std::string_view field_name,
+                                                  uint16_t& legacy_port, bool optional)
+{
+    CHECK_NONFATAL(payload.netInfo);
+
+    const auto add_entry = [&](const std::string& entry, size_t index) -> std::optional<ProviderTxError> {
+        if (entry.empty()) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                         strprintf("Invalid param for %s[%zu], cannot be empty", field_name, index));
+        }
+        if (const auto status{payload.netInfo->AddEntry(purpose, entry)}; status != NetInfoStatus::Success) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                         strprintf("Error setting %s[%zu] to '%s' (%s)", field_name, index, entry, NISToString(status)));
+        }
+        return std::nullopt;
+    };
+
+    if (const auto* port{std::get_if<uint16_t>(&input)}) {
+        if (*port == 0) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                         strprintf("Invalid param for %s, must be a valid port [1-65535]", field_name));
+        }
+        if (!payload.netInfo->CanStorePlatform()) {
+            legacy_port = *port;
+            return std::nullopt;
+        }
+        if (!payload.netInfo->HasEntries(NetInfoPurpose::CORE_P2P)) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                         strprintf("Cannot set param for %s, must specify coreP2PAddrs first", field_name));
+        }
+        const CService service{CNetAddr{payload.netInfo->GetPrimary()}, *port};
+        return add_entry(service.ToStringAddrPort(), 0);
+    }
+
+    const auto* entries{std::get_if<std::vector<std::string>>(&input)};
+    const bool empty{!entries || entries->empty()};
+    if (empty) {
+        if (!optional) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                         strprintf("Invalid param for %s, cannot be empty", field_name));
+        }
+        if (!payload.netInfo->IsEmpty()) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                         strprintf("Invalid param for %s, cannot be empty if other fields populated", field_name));
+        }
+    }
+
+    if (!payload.netInfo->CanStorePlatform()) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                     strprintf("Invalid param for %s, this ProTx version only accepts a bare port number; the "
+                               "\"ADDR:PORT\" / address-array form requires upgrading to a version 3 ProTx",
+                               field_name));
+    }
+    if (!entries) return std::nullopt;
+    for (size_t index{0}; index < entries->size(); ++index) {
+        if (IsNumeric((*entries)[index])) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                         strprintf("Invalid param for %s[%zu], must be string", field_name, index));
+        }
+        if (auto error{add_entry((*entries)[index], index)}) return error;
+    }
+    return std::nullopt;
+}
+
+template <typename ProTx>
+std::optional<ProviderTxError> ApplyNetInfo(ProTx& payload, const ProviderNetInfo& net_info, bool platform, bool optional)
+{
+    if (auto error{ApplyCoreNetInfo(payload, net_info.core_p2p, optional)}) return error;
+    if (!platform) {
+        if (HasPlatformEndpoints(net_info.platform_p2p) || HasPlatformEndpoints(net_info.platform_https)) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER, "Platform endpoints are only valid for an EvoNode");
+        }
+        return std::nullopt;
+    }
+    if (auto error{ApplyPlatformField(payload, net_info.platform_p2p, NetInfoPurpose::PLATFORM_P2P, "platformP2PAddrs",
+                                      payload.platformP2PPort, optional)}) {
+        return error;
+    }
+    return ApplyPlatformField(payload, net_info.platform_https, NetInfoPurpose::PLATFORM_HTTPS, "platformHTTPSAddrs",
+                              payload.platformHTTPPort, optional);
+}
+
+template <typename ProTx>
+std::optional<ProviderTxError> ValidateNetworkFields(const ProTx& payload, bool allow_empty, bool check_platform_node_id)
+{
+    TxValidationState state;
+    const uint160* platform_node_id{check_platform_node_id && payload.nType == MnType::Evo ? &payload.platformNodeID
+                                                                                           : nullptr};
+    if (!CheckProviderNetworkFields(payload.netInfo, payload.nType, payload.nVersion, platform_node_id,
+                                    payload.platformP2PPort, payload.platformHTTPPort, allow_empty, state)) {
+        return Error(ProviderTxErrorCode::CONSENSUS_REJECTED, state.ToString(), state.GetRejectReason());
+    }
+    return std::nullopt;
+}
+
+using PayoutResult = std::variant<MasternodePayoutShares, ProviderTxError>;
+
+PayoutResult BuildPayouts(const std::vector<ProviderPayout>& payouts)
+{
+    if (payouts.empty()) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "payouts must contain at least one entry");
+    }
+    if (payouts.size() > 8) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "payouts must not contain more than 8 entries");
+    }
+
+    MasternodePayoutShares result;
+    result.reserve(payouts.size());
+    for (const auto& payout : payouts) {
+        if (!IsValidDestination(payout.destination)) {
+            return Error(ProviderTxErrorCode::INVALID_ADDRESS_OR_KEY,
+                         strprintf("invalid payout address: %s", EncodeDestination(payout.destination)));
+        }
+        result.emplace_back(GetScriptForDestination(payout.destination), payout.reward);
+    }
+    return result;
+}
+
+template <typename Payload>
+void UpdateInputsHash(const CMutableTransaction& tx, Payload& payload)
+{
+    payload.inputsHash = CalcTxInputsHash(CTransaction(tx));
+}
+
+template <typename Payload>
+std::optional<ProviderTxError> SignPayload(const CMutableTransaction& tx, Payload& payload, const CKeyID& key_id,
+                                           Wallet& wallet)
+{
+    UpdateInputsHash(tx, payload);
+    payload.vchSig.clear();
+    if (!wallet.signSpecialTxPayload(::SerializeHash(payload), key_id, payload.vchSig)) {
+        return Error(ProviderTxErrorCode::INTERNAL_ERROR, "failed to sign special tx");
+    }
+    return std::nullopt;
+}
+
+template <typename Payload>
+void SignPayload(const CMutableTransaction& tx, Payload& payload, const CBLSSecretKey& key, bool legacy)
+{
+    UpdateInputsHash(tx, payload);
+    payload.sig = key.Sign(::SerializeHash(payload), legacy);
+}
+
+using MutableTxResult = std::variant<CMutableTransaction, ProviderTxError>;
+
+template <typename Payload>
+MutableTxResult Fund(Wallet& wallet, CMutableTransaction tx, const Payload& payload, const CTxDestination& fund_destination)
+{
+    AssertLockNotHeld(::cs_main);
+    if (!IsValidDestination(fund_destination)) {
+        return Error(ProviderTxErrorCode::FUNDING_ERROR, "No source of funds specified");
+    }
+    SetTxPayload(tx, payload);
+    auto funded{wallet.fundTransaction(tx, fund_destination)};
+    if (!funded) {
+        return Error(ProviderTxErrorCode::FUNDING_ERROR, util::ErrorString(funded).original);
+    }
+    return CMutableTransaction{**funded};
+}
+
+std::optional<ProviderTxError> Preflight(node::NodeContext& node, const CTransaction& tx)
+{
+    AssertLockNotHeld(::cs_main);
+    auto& chainman{*Assert(node.chainman)};
+    auto& chain_helper{*Assert(node.chain_helper)};
+    LOCK(::cs_main);
+
+    const CBlockIndex* tip{chainman.ActiveChain().Tip()};
+    const auto& consensus{chainman.GetConsensus()};
+    if (!DeploymentActiveAfter(tip, consensus, Consensus::DEPLOYMENT_DIP0003)) {
+        const int current_height{tip ? tip->nHeight : -1};
+        const int next_block_height{current_height + 1};
+        const int activation_height{consensus.DIP0003Height};
+        const int blocks_to_mine{activation_height > next_block_height ? activation_height - next_block_height : 0};
+        return Error(ProviderTxErrorCode::VERIFY_ERROR,
+                     strprintf("DIP0003 is not active yet; ProTx transactions are valid starting at block height %d "
+                               "(current chain height %d, next block height %d). Mine %d more block%s or restart "
+                               "this regtest/devnet chain with DIP3 activation parameters that are already active.",
+                               activation_height, current_height, next_block_height, blocks_to_mine,
+                               blocks_to_mine == 1 ? "" : "s"));
+    }
+
+    TxValidationState state;
+    if (!chain_helper.special_tx->CheckSpecialTx(tx, tip, chainman.ActiveChainstate().CoinsTip(), true, state)) {
+        return Error(ProviderTxErrorCode::CONSENSUS_REJECTED, state.ToString(), state.GetRejectReason());
+    }
+    return std::nullopt;
+}
+
+ProviderTxResult<ProviderTxSubmission> Finish(node::NodeContext& node, Wallet& wallet, const CMutableTransaction& tx,
+                                              bool submit)
+{
+    AssertLockNotHeld(::cs_main);
+    if (auto error{Preflight(node, CTransaction{tx})}) return *error;
+
+    auto signed_result{wallet.signTransaction(tx)};
+    if (!signed_result) {
+        return Error(wallet.isLocked() ? ProviderTxErrorCode::WALLET_UNLOCK_NEEDED : ProviderTxErrorCode::WALLET_ERROR,
+                     util::ErrorString(signed_result).original);
+    }
+    if (!signed_result->complete) {
+        std::string errors;
+        for (const auto& error : signed_result->errors) {
+            if (!errors.empty()) errors += ", ";
+            errors += error.original;
+        }
+        return Error(ProviderTxErrorCode::WALLET_ERROR,
+                     strprintf("transaction inputs could not be fully signed by this wallet; run this command on "
+                               "the wallet that funded the transaction, or finish signing there with "
+                               "signrawtransactionwithwallet (%s)",
+                               errors));
+    }
+    if (!submit) return ProviderTxSubmission{signed_result->tx, false};
+
+    const CAmount max_fee{node::DEFAULT_MAX_RAW_TX_FEE_RATE.GetFee(GetVirtualTransactionSize(*signed_result->tx))};
+    bilingual_str message;
+    const TransactionError transaction_error{
+        node::BroadcastTransaction(node, signed_result->tx, message, max_fee, /*relay=*/true, /*wait_callback=*/true)};
+    if (transaction_error != TransactionError::OK) {
+        return Error(ProviderTxErrorCode::BROADCAST_ERROR, message.original, {}, transaction_error);
+    }
+    return ProviderTxSubmission{signed_result->tx, true};
+}
+
+class CollateralLockGuard
+{
+public:
+    CollateralLockGuard(Wallet& wallet, const COutPoint& outpoint) :
+        m_wallet(wallet),
+        m_outpoint(outpoint)
+    {
+        m_result = m_wallet.acquireCoinLock(m_outpoint, /*write_to_db=*/false);
+    }
+
+    ~CollateralLockGuard()
+    {
+        if (m_result == CoinLockResult::ACQUIRED && !m_keep) m_wallet.unlockCoin(m_outpoint);
+    }
+
+    bool Succeeded() const { return m_result != CoinLockResult::FAILED; }
+    bool Acquired() const { return m_result == CoinLockResult::ACQUIRED; }
+    void Keep() { m_keep = true; }
+
+private:
+    Wallet& m_wallet;
+    COutPoint m_outpoint;
+    CoinLockResult m_result{CoinLockResult::FAILED};
+    bool m_keep{false};
+};
+
+using RegistrationOutcome = std::variant<ProviderTxSubmission, PreparedProviderRegistration>;
+using RegistrationResult = ProviderTxResult<RegistrationOutcome>;
+
+RegistrationResult BuildRegistration(node::NodeContext& node, Wallet& wallet,
+                                     const ProviderRegistrationRequest& request, bool prepare)
+{
+    if (!IsValidMnType(request.type)) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "invalid masternode type");
+    }
+    if (prepare && !std::holds_alternative<ExistingProviderCollateral>(request.collateral)) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                     "prepared registration requires an existing collateral outpoint");
+    }
+    if (!request.operator_key.IsValid()) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "operator BLS address must be a valid BLS public key");
+    }
+    if (request.operator_reward > 10000) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "operatorReward must be between 0 and 10000");
+    }
+    if (auto error{CheckDestination(request.fee_source, "fee source")}) return *error;
+
+    const auto* existing_collateral{std::get_if<ExistingProviderCollateral>(&request.collateral)};
+    const ChainSnapshot chain_snapshot{
+        SnapshotChain(node, std::nullopt, existing_collateral ? std::optional{existing_collateral->outpoint} : std::nullopt,
+                      /*basic_override=*/!request.use_legacy_bls_scheme)};
+    if (auto error{CheckWallet(wallet)}) return *error;
+
+    CMutableTransaction tx;
+    tx.nVersion = 3;
+    tx.nType = TRANSACTION_PROVIDER_REGISTER;
+
+    CProRegTx payload;
+    payload.nType = request.type;
+    payload.nVersion = chain_snapshot.provider_tx_version;
+    payload.netInfo = NetInfoInterface::MakeNetInfo(payload.nVersion);
+
+    if (const auto* collateral{std::get_if<FundProviderCollateral>(&request.collateral)}) {
+        if (!IsValidDestination(collateral->destination)) {
+            return Error(ProviderTxErrorCode::INVALID_ADDRESS_OR_KEY,
+                         strprintf("invalid collaterall address: %s", EncodeDestination(collateral->destination)));
+        }
+        tx.vout.emplace_back(GetMnType(request.type).collat_amount, GetScriptForDestination(collateral->destination));
+    } else {
+        payload.collateralOutpoint = std::get<ExistingProviderCollateral>(request.collateral).outpoint;
+        if (payload.collateralOutpoint.hash.IsNull()) {
+            return Error(ProviderTxErrorCode::INVALID_ADDRESS_OR_KEY,
+                         strprintf("invalid hash or index: %s-%d", payload.collateralOutpoint.hash.ToString(),
+                                   payload.collateralOutpoint.n));
+        }
+    }
+
+    if (auto error{ApplyNetInfo(payload, request.net_info, request.type == MnType::Evo, /*optional=*/true)}) {
+        return *error;
+    }
+    payload.keyIDOwner = request.owner_key;
+    payload.keyIDVoting = request.voting_key.IsNull() ? request.owner_key : request.voting_key;
+    payload.pubKeyOperator.Set(request.operator_key, request.use_legacy_bls_scheme);
+    if (payload.pubKeyOperator.IsLegacy() != (payload.nVersion == ProTxVersion::LegacyBLS)) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "operator key encoding does not match ProTx version");
+    }
+    payload.nOperatorReward = request.operator_reward;
+
+    auto payouts_result{BuildPayouts(request.payouts)};
+    if (const auto* error{std::get_if<ProviderTxError>(&payouts_result)}) return *error;
+    payload.payouts = std::get<MasternodePayoutShares>(std::move(payouts_result));
+    payload.scriptPayout = payload.payouts.front().scriptPayout;
+    if (payload.nVersion < ProTxVersion::ExtAddr && (request.uses_extended_payouts || payload.payouts.size() > 1)) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "payouts array requires provider transaction version 3");
+    }
+
+    if (request.type == MnType::Evo) {
+        if (!request.platform_node_id) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER, "platformNodeID must be specified for an EvoNode");
+        }
+        payload.platformNodeID = *request.platform_node_id;
+    }
+    if (auto error{ValidateNetworkFields(payload, /*allow_empty=*/true,
+                                         /*check_platform_node_id=*/true)}) {
+        return *error;
+    }
+
+    const CTxDestination fund_destination{request.fee_source.value_or(request.payouts.front().destination)};
+    if (std::holds_alternative<FundProviderCollateral>(request.collateral)) {
+        auto funded_result{Fund(wallet, std::move(tx), payload, fund_destination)};
+        if (const auto* error{std::get_if<ProviderTxError>(&funded_result)}) return *error;
+        tx = std::get<CMutableTransaction>(std::move(funded_result));
+        UpdateInputsHash(tx, payload);
+
+        const CAmount collateral_amount{GetMnType(request.type).collat_amount};
+        // Funding may reorder outputs and can produce a change output of the
+        // exact collateral amount, so match the destination script too.
+        const CScript collateral_script{
+            GetScriptForDestination(std::get<FundProviderCollateral>(request.collateral).destination)};
+        const auto it{std::find_if(tx.vout.begin(), tx.vout.end(), [&](const CTxOut& output) {
+            return output.nValue == collateral_amount && output.scriptPubKey == collateral_script;
+        })};
+        if (it == tx.vout.end()) {
+            return Error(ProviderTxErrorCode::INTERNAL_ERROR, "funded transaction lost its collateral output");
+        }
+        payload.collateralOutpoint.n = static_cast<uint32_t>(std::distance(tx.vout.begin(), it));
+        SetTxPayload(tx, payload);
+        auto result{Finish(node, wallet, tx, request.submit)};
+        if (const auto* error{std::get_if<ProviderTxError>(&result)}) return *error;
+        return RegistrationOutcome{std::get<ProviderTxSubmission>(std::move(result))};
+    }
+
+    CollateralLockGuard collateral_lock{wallet, payload.collateralOutpoint};
+    if (!collateral_lock.Succeeded()) {
+        return Error(ProviderTxErrorCode::WALLET_ERROR,
+                     strprintf("failed to lock collateral: %s", payload.collateralOutpoint.ToStringShort()));
+    }
+
+    payload.vchSig.resize(CPubKey::COMPACT_SIGNATURE_SIZE);
+    auto funded_result{Fund(wallet, std::move(tx), payload, fund_destination)};
+    if (const auto* error{std::get_if<ProviderTxError>(&funded_result)}) return *error;
+    tx = std::get<CMutableTransaction>(std::move(funded_result));
+    UpdateInputsHash(tx, payload);
+
+    if (!chain_snapshot.collateral_coin) {
+        return Error(ProviderTxErrorCode::INVALID_ADDRESS_OR_KEY,
+                     strprintf("collateral not found: %s", payload.collateralOutpoint.ToStringShort()));
+    }
+    CTxDestination collateral_destination;
+    ExtractDestination(chain_snapshot.collateral_coin->out.scriptPubKey, collateral_destination);
+    const auto* collateral_key{std::get_if<PKHash>(&collateral_destination)};
+    if (!collateral_key) {
+        return Error(ProviderTxErrorCode::INVALID_ADDRESS_OR_KEY,
+                     strprintf("collateral type not supported: %s", payload.collateralOutpoint.ToStringShort()));
+    }
+
+    if (prepare) {
+        payload.vchSig.clear();
+        SetTxPayload(tx, payload);
+        collateral_lock.Keep();
+        return RegistrationOutcome{PreparedProviderRegistration{MakeTransactionRef(std::move(tx)), collateral_destination,
+                                                                payload.MakeSignString(), collateral_lock.Acquired()}};
+    }
+
+    std::string signature;
+    const SigningResult signing_result{wallet.signMessage(payload.MakeSignString(), *collateral_key, signature)};
+    if (signing_result != SigningResult::OK) {
+        return Error(signing_result == SigningResult::SIGNING_FAILED ? ProviderTxErrorCode::INVALID_ADDRESS_OR_KEY
+                                                                     : ProviderTxErrorCode::WALLET_ERROR,
+                     SigningResultString(signing_result));
+    }
+    auto decoded_signature{DecodeBase64(signature)};
+    if (!decoded_signature) {
+        return Error(ProviderTxErrorCode::INTERNAL_ERROR, "failed to decode base64 ready signature for protx");
+    }
+    payload.vchSig = std::move(*decoded_signature);
+    SetTxPayload(tx, payload);
+    auto result{Finish(node, wallet, tx, request.submit)};
+    if (const auto* error{std::get_if<ProviderTxError>(&result)}) return *error;
+    collateral_lock.Keep();
+    return RegistrationOutcome{std::get<ProviderTxSubmission>(std::move(result))};
+}
+
+} // namespace
+
+interfaces::ProviderTxCapabilities GetCapabilities(node::NodeContext& node, std::optional<bool> basic_override)
+{
+    const uint16_t version{CurrentProviderTxVersion(node, basic_override)};
+    return interfaces::ProviderTxCapabilities{version, version >= ProTxVersion::ExtAddr};
+}
+
+std::optional<ProviderTxError> ValidateNetInfo(const ProviderNetInfo& net_info, MnType type, uint16_t version, bool optional)
+{
+    if (!IsValidMnType(type)) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "invalid masternode type");
+    }
+    if (version < ProTxVersion::LegacyBLS || version > ProTxVersion::ExtAddr) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "invalid provider transaction version");
+    }
+
+    CProRegTx payload;
+    payload.nType = type;
+    payload.nVersion = version;
+    payload.netInfo = NetInfoInterface::MakeNetInfo(version);
+    if (auto error{ApplyNetInfo(payload, net_info, type == MnType::Evo, optional)}) return error;
+    return ValidateNetworkFields(payload, optional, /*check_platform_node_id=*/false);
+}
+
+ProviderTxResult<ProviderTxSubmission> Register(node::NodeContext& node, Wallet& wallet,
+                                                const ProviderRegistrationRequest& request)
+{
+    auto result{BuildRegistration(node, wallet, request, /*prepare=*/false)};
+    if (const auto* error{std::get_if<ProviderTxError>(&result)}) return *error;
+    auto& outcome{std::get<RegistrationOutcome>(result)};
+    if (auto* submission{std::get_if<ProviderTxSubmission>(&outcome)}) return std::move(*submission);
+    return Error(ProviderTxErrorCode::INTERNAL_ERROR, "registration returned an unexpected prepared transaction");
+}
+
+ProviderTxResult<PreparedProviderRegistration> PrepareRegistration(node::NodeContext& node, Wallet& wallet,
+                                                                   const ProviderRegistrationRequest& request)
+{
+    auto result{BuildRegistration(node, wallet, request, /*prepare=*/true)};
+    if (const auto* error{std::get_if<ProviderTxError>(&result)}) return *error;
+    auto& outcome{std::get<RegistrationOutcome>(result)};
+    if (auto* prepared{std::get_if<PreparedProviderRegistration>(&outcome)}) return std::move(*prepared);
+    return Error(ProviderTxErrorCode::INTERNAL_ERROR, "registration returned an unexpected submitted transaction");
+}
+
+ProviderTxResult<ProviderTxSubmission> SubmitRegistration(node::NodeContext& node, Wallet& wallet,
+                                                          const CTransactionRef& transaction,
+                                                          const std::vector<unsigned char>& collateral_signature)
+{
+    if (auto error{CheckWallet(wallet)}) return *error;
+    if (!transaction) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "transaction not deserializable");
+    }
+
+    CMutableTransaction tx{*transaction};
+    if (tx.nType != TRANSACTION_PROVIDER_REGISTER) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "transaction not a ProRegTx");
+    }
+    auto payload{GetTxPayload<CProRegTx>(tx)};
+    if (!payload) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "transaction payload not deserializable");
+    }
+    if (!payload->vchSig.empty()) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "payload signature not empty");
+    }
+    payload->vchSig = collateral_signature;
+    SetTxPayload(tx, *payload);
+    return Finish(node, wallet, tx, /*submit=*/true);
+}
+
+ProviderTxResult<ProviderTxSubmission> UpdateService(node::NodeContext& node, Wallet& wallet,
+                                                     const ProviderUpdateServiceRequest& request)
+{
+    if (!IsValidMnType(request.type)) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "invalid masternode type");
+    }
+    if (!request.operator_key.IsValid()) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "operatorKey must be a valid BLS secret key");
+    }
+    if (auto error{CheckDestination(request.operator_payout, "operator payout")}) return *error;
+    if (auto error{CheckDestination(request.fee_source, "fee source")}) return *error;
+
+    const ChainSnapshot chain_snapshot{SnapshotChain(node, request.pro_tx_hash, std::nullopt)};
+    if (auto error{CheckWallet(wallet)}) return *error;
+    const auto& dmn{chain_snapshot.dmn};
+    if (!dmn) {
+        return Error(ProviderTxErrorCode::CONSENSUS_REJECTED,
+                     strprintf("masternode with proTxHash %s not found", request.pro_tx_hash.ToString()));
+    }
+    if (dmn->nType != request.type) {
+        return Error(ProviderTxErrorCode::CONSENSUS_REJECTED,
+                     strprintf("masternode with proTxHash %s is not a %s", request.pro_tx_hash.ToString(),
+                               GetMnType(request.type).description));
+    }
+    if (request.operator_key.GetPublicKey() != dmn->pdmnState->pubKeyOperator.Get()) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                     "the operator key does not belong to the registered public key");
+    }
+
+    CProUpServTx payload;
+    payload.proTxHash = request.pro_tx_hash;
+    payload.nType = request.type;
+    payload.nVersion = chain_snapshot.provider_tx_version;
+    payload.netInfo = NetInfoInterface::MakeNetInfo(payload.nVersion);
+    if (auto error{ApplyNetInfo(payload, request.net_info, request.type == MnType::Evo, /*optional=*/false)}) {
+        return *error;
+    }
+    if (request.type == MnType::Evo) {
+        if (!request.platform_node_id) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER, "platformNodeID must be specified for an EvoNode");
+        }
+        payload.platformNodeID = *request.platform_node_id;
+    }
+    if (auto error{ValidateNetworkFields(payload, /*allow_empty=*/false,
+                                         /*check_platform_node_id=*/true)}) {
+        return *error;
+    }
+    payload.scriptOperatorPayout = request.operator_payout ? GetScriptForDestination(*request.operator_payout)
+                                                           : dmn->pdmnState->scriptOperatorPayout;
+
+    CTxDestination fund_destination;
+    if (request.fee_source) {
+        fund_destination = *request.fee_source;
+    } else if (!payload.scriptOperatorPayout.empty()) {
+        ExtractDestination(payload.scriptOperatorPayout, fund_destination);
+    } else {
+        const auto owner_payouts{GetOwnerPayouts(*dmn->pdmnState)};
+        if (owner_payouts.empty() || !ExtractDestination(owner_payouts.front().scriptPayout, fund_destination)) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                         "masternode has no default fee source; specify feeSourceAddress");
+        }
+    }
+
+    CMutableTransaction tx;
+    tx.nVersion = 3;
+    tx.nType = TRANSACTION_PROVIDER_UPDATE_SERVICE;
+    auto funded_result{Fund(wallet, std::move(tx), payload, fund_destination)};
+    if (const auto* error{std::get_if<ProviderTxError>(&funded_result)}) return *error;
+    tx = std::get<CMutableTransaction>(std::move(funded_result));
+    SignPayload(tx, payload, request.operator_key, payload.nVersion == ProTxVersion::LegacyBLS);
+    SetTxPayload(tx, payload);
+    return Finish(node, wallet, tx, request.submit);
+}
+
+ProviderTxResult<ProviderTxSubmission> UpdateRegistrar(node::NodeContext& node, Wallet& wallet,
+                                                       const ProviderUpdateRegistrarRequest& request)
+{
+    if (auto error{CheckDestination(request.fee_source, "fee source")}) return *error;
+    const ChainSnapshot chain_snapshot{
+        SnapshotChain(node, request.pro_tx_hash, std::nullopt, /*basic_override=*/!request.use_legacy_bls_scheme)};
+    if (auto error{CheckWallet(wallet)}) return *error;
+    const auto& dmn{chain_snapshot.dmn};
+    if (!dmn) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                     strprintf("masternode %s not found", request.pro_tx_hash.ToString()));
+    }
+
+    CProUpRegTx payload;
+    payload.nVersion = chain_snapshot.provider_tx_version;
+    payload.proTxHash = request.pro_tx_hash;
+    payload.keyIDVoting = request.voting_key.value_or(dmn->pdmnState->keyIDVoting);
+
+    if (request.operator_key) {
+        if (!request.operator_key->IsValid()) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER, "operator BLS address must be a valid BLS public key");
+        }
+        payload.pubKeyOperator.Set(*request.operator_key, request.use_legacy_bls_scheme);
+    } else {
+        payload.pubKeyOperator = dmn->pdmnState->pubKeyOperator;
+        if (!request.use_legacy_bls_scheme && payload.pubKeyOperator != CBLSLazyPublicKey() &&
+            payload.pubKeyOperator.IsLegacy()) {
+            payload.pubKeyOperator.Set(payload.pubKeyOperator.Get(), /*specificLegacyScheme=*/false);
+        }
+    }
+    if (payload.pubKeyOperator.IsLegacy() != (payload.nVersion == ProTxVersion::LegacyBLS)) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "operator key encoding does not match ProTx version");
+    }
+
+    CTxDestination payout_destination;
+    if (request.payouts) {
+        auto payouts_result{BuildPayouts(*request.payouts)};
+        if (const auto* error{std::get_if<ProviderTxError>(&payouts_result)}) return *error;
+        payload.payouts = std::get<MasternodePayoutShares>(std::move(payouts_result));
+        if (payload.nVersion < ProTxVersion::ExtAddr && (request.uses_extended_payouts || payload.payouts.size() > 1)) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                         "payouts array requires provider transaction version 3");
+        }
+    } else {
+        payload.payouts = GetOwnerPayouts(*dmn->pdmnState);
+    }
+    if (payload.payouts.empty() || !ExtractDestination(payload.payouts.front().scriptPayout, payout_destination)) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "masternode has no payout address");
+    }
+    payload.scriptPayout = payload.payouts.front().scriptPayout;
+
+    if (!wallet.isSpendable(GetScriptForDestination(PKHash{dmn->pdmnState->keyIDOwner}))) {
+        // Wallet-side condition, but CONSENSUS_REJECTED is used deliberately so the
+        // RPC layer keeps throwing the legacy error code -1 for this failure.
+        return Error(ProviderTxErrorCode::CONSENSUS_REJECTED,
+                     strprintf("Private key for owner address %s not found in your wallet",
+                               EncodeDestination(PKHash{dmn->pdmnState->keyIDOwner})));
+    }
+
+    CMutableTransaction tx;
+    tx.nVersion = 3;
+    tx.nType = TRANSACTION_PROVIDER_UPDATE_REGISTRAR;
+    payload.vchSig.resize(CPubKey::COMPACT_SIGNATURE_SIZE);
+    auto funded_result{Fund(wallet, std::move(tx), payload, request.fee_source.value_or(payout_destination))};
+    if (const auto* error{std::get_if<ProviderTxError>(&funded_result)}) return *error;
+    tx = std::get<CMutableTransaction>(std::move(funded_result));
+    if (auto error{SignPayload(tx, payload, dmn->pdmnState->keyIDOwner, wallet)}) return *error;
+    SetTxPayload(tx, payload);
+    return Finish(node, wallet, tx, request.submit);
+}
+
+ProviderTxResult<ProviderTxSubmission> Revoke(node::NodeContext& node, Wallet& wallet, const ProviderRevokeRequest& request)
+{
+    if (!request.operator_key.IsValid()) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER, "operatorKey must be a valid BLS secret key");
+    }
+    if (request.reason > CProUpRevTx::REASON_LAST) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                     strprintf("invalid reason %d, must be between 0 and %d", request.reason, CProUpRevTx::REASON_LAST));
+    }
+    if (auto error{CheckDestination(request.fee_source, "fee source")}) return *error;
+
+    const ChainSnapshot chain_snapshot{SnapshotChain(node, request.pro_tx_hash, std::nullopt)};
+    if (auto error{CheckWallet(wallet)}) return *error;
+    const auto& dmn{chain_snapshot.dmn};
+    if (!dmn) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                     strprintf("masternode %s not found", request.pro_tx_hash.ToString()));
+    }
+    if (request.operator_key.GetPublicKey() != dmn->pdmnState->pubKeyOperator.Get()) {
+        return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                     "the operator key does not belong to the registered public key");
+    }
+
+    CProUpRevTx payload;
+    payload.proTxHash = request.pro_tx_hash;
+    payload.nVersion = chain_snapshot.provider_tx_version;
+    payload.nReason = request.reason;
+
+    CTxDestination fund_destination;
+    if (request.fee_source) {
+        fund_destination = *request.fee_source;
+    } else if (!dmn->pdmnState->scriptOperatorPayout.empty()) {
+        ExtractDestination(dmn->pdmnState->scriptOperatorPayout, fund_destination);
+    } else {
+        const auto owner_payouts{GetOwnerPayouts(*dmn->pdmnState)};
+        if (owner_payouts.empty() || !ExtractDestination(owner_payouts.front().scriptPayout, fund_destination)) {
+            return Error(ProviderTxErrorCode::INVALID_PARAMETER,
+                         "No payout or fee source addresses found, can't revoke");
+        }
+    }
+
+    CMutableTransaction tx;
+    tx.nVersion = 3;
+    tx.nType = TRANSACTION_PROVIDER_UPDATE_REVOKE;
+    auto funded_result{Fund(wallet, std::move(tx), payload, fund_destination)};
+    if (const auto* error{std::get_if<ProviderTxError>(&funded_result)}) return *error;
+    tx = std::get<CMutableTransaction>(std::move(funded_result));
+    SignPayload(tx, payload, request.operator_key, payload.nVersion == ProTxVersion::LegacyBLS);
+    SetTxPayload(tx, payload);
+    return Finish(node, wallet, tx, request.submit);
+}
+
+} // namespace evo::provider
diff --git a/src/evo/providertx_service.h b/src/evo/providertx_service.h
new file mode 100644
index 000000000000..53d1f4999af8
--- /dev/null
+++ b/src/evo/providertx_service.h
@@ -0,0 +1,49 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_EVO_PROVIDERTX_SERVICE_H
+#define BITCOIN_EVO_PROVIDERTX_SERVICE_H
+
+#include <interfaces/providertx.h>
+
+#include <optional>
+
+namespace interfaces {
+class Wallet;
+} // namespace interfaces
+
+namespace node {
+struct NodeContext;
+} // namespace node
+
+namespace evo::provider {
+
+interfaces::ProviderTxCapabilities GetCapabilities(node::NodeContext& node,
+                                                   std::optional<bool> basic_override = std::nullopt);
+
+std::optional<interfaces::ProviderTxError> ValidateNetInfo(const interfaces::ProviderNetInfo& net_info, MnType type,
+                                                           uint16_t version, bool optional);
+
+interfaces::ProviderTxResult<interfaces::ProviderTxSubmission> Register(
+    node::NodeContext& node, interfaces::Wallet& wallet, const interfaces::ProviderRegistrationRequest& request);
+
+interfaces::ProviderTxResult<interfaces::PreparedProviderRegistration> PrepareRegistration(
+    node::NodeContext& node, interfaces::Wallet& wallet, const interfaces::ProviderRegistrationRequest& request);
+
+interfaces::ProviderTxResult<interfaces::ProviderTxSubmission> SubmitRegistration(
+    node::NodeContext& node, interfaces::Wallet& wallet, const CTransactionRef& tx,
+    const std::vector<unsigned char>& collateral_signature);
+
+interfaces::ProviderTxResult<interfaces::ProviderTxSubmission> UpdateService(
+    node::NodeContext& node, interfaces::Wallet& wallet, const interfaces::ProviderUpdateServiceRequest& request);
+
+interfaces::ProviderTxResult<interfaces::ProviderTxSubmission> UpdateRegistrar(
+    node::NodeContext& node, interfaces::Wallet& wallet, const interfaces::ProviderUpdateRegistrarRequest& request);
+
+interfaces::ProviderTxResult<interfaces::ProviderTxSubmission> Revoke(node::NodeContext& node, interfaces::Wallet& wallet,
+                                                                      const interfaces::ProviderRevokeRequest& request);
+
+} // namespace evo::provider
+
+#endif // BITCOIN_EVO_PROVIDERTX_SERVICE_H
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 73c08df28492..bf3f11ba5df3 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -961,75 +961,6 @@ bool CSpecialTxProcessor::CheckCreditPoolDiffForBlock(const CBlock& block, const
     return true;
 }
 
-template <typename ProTx>
-static bool CheckService(const ProTx& proTx, TxValidationState& state)
-{
-    switch (proTx.netInfo->Validate()) {
-    case NetInfoStatus::BadAddress:
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr");
-    case NetInfoStatus::BadPort:
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-port");
-    case NetInfoStatus::BadType:
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr-type");
-    case NetInfoStatus::NotRoutable:
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr-unroutable");
-    case NetInfoStatus::Malformed:
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-bad");
-    case NetInfoStatus::Success:
-        return true;
-    // Reachable through a serialized netInfo that bypasses the in-memory builder's checks
-    case NetInfoStatus::BadInput:
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-entry");
-    case NetInfoStatus::Duplicate:
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-netinfo-entry");
-    case NetInfoStatus::MaxLimit:
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-maxlimit");
-    } // no default case, so the compiler can warn about missing cases
-    assert(false);
-}
-
-template <typename ProTx>
-static bool CheckPlatformFields(const ProTx& proTx, bool is_extended_addr, TxValidationState& state)
-{
-    if (proTx.platformNodeID.IsNull()) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-nodeid");
-    }
-
-    if (is_extended_addr) {
-        // platformHTTPPort and platformP2PPort have been subsumed by netInfo. They should always be zero.
-        if (proTx.platformP2PPort != 0) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
-        }
-        if (proTx.platformHTTPPort != 0) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
-        }
-        return true;
-    }
-
-    if (::IsNodeOnMainnet()) {
-        if (proTx.platformP2PPort != ::MainParams().GetDefaultPlatformP2PPort()) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
-        }
-        if (proTx.platformHTTPPort != ::MainParams().GetDefaultPlatformHTTPPort()) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
-        }
-    }
-    if (proTx.platformP2PPort == ::MainParams().GetDefaultPort()) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
-    }
-    if (proTx.platformHTTPPort == ::MainParams().GetDefaultPort()) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
-    }
-
-    const uint16_t core_port{proTx.netInfo->GetPrimary().GetPort()};
-    if (proTx.platformP2PPort == proTx.platformHTTPPort || proTx.platformP2PPort == core_port ||
-        proTx.platformHTTPPort == core_port) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-dup-ports");
-    }
-
-    return true;
-}
-
 template <typename ProTx>
 static bool CheckHashSig(const ProTx& proTx, const PKHash& pkhash, TxValidationState& state)
 {
@@ -1126,17 +1057,11 @@ bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pin
 
     // 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
-    if (!opt_ptx->netInfo->IsEmpty() && !CheckService(*opt_ptx, state)) {
-        // pass the state returned by the function above
+    if (!CheckProviderNetworkFields(opt_ptx->netInfo, opt_ptx->nType, opt_ptx->nVersion, &opt_ptx->platformNodeID,
+                                    opt_ptx->platformP2PPort, opt_ptx->platformHTTPPort, /*allow_empty=*/true, state)) {
         return false;
     }
 
-    if (opt_ptx->nType == MnType::Evo) {
-        if (!CheckPlatformFields(*opt_ptx, opt_ptx->nVersion >= ProTxVersion::ExtAddr, state)) {
-            return false;
-        }
-    }
-
     CTxDestination collateralTxDest;
     const PKHash* keyForPayloadSig = nullptr;
     COutPoint collateralOutpoint;
@@ -1260,17 +1185,11 @@ bool CheckProUpServTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*>
         return false;
     }
 
-    if (!CheckService(*opt_ptx, state)) {
-        // pass the state returned by the function above
+    if (!CheckProviderNetworkFields(opt_ptx->netInfo, opt_ptx->nType, opt_ptx->nVersion, &opt_ptx->platformNodeID,
+                                    opt_ptx->platformP2PPort, opt_ptx->platformHTTPPort, /*allow_empty=*/false, state)) {
         return false;
     }
 
-    if (opt_ptx->nType == MnType::Evo) {
-        if (!CheckPlatformFields(*opt_ptx, opt_ptx->nVersion >= ProTxVersion::ExtAddr, state)) {
-            return false;
-        }
-    }
-
     auto mnList = dmnman.GetListForBlock(pindexPrev);
     auto dmn = mnList.GetMN(opt_ptx->proTxHash);
     if (!dmn) {
diff --git a/src/interfaces/node.h b/src/interfaces/node.h
index ba85809416be..f3362cefba6b 100644
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -17,6 +17,7 @@
 #include <util/translation.h>
 
 #include <evo/types.h>
+#include <interfaces/providertx.h>
 
 #include <functional>
 #include <memory>
@@ -129,6 +130,27 @@ class EVO
 public:
     virtual ~EVO() {}
     virtual std::pair<MnListPtr, const CBlockIndex*> getListAtChainTip() = 0;
+    virtual ProviderTxCapabilities getProviderTxCapabilities() = 0;
+    //! Validate provider endpoints against a capability snapshot without changing node or wallet state.
+    //! Transaction creation validates them again against the then-active rules.
+    virtual std::optional<ProviderTxError> validateProviderNetInfo(const ProviderNetInfo& net_info, MnType type,
+                                                                   uint16_t version, bool optional) = 0;
+    //! Successful registration with an existing collateral leaves that coin locked,
+    //! including when the signed transaction is returned without submission.
+    virtual ProviderTxResult<ProviderTxSubmission> registerMasternode(Wallet& wallet,
+                                                                      const ProviderRegistrationRequest& request) = 0;
+    //! Successful preparation leaves existing collateral locked. The result identifies
+    //! whether this call acquired the lock so a discarded flow cannot unlock an older lock.
+    virtual ProviderTxResult<PreparedProviderRegistration> prepareMasternodeRegistration(
+        Wallet& wallet, const ProviderRegistrationRequest& request) = 0;
+    virtual ProviderTxResult<ProviderTxSubmission> submitMasternodeRegistration(
+        Wallet& wallet, const CTransactionRef& tx, const std::vector<unsigned char>& collateral_signature) = 0;
+    virtual ProviderTxResult<ProviderTxSubmission> updateMasternodeService(Wallet& wallet,
+                                                                           const ProviderUpdateServiceRequest& request) = 0;
+    virtual ProviderTxResult<ProviderTxSubmission> updateMasternodeRegistrar(
+        Wallet& wallet, const ProviderUpdateRegistrarRequest& request) = 0;
+    virtual ProviderTxResult<ProviderTxSubmission> revokeMasternode(Wallet& wallet,
+                                                                    const ProviderRevokeRequest& request) = 0;
     virtual void setContext(node::NodeContext* context) {}
 };
 
diff --git a/src/interfaces/providertx.h b/src/interfaces/providertx.h
new file mode 100644
index 000000000000..c9f048efe31d
--- /dev/null
+++ b/src/interfaces/providertx.h
@@ -0,0 +1,142 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_INTERFACES_PROVIDERTX_H
+#define BITCOIN_INTERFACES_PROVIDERTX_H
+
+#include <bls/bls.h>
+#include <evo/dmn_types.h>
+#include <primitives/transaction.h>
+#include <pubkey.h>
+#include <script/standard.h>
+#include <uint256.h>
+#include <util/translation.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+enum class TransactionError;
+
+namespace interfaces {
+
+enum class ProviderTxErrorCode {
+    INVALID_PARAMETER,
+    INVALID_ADDRESS_OR_KEY,
+    FUNDING_ERROR,
+    WALLET_ERROR,
+    WALLET_UNLOCK_NEEDED,
+    INTERNAL_ERROR,
+    VERIFY_ERROR,
+    CONSENSUS_REJECTED,
+    BROADCAST_ERROR,
+};
+
+struct ProviderTxError {
+    ProviderTxErrorCode code{ProviderTxErrorCode::INTERNAL_ERROR};
+    bilingual_str message;
+    std::string reject_reason;
+    std::optional<TransactionError> transaction_error;
+};
+
+template <typename T>
+using ProviderTxResult = std::variant<T, ProviderTxError>;
+
+struct ProviderTxSubmission {
+    CTransactionRef tx;
+    bool submitted{false};
+};
+
+struct PreparedProviderRegistration {
+    CTransactionRef tx;
+    CTxDestination collateral_address;
+    std::string sign_message;
+    //! True only if this prepare call newly locked the collateral. A successful prepare
+    //! leaves the lock held; the caller may release this one lock if the flow is discarded.
+    bool collateral_lock_acquired{false};
+};
+
+//! A point-in-time view of the provider transaction rules. Transaction creation and
+//! submission always re-evaluate the active rules and can reject a stale request.
+struct ProviderTxCapabilities {
+    uint16_t version{0};
+    bool extended_addresses{false};
+};
+
+using ProviderPlatformEndpoints = std::variant<std::monostate, uint16_t, std::vector<std::string>>;
+
+struct ProviderNetInfo {
+    std::vector<std::string> core_p2p;
+    ProviderPlatformEndpoints platform_p2p;
+    ProviderPlatformEndpoints platform_https;
+};
+
+struct ProviderPayout {
+    CTxDestination destination;
+    uint16_t reward{0};
+};
+
+struct FundProviderCollateral {
+    CTxDestination destination;
+};
+
+struct ExistingProviderCollateral {
+    COutPoint outpoint;
+};
+
+using ProviderCollateral = std::variant<FundProviderCollateral, ExistingProviderCollateral>;
+
+struct ProviderRegistrationRequest {
+    MnType type{MnType::Regular};
+    ProviderCollateral collateral;
+    ProviderNetInfo net_info;
+    CKeyID owner_key;
+    CBLSPublicKey operator_key;
+    CKeyID voting_key;
+    uint16_t operator_reward{0};
+    std::vector<ProviderPayout> payouts;
+    //! Whether payouts use the version-3 extended representation, even if there is only one.
+    bool uses_extended_payouts{false};
+    std::optional<uint160> platform_node_id;
+    std::optional<CTxDestination> fee_source;
+    bool use_legacy_bls_scheme{false};
+    bool submit{true};
+};
+
+struct ProviderUpdateServiceRequest {
+    MnType type{MnType::Regular};
+    uint256 pro_tx_hash;
+    ProviderNetInfo net_info;
+    CBLSSecretKey operator_key;
+    std::optional<uint160> platform_node_id;
+    std::optional<CTxDestination> operator_payout;
+    std::optional<CTxDestination> fee_source;
+    bool submit{true};
+};
+
+struct ProviderUpdateRegistrarRequest {
+    uint256 pro_tx_hash;
+    std::optional<CBLSPublicKey> operator_key;
+    std::optional<CKeyID> voting_key;
+    std::optional<std::vector<ProviderPayout>> payouts;
+    //! Whether payouts use the version-3 extended representation, even if there is only one.
+    bool uses_extended_payouts{false};
+    std::optional<CTxDestination> fee_source;
+    bool use_legacy_bls_scheme{false};
+    bool submit{true};
+};
+
+struct ProviderRevokeRequest {
+    uint256 pro_tx_hash;
+    CBLSSecretKey operator_key;
+    uint16_t reason{0};
+    std::optional<CTxDestination> fee_source;
+    bool submit{true};
+};
+
+} // namespace interfaces
+
+#endif // BITCOIN_INTERFACES_PROVIDERTX_H
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index 7300f4286e99..9fc779906135 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -69,6 +69,18 @@ class Loader;
 using WalletOrderForm = std::vector<std::pair<std::string, std::string>>;
 using WalletValueMap = std::map<std::string, std::string>;
 
+struct WalletTxSignResult {
+    CTransactionRef tx;
+    bool complete{false};
+    std::vector<bilingual_str> errors;
+};
+
+enum class CoinLockResult {
+    ACQUIRED,
+    ALREADY_LOCKED,
+    FAILED,
+};
+
 //! Interface for accessing a wallet.
 class Wallet
 {
@@ -164,6 +176,9 @@ class Wallet
     //! Lock coin.
     virtual bool lockCoin(const COutPoint& output, const bool write_to_db) = 0;
 
+    //! Atomically lock a coin only when it is not already locked.
+    virtual CoinLockResult acquireCoinLock(const COutPoint& output, bool write_to_db) = 0;
+
     //! Unlock coin.
     virtual bool unlockCoin(const COutPoint& output) = 0;
 
@@ -195,6 +210,18 @@ class Wallet
         int& change_pos,
         CAmount& fee) = 0;
 
+    //! Fund a transaction template per the provider-transaction funding policy:
+    //! inputs are selected only from coins received at the single specified
+    //! fee-source destination, change is returned to that same destination, and
+    //! a temporary dummy output is added (and later removed) when the template
+    //! has no outputs. Not a generic funding primitive. The template's version,
+    //! type, payload, and required outputs are preserved.
+    virtual util::Result<CTransactionRef> fundTransaction(const CMutableTransaction& tx_template,
+                                                          const CTxDestination& fund_destination) = 0;
+
+    //! Sign every wallet-owned input of a transaction and report whether signing is complete.
+    virtual util::Result<WalletTxSignResult> signTransaction(const CMutableTransaction& tx) = 0;
+
     //! Commit transaction.
     virtual void commitTransaction(CTransactionRef tx,
         WalletValueMap value_map,
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index f7f91f8a368d..c57159887945 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -15,6 +15,7 @@
 #include <evo/chainhelper.h>
 #include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
+#include <evo/providertx_service.h>
 #include <evo/specialtxman.h>
 #include <external_signer.h>
 #include <governance/governance.h>
@@ -23,11 +24,12 @@
 #include <governance/vote.h>
 #include <index/blockfilterindex.h>
 #include <init.h>
+#include <instantsend/instantsend.h>
 #include <interfaces/chain.h>
 #include <interfaces/coinjoin.h>
 #include <interfaces/handler.h>
 #include <interfaces/wallet.h>
-#include <instantsend/instantsend.h>
+#include <kernel/chain.h>
 #include <llmq/commitment.h>
 #include <llmq/context.h>
 #include <llmq/options.h>
@@ -40,7 +42,6 @@
 #include <netaddress.h>
 #include <netbase.h>
 #include <node/blockstorage.h>
-#include <kernel/chain.h>
 #include <node/coin.h>
 #include <node/context.h>
 #include <node/interface_ui.h>
@@ -99,6 +100,17 @@ using interfaces::MnEntryCPtr;
 using interfaces::MnList;
 using interfaces::MnListPtr;
 using interfaces::Node;
+using interfaces::PreparedProviderRegistration;
+using interfaces::ProviderNetInfo;
+using interfaces::ProviderRegistrationRequest;
+using interfaces::ProviderRevokeRequest;
+using interfaces::ProviderTxCapabilities;
+using interfaces::ProviderTxError;
+using interfaces::ProviderTxResult;
+using interfaces::ProviderTxSubmission;
+using interfaces::ProviderUpdateRegistrarRequest;
+using interfaces::ProviderUpdateServiceRequest;
+using interfaces::Wallet;
 using interfaces::WalletLoader;
 
 namespace node {
@@ -224,6 +236,40 @@ class EVOImpl : public EVO
         }
         return {nullptr, nullptr};
     }
+    ProviderTxCapabilities getProviderTxCapabilities() override { return evo::provider::GetCapabilities(context()); }
+    std::optional<ProviderTxError> validateProviderNetInfo(const ProviderNetInfo& net_info, MnType type,
+                                                           uint16_t version, bool optional) override
+    {
+        return evo::provider::ValidateNetInfo(net_info, type, version, optional);
+    }
+    ProviderTxResult<ProviderTxSubmission> registerMasternode(Wallet& wallet, const ProviderRegistrationRequest& request) override
+    {
+        return evo::provider::Register(context(), wallet, request);
+    }
+    ProviderTxResult<PreparedProviderRegistration> prepareMasternodeRegistration(
+        Wallet& wallet, const ProviderRegistrationRequest& request) override
+    {
+        return evo::provider::PrepareRegistration(context(), wallet, request);
+    }
+    ProviderTxResult<ProviderTxSubmission> submitMasternodeRegistration(
+        Wallet& wallet, const CTransactionRef& tx, const std::vector<unsigned char>& collateral_signature) override
+    {
+        return evo::provider::SubmitRegistration(context(), wallet, tx, collateral_signature);
+    }
+    ProviderTxResult<ProviderTxSubmission> updateMasternodeService(Wallet& wallet,
+                                                                   const ProviderUpdateServiceRequest& request) override
+    {
+        return evo::provider::UpdateService(context(), wallet, request);
+    }
+    ProviderTxResult<ProviderTxSubmission> updateMasternodeRegistrar(Wallet& wallet,
+                                                                     const ProviderUpdateRegistrarRequest& request) override
+    {
+        return evo::provider::UpdateRegistrar(context(), wallet, request);
+    }
+    ProviderTxResult<ProviderTxSubmission> revokeMasternode(Wallet& wallet, const ProviderRevokeRequest& request) override
+    {
+        return evo::provider::Revoke(context(), wallet, request);
+    }
     void setContext(NodeContext* context) override
     {
         m_context = context;
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index fc0a3640212c..a41b02e83df2 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -11,14 +11,16 @@
 #include <evo/deterministicmns.h>
 #include <evo/dmn_types.h>
 #include <evo/providertx.h>
+#include <evo/providertx_service.h>
 #include <evo/smldiff.h>
 #include <evo/specialtx.h>
 #include <evo/specialtxman.h>
 #include <index/txindex.h>
+#include <interfaces/wallet.h>
 #include <llmq/context.h>
 #include <masternode/meta.h>
 #include <node/context.h>
-#include <rpc/evo_util.h>
+#include <node/transaction.h>
 #include <rpc/server.h>
 #include <rpc/server_util.h>
 #include <rpc/util.h>
@@ -31,17 +33,10 @@
 #include <limits>
 
 #ifdef ENABLE_WALLET
-#include <wallet/coincontrol.h>
-#include <wallet/spend.h>
 #include <wallet/wallet.h>
 #endif // ENABLE_WALLET
 
-#ifdef ENABLE_WALLET
-extern RPCHelpMan sendrawtransaction();
-namespace wallet {
-extern RPCHelpMan signrawtransactionwithwallet();
-} // namespace wallet
-#else
+#ifndef ENABLE_WALLET
 namespace wallet {
 class CWallet;
 } // namespace wallet
@@ -51,13 +46,10 @@ using node::GetTransaction;
 using node::NodeContext;
 using wallet::CWallet;
 #ifdef ENABLE_WALLET
-using wallet::CCoinControl;
-using wallet::CRecipient;
 using wallet::DEFAULT_DISABLE_WALLET;
 using wallet::GetWalletForJSONRPCRequest;
 using wallet::HELP_REQUIRING_PASSPHRASE;
 using wallet::isminetype;
-using wallet::RANDOM_CHANGE_POSITION;
 #endif // ENABLE_WALLET
 
 static RPCArg GetRpcArg(const std::string& strParamName)
@@ -292,9 +284,9 @@ static CBLSPublicKey ParseBLSPubKey(const std::string& hexKey, const std::string
     return pubKey;
 }
 
-static MasternodePayoutShares ParsePayouts(const UniValue& value, const std::string& paramName, CTxDestination& first_dest)
+static std::vector<interfaces::ProviderPayout> ParsePayouts(const UniValue& value, const std::string& paramName)
 {
-    MasternodePayoutShares payouts;
+    std::vector<interfaces::ProviderPayout> payouts;
     if (value.isArray()) {
         const auto& arr = value.get_array();
         if (arr.empty()) {
@@ -317,164 +309,128 @@ static MasternodePayoutShares ParsePayouts(const UniValue& value, const std::str
             if (!IsValidDestination(dest)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid payout address: %s", address_value.get_str()));
             }
-            if (payouts.empty()) {
-                first_dest = dest;
-            }
             const int64_t reward = reward_value.getInt<int64_t>();
             if (reward < 0 || reward > std::numeric_limits<uint16_t>::max()) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "payout reward out of range");
             }
-            payouts.emplace_back(GetScriptForDestination(dest), static_cast<uint16_t>(reward));
+            payouts.push_back({dest, static_cast<uint16_t>(reward)});
         }
     } else {
-        first_dest = DecodeDestination(value.get_str());
-        if (!IsValidDestination(first_dest)) {
+        CTxDestination destination{DecodeDestination(value.get_str())};
+        if (!IsValidDestination(destination)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid payout address: %s", value.get_str()));
         }
-        payouts.emplace_back(GetScriptForDestination(first_dest), MasternodePayoutShare::MAX_REWARD);
+        payouts.push_back({destination, MasternodePayoutShare::MAX_REWARD});
     }
     return payouts;
 }
 
-template <typename SpecialTxPayload>
-static void FundSpecialTx(CWallet& wallet, CMutableTransaction& tx, const SpecialTxPayload& payload,
-                          const CTxDestination& fundDest) EXCLUSIVE_LOCKS_REQUIRED(!wallet.cs_wallet)
+static std::unique_ptr<interfaces::Wallet> MakeWalletInterface(const NodeContext& node,
+                                                               const std::shared_ptr<CWallet>& wallet)
 {
-    // Make sure the results are valid at least up to the most recent block
-    // the user could have gotten from another RPC command prior to now
-    wallet.BlockUntilSyncedToCurrentChain();
-
-    LOCK(wallet.cs_wallet);
-
-    CTxDestination nodest = CNoDestination();
-    if (fundDest == nodest) {
-        throw JSONRPCError(RPC_INTERNAL_ERROR, "No source of funds specified");
-    }
-
-    CDataStream ds(SER_NETWORK, PROTOCOL_VERSION);
-    ds << payload;
-    tx.vExtraPayload.assign(UCharCast(ds.data()), UCharCast(ds.data() + ds.size()));
-
-    static const CTxOut dummyTxOut(0, CScript() << OP_RETURN);
-    std::vector<CRecipient> vecSend;
-    bool dummyTxOutAdded = false;
-
-    if (tx.vout.empty()) {
-        // add dummy txout as CreateTransaction requires at least one recipient
-        tx.vout.emplace_back(dummyTxOut);
-        dummyTxOutAdded = true;
-    }
-
-    for (const auto& txOut : tx.vout) {
-        CRecipient recipient = {txOut.scriptPubKey, txOut.nValue, false};
-        vecSend.push_back(recipient);
-    }
-
-    CCoinControl coinControl;
-    coinControl.destChange = fundDest;
-    coinControl.fRequireAllInputs = false;
-
-    for (const auto& out : AvailableCoinsListUnspent(wallet).all()) {
-        CTxDestination txDest;
-        if (ExtractDestination(out.txout.scriptPubKey, txDest) && txDest == fundDest) {
-            coinControl.Select(out.outpoint);
-        }
-    }
-
-    if (!coinControl.HasSelected()) {
-        throw JSONRPCError(RPC_INTERNAL_ERROR, strprintf("No funds at specified address %s", EncodeDestination(fundDest)));
-    }
-
-    auto res = CreateTransaction(wallet, vecSend, RANDOM_CHANGE_POSITION, coinControl, /*sign=*/true, tx.vExtraPayload.size());
-    if (!res) {
-        throw JSONRPCError(RPC_INTERNAL_ERROR, util::ErrorString(res).original);
-    }
-
-    const CTransactionRef& newTx = res->tx;
-    tx.vin = newTx->vin;
-    tx.vout = newTx->vout;
-
-    if (dummyTxOutAdded && tx.vout.size() > 1) {
-        // CreateTransaction added a change output, so we don't need the dummy txout anymore.
-        // Removing it results in slight overpayment of fees, but we ignore this for now (as it's a very low amount).
-        auto it = std::find(tx.vout.begin(), tx.vout.end(), dummyTxOut);
-        CHECK_NONFATAL(it != tx.vout.end());
-        tx.vout.erase(it);
-    }
+    auto* wallet_loader{CHECK_NONFATAL(node.wallet_loader)};
+    return interfaces::MakeWallet(*CHECK_NONFATAL(wallet_loader->context()), wallet);
 }
 
-template<typename SpecialTxPayload>
-static void UpdateSpecialTxInputsHash(const CMutableTransaction& tx, SpecialTxPayload& payload)
-{
-    payload.inputsHash = CalcTxInputsHash(CTransaction(tx));
-}
-
-template<typename SpecialTxPayload>
-static void SignSpecialTxPayloadByHash(const CMutableTransaction& tx, SpecialTxPayload& payload, const CKeyID& keyID, const CWallet& wallet)
-{
-    UpdateSpecialTxInputsHash(tx, payload);
-    payload.vchSig.clear();
-
-    const uint256 hash = ::SerializeHash(payload);
-    if (!wallet.SignSpecialTxPayload(hash, keyID, payload.vchSig)) {
-        throw JSONRPCError(RPC_INTERNAL_ERROR, "failed to sign special tx");
-    }
+[[noreturn]] static void ThrowProviderTxError(const interfaces::ProviderTxError& provider_error)
+{
+    using interfaces::ProviderTxErrorCode;
+    switch (provider_error.code) {
+    case ProviderTxErrorCode::INVALID_PARAMETER:
+        throw JSONRPCError(RPC_INVALID_PARAMETER, provider_error.message.original);
+    case ProviderTxErrorCode::INVALID_ADDRESS_OR_KEY:
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, provider_error.message.original);
+    case ProviderTxErrorCode::FUNDING_ERROR:
+        // Preserve the historical protx RPC error code while exposing a useful typed category.
+        throw JSONRPCError(RPC_INTERNAL_ERROR, provider_error.message.original);
+    case ProviderTxErrorCode::WALLET_ERROR:
+        throw JSONRPCError(RPC_WALLET_ERROR, provider_error.message.original);
+    case ProviderTxErrorCode::WALLET_UNLOCK_NEEDED:
+        throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, provider_error.message.original);
+    case ProviderTxErrorCode::INTERNAL_ERROR:
+        throw JSONRPCError(RPC_INTERNAL_ERROR, provider_error.message.original);
+    case ProviderTxErrorCode::VERIFY_ERROR:
+        throw JSONRPCError(RPC_VERIFY_ERROR, provider_error.message.original);
+    case ProviderTxErrorCode::CONSENSUS_REJECTED:
+        throw std::runtime_error(provider_error.message.original);
+    case ProviderTxErrorCode::BROADCAST_ERROR:
+        throw JSONRPCTransactionError(*CHECK_NONFATAL(provider_error.transaction_error), provider_error.message.original);
+    }
+    NONFATAL_UNREACHABLE();
 }
 
-template <typename SpecialTxPayload>
-static void SignSpecialTxPayloadByHash(const CMutableTransaction& tx, SpecialTxPayload& payload,
-                                       const CBLSSecretKey& key, bool use_legacy)
+static std::string SubmissionToString(const interfaces::ProviderTxSubmission& submission)
 {
-    UpdateSpecialTxInputsHash(tx, payload);
-
-    uint256 hash = ::SerializeHash(payload);
-    payload.sig = key.Sign(hash, use_legacy);
+    return submission.submitted ? submission.tx->GetHash().GetHex() : EncodeHexTx(*submission.tx);
 }
 
-static std::string SignAndSendSpecialTx(const JSONRPCRequest& request, CChainstateHelper& chain_helper, const ChainstateManager& chainman, const CMutableTransaction& tx, bool fSubmit)
+static std::vector<std::string> ParseCoreNetInfo(const UniValue& input, bool optional)
 {
-    {
-    LOCK(::cs_main);
-
-    const CBlockIndex* tip{chainman.ActiveChain().Tip()};
-    const Consensus::Params& consensus_params{chainman.GetConsensus()};
-    if (!DeploymentActiveAfter(tip, consensus_params, Consensus::DEPLOYMENT_DIP0003)) {
-        const int current_height{tip ? tip->nHeight : -1};
-        const int next_block_height{current_height + 1};
-        const int activation_height{consensus_params.DIP0003Height};
-        const int blocks_to_mine{
-            activation_height > next_block_height ? activation_height - next_block_height : 0
-        };
-        throw JSONRPCError(RPC_VERIFY_ERROR, strprintf(
-            "DIP0003 is not active yet; ProTx transactions are valid starting at block height %d "
-            "(current chain height %d, next block height %d). Mine %d more block%s or restart "
-            "this regtest/devnet chain with DIP3 activation parameters that are already active.",
-            activation_height, current_height, next_block_height, blocks_to_mine,
-            blocks_to_mine == 1 ? "" : "s"));
+    if (input.isStr()) {
+        if (input.get_str().empty()) {
+            if (!optional) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid param for coreP2PAddrs[0], cannot be empty");
+            }
+            return {};
+        }
+        return {input.get_str()};
     }
-
-    TxValidationState state;
-    if (!chain_helper.special_tx->CheckSpecialTx(CTransaction(tx), tip, chainman.ActiveChainstate().CoinsTip(), true, state)) {
-        throw std::runtime_error(state.ToString());
+    if (!input.isArray()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid param for coreP2PAddrs, must be string or array");
     }
-    } // cs_main
-
-    CDataStream ds(SER_NETWORK, PROTOCOL_VERSION);
-    ds << tx;
-
-    JSONRPCRequest signRequest(request);
-    signRequest.params.setArray();
-    signRequest.params.push_back(HexStr(ds));
-    UniValue signResult = wallet::signrawtransactionwithwallet().HandleRequest(signRequest);
-
-    if (!fSubmit) {
-        return signResult["hex"].get_str();
+    const auto& entries{input.get_array()};
+    if (!optional && entries.empty()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid param for coreP2PAddrs, cannot be empty");
     }
+    std::vector<std::string> result;
+    result.reserve(entries.size());
+    for (size_t index{0}; index < entries.size(); ++index) {
+        if (!entries[index].isStr()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER,
+                               strprintf("Invalid param for coreP2PAddrs[%zu], must be string", index));
+        }
+        result.push_back(entries[index].get_str());
+    }
+    return result;
+}
 
-    JSONRPCRequest sendRequest(request);
-    sendRequest.params.setArray();
-    sendRequest.params.push_back(signResult["hex"].get_str());
-    return ::sendrawtransaction().HandleRequest(sendRequest).get_str();
+static interfaces::ProviderPlatformEndpoints ParsePlatformNetInfo(const UniValue& input, std::string_view field_name,
+                                                                  bool extended_addresses)
+{
+    if (!input.isArray() && !input.isNum() && !input.isStr()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER,
+                           strprintf("Invalid param for %s, must be array, number or string", field_name));
+    }
+    if (input.isArray()) {
+        std::vector<std::string> result;
+        const auto& entries{input.get_array()};
+        if (!entries.empty() && !extended_addresses) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER,
+                               strprintf("Invalid param for %s, this ProTx version only accepts a bare port number; "
+                                         "the "
+                                         "\"ADDR:PORT\" / address-array form requires upgrading to a version 3 ProTx",
+                                         field_name));
+        }
+        result.reserve(entries.size());
+        for (size_t index{0}; index < entries.size(); ++index) {
+            if (!entries[index].isStr() || entries[index].get_str().find_first_not_of("0123456789") == std::string::npos) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER,
+                                   strprintf("Invalid param for %s[%zu], must be string", field_name, index));
+            }
+            result.push_back(entries[index].get_str());
+        }
+        return result;
+    }
+    const std::string& value{input.getValStr()};
+    if (value.empty()) return std::monostate{};
+    int32_t port{0};
+    if (ParseInt32(value, &port) && port >= 1 && port <= std::numeric_limits<uint16_t>::max()) {
+        return static_cast<uint16_t>(port);
+    }
+    if (input.isStr() && value.find_first_not_of("0123456789") != std::string::npos)
+        return std::vector<std::string>{value};
+    throw JSONRPCError(RPC_INVALID_PARAMETER,
+                       strprintf("Invalid param for %s, must be a valid port [1-65535]", field_name));
 }
 
 // forward declaration
@@ -772,65 +728,42 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
                                               const ProTxRegisterAction action,
                                               const MnType mnType)
 {
-    const NodeContext& node = EnsureAnyNodeContext(request.context);
-    const ChainstateManager& chainman = EnsureChainman(node);
-
-    CChainstateHelper& chain_helper = *CHECK_NONFATAL(node.chain_helper);
-
-    const bool isEvoRequested = mnType == MnType::Evo;
-
-    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
+    NodeContext& node{EnsureAnyNodeContext(request.context)};
+    std::shared_ptr<CWallet> const pwallet{GetWalletForJSONRPCRequest(request)};
     if (!pwallet) return UniValue::VNULL;
-
     EnsureWalletIsUnlocked(*pwallet);
 
-    size_t paramIdx = 0;
-
-    CMutableTransaction tx;
-    tx.nVersion = 3;
-    tx.nType = TRANSACTION_PROVIDER_REGISTER;
-
-    const bool use_legacy = specific_legacy_bls_scheme;
-
-    CProRegTx ptx;
-    ptx.nType = mnType;
-    ptx.nVersion = DeploymentToProtxVersion(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()), chainman,
-                                            /*is_basic_override=*/!use_legacy);
-    ptx.netInfo = NetInfoInterface::MakeNetInfo(ptx.nVersion);
-
+    interfaces::ProviderRegistrationRequest typed_request;
+    typed_request.type = mnType;
+    typed_request.use_legacy_bls_scheme = specific_legacy_bls_scheme;
+    size_t paramIdx{0};
     if (action == ProTxRegisterAction::Fund) {
-        CTxDestination collateralDest = DecodeDestination(request.params[paramIdx].get_str());
-        if (!IsValidDestination(collateralDest)) {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid collaterall address: %s", request.params[paramIdx].get_str()));
+        CTxDestination collateral_destination{DecodeDestination(request.params[paramIdx].get_str())};
+        if (!IsValidDestination(collateral_destination)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
+                               strprintf("invalid collaterall address: %s", request.params[paramIdx].get_str()));
         }
-        CScript collateralScript = GetScriptForDestination(collateralDest);
-
-        CAmount fundCollateral = GetMnType(mnType).collat_amount;
-        CTxOut collateralTxOut(fundCollateral, collateralScript);
-        tx.vout.emplace_back(collateralTxOut);
-
+        typed_request.collateral = interfaces::FundProviderCollateral{collateral_destination};
         paramIdx++;
     } else {
-        uint256 collateralHash(ParseHashV(request.params[paramIdx], "collateralHash"));
-        int32_t collateralIndex = request.params[paramIdx + 1].getInt<int>();
-        if (collateralHash.IsNull() || collateralIndex < 0) {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid hash or index: %s-%d", collateralHash.ToString(), collateralIndex));
+        const uint256 collateral_hash{ParseHashV(request.params[paramIdx], "collateralHash")};
+        const int32_t collateral_index{request.params[paramIdx + 1].getInt<int>()};
+        if (collateral_hash.IsNull() || collateral_index < 0) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
+                               strprintf("invalid hash or index: %s-%d", collateral_hash.ToString(), collateral_index));
         }
-
-        ptx.collateralOutpoint = COutPoint(collateralHash, (uint32_t)collateralIndex);
+        typed_request.collateral = interfaces::ExistingProviderCollateral{
+            COutPoint{collateral_hash, static_cast<uint32_t>(collateral_index)}};
         paramIdx += 2;
     }
 
-    ProcessNetInfoCore(ptx, request.params[paramIdx], /*optional=*/true);
-
-    ptx.keyIDOwner = ParsePubKeyIDFromAddress(request.params[paramIdx + 1].get_str(), "owner address");
-    ptx.pubKeyOperator.Set(ParseBLSPubKey(request.params[paramIdx + 2].get_str(), "operator BLS address", use_legacy), use_legacy);
-    CHECK_NONFATAL(ptx.pubKeyOperator.IsLegacy() == (ptx.nVersion == ProTxVersion::LegacyBLS));
-
-    CKeyID keyIDVoting = ptx.keyIDOwner;
-
+    typed_request.net_info.core_p2p = ParseCoreNetInfo(request.params[paramIdx], /*optional=*/true);
+    typed_request.owner_key = ParsePubKeyIDFromAddress(request.params[paramIdx + 1].get_str(), "owner address");
+    typed_request.operator_key = ParseBLSPubKey(request.params[paramIdx + 2].get_str(), "operator BLS address",
+                                                specific_legacy_bls_scheme);
+    typed_request.voting_key = typed_request.owner_key;
     if (!request.params[paramIdx + 3].get_str().empty()) {
-        keyIDVoting = ParsePubKeyIDFromAddress(request.params[paramIdx + 3].get_str(), "voting address");
+        typed_request.voting_key = ParsePubKeyIDFromAddress(request.params[paramIdx + 3].get_str(), "voting address");
     }
 
     int64_t operatorReward;
@@ -840,179 +773,93 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
     if (operatorReward < 0 || operatorReward > 10000) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "operatorReward must be between 0 and 10000");
     }
-    ptx.nOperatorReward = operatorReward;
-
-    CTxDestination payoutDest;
-    if (request.params[paramIdx + 5].isArray() && ptx.nVersion < ProTxVersion::ExtAddr) {
+    typed_request.operator_reward = static_cast<uint16_t>(operatorReward);
+    const auto capabilities{evo::provider::GetCapabilities(node, /*basic_override=*/!specific_legacy_bls_scheme)};
+    typed_request.uses_extended_payouts = request.params[paramIdx + 5].isArray();
+    if (typed_request.uses_extended_payouts && !capabilities.extended_addresses) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "payouts array requires provider transaction version 3");
     }
-    ptx.payouts = ParsePayouts(request.params[paramIdx + 5], "payouts", payoutDest);
+    typed_request.payouts = ParsePayouts(request.params[paramIdx + 5], "payouts");
 
-    if (isEvoRequested) {
+    if (mnType == MnType::Evo) {
         if (!IsHex(request.params[paramIdx + 6].get_str())) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "platformNodeID must be hexadecimal string");
         }
-        ptx.platformNodeID.SetHex(request.params[paramIdx + 6].get_str());
-
-        ProcessNetInfoPlatform(ptx, request.params[paramIdx + 7], request.params[paramIdx + 8], /*optional=*/true);
-
+        uint160 platform_node_id;
+        platform_node_id.SetHex(request.params[paramIdx + 6].get_str());
+        typed_request.platform_node_id = platform_node_id;
+        typed_request.net_info.platform_p2p = ParsePlatformNetInfo(request.params[paramIdx + 7], "platformP2PAddrs",
+                                                                   capabilities.extended_addresses);
+        typed_request.net_info.platform_https = ParsePlatformNetInfo(request.params[paramIdx + 8], "platformHTTPSAddrs",
+                                                                     capabilities.extended_addresses);
         paramIdx += 3;
     }
 
-    ptx.keyIDVoting = keyIDVoting;
-    ptx.scriptPayout = ptx.payouts.front().scriptPayout;
-
-    if (action != ProTxRegisterAction::Fund) {
-        // make sure fee calculation works
-        ptx.vchSig.resize(65);
-    }
-
-    CTxDestination fundDest = payoutDest;
     if (!request.params[paramIdx + 6].isNull()) {
-        fundDest = DecodeDestination(request.params[paramIdx + 6].get_str());
-        if (!IsValidDestination(fundDest))
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Dash address: ") + request.params[paramIdx + 6].get_str());
-    }
-
-    bool fSubmit{true};
-    if ((action == ProTxRegisterAction::External || action == ProTxRegisterAction::Fund) && !request.params[paramIdx + 7].isNull()) {
-        fSubmit = ParseBoolV(request.params[paramIdx + 7], "submit");
-    }
-
-    if (action == ProTxRegisterAction::Fund) {
-        FundSpecialTx(*pwallet, tx, ptx, fundDest);
-        UpdateSpecialTxInputsHash(tx, ptx);
-        CAmount fundCollateral = GetMnType(mnType).collat_amount;
-        uint32_t collateralIndex = (uint32_t) -1;
-        for (uint32_t i = 0; i < tx.vout.size(); i++) {
-            if (tx.vout[i].nValue == fundCollateral) {
-                collateralIndex = i;
-                break;
-            }
-        }
-        CHECK_NONFATAL(collateralIndex != (uint32_t) -1);
-        ptx.collateralOutpoint.n = collateralIndex;
-
-        SetTxPayload(tx, ptx);
-        return SignAndSendSpecialTx(request, chain_helper, chainman, tx, fSubmit);
-    } else {
-        // referencing external collateral
-
-        const bool unlockOnError = [&]() {
-            if (LOCK(pwallet->cs_wallet); !pwallet->IsLockedCoin(ptx.collateralOutpoint)) {
-                pwallet->LockCoin(ptx.collateralOutpoint);
-                return true;
-            }
-            return false;
-        }();
-        try {
-            FundSpecialTx(*pwallet, tx, ptx, fundDest);
-            UpdateSpecialTxInputsHash(tx, ptx);
-            Coin coin;
-            if (!GetUTXOCoin(chainman.ActiveChainstate(), ptx.collateralOutpoint, coin)) {
-                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("collateral not found: %s", ptx.collateralOutpoint.ToStringShort()));
-            }
-            CTxDestination txDest;
-            ExtractDestination(coin.out.scriptPubKey, txDest);
-            const PKHash* pkhash = std::get_if<PKHash>(&txDest);
-            if (!pkhash) {
-                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("collateral type not supported: %s", ptx.collateralOutpoint.ToStringShort()));
-            }
-
-            if (action == ProTxRegisterAction::Prepare) {
-                // external signing with collateral key
-                ptx.vchSig.clear();
-                SetTxPayload(tx, ptx);
-
-                UniValue ret(UniValue::VOBJ);
-                ret.pushKV("tx", EncodeHexTx(CTransaction(tx)));
-                ret.pushKV("collateralAddress", EncodeDestination(txDest));
-                ret.pushKV("signMessage", ptx.MakeSignString());
-                return ret;
-            } else {
-                {
-                    LOCK(pwallet->cs_wallet);
-                    // lets prove we own the collateral
-                    CScript scriptPubKey = GetScriptForDestination(txDest);
-
-                    std::string signed_payload;
-                    SigningResult err = pwallet->SignMessage(ptx.MakeSignString(), *pkhash, signed_payload);
-                    if (err == SigningResult::SIGNING_FAILED) {
-                        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, SigningResultString(err));
-                    } else if (err != SigningResult::OK){
-                        throw JSONRPCError(RPC_WALLET_ERROR, SigningResultString(err));
-                    }
-                    auto opt_vchSig = DecodeBase64(signed_payload);
-                    if (!opt_vchSig.has_value()) throw JSONRPCError(RPC_INTERNAL_ERROR, "failed to decode base64 ready signature for protx");
-                    ptx.vchSig = opt_vchSig.value();
-                } // cs_wallet
-                SetTxPayload(tx, ptx);
-                return SignAndSendSpecialTx(request, chain_helper, chainman, tx, fSubmit);
-            }
-        } catch (...) {
-            if (unlockOnError) {
-                WITH_LOCK(pwallet->cs_wallet, pwallet->UnlockCoin(ptx.collateralOutpoint));
-            }
-            throw;
+        CTxDestination fund_destination{DecodeDestination(request.params[paramIdx + 6].get_str())};
+        if (!IsValidDestination(fund_destination)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
+                               std::string("Invalid Dash address: ") + request.params[paramIdx + 6].get_str());
         }
-    }
+        typed_request.fee_source = fund_destination;
+    }
+    if ((action == ProTxRegisterAction::External || action == ProTxRegisterAction::Fund) &&
+        !request.params[paramIdx + 7].isNull()) {
+        typed_request.submit = ParseBoolV(request.params[paramIdx + 7], "submit");
+    }
+
+    auto wallet_interface{MakeWalletInterface(node, pwallet)};
+    if (action == ProTxRegisterAction::Prepare) {
+        auto result{evo::provider::PrepareRegistration(node, *wallet_interface, typed_request)};
+        if (const auto* error{std::get_if<interfaces::ProviderTxError>(&result)}) ThrowProviderTxError(*error);
+        const auto& prepared{std::get<interfaces::PreparedProviderRegistration>(result)};
+        UniValue response{UniValue::VOBJ};
+        response.pushKV("tx", EncodeHexTx(*prepared.tx));
+        response.pushKV("collateralAddress", EncodeDestination(prepared.collateral_address));
+        response.pushKV("signMessage", prepared.sign_message);
+        return response;
+    }
+    auto result{evo::provider::Register(node, *wallet_interface, typed_request)};
+    if (const auto* error{std::get_if<interfaces::ProviderTxError>(&result)}) ThrowProviderTxError(*error);
+    return SubmissionToString(std::get<interfaces::ProviderTxSubmission>(result));
 }
 
 static RPCHelpMan protx_register_submit()
 {
-    return RPCHelpMan{"protx register_submit",
+    return RPCHelpMan{
+        "protx register_submit",
         "\nCombines the unsigned ProTx and a signature of the signMessage, signs all inputs\n"
         "which were added to cover fees and submits the resulting transaction to the network.\n"
-        "Note: See \"help protx register_prepare\" for more info about creating a ProTx and a message to sign.\n"
-        + HELP_REQUIRING_PASSPHRASE,
+        "Note: See \"help protx register_prepare\" for more info about creating a ProTx and a message to sign.\n" +
+            HELP_REQUIRING_PASSPHRASE,
         {
             {"tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized unsigned ProTx in hex format."},
-            {"sig", RPCArg::Type::STR, RPCArg::Optional::NO, "The signature signed with the collateral key. Must be in base64 format."},
-        },
-        RPCResult{
-            RPCResult::Type::STR_HEX, "txid", "The transaction id"
-        },
-        RPCExamples{
-            HelpExampleCli("protx", "register_submit \"tx\" \"sig\"")
+            {"sig", RPCArg::Type::STR, RPCArg::Optional::NO,
+             "The signature signed with the collateral key. Must be in base64 format."},
         },
-        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
-{
-    const NodeContext& node = EnsureAnyNodeContext(request.context);
-    const ChainstateManager& chainman = EnsureChainman(node);
-
-    CChainstateHelper& chain_helper = *CHECK_NONFATAL(node.chain_helper);
-
-    const std::shared_ptr<const CWallet> wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return UniValue::VNULL;
-
-    EnsureWalletIsUnlocked(*wallet);
-
-    CMutableTransaction tx;
-    if (!DecodeHexTx(tx, request.params[0].get_str())) {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction not deserializable");
-    }
-    if (tx.nType != TRANSACTION_PROVIDER_REGISTER) {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction not a ProRegTx");
-    }
-    auto ptx = [&tx]() {
-        if (const auto opt_ptx = GetTxPayload<CProRegTx>(tx); opt_ptx.has_value()) {
-            return *opt_ptx;
-        }
-        throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction payload not deserializable");
-    }();
-    if (!ptx.vchSig.empty()) {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, "payload signature not empty");
-    }
-
-    auto opt_vchSig= DecodeBase64(request.params[1].get_str());
-    if (!opt_vchSig.has_value()) {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, "malformed base64 encoding");
-    }
-    ptx.vchSig = opt_vchSig.value();
+        RPCResult{RPCResult::Type::STR_HEX, "txid", "The transaction id"},
+        RPCExamples{HelpExampleCli("protx", "register_submit \"tx\" \"sig\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            NodeContext& node{EnsureAnyNodeContext(request.context)};
+            const std::shared_ptr<CWallet> wallet{GetWalletForJSONRPCRequest(request)};
+            if (!wallet) return UniValue::VNULL;
+            EnsureWalletIsUnlocked(*wallet);
+
+            CMutableTransaction tx;
+            if (!DecodeHexTx(tx, request.params[0].get_str())) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction not deserializable");
+            }
+            auto opt_vchSig{DecodeBase64(request.params[1].get_str())};
+            if (!opt_vchSig.has_value()) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "malformed base64 encoding");
+            }
 
-    SetTxPayload(tx, ptx);
-    return SignAndSendSpecialTx(request, chain_helper, chainman, tx, /*fSubmit=*/true);
-},
+            auto wallet_interface{MakeWalletInterface(node, wallet)};
+            auto result{evo::provider::SubmitRegistration(node, *wallet_interface, MakeTransactionRef(std::move(tx)),
+                                                          *opt_vchSig)};
+            if (const auto* error{std::get_if<interfaces::ProviderTxError>(&result)}) ThrowProviderTxError(*error);
+            return SubmissionToString(std::get<interfaces::ProviderTxSubmission>(result));
+        },
     };
 }
 
@@ -1084,102 +931,57 @@ static RPCHelpMan protx_update_service_evo()
 
 static UniValue protx_update_service_common_wrapper(const JSONRPCRequest& request, const MnType mnType)
 {
-    const NodeContext& node = EnsureAnyNodeContext(request.context);
-    const ChainstateManager& chainman = EnsureChainman(node);
-
-    CDeterministicMNManager& dmnman = *CHECK_NONFATAL(node.dmnman);
-    CChainstateHelper& chain_helper = *CHECK_NONFATAL(node.chain_helper);
-
-    const bool isEvoRequested = mnType == MnType::Evo;
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    NodeContext& node{EnsureAnyNodeContext(request.context)};
+    std::shared_ptr<CWallet> const wallet{GetWalletForJSONRPCRequest(request)};
     if (!wallet) return UniValue::VNULL;
-
     EnsureWalletIsUnlocked(*wallet);
 
-    CProUpServTx ptx;
-    ptx.proTxHash = ParseHashV(request.params[0], "proTxHash");
-    auto dmn = dmnman.GetListAtChainTip().GetMN(ptx.proTxHash);
-    if (!dmn) {
-        throw std::runtime_error(strprintf("masternode with proTxHash %s not found", ptx.proTxHash.ToString()));
-    }
-
-    ptx.nType = mnType;
-    if (dmn->nType != mnType) {
-        throw std::runtime_error(strprintf("masternode with proTxHash %s is not a %s", ptx.proTxHash.ToString(), GetMnType(mnType).description));
-    }
-
-    ptx.nVersion = DeploymentToProtxVersion(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()), chainman);
-
-    ptx.netInfo = NetInfoInterface::MakeNetInfo(ptx.nVersion);
-
-    ProcessNetInfoCore(ptx, request.params[1], /*optional=*/false);
-
-    CBLSSecretKey keyOperator = ParseBLSSecretKey(request.params[2].get_str(), "operatorKey");
+    interfaces::ProviderUpdateServiceRequest typed_request;
+    typed_request.type = mnType;
+    typed_request.pro_tx_hash = ParseHashV(request.params[0], "proTxHash");
+    typed_request.net_info.core_p2p = ParseCoreNetInfo(request.params[1], /*optional=*/false);
+    typed_request.operator_key = ParseBLSSecretKey(request.params[2].get_str(), "operatorKey");
 
-    size_t paramIdx = 3;
-    if (isEvoRequested) {
+    size_t paramIdx{3};
+    if (mnType == MnType::Evo) {
+        const auto capabilities{evo::provider::GetCapabilities(node)};
         if (!IsHex(request.params[paramIdx].get_str())) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "platformNodeID must be hexadecimal string");
         }
-        ptx.platformNodeID.SetHex(request.params[paramIdx].get_str());
-
-        ProcessNetInfoPlatform(ptx, request.params[paramIdx + 1], request.params[paramIdx + 2], /*optional=*/false);
-
+        uint160 platform_node_id;
+        platform_node_id.SetHex(request.params[paramIdx].get_str());
+        typed_request.platform_node_id = platform_node_id;
+        typed_request.net_info.platform_p2p = ParsePlatformNetInfo(request.params[paramIdx + 1], "platformP2PAddrs",
+                                                                   capabilities.extended_addresses);
+        typed_request.net_info.platform_https = ParsePlatformNetInfo(request.params[paramIdx + 2], "platformHTTPSAddrs",
+                                                                     capabilities.extended_addresses);
         paramIdx += 3;
     }
 
-    if (keyOperator.GetPublicKey() != dmn->pdmnState->pubKeyOperator.Get()) {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("the operator key does not belong to the registered public key"));
-    }
-
-    CMutableTransaction tx;
-    tx.nVersion = 3;
-    tx.nType = TRANSACTION_PROVIDER_UPDATE_SERVICE;
-
-    // param operatorPayoutAddress
-    if (!request.params[paramIdx].isNull()) {
-        if (request.params[paramIdx].get_str().empty()) {
-            ptx.scriptOperatorPayout = dmn->pdmnState->scriptOperatorPayout;
-        } else {
-            CTxDestination payoutDest = DecodeDestination(request.params[paramIdx].get_str());
-            if (!IsValidDestination(payoutDest)) {
-                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid operator payout address: %s", request.params[paramIdx].get_str()));
-            }
-            ptx.scriptOperatorPayout = GetScriptForDestination(payoutDest);
+    if (!request.params[paramIdx].isNull() && !request.params[paramIdx].get_str().empty()) {
+        CTxDestination payout_destination{DecodeDestination(request.params[paramIdx].get_str())};
+        if (!IsValidDestination(payout_destination)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
+                               strprintf("invalid operator payout address: %s", request.params[paramIdx].get_str()));
         }
-    } else {
-        ptx.scriptOperatorPayout = dmn->pdmnState->scriptOperatorPayout;
+        typed_request.operator_payout = payout_destination;
     }
-
-    CTxDestination feeSource;
-
-    // param feeSourceAddress
     if (!request.params[paramIdx + 1].isNull()) {
-        feeSource = DecodeDestination(request.params[paramIdx + 1].get_str());
-        if (!IsValidDestination(feeSource))
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Dash address: ") + request.params[paramIdx + 1].get_str());
-    } else {
-        if (ptx.scriptOperatorPayout != CScript()) {
-            // use operator reward address as default source for fees
-            ExtractDestination(ptx.scriptOperatorPayout, feeSource);
-        } else {
-            // use payout address as default source for fees
-            const auto owner_payouts = GetOwnerPayouts(*dmn->pdmnState);
-            ExtractDestination(owner_payouts.front().scriptPayout, feeSource);
+        CTxDestination fee_source{DecodeDestination(request.params[paramIdx + 1].get_str())};
+        if (!IsValidDestination(fee_source)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
+                               std::string("Invalid Dash address: ") + request.params[paramIdx + 1].get_str());
         }
+        typed_request.fee_source = fee_source;
     }
-
-    bool fSubmit{true};
     if (!request.params[paramIdx + 2].isNull()) {
-        fSubmit = ParseBoolV(request.params[paramIdx + 2], "submit");
+        typed_request.submit = ParseBoolV(request.params[paramIdx + 2], "submit");
     }
 
-    FundSpecialTx(*wallet, tx, ptx, feeSource);
-
-    SignSpecialTxPayloadByHash(tx, ptx, keyOperator, /*use_legacy=*/ptx.nVersion == ProTxVersion::LegacyBLS);
-    SetTxPayload(tx, ptx);
-
-    return SignAndSendSpecialTx(request, chain_helper, chainman, tx, fSubmit);
+    auto wallet_interface{MakeWalletInterface(node, wallet)};
+    auto result{evo::provider::UpdateService(node, *wallet_interface, typed_request)};
+    if (const auto* error{std::get_if<interfaces::ProviderTxError>(&result)}) ThrowProviderTxError(*error);
+    return SubmissionToString(std::get<interfaces::ProviderTxSubmission>(result));
 }
 
 static RPCHelpMan protx_update_registrar_wrapper(const bool specific_legacy_bls_scheme)
@@ -1188,12 +990,15 @@ static RPCHelpMan protx_update_registrar_wrapper(const bool specific_legacy_bls_
     std::string rpc_full_name = std::string("protx ").append(rpc_name);
     std::string pubkey_operator = specific_legacy_bls_scheme ? "\"0532646990082f4fd639f90387b1551f2c7c39d37392cb9055a06a7e85c1d23692db8f87f827886310bccc1e29db9aee\"" : "\"8532646990082f4fd639f90387b1551f2c7c39d37392cb9055a06a7e85c1d23692db8f87f827886310bccc1e29db9aee\"";
     std::string rpc_example = rpc_name.append(" \"0123456701234567012345670123456701234567012345670123456701234567\" ").append(pubkey_operator).append(" \"" + EXAMPLE_ADDRESS[1] + "\"");
-    return RPCHelpMan{rpc_full_name,
+    return RPCHelpMan{
+        rpc_full_name,
         "\nCreates and sends a ProUpRegTx to the network. This will update the operator key, voting key and payout\n"
         "address of the masternode specified by \"proTxHash\".\n"
-        "The owner key of the masternode must be known to your wallet.\n"
-        + std::string(specific_legacy_bls_scheme ? "\nDEPRECATED: May be removed in a future version, pass config option -deprecatedrpc=legacy_mn to use RPC\n" : "")
-        + HELP_REQUIRING_PASSPHRASE,
+        "The owner key of the masternode must be known to your wallet.\n" +
+            std::string(specific_legacy_bls_scheme ? "\nDEPRECATED: May be removed in a future version, pass config "
+                                                     "option -deprecatedrpc=legacy_mn to use RPC\n"
+                                                   : "") +
+            HELP_REQUIRING_PASSPHRASE,
         {
             GetRpcArg("proTxHash"),
             specific_legacy_bls_scheme ? GetRpcArg("operatorPubKey_update_legacy") : GetRpcArg("operatorPubKey_update"),
@@ -1203,118 +1008,57 @@ static RPCHelpMan protx_update_registrar_wrapper(const bool specific_legacy_bls_
             GetRpcArg("submit"),
         },
         {
-            RPCResult{"if \"submit\" is not set or set to true",
-                RPCResult::Type::STR_HEX, "txid", "The transaction id"},
-            RPCResult{"if \"submit\" is set to false",
-                RPCResult::Type::STR_HEX, "hex", "The serialized signed ProTx in hex format"},
-        },
-        RPCExamples{
-            HelpExampleCli("protx", rpc_example)
+            RPCResult{"if \"submit\" is not set or set to true", RPCResult::Type::STR_HEX, "txid", "The transaction id"},
+            RPCResult{"if \"submit\" is set to false", RPCResult::Type::STR_HEX, "hex",
+                      "The serialized signed ProTx in hex format"},
         },
-        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
-{
-    const bool use_legacy{self.m_name == "protx update_registrar_legacy"};
-    if (use_legacy && !IsDeprecatedRPCEnabled("legacy_mn")) {
-        throw std::runtime_error("DEPRECATED: Pass config option -deprecatedrpc=legacy_mn to enable this RPC");
-    }
-
-    const NodeContext& node = EnsureAnyNodeContext(request.context);
-    const ChainstateManager& chainman = EnsureChainman(node);
-
-    CDeterministicMNManager& dmnman = *CHECK_NONFATAL(node.dmnman);
-    CChainstateHelper& chain_helper = *CHECK_NONFATAL(node.chain_helper);
-
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return UniValue::VNULL;
-
-    EnsureWalletIsUnlocked(*wallet);
-
-    CProUpRegTx ptx;
-    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);
-    if (!dmn) {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("masternode %s not found", ptx.proTxHash.ToString()));
-    }
-
-    ptx.keyIDVoting = dmn->pdmnState->keyIDVoting;
-    ptx.scriptPayout = dmn->pdmnState->scriptPayout;
-    ptx.payouts = GetOwnerPayouts(*dmn->pdmnState);
-
-    if (!request.params[1].get_str().empty()) {
-        // new pubkey
-        ptx.pubKeyOperator.Set(ParseBLSPubKey(request.params[1].get_str(), "operator BLS address", use_legacy), use_legacy);
-    } else {
-        // same pubkey, reuse as is
-        ptx.pubKeyOperator = dmn->pdmnState->pubKeyOperator;
-    }
-
-    // A legacy masternode migrates to the basic scheme via a (non-legacy) registrar update, keeping
-    // its operator key (migration) or supplying a new one (rotation). ptx.nVersion is already set from
-    // the deployment state above -- LegacyBLS for the legacy-BLS RPC variant, basic otherwise -- so
-    // only the key encoding needs fixing up here: a reused key is stored in the legacy encoding, so
-    // re-encode it to the basic scheme to keep the stored key consistent with its version (and the
-    // assertion below holding). A freshly parsed key already matches the requested scheme, and basic
-    // masternodes are untouched.
-    if (!use_legacy && ptx.pubKeyOperator != CBLSLazyPublicKey() && ptx.pubKeyOperator.IsLegacy()) {
-        const CBLSPublicKey& pubkey{ptx.pubKeyOperator.Get()};
-        ptx.pubKeyOperator.Set(pubkey, /*specificLegacyScheme=*/false);
-    }
-
-    CHECK_NONFATAL(ptx.pubKeyOperator.IsLegacy() == (ptx.nVersion == ProTxVersion::LegacyBLS));
-
-    if (!request.params[2].get_str().empty()) {
-        ptx.keyIDVoting = ParsePubKeyIDFromAddress(request.params[2].get_str(), "voting address");
-    }
-
-    CTxDestination payoutDest;
-    ExtractDestination(ptx.payouts.front().scriptPayout, payoutDest);
-    if (request.params[3].isArray()) {
-        if (ptx.nVersion < ProTxVersion::ExtAddr) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, "payouts array requires provider transaction version 3");
-        }
-        ptx.payouts = ParsePayouts(request.params[3], "payouts", payoutDest);
-        ptx.scriptPayout = ptx.payouts.front().scriptPayout;
-    } else if (!request.params[3].get_str().empty()) {
-        ptx.payouts = ParsePayouts(request.params[3], "payouts", payoutDest);
-        ptx.scriptPayout = ptx.payouts.front().scriptPayout;
-    }
-
-    {
-        const auto pkhash{PKHash(dmn->pdmnState->keyIDOwner)};
-        LOCK(wallet->cs_wallet);
-        if (wallet->IsMine(GetScriptForDestination(pkhash)) != isminetype::ISMINE_SPENDABLE) {
-            throw std::runtime_error(strprintf("Private key for owner address %s not found in your wallet", EncodeDestination(pkhash)));
-        }
-    }
-
-    CMutableTransaction tx;
-    tx.nVersion = 3;
-    tx.nType = TRANSACTION_PROVIDER_UPDATE_REGISTRAR;
-
-    // make sure we get anough fees added
-    ptx.vchSig.resize(65);
-
-    CTxDestination feeSourceDest = payoutDest;
-    if (!request.params[4].isNull()) {
-        feeSourceDest = DecodeDestination(request.params[4].get_str());
-        if (!IsValidDestination(feeSourceDest))
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Dash address: ") + request.params[4].get_str());
-    }
-
-    bool fSubmit{true};
-    if (!request.params[5].isNull()) {
-        fSubmit = ParseBoolV(request.params[5], "submit");
-    }
+        RPCExamples{HelpExampleCli("protx", rpc_example)},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            const bool use_legacy{self.m_name == "protx update_registrar_legacy"};
+            if (use_legacy && !IsDeprecatedRPCEnabled("legacy_mn")) {
+                throw std::runtime_error("DEPRECATED: Pass config option -deprecatedrpc=legacy_mn to enable this RPC");
+            }
 
-    FundSpecialTx(*wallet, tx, ptx, feeSourceDest);
-    SignSpecialTxPayloadByHash(tx, ptx, dmn->pdmnState->keyIDOwner, *wallet);
-    SetTxPayload(tx, ptx);
+            NodeContext& node{EnsureAnyNodeContext(request.context)};
+            std::shared_ptr<CWallet> const wallet{GetWalletForJSONRPCRequest(request)};
+            if (!wallet) return UniValue::VNULL;
+            EnsureWalletIsUnlocked(*wallet);
+
+            interfaces::ProviderUpdateRegistrarRequest typed_request;
+            typed_request.pro_tx_hash = ParseHashV(request.params[0], "proTxHash");
+            typed_request.use_legacy_bls_scheme = use_legacy;
+            if (!request.params[1].get_str().empty()) {
+                typed_request.operator_key = ParseBLSPubKey(request.params[1].get_str(), "operator BLS address",
+                                                            use_legacy);
+            }
+            if (!request.params[2].get_str().empty()) {
+                typed_request.voting_key = ParsePubKeyIDFromAddress(request.params[2].get_str(), "voting address");
+            }
+            if (request.params[3].isArray() || !request.params[3].get_str().empty()) {
+                typed_request.uses_extended_payouts = request.params[3].isArray();
+                if (typed_request.uses_extended_payouts &&
+                    !evo::provider::GetCapabilities(node, /*basic_override=*/!use_legacy).extended_addresses) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, "payouts array requires provider transaction version 3");
+                }
+                typed_request.payouts = ParsePayouts(request.params[3], "payouts");
+            }
+            if (!request.params[4].isNull()) {
+                CTxDestination fee_source{DecodeDestination(request.params[4].get_str())};
+                if (!IsValidDestination(fee_source)) {
+                    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
+                                       std::string("Invalid Dash address: ") + request.params[4].get_str());
+                }
+                typed_request.fee_source = fee_source;
+            }
+            if (!request.params[5].isNull()) {
+                typed_request.submit = ParseBoolV(request.params[5], "submit");
+            }
 
-    return SignAndSendSpecialTx(request, chain_helper, chainman, tx, fSubmit);
-},
+            auto wallet_interface{MakeWalletInterface(node, wallet)};
+            auto result{evo::provider::UpdateRegistrar(node, *wallet_interface, typed_request)};
+            if (const auto* error{std::get_if<interfaces::ProviderTxError>(&result)}) ThrowProviderTxError(*error);
+            return SubmissionToString(std::get<interfaces::ProviderTxSubmission>(result));
+        },
     };
 }
 
@@ -1330,12 +1074,13 @@ static RPCHelpMan protx_update_registrar_legacy()
 
 static RPCHelpMan protx_revoke()
 {
-    return RPCHelpMan{"protx revoke",
+    return RPCHelpMan{
+        "protx revoke",
         "\nCreates and sends a ProUpRevTx to the network. This will revoke the operator key of the masternode and\n"
         "put it into the PoSe-banned state. It will also set the service field of the masternode\n"
         "to zero. Use this in case your operator key got compromised or you want to stop providing your service\n"
-        "to the masternode owner.\n"
-        + HELP_REQUIRING_PASSPHRASE,
+        "to the masternode owner.\n" +
+            HELP_REQUIRING_PASSPHRASE,
         {
             GetRpcArg("proTxHash"),
             GetRpcArg("operatorKey"),
@@ -1344,85 +1089,47 @@ static RPCHelpMan protx_revoke()
             GetRpcArg("submit"),
         },
         {
-            RPCResult{"if \"submit\" is not set or set to true",
-                RPCResult::Type::STR_HEX, "txid", "The transaction id"},
-            RPCResult{"if \"submit\" is set to false",
-                RPCResult::Type::STR_HEX, "hex", "The serialized signed ProTx in hex format"},
+            RPCResult{"if \"submit\" is not set or set to true", RPCResult::Type::STR_HEX, "txid", "The transaction id"},
+            RPCResult{"if \"submit\" is set to false", RPCResult::Type::STR_HEX, "hex",
+                      "The serialized signed ProTx in hex format"},
         },
-        RPCExamples{
-            HelpExampleCli("protx", "revoke \"0123456701234567012345670123456701234567012345670123456701234567\" \"072f36a77261cdd5d64c32d97bac417540eddca1d5612f416feb07ff75a8e240\"")
-        },
-        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
-{
-    const NodeContext& node = EnsureAnyNodeContext(request.context);
-    const ChainstateManager& chainman = EnsureChainman(node);
-
-    CDeterministicMNManager& dmnman = *CHECK_NONFATAL(node.dmnman);
-    CChainstateHelper& chain_helper = *CHECK_NONFATAL(node.chain_helper);
-
-    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
-    if (!pwallet) return UniValue::VNULL;
-
-    EnsureWalletIsUnlocked(*pwallet);
-
-    CProUpRevTx ptx;
-    ptx.proTxHash = ParseHashV(request.params[0], "proTxHash");
-
-    auto dmn = dmnman.GetListAtChainTip().GetMN(ptx.proTxHash);
-    if (!dmn) {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("masternode %s not found", ptx.proTxHash.ToString()));
-    }
-
-    ptx.nVersion = DeploymentToProtxVersion(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()), chainman);
-
-    CBLSSecretKey keyOperator = ParseBLSSecretKey(request.params[1].get_str(), "operatorKey");
-
-    if (!request.params[2].isNull()) {
-        int32_t nReason = request.params[2].getInt<int>();
-        if (nReason < 0 || nReason > CProUpRevTx::REASON_LAST) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("invalid reason %d, must be between 0 and %d", nReason, CProUpRevTx::REASON_LAST));
-        }
-        ptx.nReason = (uint16_t)nReason;
-    }
-
-    if (keyOperator.GetPublicKey() != dmn->pdmnState->pubKeyOperator.Get()) {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("the operator key does not belong to the registered public key"));
-    }
-
-    CMutableTransaction tx;
-    tx.nVersion = 3;
-    tx.nType = TRANSACTION_PROVIDER_UPDATE_REVOKE;
-
-    if (!request.params[3].isNull()) {
-        CTxDestination feeSourceDest = DecodeDestination(request.params[3].get_str());
-        if (!IsValidDestination(feeSourceDest))
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Dash address: ") + request.params[3].get_str());
-        FundSpecialTx(*pwallet, tx, ptx, feeSourceDest);
-    } else if (dmn->pdmnState->scriptOperatorPayout != CScript()) {
-        // Using funds from previousely specified operator payout address
-        CTxDestination txDest;
-        ExtractDestination(dmn->pdmnState->scriptOperatorPayout, txDest);
-        FundSpecialTx(*pwallet, tx, ptx, txDest);
-    } else {
-        // Using funds from previousely specified masternode payout address
-        CTxDestination txDest;
-        const auto owner_payouts = GetOwnerPayouts(*dmn->pdmnState);
-        if (owner_payouts.empty() || !ExtractDestination(owner_payouts.front().scriptPayout, txDest)) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, "No payout or fee source addresses found, can't revoke");
-        }
-        FundSpecialTx(*pwallet, tx, ptx, txDest);
-    }
-
-    bool fSubmit{true};
-    if (!request.params[4].isNull()) {
-        fSubmit = ParseBoolV(request.params[4], "submit");
-    }
-
-    SignSpecialTxPayloadByHash(tx, ptx, keyOperator, /*use_legacy=*/ptx.nVersion == ProTxVersion::LegacyBLS);
-    SetTxPayload(tx, ptx);
+        RPCExamples{HelpExampleCli("protx",
+                                   "revoke \"0123456701234567012345670123456701234567012345670123456701234567\" "
+                                   "\"072f36a77261cdd5d64c32d97bac417540eddca1d5612f416feb07ff75a8e240\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            NodeContext& node{EnsureAnyNodeContext(request.context)};
+            std::shared_ptr<CWallet> const pwallet{GetWalletForJSONRPCRequest(request)};
+            if (!pwallet) return UniValue::VNULL;
+            EnsureWalletIsUnlocked(*pwallet);
+
+            interfaces::ProviderRevokeRequest typed_request;
+            typed_request.pro_tx_hash = ParseHashV(request.params[0], "proTxHash");
+            typed_request.operator_key = ParseBLSSecretKey(request.params[1].get_str(), "operatorKey");
+            if (!request.params[2].isNull()) {
+                const int32_t nReason{request.params[2].getInt<int>()};
+                if (nReason < 0 || nReason > CProUpRevTx::REASON_LAST) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("invalid reason %d, must be between 0 and %d",
+                                                                        nReason, CProUpRevTx::REASON_LAST));
+                }
+                typed_request.reason = static_cast<uint16_t>(nReason);
+            }
+            if (!request.params[3].isNull()) {
+                CTxDestination fee_source{DecodeDestination(request.params[3].get_str())};
+                if (!IsValidDestination(fee_source)) {
+                    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
+                                       std::string("Invalid Dash address: ") + request.params[3].get_str());
+                }
+                typed_request.fee_source = fee_source;
+            }
+            if (!request.params[4].isNull()) {
+                typed_request.submit = ParseBoolV(request.params[4], "submit");
+            }
 
-    return SignAndSendSpecialTx(request, chain_helper, chainman, tx, fSubmit);
-},
+            auto wallet_interface{MakeWalletInterface(node, pwallet)};
+            auto result{evo::provider::Revoke(node, *wallet_interface, typed_request)};
+            if (const auto* error{std::get_if<interfaces::ProviderTxError>(&result)}) ThrowProviderTxError(*error);
+            return SubmissionToString(std::get<interfaces::ProviderTxSubmission>(result));
+        },
     };
 }
 
diff --git a/src/rpc/evo_util.cpp b/src/rpc/evo_util.cpp
index e73bb5cc61b6..29a06993b735 100644
--- a/src/rpc/evo_util.cpp
+++ b/src/rpc/evo_util.cpp
@@ -5,143 +5,10 @@
 #include <rpc/evo_util.h>
 
 #include <evo/deterministicmns.h>
-#include <evo/providertx.h>
 #include <index/txindex.h>
-#include <rpc/protocol.h>
-#include <rpc/request.h>
 
 #include <univalue.h>
 
-namespace {
-bool IsNumeric(std::string_view input) { return input.find_first_not_of("0123456789") == std::string::npos; }
-
-template <typename ProTx>
-void ParseInput(ProTx& ptx, std::string_view field_name, const std::string& input_str, NetInfoPurpose purpose,
-                size_t idx, bool optional)
-{
-    if (input_str.empty()) {
-        if (!optional) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER,
-                               strprintf("Invalid param for %s[%zu], cannot be empty", field_name, idx));
-        }
-        return; // Nothing to do
-    }
-    if (auto ret = ptx.netInfo->AddEntry(purpose, input_str); ret != NetInfoStatus::Success) {
-        throw JSONRPCError(RPC_INVALID_PARAMETER,
-                           strprintf("Error setting %s[%zu] to '%s' (%s)", field_name, idx, input_str, NISToString(ret)));
-    }
-}
-} // anonymous namespace
-
-template <typename ProTx>
-void ProcessNetInfoCore(ProTx& ptx, const UniValue& input, const bool optional)
-{
-    CHECK_NONFATAL(ptx.netInfo);
-
-    if (input.isStr()) {
-        ParseInput(ptx, /*field_name=*/"coreP2PAddrs", input.get_str(), NetInfoPurpose::CORE_P2P, /*idx=*/0, optional);
-    } else if (input.isArray()) {
-        const UniValue& entries = input.get_array();
-        if (!optional && entries.empty()) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid param for coreP2PAddrs, cannot be empty");
-        }
-        for (size_t idx{0}; idx < entries.size(); idx++) {
-            const UniValue& entry_uv{entries[idx]};
-            if (!entry_uv.isStr()) {
-                throw JSONRPCError(RPC_INVALID_PARAMETER,
-                                   strprintf("Invalid param for coreP2PAddrs[%zu], must be string", idx));
-            }
-            ParseInput(ptx, /*field_name=*/"coreP2PAddrs", entry_uv.get_str(), NetInfoPurpose::CORE_P2P, idx,
-                       /*optional=*/false);
-        }
-    } else {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid param for coreP2PAddrs, must be string or array");
-    }
-}
-template void ProcessNetInfoCore(CProRegTx& ptx, const UniValue& input, const bool optional);
-template void ProcessNetInfoCore(CProUpServTx& ptx, const UniValue& input, const bool optional);
-
-template <typename ProTx>
-void ProcessNetInfoPlatform(ProTx& ptx, const UniValue& input_p2p, const UniValue& input_http, const bool optional)
-{
-    CHECK_NONFATAL(ptx.netInfo);
-
-    auto process_field = [&](uint16_t& maybe_target, const UniValue& input, const NetInfoPurpose purpose,
-                             std::string_view field_name) {
-        if (!input.isArray() && !input.isNum() && !input.isStr()) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER,
-                               strprintf("Invalid param for %s, must be array, number or string", field_name));
-        }
-
-        bool is_empty{input.isArray() ? input.get_array().empty() : input.getValStr().empty()};
-        bool is_nonnumeric_str{input.isStr() && !IsNumeric(input.getValStr())};
-        if (is_empty || is_nonnumeric_str || input.isArray()) {
-            if (is_empty) {
-                if (!optional) {
-                    // Mandatory field, cannot specify blank value
-                    throw JSONRPCError(RPC_INVALID_PARAMETER,
-                                       strprintf("Invalid param for %s, cannot be empty", field_name));
-                }
-                if (!ptx.netInfo->IsEmpty()) {
-                    // Blank values are tolerable so long as no other field has been populated.
-                    throw JSONRPCError(RPC_INVALID_PARAMETER,
-                                       strprintf("Invalid param for %s, cannot be empty if other fields populated",
-                                                 field_name));
-                }
-            }
-            if (!ptx.netInfo->CanStorePlatform()) {
-                //      Arrays: Expected to be address strings, if relying on platform{HTTP,P2P}Port, bail out.
-                // Empty Input: We can tolerate blank values if netInfo can store platform fields, if it cannot, we are relying
-                //              on platform{HTTP,P2P}Port, where it is mandatory even if their netInfo counterpart is optional.
-                //      String: If not parsable as port and relying on platform{HTTP,P2P}Port, bail out.
-                throw JSONRPCError(
-                    RPC_INVALID_PARAMETER,
-                    strprintf("Invalid param for %s, this ProTx version only accepts a bare port number; the "
-                              "\"ADDR:PORT\" / address-array form requires upgrading to a version 3 ProTx",
-                              field_name));
-            }
-            if (input.isArray()) {
-                const UniValue& entries = input.get_array();
-                for (size_t idx{0}; idx < entries.size(); idx++) {
-                    const UniValue& entry{entries[idx]};
-                    if (!entry.isStr() || IsNumeric(entry.get_str())) {
-                        throw JSONRPCError(RPC_INVALID_PARAMETER,
-                                           strprintf("Invalid param for %s[%zu], must be string", field_name, idx));
-                    }
-                    ParseInput(ptx, field_name, entry.get_str(), purpose, idx, /*optional=*/false);
-                }
-            } else {
-                CHECK_NONFATAL(is_empty || is_nonnumeric_str);
-                ParseInput(ptx, field_name, input.get_str(), purpose, /*idx=*/0, /*optional=*/true);
-            }
-        } else {
-            if (int32_t port{0};
-                ParseInt32(input.getValStr(), &port) && port >= 1 && port <= std::numeric_limits<uint16_t>::max()) {
-                // Valid port
-                if (!ptx.netInfo->CanStorePlatform()) {
-                    maybe_target = static_cast<uint16_t>(port);
-                    return; // Parsing complete
-                }
-                // We cannot store *only* a port number in netInfo so we need to associate it with the primary service of CORE_P2P manually
-                if (!ptx.netInfo->HasEntries(NetInfoPurpose::CORE_P2P)) {
-                    throw JSONRPCError(RPC_INVALID_PARAMETER,
-                                       strprintf("Cannot set param for %s, must specify coreP2PAddrs first", field_name));
-                }
-                const CService service{CNetAddr{ptx.netInfo->GetPrimary()}, static_cast<uint16_t>(port)};
-                CHECK_NONFATAL(service.IsValid());
-                ParseInput(ptx, field_name, service.ToStringAddrPort(), purpose, /*idx=*/0, /*optional=*/false);
-            } else {
-                throw JSONRPCError(RPC_INVALID_PARAMETER,
-                                   strprintf("Invalid param for %s, must be a valid port [1-65535]", field_name));
-            }
-        }
-    };
-    process_field(ptx.platformP2PPort, input_p2p, NetInfoPurpose::PLATFORM_P2P, "platformP2PAddrs");
-    process_field(ptx.platformHTTPPort, input_http, NetInfoPurpose::PLATFORM_HTTPS, "platformHTTPSAddrs");
-}
-template void ProcessNetInfoPlatform(CProRegTx& ptx, const UniValue& input_p2p, const UniValue& input_http, const bool optional);
-template void ProcessNetInfoPlatform(CProUpServTx& ptx, const UniValue& input_p2p, const UniValue& input_http, const bool optional);
-
 
 UniValue CDeterministicMN::ToJson() const
 {
diff --git a/src/rpc/evo_util.h b/src/rpc/evo_util.h
index 6734558e43bb..0a5e08c98225 100644
--- a/src/rpc/evo_util.h
+++ b/src/rpc/evo_util.h
@@ -18,14 +18,6 @@
 
 class CSimplifiedMNListEntry;
 
-/** Process setting (legacy) Core network information field based on ProTx version */
-template <typename ProTx>
-void ProcessNetInfoCore(ProTx& ptx, const UniValue& input, const bool optional);
-
-/** Process setting (legacy) Platform network information fields based on ProTx version */
-template <typename ProTx>
-void ProcessNetInfoPlatform(ProTx& ptx, const UniValue& input_p2p, const UniValue& input_http, const bool optional);
-
 /** Reads network info reporting and appends data from legacy fields if applicable */
 template <typename Obj>
 UniValue GetNetInfoWithLegacyFields(const Obj& obj, const MnType& type)
diff --git a/src/test/evo_netinfo_tests.cpp b/src/test/evo_netinfo_tests.cpp
index b9f30eb1081a..2211720c6aaf 100644
--- a/src/test/evo_netinfo_tests.cpp
+++ b/src/test/evo_netinfo_tests.cpp
@@ -5,6 +5,8 @@
 #include <test/util/setup_common.h>
 
 #include <evo/netinfo.h>
+#include <evo/types.h>
+#include <interfaces/node.h>
 #include <util/helpers.h>
 
 #include <chainparams.h>
@@ -134,6 +136,47 @@ BOOST_AUTO_TEST_CASE(mnnetinfo_rules_main)
 
 BOOST_AUTO_TEST_CASE(extnetinfo_rules_main) { TestExtNetInfo(addr_vals_main); }
 
+BOOST_AUTO_TEST_CASE(provider_network_fields_main)
+{
+    auto node{interfaces::MakeNode(m_node)};
+    interfaces::ProviderNetInfo net_info{
+        .core_p2p = {strprintf("1.1.1.1:%d", MainParams().GetDefaultPort())},
+        .platform_p2p = MainParams().GetDefaultPlatformP2PPort(),
+        .platform_https = MainParams().GetDefaultPlatformHTTPPort(),
+    };
+    BOOST_CHECK(!node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::BasicBLS, /*optional=*/false));
+
+    net_info.platform_p2p = static_cast<uint16_t>(MainParams().GetDefaultPlatformP2PPort() + 1);
+    auto validation_error{
+        node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::BasicBLS, /*optional=*/false)};
+    BOOST_REQUIRE(validation_error);
+    BOOST_CHECK_EQUAL(validation_error->reject_reason, "bad-protx-platform-p2p-port");
+
+    net_info.platform_p2p = MainParams().GetDefaultPlatformP2PPort();
+    net_info.platform_https = static_cast<uint16_t>(MainParams().GetDefaultPlatformHTTPPort() + 1);
+    validation_error = node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::BasicBLS,
+                                                           /*optional=*/false);
+    BOOST_REQUIRE(validation_error);
+    BOOST_CHECK_EQUAL(validation_error->reject_reason, "bad-protx-platform-http-port");
+
+    net_info.platform_p2p = MainParams().GetDefaultPort();
+    net_info.platform_https = MainParams().GetDefaultPlatformHTTPPort();
+    validation_error = node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::BasicBLS,
+                                                           /*optional=*/false);
+    BOOST_REQUIRE(validation_error);
+    BOOST_CHECK_EQUAL(validation_error->reject_reason, "bad-protx-platform-p2p-port");
+
+    net_info = {
+        .core_p2p = {"127.0.0.1:9999"},
+        .platform_p2p = std::vector<std::string>{"1.1.1.2:22200"},
+        .platform_https = std::vector<std::string>{"server.example.com:443"},
+    };
+    validation_error = node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::ExtAddr,
+                                                           /*optional=*/false);
+    BOOST_REQUIRE(validation_error);
+    BOOST_CHECK(validation_error->message.original.find("unroutable address") != std::string::npos);
+}
+
 static const std::vector<TestEntry> addr_vals_reg{
     // - MnNetInfo doesn't mind using port 0
     // - ExtNetInfo requires non-zero ports
diff --git a/src/test/interfaces_tests.cpp b/src/test/interfaces_tests.cpp
index 11c10a4f6432..6dfd816b0721 100644
--- a/src/test/interfaces_tests.cpp
+++ b/src/test/interfaces_tests.cpp
@@ -4,7 +4,9 @@
 
 #include <chainparams.h>
 #include <consensus/validation.h>
+#include <evo/providertx.h>
 #include <interfaces/chain.h>
+#include <interfaces/node.h>
 #include <script/standard.h>
 #include <test/util/setup_common.h>
 #include <validation.h>
@@ -60,6 +62,107 @@ BOOST_AUTO_TEST_CASE(findBlock)
     BOOST_CHECK(!chain->findBlock({}, FoundBlock()));
 }
 
+BOOST_AUTO_TEST_CASE(providerTxCapabilities)
+{
+    auto node{interfaces::MakeNode(m_node)};
+    const auto capabilities{node->evo().getProviderTxCapabilities()};
+    const uint16_t expected_version{
+        WITH_LOCK(::cs_main, return DeploymentToProtxVersion(Assert(m_node.chainman)->ActiveChain().Tip(),
+                                                             *Assert(m_node.chainman)))};
+    BOOST_CHECK_EQUAL(capabilities.version, expected_version);
+    BOOST_CHECK_EQUAL(capabilities.extended_addresses, expected_version >= ProTxVersion::ExtAddr);
+}
+
+BOOST_AUTO_TEST_CASE(providerNetInfoValidation)
+{
+    auto node{interfaces::MakeNode(m_node)};
+    interfaces::ProviderNetInfo net_info{
+        .core_p2p = {"1.1.1.1:9998"},
+        .platform_p2p = std::vector<std::string>{"1.1.1.2:22200"},
+        .platform_https = std::vector<std::string>{"server.example.com:443"},
+    };
+
+    BOOST_CHECK(!node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::ExtAddr, /*optional=*/false));
+
+    net_info.platform_p2p = std::vector<std::string>{"server.example.com:22200"};
+    auto error{node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::ExtAddr, /*optional=*/false)};
+    BOOST_REQUIRE(error);
+    BOOST_CHECK_EQUAL(error->code, interfaces::ProviderTxErrorCode::INVALID_PARAMETER);
+    BOOST_CHECK_EQUAL(error->message.original,
+                      "Error setting platformP2PAddrs[0] to 'server.example.com:22200' (invalid input)");
+
+    net_info.platform_p2p = std::vector<std::string>{"1.1.1.1:9998"};
+    error = node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::ExtAddr, /*optional=*/false);
+    BOOST_REQUIRE(error);
+    BOOST_CHECK_EQUAL(error->message.original, "Error setting platformP2PAddrs[0] to '1.1.1.1:9998' (duplicate)");
+
+    net_info.platform_p2p = std::vector<std::string>{"1.1.1.2:22200", "1.1.1.3:22200", "1.1.1.4:22200", "1.1.1.5:22200",
+                                                     "1.1.1.6:22200"};
+    error = node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::ExtAddr, /*optional=*/false);
+    BOOST_REQUIRE(error);
+    BOOST_CHECK_EQUAL(error->message.original,
+                      "Error setting platformP2PAddrs[4] to '1.1.1.6:22200' (too many entries)");
+
+    net_info.platform_p2p = uint16_t{22200};
+    net_info.platform_https = uint16_t{22201};
+    BOOST_CHECK(!node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::BasicBLS, /*optional=*/false));
+
+    net_info.platform_p2p = std::vector<std::string>{"1.1.1.2:22200"};
+    error = node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::BasicBLS, /*optional=*/false);
+    BOOST_REQUIRE(error);
+    BOOST_CHECK(error->message.original.find("only accepts a bare port number") != std::string::npos);
+
+    net_info = {
+        .core_p2p = {},
+        .platform_p2p = std::vector<std::string>{"1.1.1.2:22200"},
+        .platform_https = std::vector<std::string>{"server.example.com:443"},
+    };
+    error = node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::ExtAddr, /*optional=*/true);
+    BOOST_REQUIRE(error);
+    BOOST_CHECK_EQUAL(error->reject_reason, "bad-protx-netinfo-empty");
+
+    net_info = {
+        .core_p2p = {"1.1.1.1:9998"},
+        .platform_p2p = std::monostate{},
+        .platform_https = std::monostate{},
+    };
+    error = node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::ExtAddr, /*optional=*/true);
+    BOOST_REQUIRE(error);
+    BOOST_CHECK(error->message.original.find("platformP2PAddrs, cannot be empty if other fields populated") !=
+                std::string::npos);
+    BOOST_CHECK(!node->evo().validateProviderNetInfo(net_info, MnType::Regular, ProTxVersion::ExtAddr, /*optional=*/true));
+
+    net_info.platform_p2p = std::vector<std::string>{"1.1.1.2:22200"};
+    error = node->evo().validateProviderNetInfo(net_info, MnType::Regular, ProTxVersion::ExtAddr, /*optional=*/true);
+    BOOST_REQUIRE(error);
+    BOOST_CHECK_EQUAL(error->message.original, "Platform endpoints are only valid for an EvoNode");
+
+    net_info = {
+        .core_p2p = {"1.1.1.1:9998"},
+        .platform_p2p = std::vector<std::string>{"1.1.1.2:22200"},
+        .platform_https = std::monostate{},
+    };
+    error = node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::ExtAddr, /*optional=*/true);
+    BOOST_REQUIRE(error);
+    BOOST_CHECK(error->message.original.find("platformHTTPSAddrs, cannot be empty if other fields populated") !=
+                std::string::npos);
+
+    net_info = {
+        .core_p2p = {"1.1.1.1:9998"},
+        .platform_p2p = uint16_t{22200},
+        .platform_https = uint16_t{22200},
+    };
+    error = node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::BasicBLS, /*optional=*/false);
+    BOOST_REQUIRE(error);
+    BOOST_CHECK_EQUAL(error->reject_reason, "bad-protx-platform-dup-ports");
+
+    net_info.platform_p2p = uint16_t{MainParams().GetDefaultPort()};
+    net_info.platform_https = uint16_t{22201};
+    error = node->evo().validateProviderNetInfo(net_info, MnType::Evo, ProTxVersion::BasicBLS, /*optional=*/false);
+    BOOST_REQUIRE(error);
+    BOOST_CHECK_EQUAL(error->reject_reason, "bad-protx-platform-p2p-port");
+}
+
 BOOST_AUTO_TEST_CASE(findFirstBlockWithTimeAndHeight)
 {
     LOCK(Assert(m_node.chainman)->GetMutex());
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index 099437d099a3..4af755044de8 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -45,6 +45,7 @@
 #include <vector>
 
 using interfaces::Chain;
+using interfaces::CoinLockResult;
 using interfaces::FoundBlock;
 using interfaces::Handler;
 using interfaces::MakeHandler;
@@ -55,6 +56,7 @@ using interfaces::WalletLoader;
 using interfaces::WalletOrderForm;
 using interfaces::WalletTx;
 using interfaces::WalletTxOut;
+using interfaces::WalletTxSignResult;
 using interfaces::WalletTxStatus;
 using interfaces::WalletValueMap;
 using node::NodeContext;
@@ -325,6 +327,20 @@ class WalletImpl : public Wallet
         std::unique_ptr<WalletBatch> batch = write_to_db ? std::make_unique<WalletBatch>(m_wallet->GetDatabase()) : nullptr;
         return m_wallet->LockCoin(output, batch.get());
     }
+    CoinLockResult acquireCoinLock(const COutPoint& output, bool write_to_db) override
+    {
+        LOCK(m_wallet->cs_wallet);
+        if (m_wallet->IsLockedCoin(output)) return CoinLockResult::ALREADY_LOCKED;
+        std::unique_ptr<WalletBatch> batch = write_to_db ? std::make_unique<WalletBatch>(m_wallet->GetDatabase()) : nullptr;
+        if (!m_wallet->LockCoin(output, batch.get())) {
+            // LockCoin inserts into memory before persisting; the coin was not
+            // locked on entry, so undo the insertion (and erase any partially
+            // persisted record) to keep FAILED meaning "no lock acquired".
+            m_wallet->UnlockCoin(output, batch.get());
+            return CoinLockResult::FAILED;
+        }
+        return CoinLockResult::ACQUIRED;
+    }
     bool unlockCoin(const COutPoint& output) override
     {
         LOCK(m_wallet->cs_wallet);
@@ -389,6 +405,78 @@ class WalletImpl : public Wallet
 
         return txr.tx;
     }
+    util::Result<CTransactionRef> fundTransaction(const CMutableTransaction& tx_template,
+                                                  const CTxDestination& fund_destination) override
+    {
+        // Callers must not hold cs_main: the wallet library cannot reference
+        // node locks, and syncing below would deadlock if it were held.
+        m_wallet->BlockUntilSyncedToCurrentChain();
+
+        LOCK(m_wallet->cs_wallet);
+        if (std::holds_alternative<CNoDestination>(fund_destination)) {
+            return util::Error{Untranslated("No source of funds specified")};
+        }
+
+        CMutableTransaction tx{tx_template};
+        static const CTxOut dummy_output{0, CScript() << OP_RETURN};
+        const bool add_dummy_output{tx.vout.empty()};
+        if (add_dummy_output) tx.vout.emplace_back(dummy_output);
+
+        std::vector<CRecipient> recipients;
+        recipients.reserve(tx.vout.size());
+        for (const auto& output : tx.vout) {
+            recipients.push_back({output.scriptPubKey, output.nValue, /*fSubtractFeeFromAmount=*/false});
+        }
+
+        CCoinControl coin_control;
+        coin_control.destChange = fund_destination;
+        coin_control.fRequireAllInputs = false;
+        for (const auto& output : AvailableCoinsListUnspent(*m_wallet).all()) {
+            CTxDestination destination;
+            if (ExtractDestination(output.txout.scriptPubKey, destination) && destination == fund_destination) {
+                coin_control.Select(output.outpoint);
+            }
+        }
+        if (!coin_control.HasSelected()) {
+            return util::Error{
+                strprintf(Untranslated("No funds at specified address %s"), EncodeDestination(fund_destination))};
+        }
+
+        auto result{CreateTransaction(*m_wallet, recipients, RANDOM_CHANGE_POSITION, coin_control,
+                                      /*sign=*/true, tx.vExtraPayload.size())};
+        if (!result) return util::Error{util::ErrorString(result)};
+
+        tx.vin = result->tx->vin;
+        tx.vout = result->tx->vout;
+        if (add_dummy_output && tx.vout.size() > 1) {
+            const auto it{std::find(tx.vout.begin(), tx.vout.end(), dummy_output)};
+            CHECK_NONFATAL(it != tx.vout.end());
+            tx.vout.erase(it);
+        }
+        return MakeTransactionRef(std::move(tx));
+    }
+    util::Result<WalletTxSignResult> signTransaction(const CMutableTransaction& tx) override
+    {
+        // Callers must not hold cs_main (see fundTransaction above).
+        std::map<COutPoint, Coin> coins;
+        for (const auto& input : tx.vin)
+            coins.try_emplace(input.prevout);
+        m_wallet->chain().findCoins(coins);
+
+        LOCK(m_wallet->cs_wallet);
+        if (m_wallet->IsLocked()) {
+            return util::Error{_("Please enter the wallet passphrase with walletpassphrase first.")};
+        }
+
+        CMutableTransaction signed_tx{tx};
+        std::map<int, bilingual_str> input_errors;
+        const bool complete{m_wallet->SignTransaction(signed_tx, coins, SIGHASH_ALL, input_errors)};
+        std::vector<bilingual_str> errors;
+        errors.reserve(input_errors.size());
+        for (auto& [index, error] : input_errors)
+            errors.push_back(std::move(error));
+        return WalletTxSignResult{MakeTransactionRef(std::move(signed_tx)), complete, std::move(errors)};
+    }
     void commitTransaction(CTransactionRef tx,
         WalletValueMap value_map,
         WalletOrderForm order_form) override
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index ba7fc6640ec6..bd4ad61a182d 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -28,6 +28,7 @@
 #include <wallet/receive.h>
 #include <wallet/spend.h>
 #include <wallet/test/util.h>
+#include <wallet/walletdb.h>
 #include <wallet/test/wallet_test_fixture.h>
 
 #include <boost/test/unit_test.hpp>
@@ -49,8 +50,95 @@ extern RPCHelpMan addmultisigaddress();
 // as the default levels for node policy.
 static_assert(DEFAULT_TRANSACTION_MINFEE >= DEFAULT_MIN_RELAY_TX_FEE, "wallet minimum fee is smaller than default relay fee");
 
+namespace {
+//! Database whose writes can be toggled to fail, to prove that a failed
+//! persistent coin-lock acquisition leaves the caller owning no lock.
+class ToggleFailBatch final : public DatabaseBatch
+{
+private:
+    bool& m_write_success;
+    bool ReadKey(CDataStream&&, CDataStream&) override { return false; }
+    bool WriteKey(CDataStream&&, CDataStream&&, bool) override { return m_write_success; }
+    bool EraseKey(CDataStream&&) override { return m_write_success; }
+    bool HasKey(CDataStream&&) override { return false; }
+    bool ErasePrefix(Span<const std::byte>) override { return m_write_success; }
+
+public:
+    explicit ToggleFailBatch(bool& write_success) : m_write_success(write_success) {}
+    void Flush() override {}
+    void Close() override {}
+    bool StartCursor() override { return true; }
+    bool ReadAtCursor(CDataStream&, CDataStream&, bool& complete) override
+    {
+        complete = true;
+        return true;
+    }
+    void CloseCursor() override {}
+    bool TxnBegin() override { return true; }
+    bool TxnCommit() override { return true; }
+    bool TxnAbort() override { return true; }
+};
+
+class ToggleFailDatabase final : public WalletDatabase
+{
+public:
+    bool write_success{true};
+
+    void Open() override {}
+    void AddRef() override {}
+    void RemoveRef() override {}
+    bool Rewrite(const char*) override { return true; }
+    bool Backup(const std::string&) const override { return true; }
+    void Flush() override {}
+    void Close() override {}
+    bool PeriodicFlush() override { return true; }
+    void IncrementUpdateCounter() override { ++nUpdateCounter; }
+    void ReloadDbEnv() override {}
+    std::string Filename() override { return "toggle-fail"; }
+    std::string Format() override { return "toggle-fail"; }
+    std::unique_ptr<DatabaseBatch> MakeBatch(bool) override { return std::make_unique<ToggleFailBatch>(write_success); }
+};
+} // namespace
+
 BOOST_FIXTURE_TEST_SUITE(wallet_tests, WalletTestingSetup)
 
+BOOST_AUTO_TEST_CASE(interface_coin_lock_ownership)
+{
+    const auto wallet_ref{std::shared_ptr<CWallet>(&m_wallet, [](CWallet*) {})};
+    auto wallet_interface{interfaces::MakeWallet(*m_wallet_loader->context(), wallet_ref)};
+    const COutPoint outpoint{uint256::ONE, 0};
+
+    BOOST_CHECK(wallet_interface->acquireCoinLock(outpoint, /*write_to_db=*/false) == interfaces::CoinLockResult::ACQUIRED);
+    BOOST_CHECK(wallet_interface->acquireCoinLock(outpoint, /*write_to_db=*/false) ==
+                interfaces::CoinLockResult::ALREADY_LOCKED);
+    BOOST_CHECK(wallet_interface->unlockCoin(outpoint));
+    BOOST_CHECK(wallet_interface->acquireCoinLock(outpoint, /*write_to_db=*/false) == interfaces::CoinLockResult::ACQUIRED);
+    BOOST_CHECK(wallet_interface->unlockCoin(outpoint));
+}
+
+BOOST_AUTO_TEST_CASE(interface_coin_lock_failed_persist)
+{
+    auto database{std::make_unique<ToggleFailDatabase>()};
+    auto* database_ptr{database.get()};
+    auto wallet{std::make_shared<CWallet>(m_node.chain.get(), m_coinjoin_loader.get(), "", m_args,
+                                          std::move(database))};
+    BOOST_REQUIRE(wallet->LoadWallet() == DBErrors::LOAD_OK);
+    auto wallet_interface{interfaces::MakeWallet(*m_wallet_loader->context(), wallet)};
+    const COutPoint outpoint{uint256::ONE, 0};
+
+    // FAILED must mean no lock was acquired: the in-memory insertion is rolled
+    // back when the persistent write fails.
+    database_ptr->write_success = false;
+    BOOST_CHECK(wallet_interface->acquireCoinLock(outpoint, /*write_to_db=*/true) ==
+                interfaces::CoinLockResult::FAILED);
+    BOOST_CHECK(!wallet_interface->isLockedCoin(outpoint));
+
+    database_ptr->write_success = true;
+    BOOST_CHECK(wallet_interface->acquireCoinLock(outpoint, /*write_to_db=*/true) ==
+                interfaces::CoinLockResult::ACQUIRED);
+    BOOST_CHECK(wallet_interface->isLockedCoin(outpoint));
+}
+
 static std::shared_ptr<CWallet> TestLoadWallet(WalletContext& context)
 {
     DatabaseOptions options;
diff --git a/test/functional/wallet_dash_rpcs.py b/test/functional/wallet_dash_rpcs.py
index ecf72572985a..0b37c3e731d2 100755
--- a/test/functional/wallet_dash_rpcs.py
+++ b/test/functional/wallet_dash_rpcs.py
@@ -27,7 +27,7 @@
     DashTestFramework,
     MasternodeInfo,
 )
-from test_framework.util import assert_equal, p2p_port, softfork_active
+from test_framework.util import assert_equal, assert_raises_rpc_error, p2p_port, softfork_active
 
 
 class WalletDashRPCsTest(DashTestFramework):
@@ -58,6 +58,7 @@ def run_test(self):
 
         self.test_gobject_wallet_paths()
         funded_mn = self.test_protx_register_fund()
+        self.test_protx_collateral_lock_errors()
         self.test_protx_register_own_collateral()
         self.test_protx_register_external()
         self.test_protx_update_service(funded_mn)
@@ -130,14 +131,49 @@ def test_protx_register_own_collateral(self):
         mn.set_params(collateral_txid=collateral_txid, collateral_vout=collateral_vout)
         # Unlike register_prepare, this proves ownership of the collateral by signing the
         # payload with the wallet itself (CWallet::SignMessage -> SPKM dispatch)
-        protx_hash = mn.register(node, submit=True)
-        assert protx_hash is not None
+        raw_tx = mn.register(node, submit=False)
+        assert raw_tx is not None
+        collateral_outpoint = {"txid": collateral_txid, "vout": collateral_vout}
+        assert collateral_outpoint in node.listlockunspent()
+        protx_hash = node.sendrawtransaction(raw_tx)
         mn.set_params(proTxHash=protx_hash)
         self.confirm_tx(protx_hash)
         assert protx_hash in node.protx("list", "registered")
         assert_equal(node.protx("info", protx_hash)["collateralHash"], collateral_txid)
         assert "%s-%d" % (collateral_txid, collateral_vout) in node.masternode("list")
 
+    def test_protx_collateral_lock_errors(self):
+        node = self.nodes[0]
+        self.log.info("Test protx collateral lock ownership on errors")
+        mn = self.prepare_unstarted_mn(len(self.nodes) + 4)
+        collateral_txid = node.sendtoaddress(mn.collateral_address, mn.get_collateral_value())
+        self.bump_mocktime(1)
+        self.generate(node, 1)
+        collateral_vout = mn.get_collateral_vout(node, collateral_txid)
+        mn.set_params(collateral_txid=collateral_txid, collateral_vout=collateral_vout)
+        collateral_outpoint = {"txid": collateral_txid, "vout": collateral_vout}
+        unfunded_address = node.getnewaddress()
+
+        # A failing call releases only a lock that it acquired itself.
+        mn.register(node, submit=False, fundsAddr=unfunded_address,
+                    expected_assert_code=-32603, expected_assert_msg="No funds at specified address")
+        assert collateral_outpoint not in node.listlockunspent()
+
+        command = "register_prepare_legacy" if mn.legacy else "register_prepare"
+        prepare_args = [collateral_txid, collateral_vout, f'127.0.0.1:{mn.nodePort}',
+                        mn.ownerAddr, mn.pubKeyOperator, mn.votingAddr, 0,
+                        mn.rewards_address, unfunded_address]
+        assert_raises_rpc_error(-32603, "No funds at specified address", node.protx, command, *prepare_args)
+        assert collateral_outpoint not in node.listlockunspent()
+
+        node.lockunspent(False, [collateral_outpoint])
+        mn.register(node, submit=False, fundsAddr=unfunded_address,
+                    expected_assert_code=-32603, expected_assert_msg="No funds at specified address")
+        assert collateral_outpoint in node.listlockunspent()
+        assert_raises_rpc_error(-32603, "No funds at specified address", node.protx, command, *prepare_args)
+        assert collateral_outpoint in node.listlockunspent()
+        node.lockunspent(True, [collateral_outpoint])
+
     def test_protx_register_external(self):
         node = self.nodes[0]
         self.log.info("Test protx register_prepare + signmessage + register_submit (external collateral)")
@@ -153,8 +189,19 @@ def test_protx_register_external(self):
         prepared = node.protx(command, collateral_txid, collateral_vout, f'127.0.0.1:{mn.nodePort}',
                               mn.ownerAddr, mn.pubKeyOperator, mn.votingAddr, 0, mn.rewards_address, mn.fundsAddr)
         assert_equal(prepared["collateralAddress"], mn.collateral_address)
+        collateral_outpoint = {"txid": collateral_txid, "vout": collateral_vout}
+        assert collateral_outpoint in node.listlockunspent()
         signature = node.signmessage(prepared["collateralAddress"], prepared["signMessage"])
+
+        assert_raises_rpc_error(-1, "bad-protx-sig", node.protx, "register_submit", prepared["tx"], "AA==")
+        assert collateral_outpoint in node.listlockunspent()
+        node.createwallet("empty_signing_wallet")
+        empty_wallet = node.get_wallet_rpc("empty_signing_wallet")
+        assert_raises_rpc_error(-4, "transaction inputs could not be fully signed", empty_wallet.protx,
+                                "register_submit", prepared["tx"], signature)
+        node.unloadwallet("empty_signing_wallet")
         protx_hash = node.protx("register_submit", prepared["tx"], signature)
+        assert collateral_outpoint in node.listlockunspent()
         mn.set_params(proTxHash=protx_hash)
         self.confirm_tx(protx_hash)
         assert protx_hash in node.protx("list", "registered")
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index f7482bfb0da7..c3723d63036e 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -25,6 +25,7 @@ src/index/spent*.cpp
 src/index/spent*.h
 src/index/timestamp*.cpp
 src/index/timestamp*.h
+src/interfaces/providertx.h
 src/instantsend/*.cpp
 src/instantsend/*.h
 src/llmq/*.cpp