diff --git a/src/Makefile.am b/src/Makefile.am
index 74db920908d0..daa4a2568587 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -365,6 +365,7 @@ BITCOIN_CORE_H = \
   util/moneystr.h \
   util/overflow.h \
   util/overloaded.h \
+  util/pointer.h \
   util/ranges.h \
   util/readwritefile.h \
   util/underlying.h \
diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 025823f9b9bd..d5f5185e4b28 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -193,7 +193,7 @@ void CCoinJoinClientSession::ProcessMessage(CNode& peer, CChainState& active_cha
     if (!m_mn_sync.IsBlockchainSynced()) return;
 
     if (!mixingMasternode) return;
-    if (mixingMasternode->pdmnState->netInfo.GetPrimary() != peer.addr) return;
+    if (mixingMasternode->pdmnState->netInfo->GetPrimary() != peer.addr) return;
 
     if (msg_type == NetMsgType::DSSTATUSUPDATE) {
         CCoinJoinStatusUpdate psssup;
@@ -1113,7 +1113,7 @@ bool CCoinJoinClientSession::JoinExistingQueue(CAmount nBalanceNeedsAnonymized,
 
         m_clientman.AddUsedMasternode(dsq.masternodeOutpoint);
 
-        if (connman.IsMasternodeOrDisconnectRequested(dmn->pdmnState->netInfo.GetPrimary())) {
+        if (connman.IsMasternodeOrDisconnectRequested(dmn->pdmnState->netInfo->GetPrimary())) {
             WalletCJLogPrint(m_wallet, /* Continued */
                              "CCoinJoinClientSession::JoinExistingQueue -- skipping connection, masternode=%s\n", dmn->proTxHash.ToString());
             continue;
@@ -1185,7 +1185,7 @@ bool CCoinJoinClientSession::StartNewQueue(CAmount nBalanceNeedsAnonymized, CCon
             continue;
         }
 
-        if (connman.IsMasternodeOrDisconnectRequested(dmn->pdmnState->netInfo.GetPrimary())) {
+        if (connman.IsMasternodeOrDisconnectRequested(dmn->pdmnState->netInfo->GetPrimary())) {
             WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::StartNewQueue -- skipping connection, masternode=%s\n",
                              dmn->proTxHash.ToString());
             nTries++;
@@ -1225,7 +1225,7 @@ bool CCoinJoinClientSession::ProcessPendingDsaRequest(CConnman& connman)
 
     CService mn_addr;
     if (auto dmn = m_dmnman.GetListAtChainTip().GetMN(pendingDsaRequest.GetProTxHash())) {
-        mn_addr = Assert(dmn->pdmnState)->netInfo.GetPrimary();
+        mn_addr = Assert(dmn->pdmnState)->netInfo->GetPrimary();
     } else {
         WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::%s -- cannot find address to connect, masternode=%s\n", __func__,
             pendingDsaRequest.GetProTxHash().ToString());
@@ -1827,7 +1827,7 @@ void CCoinJoinClientSession::RelayIn(const CCoinJoinEntry& entry, CConnman& conn
 {
     if (!mixingMasternode) return;
 
-    connman.ForNode(mixingMasternode->pdmnState->netInfo.GetPrimary(), [&entry, &connman, this](CNode* pnode) {
+    connman.ForNode(mixingMasternode->pdmnState->netInfo->GetPrimary(), [&entry, &connman, this](CNode* pnode) {
         WalletCJLogPrint(m_wallet, "CCoinJoinClientSession::RelayIn -- found master, relaying message to %s\n",
                          pnode->addr.ToStringAddrPort());
         CNetMsgMaker msgMaker(pnode->GetCommonVersion());
@@ -1883,7 +1883,7 @@ void CCoinJoinClientSession::GetJsonInfo(UniValue& obj) const
         assert(mixingMasternode->pdmnState);
         obj.pushKV("protxhash", mixingMasternode->proTxHash.ToString());
         obj.pushKV("outpoint", mixingMasternode->collateralOutpoint.ToStringShort());
-        obj.pushKV("service", mixingMasternode->pdmnState->netInfo.GetPrimary().ToStringAddrPort());
+        obj.pushKV("service", mixingMasternode->pdmnState->netInfo->GetPrimary().ToStringAddrPort());
     }
     obj.pushKV("denomination", ValueFromAmount(CoinJoin::DenominationToAmount(nSessionDenom)));
     obj.pushKV("state", GetStateString());
diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index 55af0bf50352..91ffc5c2270f 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -67,7 +67,7 @@
     ret.pushKV("type", ToUnderlying(nType));
     ret.pushKV("collateralHash", collateralOutpoint.hash.ToString());
     ret.pushKV("collateralIndex", (int)collateralOutpoint.n);
-    ret.pushKV("service", netInfo.GetPrimary().ToStringAddrPort());
+    ret.pushKV("service", netInfo->GetPrimary().ToStringAddrPort());
     ret.pushKV("ownerAddress", EncodeDestination(PKHash(keyIDOwner)));
     ret.pushKV("votingAddress", EncodeDestination(PKHash(keyIDVoting)));
     if (CTxDestination dest; ExtractDestination(scriptPayout, dest)) {
@@ -114,7 +114,7 @@
     ret.pushKV("version", nVersion);
     ret.pushKV("type", ToUnderlying(nType));
     ret.pushKV("proTxHash", proTxHash.ToString());
-    ret.pushKV("service", netInfo.GetPrimary().ToStringAddrPort());
+    ret.pushKV("service", netInfo->GetPrimary().ToStringAddrPort());
     if (CTxDestination dest; ExtractDestination(scriptOperatorPayout, dest)) {
         ret.pushKV("operatorPayoutAddress", EncodeDestination(dest));
     }
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index e38e699f5270..7eecfd6fbbb2 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -22,6 +22,7 @@
 #include <stats/client.h>
 #include <uint256.h>
 #include <univalue.h>
+#include <util/pointer.h>
 #include <validationinterface.h>
 
 #include <optional>
@@ -409,7 +410,7 @@ void CDeterministicMNList::AddMN(const CDeterministicMNCPtr& dmn, bool fBumpTota
         throw(std::runtime_error(strprintf("%s: Can't add a masternode %s with a duplicate collateralOutpoint=%s", __func__,
                 dmn->proTxHash.ToString(), dmn->collateralOutpoint.ToStringShort())));
     }
-    for (const NetInfoEntry& entry : dmn->pdmnState->netInfo.GetEntries()) {
+    for (const NetInfoEntry& entry : dmn->pdmnState->netInfo->GetEntries()) {
         if (const auto& service_opt{entry.GetAddrPort()}; service_opt.has_value()) {
             const CService& service{service_opt.value()};
             if (!AddUniqueProperty(*dmn, service)) {
@@ -459,13 +460,13 @@ void CDeterministicMNList::UpdateMN(const CDeterministicMN& oldDmn, const std::s
     // Using this temporary map as a checkpoint to roll back to in case of any issues.
     decltype(mnUniquePropertyMap) mnUniquePropertyMapSaved = mnUniquePropertyMap;
 
-    auto updateNetInfo = [this](const CDeterministicMN& dmn, const MnNetInfo& oldInfo,
-                                const MnNetInfo& newInfo) -> std::string {
-        if (oldInfo != newInfo) {
+    auto updateNetInfo = [this](const CDeterministicMN& dmn, const std::shared_ptr<NetInfoInterface>& oldInfo,
+                                const std::shared_ptr<NetInfoInterface>& newInfo) -> std::string {
+        if (util::shared_ptr_not_equal(oldInfo, newInfo)) {
             // We track each individual entry in netInfo as opposed to netInfo itself (preventing us from
             // using UpdateUniqueProperty()), so we need to successfully purge all old entries and insert
             // new entries to successfully update.
-            for (const NetInfoEntry& old_entry : oldInfo.GetEntries()) {
+            for (const NetInfoEntry& old_entry : oldInfo->GetEntries()) {
                 if (const auto& service_opt{old_entry.GetAddrPort()}) {
                     const CService& service{service_opt.value()};
                     if (!DeleteUniqueProperty(dmn, service)) {
@@ -475,7 +476,7 @@ void CDeterministicMNList::UpdateMN(const CDeterministicMN& oldDmn, const std::s
                     return "invalid address";
                 }
             }
-            for (const NetInfoEntry& new_entry : newInfo.GetEntries()) {
+            for (const NetInfoEntry& new_entry : newInfo->GetEntries()) {
                 if (const auto& service_opt{new_entry.GetAddrPort()}) {
                     const CService& service{service_opt.value()};
                     if (!AddUniqueProperty(dmn, service)) {
@@ -489,6 +490,7 @@ void CDeterministicMNList::UpdateMN(const CDeterministicMN& oldDmn, const std::s
         return "";
     };
 
+    assert(oldState->netInfo && pdmnState->netInfo);
     if (auto err = updateNetInfo(*dmn, oldState->netInfo, pdmnState->netInfo); !err.empty()) {
         mnUniquePropertyMap = mnUniquePropertyMapSaved;
         throw(std::runtime_error(strprintf("%s: Can't update masternode %s with addresses, reason=%s", __func__,
@@ -549,7 +551,7 @@ void CDeterministicMNList::RemoveMN(const uint256& proTxHash)
         throw(std::runtime_error(strprintf("%s: Can't delete a masternode %s with a collateralOutpoint=%s", __func__,
                 proTxHash.ToString(), dmn->collateralOutpoint.ToStringShort())));
     }
-    for (const NetInfoEntry& entry : dmn->pdmnState->netInfo.GetEntries()) {
+    for (const NetInfoEntry& entry : dmn->pdmnState->netInfo->GetEntries()) {
         if (const auto& service_opt{entry.GetAddrPort()}; service_opt.has_value()) {
             const CService& service{service_opt.value()};
             if (!DeleteUniqueProperty(*dmn, service)) {
@@ -730,6 +732,7 @@ bool CDeterministicMNManager::BuildNewListFromBlock(const CBlock& block, gsl::no
     newList.DecreaseScores();
 
     const bool isMNRewardReallocation{DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_MN_RR)};
+    const bool is_v23_deployed{DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_V23)};
 
     // we skip the coinbase
     for (int i = 1; i < (int)block.vtx.size(); i++) {
@@ -777,7 +780,7 @@ bool CDeterministicMNManager::BuildNewListFromBlock(const CBlock& block, gsl::no
                 }
             }
 
-            for (const NetInfoEntry& entry : proTx.netInfo.GetEntries()) {
+            for (const NetInfoEntry& entry : proTx.netInfo->GetEntries()) {
                 if (const auto& service_opt{entry.GetAddrPort()}; service_opt.has_value()) {
                     const CService& service{service_opt.value()};
                     if (newList.HasUniqueProperty(service)) {
@@ -795,7 +798,7 @@ bool CDeterministicMNManager::BuildNewListFromBlock(const CBlock& block, gsl::no
 
             auto dmnState = std::make_shared<CDeterministicMNState>(proTx);
             dmnState->nRegisteredHeight = nHeight;
-            if (proTx.netInfo.IsEmpty()) {
+            if (proTx.netInfo->IsEmpty()) {
                 // start in banned pdmnState as we need to wait for a ProUpServTx
                 dmnState->BanIfNotBanned(nHeight);
             }
@@ -813,7 +816,7 @@ bool CDeterministicMNManager::BuildNewListFromBlock(const CBlock& block, gsl::no
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-payload");
             }
 
-            for (const NetInfoEntry& entry : opt_proTx->netInfo.GetEntries()) {
+            for (const NetInfoEntry& entry : opt_proTx->netInfo->GetEntries()) {
                 if (const auto& service_opt{entry.GetAddrPort()}; service_opt.has_value()) {
                     const CService& service{service_opt.value()};
                     if (newList.HasUniqueProperty(service) &&
@@ -837,6 +840,10 @@ bool CDeterministicMNManager::BuildNewListFromBlock(const CBlock& block, gsl::no
             }
 
             auto newState = std::make_shared<CDeterministicMNState>(*dmn->pdmnState);
+            if (is_v23_deployed) {
+                // Extended addresses support in v23 means that the version can be updated
+                newState->nVersion = opt_proTx->nVersion;
+            }
             newState->netInfo = opt_proTx->netInfo;
             newState->scriptOperatorPayout = opt_proTx->scriptOperatorPayout;
             if (opt_proTx->nType == MnType::Evo) {
@@ -877,7 +884,9 @@ bool CDeterministicMNManager::BuildNewListFromBlock(const CBlock& block, gsl::no
                 newState->ResetOperatorFields();
                 newState->BanIfNotBanned(nHeight);
                 // we update pubKeyOperator here, make sure state version matches
-                newState->nVersion = opt_proTx->nVersion;
+                // Make sure we don't accidentally downgrade the state version if using version after basic BLS
+                newState->nVersion = newState->nVersion > ProTxVersion::BasicBLS ? newState->nVersion : opt_proTx->nVersion;
+                newState->netInfo = NetInfoInterface::MakeNetInfo(newState->nVersion);
                 newState->pubKeyOperator = opt_proTx->pubKeyOperator;
             }
             newState->keyIDVoting = opt_proTx->keyIDVoting;
@@ -1175,7 +1184,7 @@ void CDeterministicMNManager::CleanupCache(int nHeight)
 template <typename ProTx>
 static bool CheckService(const ProTx& proTx, TxValidationState& state)
 {
-    switch (proTx.netInfo.Validate()) {
+    switch (proTx.netInfo->Validate()) {
     case NetInfoStatus::BadAddress:
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr");
     case NetInfoStatus::BadPort:
@@ -1228,8 +1237,8 @@ static bool CheckPlatformFields(const ProTx& proTx, TxValidationState& state)
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
     }
 
-    if (proTx.platformP2PPort == proTx.platformHTTPPort || proTx.platformP2PPort == proTx.netInfo.GetPrimary().GetPort() ||
-        proTx.platformHTTPPort == proTx.netInfo.GetPrimary().GetPort()) {
+    if (proTx.platformP2PPort == proTx.platformHTTPPort || proTx.platformP2PPort == proTx.netInfo->GetPrimary().GetPort() ||
+        proTx.platformHTTPPort == proTx.netInfo->GetPrimary().GetPort()) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-dup-ports");
     }
 
@@ -1276,8 +1285,7 @@ static std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not
         state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-payload");
         return std::nullopt;
     }
-    const bool is_basic_scheme_active{DeploymentActiveAfter(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
-    if (!opt_ptx->IsTriviallyValid(is_basic_scheme_active, state)) {
+    if (!opt_ptx->IsTriviallyValid(pindexPrev, state)) {
         // pass the state returned by the function above
         return std::nullopt;
     }
@@ -1294,7 +1302,7 @@ bool CheckProRegTx(CDeterministicMNManager& dmnman, const CTransaction& tx, gsl:
 
     // 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)) {
+    if (!opt_ptx->netInfo->IsEmpty() && !CheckService(*opt_ptx, state)) {
         // pass the state returned by the function above
         return false;
     }
@@ -1354,7 +1362,7 @@ bool CheckProRegTx(CDeterministicMNManager& dmnman, const CTransaction& tx, gsl:
         auto mnList = dmnman.GetListForBlock(pindexPrev);
 
         // only allow reusing of addresses when it's for the same collateral (which replaces the old MN)
-        for (const NetInfoEntry& entry : opt_ptx->netInfo.GetEntries()) {
+        for (const NetInfoEntry& entry : opt_ptx->netInfo->GetEntries()) {
             if (const auto& service_opt{entry.GetAddrPort()}; service_opt.has_value()) {
                 const CService& service{service_opt.value()};
                 if (mnList.HasUniqueProperty(service) &&
@@ -1432,7 +1440,7 @@ bool CheckProUpServTx(CDeterministicMNManager& dmnman, const CTransaction& tx, g
     }
 
     // don't allow updating to addresses already used by other MNs
-    for (const NetInfoEntry& entry : opt_ptx->netInfo.GetEntries()) {
+    for (const NetInfoEntry& entry : opt_ptx->netInfo->GetEntries()) {
         if (const auto& service_opt{entry.GetAddrPort()}; service_opt.has_value()) {
             const CService& service{service_opt.value()};
             if (mnList.HasUniqueProperty(service) && mnList.GetUniquePropertyMN(service)->proTxHash != opt_ptx->proTxHash) {
diff --git a/src/evo/deterministicmns.h b/src/evo/deterministicmns.h
index 5b0c246a0242..3b0eee1bfbba 100644
--- a/src/evo/deterministicmns.h
+++ b/src/evo/deterministicmns.h
@@ -62,47 +62,26 @@ class CDeterministicMN
         // only non-initial values
         assert(_internalId != std::numeric_limits<uint64_t>::max());
     }
-
     template <typename Stream>
-    CDeterministicMN(deserialize_type, Stream& s, const uint8_t format_version)
-    {
-        SerializationOp(s, CSerActionUnserialize(), format_version);
-    }
+    CDeterministicMN(deserialize_type, Stream& s) { s >> *this; }
 
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action, const uint8_t format_version)
+    SERIALIZE_METHODS(CDeterministicMN, obj)
     {
-        // We no longer support EvoDB formats below MN_VERSION_FORMAT
-        if (format_version < MN_VERSION_FORMAT) {
-            throw std::ios_base::failure("EvoDb too old, run Dash Core with -reindex to rebuild");
-        }
-        READWRITE(proTxHash);
-        READWRITE(VARINT(internalId));
-        READWRITE(collateralOutpoint);
-        READWRITE(nOperatorReward);
-        READWRITE(pdmnState);
+        READWRITE(obj.proTxHash);
+        READWRITE(VARINT(obj.internalId));
+        READWRITE(obj.collateralOutpoint);
+        READWRITE(obj.nOperatorReward);
+        READWRITE(obj.pdmnState);
         // We can't know if we are serialising for the Disk or for the Network here (s.GetType() is not accessible)
         // Therefore if s.GetVersion() == CLIENT_VERSION -> Then we know we are serialising for the Disk
         // Otherwise, we can safely check with protocol versioning logic so we won't break old clients
         if (s.GetVersion() == CLIENT_VERSION || s.GetVersion() >= DMN_TYPE_PROTO_VERSION) {
-            READWRITE(nType);
+            READWRITE(obj.nType);
         } else {
-            nType = MnType::Regular;
+            SER_READ(obj, obj.nType = MnType::Regular);
         }
     }
 
-    template<typename Stream>
-    void Serialize(Stream& s) const
-    {
-        const_cast<CDeterministicMN*>(this)->SerializationOp(s, CSerActionSerialize(), MN_CURRENT_FORMAT);
-    }
-
-    template <typename Stream>
-    void Unserialize(Stream& s, const uint8_t format_version = MN_CURRENT_FORMAT)
-    {
-        SerializationOp(s, CSerActionUnserialize(), format_version);
-    }
-
     [[nodiscard]] uint64_t GetInternalId() const;
 
     [[nodiscard]] std::string ToString() const;
@@ -193,27 +172,36 @@ class CDeterministicMNList
     void Serialize(Stream& s) const
     {
         const_cast<CDeterministicMNList*>(this)->SerializationOpBase(s, CSerActionSerialize());
+
         // Serialize the map as a vector
         WriteCompactSize(s, mnMap.size());
-        for (const auto& p : mnMap) {
-            s << *p.second;
+        for (const auto& [_, dmn] : mnMap) {
+            s << *dmn;
         }
     }
 
-    template<typename Stream>
-    void Unserialize(Stream& s, const uint8_t format_version = CDeterministicMN::MN_CURRENT_FORMAT) {
-        mnMap = MnMap();
-        mnUniquePropertyMap = MnUniquePropertyMap();
-        mnInternalIdMap = MnInternalIdMap();
+    template <typename Stream>
+    void Unserialize(Stream& s)
+    {
+        Clear();
 
         SerializationOpBase(s, CSerActionUnserialize());
 
-        size_t cnt = ReadCompactSize(s);
-        for (size_t i = 0; i < cnt; i++) {
-            AddMN(std::make_shared<CDeterministicMN>(deserialize, s, format_version), false);
+        for (size_t to_read = ReadCompactSize(s); to_read > 0; --to_read) {
+            AddMN(std::make_shared<CDeterministicMN>(deserialize, s), /*fBumpTotalCount=*/false);
         }
     }
 
+    void Clear()
+    {
+        blockHash = uint256{};
+        nHeight = -1;
+        nTotalRegisteredCount = 0;
+        mnMap = MnMap();
+        mnUniquePropertyMap = MnUniquePropertyMap();
+        mnInternalIdMap = MnInternalIdMap();
+    }
+
     [[nodiscard]] size_t GetAllMNsCount() const
     {
         return mnMap.size();
@@ -397,6 +385,8 @@ class CDeterministicMNList
         DMNL_NO_TEMPLATE(CBLSPublicKey);
         DMNL_NO_TEMPLATE(MnNetInfo);
         DMNL_NO_TEMPLATE(NetInfoEntry);
+        DMNL_NO_TEMPLATE(NetInfoInterface);
+        DMNL_NO_TEMPLATE(std::shared_ptr<NetInfoInterface>);
 #undef DMNL_NO_TEMPLATE
         return ::SerializeHash(v);
     }
@@ -483,46 +473,39 @@ class CDeterministicMNListDiff
     void Serialize(Stream& s) const
     {
         s << addedMNs;
+
         WriteCompactSize(s, updatedMNs.size());
-        for (const auto& p : updatedMNs) {
-            WriteVarInt<Stream, VarIntMode::DEFAULT, uint64_t>(s, p.first);
-            s << p.second;
+        for (const auto& [internalId, pdmnState] : updatedMNs) {
+            WriteVarInt<Stream, VarIntMode::DEFAULT, uint64_t>(s, internalId);
+            s << pdmnState;
         }
+
         WriteCompactSize(s, removedMns.size());
-        for (const auto& p : removedMns) {
-            WriteVarInt<Stream, VarIntMode::DEFAULT, uint64_t>(s, p);
+        for (const auto& internalId : removedMns) {
+            WriteVarInt<Stream, VarIntMode::DEFAULT, uint64_t>(s, internalId);
         }
     }
 
     template <typename Stream>
-    void Unserialize(Stream& s, const uint8_t format_version = CDeterministicMN::MN_CURRENT_FORMAT)
+    void Unserialize(Stream& s)
     {
         updatedMNs.clear();
         removedMns.clear();
 
-        size_t tmp;
-        uint64_t tmp2;
-        tmp = ReadCompactSize(s);
-        for (size_t i = 0; i < tmp; i++) {
-            CDeterministicMN mn(0);
-            mn.Unserialize(s, format_version);
-            auto dmn = std::make_shared<CDeterministicMN>(mn);
-            addedMNs.push_back(dmn);
+        for (size_t to_read = ReadCompactSize(s); to_read > 0; --to_read) {
+            addedMNs.push_back(std::make_shared<CDeterministicMN>(deserialize, s));
         }
-        tmp = ReadCompactSize(s);
-        for (size_t i = 0; i < tmp; i++) {
-            CDeterministicMNStateDiff diff;
-            // CDeterministicMNState hold new fields {nConsecutivePayments, platformNodeID, platformP2PPort, platformHTTPPort} but no migration is needed here since:
-            // CDeterministicMNStateDiff is always serialised using a bitmask.
-            // Because the new field have a new bit guide value then we are good to continue
-            tmp2 = ReadVarInt<Stream, VarIntMode::DEFAULT, uint64_t>(s);
-            s >> diff;
-            updatedMNs.emplace(tmp2, std::move(diff));
+
+        for (size_t to_read = ReadCompactSize(s); to_read > 0; --to_read) {
+            uint64_t internalId = ReadVarInt<Stream, VarIntMode::DEFAULT, uint64_t>(s);
+            // CDeterministicMNState can have newer fields but doesn't need migration logic here as CDeterministicMNStateDiff
+            // is always serialised using a bitmask and new fields have a new bit guide value, so we are good to continue.
+            updatedMNs.emplace(internalId, CDeterministicMNStateDiff(deserialize, s));
         }
-        tmp = ReadCompactSize(s);
-        for (size_t i = 0; i < tmp; i++) {
-            tmp2 = ReadVarInt<Stream, VarIntMode::DEFAULT, uint64_t>(s);
-            removedMns.emplace(tmp2);
+
+        for (size_t to_read = ReadCompactSize(s); to_read > 0; --to_read) {
+            uint64_t internalId = ReadVarInt<Stream, VarIntMode::DEFAULT, uint64_t>(s);
+            removedMns.emplace(internalId);
         }
     }
 
diff --git a/src/evo/dmnstate.cpp b/src/evo/dmnstate.cpp
index df09e2d4611c..dd95a8b5ee4d 100644
--- a/src/evo/dmnstate.cpp
+++ b/src/evo/dmnstate.cpp
@@ -32,14 +32,14 @@ std::string CDeterministicMNState::ToString() const
                      "  %s",
                      nVersion, nRegisteredHeight, nLastPaidHeight, nPoSePenalty, nPoSeRevivedHeight, nPoSeBanHeight,
                      nRevocationReason, EncodeDestination(PKHash(keyIDOwner)), pubKeyOperator.ToString(),
-                     EncodeDestination(PKHash(keyIDVoting)), payoutAddress, operatorPayoutAddress, netInfo.ToString());
+                     EncodeDestination(PKHash(keyIDVoting)), payoutAddress, operatorPayoutAddress, netInfo->ToString());
 }
 
 UniValue CDeterministicMNState::ToJson(MnType nType) const
 {
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("version", nVersion);
-    obj.pushKV("service", netInfo.GetPrimary().ToStringAddrPort());
+    obj.pushKV("service", netInfo->GetPrimary().ToStringAddrPort());
     obj.pushKV("registeredHeight", nRegisteredHeight);
     obj.pushKV("lastPaidHeight", nLastPaidHeight);
     obj.pushKV("consecutivePayments", nConsecutivePayments);
@@ -73,7 +73,7 @@ UniValue CDeterministicMNStateDiff::ToJson(MnType nType) const
         obj.pushKV("version", state.nVersion);
     }
     if (fields & Field_netInfo) {
-        obj.pushKV("service", state.netInfo.GetPrimary().ToStringAddrPort());
+        obj.pushKV("service", state.netInfo->GetPrimary().ToStringAddrPort());
     }
     if (fields & Field_nRegisteredHeight) {
         obj.pushKV("registeredHeight", state.nRegisteredHeight);
diff --git a/src/evo/dmnstate.h b/src/evo/dmnstate.h
index 49a3b4745d55..9d2f45f3eb9d 100644
--- a/src/evo/dmnstate.h
+++ b/src/evo/dmnstate.h
@@ -11,6 +11,7 @@
 #include <netaddress.h>
 #include <pubkey.h>
 #include <script/script.h>
+#include <util/pointer.h>
 
 #include <memory>
 #include <utility>
@@ -54,7 +55,7 @@ class CDeterministicMNState
     CKeyID keyIDOwner;
     CBLSLazyPublicKey pubKeyOperator;
     CKeyID keyIDVoting;
-    MnNetInfo netInfo;
+    std::shared_ptr<NetInfoInterface> netInfo{nullptr};
     CScript scriptPayout;
     CScript scriptOperatorPayout;
 
@@ -76,12 +77,8 @@ class CDeterministicMNState
         platformHTTPPort(proTx.platformHTTPPort)
     {
     }
-
     template <typename Stream>
-    CDeterministicMNState(deserialize_type, Stream& s)
-    {
-        s >> *this;
-    }
+    CDeterministicMNState(deserialize_type, Stream& s) { s >> *this; }
 
     SERIALIZE_METHODS(CDeterministicMNState, obj)
     {
@@ -100,7 +97,8 @@ class CDeterministicMNState
         READWRITE(CBLSLazyPublicKeyVersionWrapper(const_cast<CBLSLazyPublicKey&>(obj.pubKeyOperator), obj.nVersion == ProTxVersion::LegacyBLS));
         READWRITE(
             obj.keyIDVoting,
-            obj.netInfo,
+            NetInfoSerWrapper(const_cast<std::shared_ptr<NetInfoInterface>&>(obj.netInfo),
+                              obj.nVersion >= ProTxVersion::ExtAddr),
             obj.scriptPayout,
             obj.scriptOperatorPayout,
             obj.platformNodeID,
@@ -112,7 +110,7 @@ class CDeterministicMNState
     {
         nVersion = ProTxVersion::LegacyBLS;
         pubKeyOperator = CBLSLazyPublicKey();
-        netInfo.Clear();
+        netInfo = NetInfoInterface::MakeNetInfo(nVersion);
         scriptOperatorPayout = CScript();
         nRevocationReason = CProUpRevTx::REASON_NOT_SPECIFIED;
         platformNodeID = uint160();
@@ -219,9 +217,17 @@ class CDeterministicMNStateDiff
     CDeterministicMNStateDiff(const CDeterministicMNState& a, const CDeterministicMNState& b)
     {
         boost::hana::for_each(members, [&](auto&& member) {
-            if (member.get(a) != member.get(b)) {
-                member.get(state) = member.get(b);
-                fields |= member.mask;
+            using BaseType = std::decay_t<decltype(member)>;
+            if constexpr (BaseType::mask == Field_netInfo) {
+                if (util::shared_ptr_not_equal(member.get(a), member.get(b))) {
+                    member.get(state) = member.get(b);
+                    fields |= member.mask;
+                }
+            } else {
+                if (member.get(a) != member.get(b)) {
+                    member.get(state) = member.get(b);
+                    fields |= member.mask;
+                }
             }
         });
         if (fields & Field_pubKeyOperator) {
@@ -230,6 +236,8 @@ class CDeterministicMNStateDiff
             fields |= Field_nVersion;
         }
     }
+    template <typename Stream>
+    CDeterministicMNStateDiff(deserialize_type, Stream& s) { s >> *this; }
 
     [[nodiscard]] UniValue ToJson(MnType nType) const;
 
@@ -246,6 +254,13 @@ class CDeterministicMNStateDiff
                     SER_READ(obj, read_pubkey = true);
                     READWRITE(CBLSLazyPublicKeyVersionWrapper(const_cast<CBLSLazyPublicKey&>(obj.state.pubKeyOperator), obj.state.nVersion == ProTxVersion::LegacyBLS));
                 }
+            } else if constexpr (BaseType::mask == Field_netInfo) {
+                if (obj.fields & member.mask) {
+                    // As nVersion is stored after netInfo, we use a magic word to determine the underlying implementation
+                    // TODO: Implement this
+                    READWRITE(NetInfoSerWrapper(const_cast<std::shared_ptr<NetInfoInterface>&>(obj.state.netInfo),
+                                                /*is_extended=*/false));
+                }
             } else {
                 if (obj.fields & member.mask) {
                     READWRITE(member.get(obj.state));
diff --git a/src/evo/netinfo.cpp b/src/evo/netinfo.cpp
index b25818b6aecf..76c67404a750 100644
--- a/src/evo/netinfo.cpp
+++ b/src/evo/netinfo.cpp
@@ -5,6 +5,7 @@
 #include <evo/netinfo.h>
 
 #include <chainparams.h>
+#include <evo/providertx.h>
 #include <netbase.h>
 #include <span.h>
 #include <util/check.h>
@@ -147,6 +148,12 @@ std::string NetInfoEntry::ToStringAddrPort() const
         m_data);
 }
 
+std::shared_ptr<NetInfoInterface> NetInfoInterface::MakeNetInfo(const uint16_t nVersion)
+{
+    assert(nVersion > 0 && nVersion < ProTxVersion::ExtAddr);
+    return std::make_shared<MnNetInfo>();
+}
+
 NetInfoStatus MnNetInfo::ValidateService(const CService& service)
 {
     if (!service.IsValid()) {
diff --git a/src/evo/netinfo.h b/src/evo/netinfo.h
index e09de3890ec9..84bb5b5d39c0 100644
--- a/src/evo/netinfo.h
+++ b/src/evo/netinfo.h
@@ -71,6 +71,8 @@ class NetInfoEntry
         m_type = NetInfoType::Service;
         m_data = service;
     }
+    template <typename Stream>
+    NetInfoEntry(deserialize_type, Stream& s) { s >> *this; }
 
     ~NetInfoEntry() = default;
 
@@ -124,7 +126,33 @@ template<> struct is_serializable_enum<NetInfoEntry::NetInfoType> : std::true_ty
 
 using NetInfoList = std::vector<std::reference_wrapper<const NetInfoEntry>>;
 
-class MnNetInfo
+class NetInfoInterface
+{
+public:
+    static std::shared_ptr<NetInfoInterface> MakeNetInfo(const uint16_t nVersion);
+
+public:
+    virtual ~NetInfoInterface() = default;
+
+    virtual NetInfoStatus AddEntry(const std::string& service) = 0;
+    virtual NetInfoList GetEntries() const = 0;
+
+    virtual const CService& GetPrimary() const = 0;
+    virtual bool CanStorePlatform() const = 0;
+    virtual bool IsEmpty() const = 0;
+    virtual NetInfoStatus Validate() const = 0;
+    virtual std::string ToString() const = 0;
+
+    virtual void Clear() = 0;
+
+    bool operator==(const NetInfoInterface& rhs) const { return typeid(*this) == typeid(rhs) && this->IsEqual(rhs); }
+    bool operator!=(const NetInfoInterface& rhs) const { return !(*this == rhs); }
+
+private:
+    virtual bool IsEqual(const NetInfoInterface& rhs) const = 0;
+};
+
+class MnNetInfo final : public NetInfoInterface
 {
 private:
     NetInfoEntry m_addr{};
@@ -134,10 +162,10 @@ class MnNetInfo
 
 public:
     MnNetInfo() = default;
-    ~MnNetInfo() = default;
+    template <typename Stream>
+    MnNetInfo(deserialize_type, Stream& s) { s >> *this; }
 
-    bool operator==(const MnNetInfo& rhs) const { return m_addr == rhs.m_addr; }
-    bool operator!=(const MnNetInfo& rhs) const { return !(*this == rhs); }
+    ~MnNetInfo() = default;
 
     template <typename Stream>
     void Serialize(Stream& s) const
@@ -162,15 +190,64 @@ class MnNetInfo
         m_addr = NetInfoEntry{service};
     }
 
-    NetInfoStatus AddEntry(const std::string& service);
-    NetInfoList GetEntries() const;
+    NetInfoStatus AddEntry(const std::string& service) override;
+    NetInfoList GetEntries() const override;
 
-    const CService& GetPrimary() const;
-    bool IsEmpty() const { return *this == MnNetInfo(); }
-    NetInfoStatus Validate() const;
-    std::string ToString() const;
+    const CService& GetPrimary() const override;
+    bool IsEmpty() const override { return m_addr.IsEmpty(); }
+    bool CanStorePlatform() const override { return false; }
+    NetInfoStatus Validate() const override;
+    std::string ToString() const override;
+
+    void Clear() override { m_addr.Clear(); }
+
+private:
+    // operator== and operator!= are defined by the parent which then leverage the child's IsEqual() override
+    // IsEqual() should only be called by NetInfoInterface::operator== otherwise static_cast assumption could fail
+    bool IsEqual(const NetInfoInterface& rhs) const override
+    {
+        ASSERT_IF_DEBUG(typeid(*this) == typeid(rhs));
+        const auto& rhs_obj{static_cast<const MnNetInfo&>(rhs)};
+        return m_addr == rhs_obj.m_addr;
+    }
+};
+
+class NetInfoSerWrapper
+{
+private:
+    std::shared_ptr<NetInfoInterface>& m_data;
+    const bool m_is_extended{false};
 
-    void Clear() { m_addr.Clear(); }
+public:
+    NetInfoSerWrapper() = delete;
+    NetInfoSerWrapper(const NetInfoSerWrapper&) = delete;
+    NetInfoSerWrapper(std::shared_ptr<NetInfoInterface>& data, const bool is_extended) :
+        m_data{data},
+        m_is_extended{is_extended}
+    {
+        // TODO: Remove when extended addresses implementation is added in
+        assert(!m_is_extended);
+    }
+
+    ~NetInfoSerWrapper() = default;
+
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
+        if (const auto ptr{std::dynamic_pointer_cast<MnNetInfo>(m_data)}) {
+            s << *ptr;
+        } else {
+            // NetInfoInterface::MakeNetInfo() supplied an unexpected implementation or we didn't call it and
+            // are left with a nullptr. Neither should happen.
+            assert(false);
+        }
+    }
+
+    template <typename Stream>
+    void Unserialize(Stream& s)
+    {
+        m_data = std::make_shared<MnNetInfo>(deserialize, s);
+    }
 };
 
 #endif // BITCOIN_EVO_NETINFO_H
diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index c2684fc0758b..02b749912143 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -7,14 +7,34 @@
 
 #include <chainparams.h>
 #include <consensus/validation.h>
+#include <deploymentstatus.h>
 #include <hash.h>
 #include <script/standard.h>
 #include <tinyformat.h>
 #include <util/underlying.h>
 
-bool CProRegTx::IsTriviallyValid(bool is_basic_scheme_active, TxValidationState& state) const
+namespace ProTxVersion {
+template <typename T>
+[[nodiscard]] uint16_t GetMaxFromDeployment(gsl::not_null<const CBlockIndex*> pindexPrev,
+                                            std::optional<bool> is_basic_override)
 {
-    if (nVersion == 0 || nVersion > GetMaxVersion(is_basic_scheme_active)) {
+    constexpr bool is_extaddr_eligible{std::is_same_v<std::decay_t<T>, CProRegTx> || std::is_same_v<std::decay_t<T>, CProUpServTx>};
+    return ProTxVersion::GetMax(is_basic_override ? *is_basic_override
+                                                  : DeploymentActiveAfter(pindexPrev, Params().GetConsensus(),
+                                                                          Consensus::DEPLOYMENT_V19),
+                                is_extaddr_eligible ? DeploymentActiveAfter(pindexPrev, Params().GetConsensus(),
+                                                                            Consensus::DEPLOYMENT_V23)
+                                                    : false);
+}
+template uint16_t GetMaxFromDeployment<CProRegTx>(gsl::not_null<const CBlockIndex*> pindexPrev, std::optional<bool> is_basic_override);
+template uint16_t GetMaxFromDeployment<CProUpServTx>(gsl::not_null<const CBlockIndex*> pindexPrev, std::optional<bool> is_basic_override);
+template uint16_t GetMaxFromDeployment<CProUpRegTx>(gsl::not_null<const CBlockIndex*> pindexPrev, std::optional<bool> is_basic_override);
+template uint16_t GetMaxFromDeployment<CProUpRevTx>(gsl::not_null<const CBlockIndex*> pindexPrev, std::optional<bool> is_basic_override);
+} // namespace ProTxVersion
+
+bool CProRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state) const
+{
+    if (nVersion == 0 || nVersion > ProTxVersion::GetMaxFromDeployment<decltype(*this)>(pindexPrev)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
     }
     if (nVersion < ProTxVersion::BasicBLS && nType == MnType::Evo) {
@@ -36,7 +56,10 @@ bool CProRegTx::IsTriviallyValid(bool is_basic_scheme_active, TxValidationState&
     if (!scriptPayout.IsPayToPublicKeyHash() && !scriptPayout.IsPayToScriptHash()) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee");
     }
-    for (const NetInfoEntry& entry : netInfo.GetEntries()) {
+    if (netInfo->CanStorePlatform() != (nVersion == ProTxVersion::ExtAddr)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-netinfo-version");
+    }
+    for (const NetInfoEntry& entry : netInfo->GetEntries()) {
         if (!entry.IsTriviallyValid()) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-bad");
         }
@@ -99,21 +122,24 @@ std::string CProRegTx::ToString() const
                      nVersion, ToUnderlying(nType), collateralOutpoint.ToStringShort(), (double)nOperatorReward / 100,
                      EncodeDestination(PKHash(keyIDOwner)), pubKeyOperator.ToString(),
                      EncodeDestination(PKHash(keyIDVoting)), payee, platformNodeID.ToString(), platformP2PPort,
-                     platformHTTPPort, netInfo.ToString());
+                     platformHTTPPort, netInfo->ToString());
 }
 
-bool CProUpServTx::IsTriviallyValid(bool is_basic_scheme_active, TxValidationState& state) const
+bool CProUpServTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state) const
 {
-    if (nVersion == 0 || nVersion > GetMaxVersion(is_basic_scheme_active)) {
+    if (nVersion == 0 || nVersion > ProTxVersion::GetMaxFromDeployment<decltype(*this)>(pindexPrev)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
     }
     if (nVersion < ProTxVersion::BasicBLS && nType == MnType::Evo) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-evo-version");
     }
-    if (netInfo.IsEmpty()) {
+    if (netInfo->CanStorePlatform() != (nVersion == ProTxVersion::ExtAddr)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-netinfo-version");
+    }
+    if (netInfo->IsEmpty()) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-empty");
     }
-    for (const NetInfoEntry& entry : netInfo.GetEntries()) {
+    for (const NetInfoEntry& entry : netInfo->GetEntries()) {
         if (!entry.IsTriviallyValid()) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-bad");
         }
@@ -134,12 +160,12 @@ std::string CProUpServTx::ToString() const
                      "platformNodeID=%s, platformP2PPort=%d, platformHTTPPort=%d)\n"
                      "  %s",
                      nVersion, ToUnderlying(nType), proTxHash.ToString(), payee, platformNodeID.ToString(),
-                     platformP2PPort, platformHTTPPort, netInfo.ToString());
+                     platformP2PPort, platformHTTPPort, netInfo->ToString());
 }
 
-bool CProUpRegTx::IsTriviallyValid(bool is_basic_scheme_active, TxValidationState& state) const
+bool CProUpRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state) const
 {
-    if (nVersion == 0 || nVersion > GetMaxVersion(is_basic_scheme_active)) {
+    if (nVersion == 0 || nVersion > ProTxVersion::GetMaxFromDeployment<decltype(*this)>(pindexPrev)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
     }
     if (nMode != 0) {
@@ -170,9 +196,9 @@ std::string CProUpRegTx::ToString() const
         nVersion, proTxHash.ToString(), pubKeyOperator.ToString(), EncodeDestination(PKHash(keyIDVoting)), payee);
 }
 
-bool CProUpRevTx::IsTriviallyValid(bool is_basic_scheme_active, TxValidationState& state) const
+bool CProUpRevTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state) const
 {
-    if (nVersion == 0 || nVersion > GetMaxVersion(is_basic_scheme_active)) {
+    if (nVersion == 0 || nVersion > ProTxVersion::GetMaxFromDeployment<decltype(*this)>(pindexPrev)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
     }
 
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index 48017579c14c..9b756e20e997 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -18,13 +18,41 @@
 #include <univalue.h>
 #include <util/underlying.h>
 
+#include <gsl/pointers.h>
+
+class CBlockIndex;
 class TxValidationState;
 
 namespace ProTxVersion {
 enum : uint16_t {
     LegacyBLS = 1,
     BasicBLS  = 2,
+    ExtAddr   = 3,
 };
+
+/** Get highest permissible ProTx version based on flags set. */
+[[nodiscard]] constexpr uint16_t GetMax(const bool is_basic_scheme_active, const bool is_extended_addr)
+{
+    if (is_basic_scheme_active) {
+        if (is_extended_addr) {
+            // Requires *both* forks to be active to use extended addresses. is_basic_scheme_active could
+            // be set to false due to RPC specialization, so we must evaluate is_extended_addr *last* to
+            // avoid accidentally upgrading a legacy BLS node to basic BLS due to v23 activation.
+            return ProTxVersion::ExtAddr;
+        }
+        return ProTxVersion::BasicBLS;
+    }
+    return ProTxVersion::LegacyBLS;
+}
+
+/** Get highest permissible ProTx version based on deployment status
+ *  Note: The override is needed because some RPCs need to use deployment status information for everything *except*
+ *        the BLS version upgrade since they are specializations for a specific BLS version. This is a one-off.
+ *  TODO: Resolve this oddity. Consider deprecating legacy BLS-only RPCs so we can remove them eventually.
+ */
+template <typename T>
+[[nodiscard]] uint16_t GetMaxFromDeployment(gsl::not_null<const CBlockIndex*> pindexPrev,
+                                            std::optional<bool> is_basic_override = std::nullopt);
 } // namespace ProTxVersion
 
 class CProRegTx
@@ -32,16 +60,11 @@ class CProRegTx
 public:
     static constexpr auto SPECIALTX_TYPE = TRANSACTION_PROVIDER_REGISTER;
 
-    [[nodiscard]] static constexpr uint16_t GetMaxVersion(const bool is_basic_scheme_active)
-    {
-        return is_basic_scheme_active ? ProTxVersion::BasicBLS : ProTxVersion::LegacyBLS;
-    }
-
     uint16_t nVersion{ProTxVersion::LegacyBLS}; // message version
     MnType nType{MnType::Regular};
     uint16_t nMode{0};                                     // only 0 supported for now
     COutPoint collateralOutpoint{uint256(), (uint32_t)-1}; // if hash is null, we refer to a ProRegTx output
-    MnNetInfo netInfo;
+    std::shared_ptr<NetInfoInterface> netInfo{nullptr};
     uint160 platformNodeID{};
     uint16_t platformP2PPort{0};
     uint16_t platformHTTPPort{0};
@@ -58,7 +81,8 @@ class CProRegTx
         READWRITE(
                 obj.nVersion
         );
-        if (obj.nVersion == 0 || obj.nVersion > GetMaxVersion(/*is_basic_scheme_active=*/true)) {
+        if (obj.nVersion == 0 ||
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
             // unknown version, bail out early
             return;
         }
@@ -67,7 +91,8 @@ class CProRegTx
                 obj.nType,
                 obj.nMode,
                 obj.collateralOutpoint,
-                obj.netInfo,
+                NetInfoSerWrapper(const_cast<std::shared_ptr<NetInfoInterface>&>(obj.netInfo),
+                                  obj.nVersion >= ProTxVersion::ExtAddr),
                 obj.keyIDOwner,
                 CBLSLazyPublicKeyVersionWrapper(const_cast<CBLSLazyPublicKey&>(obj.pubKeyOperator), (obj.nVersion == ProTxVersion::LegacyBLS)),
                 obj.keyIDVoting,
@@ -94,7 +119,7 @@ class CProRegTx
 
     [[nodiscard]] UniValue ToJson() const;
 
-    bool IsTriviallyValid(bool is_basic_scheme_active, TxValidationState& state) const;
+    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state) const;
 };
 
 class CProUpServTx
@@ -102,15 +127,10 @@ class CProUpServTx
 public:
     static constexpr auto SPECIALTX_TYPE = TRANSACTION_PROVIDER_UPDATE_SERVICE;
 
-    [[nodiscard]] static constexpr uint16_t GetMaxVersion(const bool is_basic_scheme_active)
-    {
-        return is_basic_scheme_active ? ProTxVersion::BasicBLS : ProTxVersion::LegacyBLS;
-    }
-
     uint16_t nVersion{ProTxVersion::LegacyBLS}; // message version
     MnType nType{MnType::Regular};
     uint256 proTxHash;
-    MnNetInfo netInfo;
+    std::shared_ptr<NetInfoInterface> netInfo{nullptr};
     uint160 platformNodeID{};
     uint16_t platformP2PPort{0};
     uint16_t platformHTTPPort{0};
@@ -123,7 +143,8 @@ class CProUpServTx
         READWRITE(
                 obj.nVersion
         );
-        if (obj.nVersion == 0 || obj.nVersion > GetMaxVersion(/*is_basic_scheme_active=*/true)) {
+        if (obj.nVersion == 0 ||
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
             // unknown version, bail out early
             return;
         }
@@ -133,7 +154,8 @@ class CProUpServTx
         }
         READWRITE(
                 obj.proTxHash,
-                obj.netInfo,
+                NetInfoSerWrapper(const_cast<std::shared_ptr<NetInfoInterface>&>(obj.netInfo),
+                                  obj.nVersion >= ProTxVersion::ExtAddr),
                 obj.scriptOperatorPayout,
                 obj.inputsHash
         );
@@ -154,7 +176,7 @@ class CProUpServTx
 
     [[nodiscard]] UniValue ToJson() const;
 
-    bool IsTriviallyValid(bool is_basic_scheme_active, TxValidationState& state) const;
+    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state) const;
 };
 
 class CProUpRegTx
@@ -162,11 +184,6 @@ class CProUpRegTx
 public:
     static constexpr auto SPECIALTX_TYPE = TRANSACTION_PROVIDER_UPDATE_REGISTRAR;
 
-    [[nodiscard]] static constexpr uint16_t GetMaxVersion(const bool is_basic_scheme_active)
-    {
-        return is_basic_scheme_active ? ProTxVersion::BasicBLS : ProTxVersion::LegacyBLS;
-    }
-
     uint16_t nVersion{ProTxVersion::LegacyBLS}; // message version
     uint256 proTxHash;
     uint16_t nMode{0}; // only 0 supported for now
@@ -181,7 +198,8 @@ class CProUpRegTx
         READWRITE(
                 obj.nVersion
         );
-        if (obj.nVersion == 0 || obj.nVersion > GetMaxVersion(/*is_basic_scheme_active=*/true)) {
+        if (obj.nVersion == 0 ||
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
             // unknown version, bail out early
             return;
         }
@@ -204,7 +222,7 @@ class CProUpRegTx
 
     [[nodiscard]] UniValue ToJson() const;
 
-    bool IsTriviallyValid(bool is_basic_scheme_active, TxValidationState& state) const;
+    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state) const;
 };
 
 class CProUpRevTx
@@ -212,11 +230,6 @@ class CProUpRevTx
 public:
     static constexpr auto SPECIALTX_TYPE = TRANSACTION_PROVIDER_UPDATE_REVOKE;
 
-    [[nodiscard]] static constexpr uint16_t GetMaxVersion(const bool is_basic_scheme_active)
-    {
-        return is_basic_scheme_active ? ProTxVersion::BasicBLS : ProTxVersion::LegacyBLS;
-    }
-
     // these are just informational and do not have any effect on the revocation
     enum {
         REASON_NOT_SPECIFIED = 0,
@@ -237,7 +250,8 @@ class CProUpRevTx
         READWRITE(
                 obj.nVersion
         );
-        if (obj.nVersion == 0 || obj.nVersion > GetMaxVersion(/*is_basic_scheme_active=*/true)) {
+        if (obj.nVersion == 0 ||
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
             // unknown version, bail out early
             return;
         }
@@ -257,7 +271,7 @@ class CProUpRevTx
 
     [[nodiscard]] UniValue ToJson() const;
 
-    bool IsTriviallyValid(bool is_basic_scheme_active, TxValidationState& state) const;
+    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state) const;
 };
 
 template <typename ProTx>
@@ -266,9 +280,7 @@ static bool CheckInputsHash(const CTransaction& tx, const ProTx& proTx, TxValida
     if (uint256 inputsHash = CalcTxInputsHash(tx); inputsHash != proTx.inputsHash) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-inputs-hash");
     }
-
     return true;
 }
 
-
 #endif // BITCOIN_EVO_PROVIDERTX_H
diff --git a/src/evo/simplifiedmns.cpp b/src/evo/simplifiedmns.cpp
index 1812f7c811df..45b101af0594 100644
--- a/src/evo/simplifiedmns.cpp
+++ b/src/evo/simplifiedmns.cpp
@@ -70,7 +70,7 @@ std::string CSimplifiedMNListEntry::ToString() const
                      "  %s",
                      nVersion, ToUnderlying(nType), proRegTxHash.ToString(), confirmedHash.ToString(),
                      pubKeyOperator.ToString(), EncodeDestination(PKHash(keyIDVoting)), isValid, payoutAddress,
-                     operatorPayoutAddress, platformHTTPPort, platformNodeID.ToString(), netInfo.ToString());
+                     operatorPayoutAddress, platformHTTPPort, platformNodeID.ToString(), netInfo->ToString());
 }
 
 UniValue CSimplifiedMNListEntry::ToJson(bool extended) const
@@ -80,7 +80,7 @@ UniValue CSimplifiedMNListEntry::ToJson(bool extended) const
     obj.pushKV("nType", ToUnderlying(nType));
     obj.pushKV("proRegTxHash", proRegTxHash.ToString());
     obj.pushKV("confirmedHash", confirmedHash.ToString());
-    obj.pushKV("service", netInfo.GetPrimary().ToStringAddrPort());
+    obj.pushKV("service", netInfo->GetPrimary().ToStringAddrPort());
     obj.pushKV("pubKeyOperator", pubKeyOperator.ToString());
     obj.pushKV("votingAddress", EncodeDestination(PKHash(keyIDVoting)));
     obj.pushKV("isValid", isValid);
diff --git a/src/evo/simplifiedmns.h b/src/evo/simplifiedmns.h
index 5e5bf7efeb81..e2c17cccb242 100644
--- a/src/evo/simplifiedmns.h
+++ b/src/evo/simplifiedmns.h
@@ -14,6 +14,7 @@
 #include <pubkey.h>
 #include <sync.h>
 #include <threadsafety.h>
+#include <util/pointer.h>
 
 class UniValue;
 class CBlockIndex;
@@ -35,7 +36,7 @@ class CSimplifiedMNListEntry
 public:
     uint256 proRegTxHash;
     uint256 confirmedHash;
-    MnNetInfo netInfo;
+    std::shared_ptr<NetInfoInterface> netInfo{nullptr};
     CBLSLazyPublicKey pubKeyOperator;
     CKeyID keyIDVoting;
     bool isValid{false};
@@ -53,7 +54,7 @@ class CSimplifiedMNListEntry
     {
         return proRegTxHash == rhs.proRegTxHash &&
                confirmedHash == rhs.confirmedHash &&
-               netInfo == rhs.netInfo &&
+               util::shared_ptr_equal(netInfo, rhs.netInfo) &&
                pubKeyOperator == rhs.pubKeyOperator &&
                keyIDVoting == rhs.keyIDVoting &&
                isValid == rhs.isValid &&
@@ -76,7 +77,8 @@ class CSimplifiedMNListEntry
         READWRITE(
                 obj.proRegTxHash,
                 obj.confirmedHash,
-                obj.netInfo,
+                NetInfoSerWrapper(const_cast<std::shared_ptr<NetInfoInterface>&>(obj.netInfo),
+                                  obj.nVersion >= ProTxVersion::ExtAddr),
                 CBLSLazyPublicKeyVersionWrapper(const_cast<CBLSLazyPublicKey&>(obj.pubKeyOperator), (obj.nVersion == ProTxVersion::LegacyBLS)),
                 obj.keyIDVoting,
                 obj.isValid
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index 020288196eee..21b6a78f8418 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -905,7 +905,7 @@ bool EnsureQuorumConnections(const Consensus::LLMQParams& llmqParams, CConnman&
                     debugMsg += strprintf("  %s (not in valid MN set anymore)\n", c.ToString());
                 } else {
                     debugMsg += strprintf("  %s (%s)\n", c.ToString(),
-                                          dmn->pdmnState->netInfo.GetPrimary().ToStringAddrPort());
+                                          dmn->pdmnState->netInfo->GetPrimary().ToStringAddrPort());
                 }
             }
             LogPrint(BCLog::NET_NETCONN, debugMsg.c_str()); /* Continued */
@@ -954,7 +954,7 @@ void AddQuorumProbeConnections(const Consensus::LLMQParams& llmqParams, CConnman
                     debugMsg += strprintf("  %s (not in valid MN set anymore)\n", c.ToString());
                 } else {
                     debugMsg += strprintf("  %s (%s)\n", c.ToString(),
-                                          dmn->pdmnState->netInfo.GetPrimary().ToStringAddrPort());
+                                          dmn->pdmnState->netInfo->GetPrimary().ToStringAddrPort());
                 }
             }
             LogPrint(BCLog::NET_NETCONN, debugMsg.c_str()); /* Continued */
diff --git a/src/masternode/node.cpp b/src/masternode/node.cpp
index 7fe30266da5d..98537844fbec 100644
--- a/src/masternode/node.cpp
+++ b/src/masternode/node.cpp
@@ -146,7 +146,7 @@ void CActiveMasternodeManager::InitInternal(const CBlockIndex* pindex)
 
     LogPrintf("CActiveMasternodeManager::Init -- proTxHash=%s, proTx=%s\n", dmn->proTxHash.ToString(), dmn->ToString());
 
-    if (m_info.service != dmn->pdmnState->netInfo.GetPrimary()) {
+    if (m_info.service != dmn->pdmnState->netInfo->GetPrimary()) {
         m_state = MasternodeState::SOME_ERROR;
         m_error = "Local address does not match the address from ProTx";
         LogPrintf("CActiveMasternodeManager::Init -- ERROR: %s\n", m_error);
@@ -201,7 +201,7 @@ void CActiveMasternodeManager::UpdatedBlockTip(const CBlockIndex* pindexNew, con
             // MN operator key changed or revoked
             return reset(MasternodeState::OPERATOR_KEY_CHANGED);
         }
-        if (newDmn->pdmnState->netInfo.GetPrimary() != oldDmn->pdmnState->netInfo.GetPrimary()) {
+        if (newDmn->pdmnState->netInfo->GetPrimary() != oldDmn->pdmnState->netInfo->GetPrimary()) {
             // MN IP changed
             return reset(MasternodeState::PROTX_IP_CHANGED);
         }
diff --git a/src/masternode/utils.cpp b/src/masternode/utils.cpp
index 0757ac8815c1..a145cd9403c9 100644
--- a/src/masternode/utils.cpp
+++ b/src/masternode/utils.cpp
@@ -78,7 +78,7 @@ void CMasternodeUtils::DoMaintenance(CConnman& connman, CDeterministicMNManager&
 
 #ifdef ENABLE_WALLET
         bool fFound = ranges::any_of(vecDmns, [&pnode](const auto& dmn) {
-            return pnode->addr == dmn->pdmnState->netInfo.GetPrimary();
+            return pnode->addr == dmn->pdmnState->netInfo->GetPrimary();
         });
         if (fFound) return; // do NOT disconnect mixing masternodes
 #endif // ENABLE_WALLET
diff --git a/src/net.cpp b/src/net.cpp
index 4f6683e145cb..97c457979afb 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -3674,7 +3674,7 @@ void CConnman::ThreadOpenMasternodeConnections(CDeterministicMNManager& dmnman,
                     if (!dmn) {
                         continue;
                     }
-                    const auto addr2 = dmn->pdmnState->netInfo.GetPrimary();
+                    const auto addr2 = dmn->pdmnState->netInfo->GetPrimary();
                     if (connectedNodes.count(addr2) && !connectedProRegTxHashes.count(proRegTxHash)) {
                         // we probably connected to it before it became a masternode
                         // or maybe we are still waiting for mnauth
@@ -3740,8 +3740,8 @@ void CConnman::ThreadOpenMasternodeConnections(CDeterministicMNManager& dmnman,
             if (!vPendingMasternodes.empty()) {
                 auto dmn = mnList.GetValidMN(vPendingMasternodes.front());
                 vPendingMasternodes.erase(vPendingMasternodes.begin());
-                if (dmn && !connectedNodes.count(dmn->pdmnState->netInfo.GetPrimary()) && !IsMasternodeOrDisconnectRequested(dmn->pdmnState->netInfo.GetPrimary())) {
-                    LogPrint(BCLog::NET_NETCONN, "CConnman::%s -- opening pending masternode connection to %s, service=%s\n", _func_, dmn->proTxHash.ToString(), dmn->pdmnState->netInfo.GetPrimary().ToStringAddrPort());
+                if (dmn && !connectedNodes.count(dmn->pdmnState->netInfo->GetPrimary()) && !IsMasternodeOrDisconnectRequested(dmn->pdmnState->netInfo->GetPrimary())) {
+                    LogPrint(BCLog::NET_NETCONN, "CConnman::%s -- opening pending masternode connection to %s, service=%s\n", _func_, dmn->proTxHash.ToString(), dmn->pdmnState->netInfo->GetPrimary().ToStringAddrPort());
                     return dmn;
                 }
             }
@@ -3750,7 +3750,7 @@ void CConnman::ThreadOpenMasternodeConnections(CDeterministicMNManager& dmnman,
                 // not-null
                 auto dmn = pending[GetRand(pending.size())];
                 LogPrint(BCLog::NET_NETCONN, "CConnman::%s -- opening quorum connection to %s, service=%s\n",
-                         _func_, dmn->proTxHash.ToString(), dmn->pdmnState->netInfo.GetPrimary().ToStringAddrPort());
+                         _func_, dmn->proTxHash.ToString(), dmn->pdmnState->netInfo->GetPrimary().ToStringAddrPort());
                 return dmn;
             }
 
@@ -3760,7 +3760,7 @@ void CConnman::ThreadOpenMasternodeConnections(CDeterministicMNManager& dmnman,
                 masternodePendingProbes.erase(dmn->proTxHash);
                 isProbe = MasternodeProbeConn::IsConnection;
 
-                LogPrint(BCLog::NET_NETCONN, "CConnman::%s -- probing masternode %s, service=%s\n", _func_, dmn->proTxHash.ToString(), dmn->pdmnState->netInfo.GetPrimary().ToStringAddrPort());
+                LogPrint(BCLog::NET_NETCONN, "CConnman::%s -- probing masternode %s, service=%s\n", _func_, dmn->proTxHash.ToString(), dmn->pdmnState->netInfo->GetPrimary().ToStringAddrPort());
                 return dmn;
             }
             return nullptr;
@@ -3776,16 +3776,16 @@ void CConnman::ThreadOpenMasternodeConnections(CDeterministicMNManager& dmnman,
 
         mn_metaman.GetMetaInfo(connectToDmn->proTxHash)->SetLastOutboundAttempt(nANow);
 
-        OpenMasternodeConnection(CAddress(connectToDmn->pdmnState->netInfo.GetPrimary(), NODE_NETWORK), /*use_v2transport=*/GetLocalServices() & NODE_P2P_V2, isProbe);
+        OpenMasternodeConnection(CAddress(connectToDmn->pdmnState->netInfo->GetPrimary(), NODE_NETWORK), /*use_v2transport=*/GetLocalServices() & NODE_P2P_V2, isProbe);
         // should be in the list now if connection was opened
-        bool connected = ForNode(connectToDmn->pdmnState->netInfo.GetPrimary(), CConnman::AllNodes, [&](CNode* pnode) {
+        bool connected = ForNode(connectToDmn->pdmnState->netInfo->GetPrimary(), CConnman::AllNodes, [&](CNode* pnode) {
             if (pnode->fDisconnect) {
                 return false;
             }
             return true;
         });
         if (!connected) {
-            LogPrint(BCLog::NET_NETCONN, "CConnman::%s -- connection failed for masternode  %s, service=%s\n", __func__, connectToDmn->proTxHash.ToString(), connectToDmn->pdmnState->netInfo.GetPrimary().ToStringAddrPort());
+            LogPrint(BCLog::NET_NETCONN, "CConnman::%s -- connection failed for masternode  %s, service=%s\n", __func__, connectToDmn->proTxHash.ToString(), connectToDmn->pdmnState->netInfo->GetPrimary().ToStringAddrPort());
             // Will take a few consequent failed attempts to PoSe-punish a MN.
             if (mn_metaman.GetMetaInfo(connectToDmn->proTxHash)->OutboundFailedTooManyTimes()) {
                 LogPrint(BCLog::NET_NETCONN, "CConnman::%s -- failed to connect to masternode %s too many times\n", __func__, connectToDmn->proTxHash.ToString());
diff --git a/src/qt/masternodelist.cpp b/src/qt/masternodelist.cpp
index 546125d92eeb..779c7e6a11ee 100644
--- a/src/qt/masternodelist.cpp
+++ b/src/qt/masternodelist.cpp
@@ -221,10 +221,10 @@ void MasternodeList::updateDIP3List()
         }
         // populate list
         // Address, Protocol, Status, Active Seconds, Last Seen, Pub Key
-        auto addr_key = dmn.pdmnState->netInfo.GetPrimary().GetKey();
+        auto addr_key = dmn.pdmnState->netInfo->GetPrimary().GetKey();
         QByteArray addr_ba(reinterpret_cast<const char*>(addr_key.data()), addr_key.size());
         QTableWidgetItem* addressItem = new CMasternodeListWidgetItem<QByteArray>(
-            QString::fromStdString(dmn.pdmnState->netInfo.GetPrimary().ToStringAddrPort()), addr_ba);
+            QString::fromStdString(dmn.pdmnState->netInfo->GetPrimary().ToStringAddrPort()), addr_ba);
         QTableWidgetItem* typeItem = new QTableWidgetItem(QString::fromStdString(std::string(GetMnType(dmn.nType).description)));
         QTableWidgetItem* statusItem = new QTableWidgetItem(dmn.pdmnState->IsBanned() ? tr("POSE_BANNED") : tr("ENABLED"));
         QTableWidgetItem* PoSeScoreItem = new CMasternodeListWidgetItem<int>(QString::number(dmn.pdmnState->nPoSePenalty), dmn.pdmnState->nPoSePenalty);
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 1d8c7a5a3bae..77437261fd44 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -686,7 +686,9 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
 
     CProRegTx ptx;
     ptx.nType = mnType;
-    ptx.nVersion = CProRegTx::GetMaxVersion(/*is_basic_scheme_active=*/!use_legacy);
+    ptx.nVersion = ProTxVersion::GetMaxFromDeployment<CProRegTx>(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()),
+                                                                 /*is_basic_override=*/!use_legacy);
+    ptx.netInfo = NetInfoInterface::MakeNetInfo(ptx.nVersion);
 
     if (action == ProTxRegisterAction::Fund) {
         CTxDestination collateralDest = DecodeDestination(request.params[paramIdx].get_str());
@@ -712,7 +714,7 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
     }
 
     if (!request.params[paramIdx].get_str().empty()) {
-        if (auto entryRet = ptx.netInfo.AddEntry(request.params[paramIdx].get_str()); entryRet != NetInfoStatus::Success) {
+        if (auto entryRet = ptx.netInfo->AddEntry(request.params[paramIdx].get_str()); entryRet != NetInfoStatus::Success) {
             throw std::runtime_error(strprintf("%s (%s)", NISToString(entryRet), request.params[paramIdx].get_str()));
         }
     }
@@ -1012,9 +1014,11 @@ static UniValue protx_update_service_common_wrapper(const JSONRPCRequest& reques
         throw std::runtime_error(strprintf("masternode with proTxHash %s is not a %s", ptx.proTxHash.ToString(), GetMnType(mnType).description));
     }
 
-    ptx.nVersion = dmn->pdmnState->nVersion;
+    ptx.nVersion = ProTxVersion::GetMaxFromDeployment<CProUpServTx>(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()),
+                                                                    /*is_basic_override=*/dmn->pdmnState->nVersion > ProTxVersion::LegacyBLS);
+    ptx.netInfo = NetInfoInterface::MakeNetInfo(ptx.nVersion);
 
-    if (auto entryRet = ptx.netInfo.AddEntry(request.params[1].get_str()); entryRet != NetInfoStatus::Success) {
+    if (auto entryRet = ptx.netInfo->AddEntry(request.params[1].get_str()); entryRet != NetInfoStatus::Success) {
         throw std::runtime_error(strprintf("%s (%s)", NISToString(entryRet), request.params[1].get_str()));
     }
 
@@ -1145,7 +1149,8 @@ static RPCHelpMan protx_update_registrar_wrapper(const bool specific_legacy_bls_
     EnsureWalletIsUnlocked(*wallet);
 
     CProUpRegTx ptx;
-    ptx.nVersion = CProUpRegTx::GetMaxVersion(/*is_basic_scheme_active=*/!use_legacy);
+    ptx.nVersion = ProTxVersion::GetMaxFromDeployment<CProUpRegTx>(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()),
+                                                                   /*is_basic_override=*/!use_legacy);
 
     ptx.proTxHash = ParseHashV(request.params[0], "proTxHash");
     auto dmn = dmnman.GetListAtChainTip().GetMN(ptx.proTxHash);
@@ -1263,9 +1268,8 @@ static RPCHelpMan protx_revoke()
 
     EnsureWalletIsUnlocked(*pwallet);
 
-    const bool isV19active{DeploymentActiveAfter(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip();), Params().GetConsensus(), Consensus::DEPLOYMENT_V19)};
     CProUpRevTx ptx;
-    ptx.nVersion = CProUpRevTx::GetMaxVersion(/*is_basic_scheme_active=*/isV19active);
+    ptx.nVersion = ProTxVersion::GetMaxFromDeployment<CProUpRevTx>(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()));
 
     ptx.proTxHash = ParseHashV(request.params[0], "proTxHash");
     auto dmn = dmnman.GetListAtChainTip().GetMN(ptx.proTxHash);
@@ -1315,7 +1319,7 @@ static RPCHelpMan protx_revoke()
         fSubmit = ParseBoolV(request.params[4], "submit");
     }
 
-    SignSpecialTxPayloadByHash(tx, ptx, keyOperator, !isV19active);
+    SignSpecialTxPayloadByHash(tx, ptx, keyOperator, /*use_legacy=*/ptx.nVersion == ProTxVersion::LegacyBLS);
     SetTxPayload(tx, ptx);
 
     return SignAndSendSpecialTx(request, chain_helper, chainman, tx, fSubmit);
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 4cbdbd09bf04..7248938326d0 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -576,7 +576,7 @@ static RPCHelpMan masternodelist_helper(bool is_composite)
         std::string strAddress{};
         if (strMode == "addr" || strMode == "full" || strMode == "info" || strMode == "json" || strMode == "recent" ||
             strMode == "evo") {
-            for (const NetInfoEntry& entry : dmn.pdmnState->netInfo.GetEntries()) {
+            for (const NetInfoEntry& entry : dmn.pdmnState->netInfo->GetEntries()) {
                 strAddress += entry.ToStringAddrPort() + " ";
             }
             if (!strAddress.empty()) strAddress.pop_back(); // Remove trailing space
@@ -623,7 +623,7 @@ static RPCHelpMan masternodelist_helper(bool is_composite)
                 strOutpoint.find(strFilter) == std::string::npos) return;
             UniValue objMN(UniValue::VOBJ);
             objMN.pushKV("proTxHash", dmn.proTxHash.ToString());
-            objMN.pushKV("address", dmn.pdmnState->netInfo.GetPrimary().ToStringAddrPort());
+            objMN.pushKV("address", dmn.pdmnState->netInfo->GetPrimary().ToStringAddrPort());
             objMN.pushKV("payee", payeeStr);
             objMN.pushKV("status", dmnToStatus(dmn));
             objMN.pushKV("type", std::string(GetMnType(dmn.nType).description));
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index 5001246f6b9a..64ceaa059c3b 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -206,7 +206,7 @@ static UniValue BuildQuorumInfo(const llmq::CQuorumBlockProcessor& quorum_block_
             const auto& dmn = quorum->members[i];
             UniValue mo(UniValue::VOBJ);
             mo.pushKV("proTxHash", dmn->proTxHash.ToString());
-            mo.pushKV("service", dmn->pdmnState->netInfo.GetPrimary().ToStringAddrPort());
+            mo.pushKV("service", dmn->pdmnState->netInfo->GetPrimary().ToStringAddrPort());
             mo.pushKV("pubKeyOperator", dmn->pdmnState->pubKeyOperator.ToString());
             mo.pushKV("valid", quorum->qc->validMembers[i]);
             if (quorum->qc->validMembers[i]) {
diff --git a/src/test/block_reward_reallocation_tests.cpp b/src/test/block_reward_reallocation_tests.cpp
index f77410b697b5..7afb4888db8c 100644
--- a/src/test/block_reward_reallocation_tests.cpp
+++ b/src/test/block_reward_reallocation_tests.cpp
@@ -118,9 +118,10 @@ static CMutableTransaction CreateProRegTx(const CChain& active_chain, const CTxM
     operatorKeyRet.MakeNewKey();
 
     CProRegTx proTx;
-    proTx.nVersion = CProRegTx::GetMaxVersion(!bls::bls_legacy_scheme);
+    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+    proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
     proTx.collateralOutpoint.n = 0;
-    BOOST_CHECK_EQUAL(proTx.netInfo.AddEntry(strprintf("1.1.1.1:%d", port)), NetInfoStatus::Success);
+    BOOST_CHECK_EQUAL(proTx.netInfo->AddEntry(strprintf("1.1.1.1:%d", port)), NetInfoStatus::Success);
     proTx.keyIDOwner = ownerKeyRet.GetPubKey().GetID();
     proTx.pubKeyOperator.Set(operatorKeyRet.GetPublicKey(), bls::bls_legacy_scheme.load());
     proTx.keyIDVoting = ownerKeyRet.GetPubKey().GetID();
diff --git a/src/test/evo_deterministicmns_tests.cpp b/src/test/evo_deterministicmns_tests.cpp
index 018b1cb15161..d9c6f6df3bbd 100644
--- a/src/test/evo_deterministicmns_tests.cpp
+++ b/src/test/evo_deterministicmns_tests.cpp
@@ -106,9 +106,10 @@ static CMutableTransaction CreateProRegTx(const CChain& active_chain, const CTxM
     operatorKeyRet.MakeNewKey();
 
     CProRegTx proTx;
-    proTx.nVersion = CProRegTx::GetMaxVersion(!bls::bls_legacy_scheme);
+    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+    proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
     proTx.collateralOutpoint.n = 0;
-    BOOST_CHECK_EQUAL(proTx.netInfo.AddEntry(strprintf("1.1.1.1:%d", port)), NetInfoStatus::Success);
+    BOOST_CHECK_EQUAL(proTx.netInfo->AddEntry(strprintf("1.1.1.1:%d", port)), NetInfoStatus::Success);
     proTx.keyIDOwner = ownerKeyRet.GetPubKey().GetID();
     proTx.pubKeyOperator.Set(operatorKeyRet.GetPublicKey(), bls::bls_legacy_scheme.load());
     proTx.keyIDVoting = ownerKeyRet.GetPubKey().GetID();
@@ -128,9 +129,10 @@ static CMutableTransaction CreateProRegTx(const CChain& active_chain, const CTxM
 static CMutableTransaction CreateProUpServTx(const CChain& active_chain, const CTxMemPool& mempool, SimpleUTXOMap& utxos, const uint256& proTxHash, const CBLSSecretKey& operatorKey, int port, const CScript& scriptOperatorPayout, const CKey& coinbaseKey)
 {
     CProUpServTx proTx;
-    proTx.nVersion = CProUpServTx::GetMaxVersion(!bls::bls_legacy_scheme);
+    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+    proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
     proTx.proTxHash = proTxHash;
-    BOOST_CHECK_EQUAL(proTx.netInfo.AddEntry(strprintf("1.1.1.1:%d", port)), NetInfoStatus::Success);
+    BOOST_CHECK_EQUAL(proTx.netInfo->AddEntry(strprintf("1.1.1.1:%d", port)), NetInfoStatus::Success);
     proTx.scriptOperatorPayout = scriptOperatorPayout;
 
     CMutableTransaction tx;
@@ -148,7 +150,7 @@ static CMutableTransaction CreateProUpServTx(const CChain& active_chain, const C
 static CMutableTransaction CreateProUpRegTx(const CChain& active_chain, const CTxMemPool& mempool, SimpleUTXOMap& utxos, const uint256& proTxHash, const CKey& mnKey, const CBLSPublicKey& pubKeyOperator, const CKeyID& keyIDVoting, const CScript& scriptPayout, const CKey& coinbaseKey)
 {
     CProUpRegTx proTx;
-    proTx.nVersion = CProUpRegTx::GetMaxVersion(!bls::bls_legacy_scheme);
+    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
     proTx.proTxHash = proTxHash;
     proTx.pubKeyOperator.Set(pubKeyOperator, bls::bls_legacy_scheme.load());
     proTx.keyIDVoting = keyIDVoting;
@@ -169,7 +171,7 @@ static CMutableTransaction CreateProUpRegTx(const CChain& active_chain, const CT
 static CMutableTransaction CreateProUpRevTx(const CChain& active_chain, const CTxMemPool& mempool, SimpleUTXOMap& utxos, const uint256& proTxHash, const CBLSSecretKey& operatorKey, const CKey& coinbaseKey)
 {
     CProUpRevTx proTx;
-    proTx.nVersion = CProUpRevTx::GetMaxVersion(!bls::bls_legacy_scheme);
+    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
     proTx.proTxHash = proTxHash;
 
     CMutableTransaction tx;
@@ -521,7 +523,7 @@ void FuncDIP3Protx(TestChainSetup& setup)
     nHeight++;
 
     auto dmn = dmnman.GetListAtChainTip().GetMN(dmnHashes[0]);
-    BOOST_REQUIRE(dmn != nullptr && dmn->pdmnState->netInfo.GetPrimary().GetPort() == 1000);
+    BOOST_REQUIRE(dmn != nullptr && dmn->pdmnState->netInfo->GetPrimary().GetPort() == 1000);
 
     // test ProUpRevTx
     tx = CreateProUpRevTx(chainman.ActiveChain(), *(setup.m_node.mempool), utxos, dmnHashes[0], operatorKeys[dmnHashes[0]], setup.coinbaseKey);
@@ -579,7 +581,7 @@ void FuncDIP3Protx(TestChainSetup& setup)
     nHeight++;
 
     dmn = dmnman.GetListAtChainTip().GetMN(dmnHashes[0]);
-    BOOST_REQUIRE(dmn != nullptr && dmn->pdmnState->netInfo.GetPrimary().GetPort() == 100);
+    BOOST_REQUIRE(dmn != nullptr && dmn->pdmnState->netInfo->GetPrimary().GetPort() == 100);
     BOOST_REQUIRE(dmn != nullptr && !dmn->pdmnState->IsBanned());
 
     // test that the revived MN gets payments again
@@ -638,8 +640,9 @@ void FuncTestMempoolReorg(TestChainSetup& setup)
     BOOST_CHECK_EQUAL(block->GetHash(), chainman.ActiveChain().Tip()->GetBlockHash());
 
     CProRegTx payload;
-    payload.nVersion = CProRegTx::GetMaxVersion(!bls::bls_legacy_scheme);
-    BOOST_CHECK_EQUAL(payload.netInfo.AddEntry("1.1.1.1:1"), NetInfoStatus::Success);
+    payload.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+    payload.netInfo = NetInfoInterface::MakeNetInfo(payload.nVersion);
+    BOOST_CHECK_EQUAL(payload.netInfo->AddEntry("1.1.1.1:1"), NetInfoStatus::Success);
     payload.keyIDOwner = ownerKey.GetPubKey().GetID();
     payload.pubKeyOperator.Set(operatorKey.GetPublicKey(), bls::bls_legacy_scheme.load());
     payload.keyIDVoting = ownerKey.GetPubKey().GetID();
@@ -713,7 +716,9 @@ void FuncTestMempoolDualProregtx(TestChainSetup& setup)
     auto scriptPayout = GetScriptForDestination(PKHash(payoutKey.GetPubKey()));
 
     CProRegTx payload;
-    BOOST_CHECK_EQUAL(payload.netInfo.AddEntry("1.1.1.1:2"), NetInfoStatus::Success);
+    payload.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+    payload.netInfo = NetInfoInterface::MakeNetInfo(payload.nVersion);
+    BOOST_CHECK_EQUAL(payload.netInfo->AddEntry("1.1.1.1:2"), NetInfoStatus::Success);
     payload.keyIDOwner = ownerKey.GetPubKey().GetID();
     payload.pubKeyOperator.Set(operatorKey.GetPublicKey(), bls::bls_legacy_scheme.load());
     payload.keyIDVoting = ownerKey.GetPubKey().GetID();
@@ -780,8 +785,9 @@ void FuncVerifyDB(TestChainSetup& setup)
     BOOST_CHECK_EQUAL(block->GetHash(), chainman.ActiveChain().Tip()->GetBlockHash());
 
     CProRegTx payload;
-    payload.nVersion = CProRegTx::GetMaxVersion(!bls::bls_legacy_scheme);
-    BOOST_CHECK_EQUAL(payload.netInfo.AddEntry("1.1.1.1:1"), NetInfoStatus::Success);
+    payload.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+    payload.netInfo = NetInfoInterface::MakeNetInfo(payload.nVersion);
+    BOOST_CHECK_EQUAL(payload.netInfo->AddEntry("1.1.1.1:1"), NetInfoStatus::Success);
     payload.keyIDOwner = ownerKey.GetPubKey().GetID();
     payload.pubKeyOperator.Set(operatorKey.GetPublicKey(), bls::bls_legacy_scheme.load());
     payload.keyIDVoting = ownerKey.GetPubKey().GetID();
diff --git a/src/test/evo_netinfo_tests.cpp b/src/test/evo_netinfo_tests.cpp
index 234f149813d5..50138f5c0818 100644
--- a/src/test/evo_netinfo_tests.cpp
+++ b/src/test/evo_netinfo_tests.cpp
@@ -9,6 +9,7 @@
 #include <evo/netinfo.h>
 #include <netbase.h>
 #include <streams.h>
+#include <util/pointer.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -214,4 +215,27 @@ BOOST_AUTO_TEST_CASE(cservice_compatible)
     BOOST_CHECK(CheckIfSerSame(service, netInfo));
 }
 
+BOOST_AUTO_TEST_CASE(interface_equality)
+{
+    // We also check for symmetry as NetInfoInterface, MnNetInfo and NetInfoEntry
+    // define their operator!= as the inverse of operator==
+    std::shared_ptr<NetInfoInterface> ptr_lhs{nullptr}, ptr_rhs{nullptr};
+
+    // Equal initialization state (uninitialized)
+    BOOST_CHECK(util::shared_ptr_equal(ptr_lhs, ptr_rhs) && !util::shared_ptr_not_equal(ptr_lhs, ptr_rhs));
+
+    // Unequal initialization state (lhs initialized, rhs unchanged)
+    ptr_lhs = std::make_shared<MnNetInfo>();
+    BOOST_CHECK(!util::shared_ptr_equal(ptr_lhs, ptr_rhs) && util::shared_ptr_not_equal(ptr_lhs, ptr_rhs));
+
+    // Equal initialization state (lhs unchanged, rhs initialized), same values
+    ptr_rhs = std::make_shared<MnNetInfo>();
+    BOOST_CHECK(ptr_lhs->IsEmpty() && ptr_rhs->IsEmpty());
+    BOOST_CHECK(util::shared_ptr_equal(ptr_lhs, ptr_rhs) && !util::shared_ptr_not_equal(ptr_lhs, ptr_rhs));
+
+    // Equal initialization state, same type, differing values
+    BOOST_CHECK_EQUAL(ptr_rhs->AddEntry("1.1.1.1:9999"), NetInfoStatus::Success);
+    BOOST_CHECK(!util::shared_ptr_equal(ptr_lhs, ptr_rhs) && util::shared_ptr_not_equal(ptr_lhs, ptr_rhs));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/evo_simplifiedmns_tests.cpp b/src/test/evo_simplifiedmns_tests.cpp
index 6c6856966d68..12bb61fab1cb 100644
--- a/src/test/evo_simplifiedmns_tests.cpp
+++ b/src/test/evo_simplifiedmns_tests.cpp
@@ -19,10 +19,12 @@ BOOST_AUTO_TEST_CASE(simplifiedmns_merkleroots)
     std::vector<CSimplifiedMNListEntry> entries;
     for (size_t i = 1; i < 16; i++) {
         CSimplifiedMNListEntry smle;
+        smle.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+        smle.netInfo = NetInfoInterface::MakeNetInfo(smle.nVersion);
         smle.proRegTxHash.SetHex(strprintf("%064x", i));
         smle.confirmedHash.SetHex(strprintf("%064x", i));
 
-        BOOST_CHECK_EQUAL(smle.netInfo.AddEntry(strprintf("%d.%d.%d.%d:%d", 0, 0, 0, i, i)), NetInfoStatus::Success);
+        BOOST_CHECK_EQUAL(smle.netInfo->AddEntry(strprintf("%d.%d.%d.%d:%d", 0, 0, 0, i, i)), NetInfoStatus::Success);
 
         std::vector<unsigned char> vecBytes{static_cast<unsigned char>(i)};
         vecBytes.resize(CBLSSecretKey::SerSize);
diff --git a/src/test/evo_trivialvalidation.cpp b/src/test/evo_trivialvalidation.cpp
index 286ec8d3dd38..55312417d9ef 100644
--- a/src/test/evo_trivialvalidation.cpp
+++ b/src/test/evo_trivialvalidation.cpp
@@ -7,19 +7,29 @@
 #include <test/util/json.h>
 #include <test/util/setup_common.h>
 
+#include <chain.h>
+#include <chainparams.h>
+#include <deploymentstatus.h>
 #include <evo/providertx.h>
 #include <primitives/transaction.h>
+#include <validation.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <univalue.h>
 
-BOOST_FIXTURE_TEST_SUITE(evo_trivialvalidation, BasicTestingSetup)
+struct TestChain100V19Activation : public TestChain100Setup {
+    TestChain100V19Activation()
+        : TestChain100Setup{CBaseChainParams::REGTEST, {"-testactivationheight=v19@100"}} {}
+};
 
-template<class T>
-void TestTxHelper(const CMutableTransaction& tx, bool is_basic_bls, bool expected_failure, const std::string& expected_error)
+BOOST_FIXTURE_TEST_SUITE(evo_trivialvalidation, TestChain100V19Activation)
+
+template <class T>
+void TestTxHelper(const CMutableTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                  const std::optional<std::string>& expected_error)
 {
-    const bool payload_to_fail = expected_failure && expected_error == "gettxpayload-fail";
+    const bool payload_to_fail = expected_error.has_value() && expected_error.value() == "gettxpayload-fail";
     const auto opt_payload = GetTxPayload<T>(tx, false);
     BOOST_CHECK_EQUAL(opt_payload.has_value(), !payload_to_fail);
 
@@ -27,13 +37,13 @@ void TestTxHelper(const CMutableTransaction& tx, bool is_basic_bls, bool expecte
     if (payload_to_fail) return;
 
     TxValidationState dummy_state;
-    BOOST_CHECK_EQUAL(opt_payload->IsTriviallyValid(is_basic_bls, dummy_state), !expected_failure);
-    if (expected_failure) {
-        BOOST_CHECK_EQUAL(dummy_state.GetRejectReason(), expected_error);
+    BOOST_CHECK_EQUAL(opt_payload->IsTriviallyValid(pindexPrev, dummy_state), !expected_error.has_value());
+    if (expected_error.has_value()) {
+        BOOST_CHECK_EQUAL(dummy_state.GetRejectReason(), expected_error.value());
     }
 }
 
-void trivialvalidation_runner(const std::string& json)
+void trivialvalidation_runner(const CChain& active_chain, const std::string& json)
 {
     const UniValue vectors = read_json(json);
 
@@ -42,21 +52,21 @@ void trivialvalidation_runner(const std::string& json)
         uint256 txHash;
         std::string txType;
         CMutableTransaction tx;
-        std::string expected_err;
+        std::optional<std::string> expected_err;
         try {
             // Additional data
             txHash = uint256S(test[0].get_str());
             BOOST_TEST_MESSAGE("tx: " << test[0].get_str());
             txType = test[1].get_str();
             BOOST_CHECK(test[2].get_str() == "basic" || test[2].get_str() == "legacy");
-            bool is_basic_bls = test[2].get_str() == "basic";
+            // Determine which pindexPrev to supply based on whether we want to validate legacy or basic
+            // TODO: Introduce trivial validation test vectors for extended addresses
+            const CBlockIndex* pindexPrev{(test[2].get_str() == "basic") ? active_chain[100] : active_chain[98]};
+            assert(pindexPrev);
             // Raw transaction
             CDataStream stream(ParseHex(test[3].get_str()), SER_NETWORK, PROTOCOL_VERSION);
             stream >> tx;
-            bool expected = test.size() > 4;
-            if (expected) {
-                expected_err = test[4].get_str();
-            }
+            expected_err = (test.size() > 4) ? std::make_optional(test[4].get_str()) : std::nullopt;
             // Sanity check
             BOOST_CHECK_EQUAL(tx.nVersion, 3);
             BOOST_CHECK_EQUAL(tx.GetHash(), txHash);
@@ -66,25 +76,25 @@ void trivialvalidation_runner(const std::string& json)
             case TRANSACTION_PROVIDER_REGISTER: {
                 BOOST_CHECK_EQUAL(txType, "proregtx");
 
-                TestTxHelper<CProRegTx>(tx, is_basic_bls, expected, expected_err);
+                TestTxHelper<CProRegTx>(tx, pindexPrev, expected_err);
                 break;
             }
             case TRANSACTION_PROVIDER_UPDATE_SERVICE: {
                 BOOST_CHECK_EQUAL(txType, "proupservtx");
 
-                TestTxHelper<CProUpServTx>(tx, is_basic_bls, expected, expected_err);
+                TestTxHelper<CProUpServTx>(tx, pindexPrev, expected_err);
                 break;
             }
             case TRANSACTION_PROVIDER_UPDATE_REGISTRAR: {
                 BOOST_CHECK_EQUAL(txType, "proupregtx");
 
-                TestTxHelper<CProUpRegTx>(tx, is_basic_bls, expected, expected_err);
+                TestTxHelper<CProUpRegTx>(tx, pindexPrev, expected_err);
                 break;
             }
             case TRANSACTION_PROVIDER_UPDATE_REVOKE: {
                 BOOST_CHECK_EQUAL(txType, "prouprevtx");
 
-                TestTxHelper<CProUpRevTx>(tx, is_basic_bls, expected, expected_err);
+                TestTxHelper<CProUpRevTx>(tx, pindexPrev, expected_err);
                 break;
             }
             default:
@@ -97,7 +107,6 @@ void trivialvalidation_runner(const std::string& json)
             continue;
         }
     }
-
 }
 
 BOOST_AUTO_TEST_CASE(trivialvalidation_valid)
@@ -105,10 +114,10 @@ BOOST_AUTO_TEST_CASE(trivialvalidation_valid)
     const std::string json(json_tests::trivially_valid, json_tests::trivially_valid + sizeof(json_tests::trivially_valid));
 
     bls::bls_legacy_scheme.store(true);
-    trivialvalidation_runner(json);
+    trivialvalidation_runner(m_node.chainman->ActiveChain(), json);
 
     bls::bls_legacy_scheme.store(false);
-    trivialvalidation_runner(json);
+    trivialvalidation_runner(m_node.chainman->ActiveChain(), json);
 }
 
 BOOST_AUTO_TEST_CASE(trivialvalidation_invalid)
@@ -116,10 +125,10 @@ BOOST_AUTO_TEST_CASE(trivialvalidation_invalid)
     const std::string json(json_tests::trivially_invalid, json_tests::trivially_invalid + sizeof(json_tests::trivially_invalid));
 
     bls::bls_legacy_scheme.store(true);
-    trivialvalidation_runner(json);
+    trivialvalidation_runner(m_node.chainman->ActiveChain(), json);
 
     bls::bls_legacy_scheme.store(false);
-    trivialvalidation_runner(json);
+    trivialvalidation_runner(m_node.chainman->ActiveChain(), json);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 69cda310bb71..47645de0709d 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -651,7 +651,7 @@ void CTxMemPool::addUncheckedProTx(indexed_transaction_set::iterator& newit, con
         if (!proTx.collateralOutpoint.hash.IsNull()) {
             mapProTxRefs.emplace(tx_hash, proTx.collateralOutpoint.hash);
         }
-        for (const NetInfoEntry& entry : proTx.netInfo.GetEntries()) {
+        for (const NetInfoEntry& entry : proTx.netInfo->GetEntries()) {
             mapProTxAddresses.emplace(entry, tx_hash);
         }
         mapProTxPubKeyIDs.emplace(proTx.keyIDOwner, tx_hash);
@@ -664,7 +664,7 @@ void CTxMemPool::addUncheckedProTx(indexed_transaction_set::iterator& newit, con
     } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SERVICE) {
         auto proTx = *Assert(GetTxPayload<CProUpServTx>(tx));
         mapProTxRefs.emplace(proTx.proTxHash, tx_hash);
-        for (const NetInfoEntry& entry : proTx.netInfo.GetEntries()) {
+        for (const NetInfoEntry& entry : proTx.netInfo->GetEntries()) {
             mapProTxAddresses.emplace(entry, tx_hash);
         }
     } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_REGISTRAR) {
@@ -755,7 +755,7 @@ void CTxMemPool::removeUncheckedProTx(const CTransaction& tx)
         if (!proTx.collateralOutpoint.IsNull()) {
             eraseProTxRef(tx_hash, proTx.collateralOutpoint.hash);
         }
-        for (const NetInfoEntry& entry : proTx.netInfo.GetEntries()) {
+        for (const NetInfoEntry& entry : proTx.netInfo->GetEntries()) {
             mapProTxAddresses.erase(entry);
         }
         mapProTxPubKeyIDs.erase(proTx.keyIDOwner);
@@ -765,7 +765,7 @@ void CTxMemPool::removeUncheckedProTx(const CTransaction& tx)
     } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SERVICE) {
         auto proTx = *Assert(GetTxPayload<CProUpServTx>(tx));
         eraseProTxRef(proTx.proTxHash, tx_hash);
-        for (const NetInfoEntry& entry : proTx.netInfo.GetEntries()) {
+        for (const NetInfoEntry& entry : proTx.netInfo->GetEntries()) {
             mapProTxAddresses.erase(entry);
         }
     } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_REGISTRAR) {
@@ -994,7 +994,7 @@ void CTxMemPool::removeProTxConflicts(const CTransaction &tx)
         }
         auto& proTx = *opt_proTx;
 
-        for (const NetInfoEntry& entry : proTx.netInfo.GetEntries()) {
+        for (const NetInfoEntry& entry : proTx.netInfo->GetEntries()) {
             if (mapProTxAddresses.count(entry)) {
                 uint256 conflictHash = mapProTxAddresses[entry];
                 if (conflictHash != tx_hash && mapTx.count(conflictHash)) {
@@ -1016,7 +1016,7 @@ void CTxMemPool::removeProTxConflicts(const CTransaction &tx)
             return;
         }
 
-        for (const NetInfoEntry& entry : opt_proTx->netInfo.GetEntries()) {
+        for (const NetInfoEntry& entry : opt_proTx->netInfo->GetEntries()) {
             if (mapProTxAddresses.count(entry)) {
                 uint256 conflictHash = mapProTxAddresses[entry];
                 if (conflictHash != tx_hash && mapTx.count(conflictHash)) {
@@ -1354,7 +1354,7 @@ bool CTxMemPool::existsProviderTxConflict(const CTransaction &tx) const {
             return true; // i.e. can't decode payload == conflict
         }
         auto& proTx = *opt_proTx;
-        for (const NetInfoEntry& entry : proTx.netInfo.GetEntries()) {
+        for (const NetInfoEntry& entry : proTx.netInfo->GetEntries()) {
             if (mapProTxAddresses.count(entry)) {
                 return true;
             }
@@ -1379,7 +1379,7 @@ bool CTxMemPool::existsProviderTxConflict(const CTransaction &tx) const {
             LogPrint(BCLog::MEMPOOL, "%s: ERROR: Invalid transaction payload, tx: %s\n", __func__, tx_hash.ToString());
             return true; // i.e. can't decode payload == conflict
         }
-        for (const NetInfoEntry& entry : opt_proTx->netInfo.GetEntries()) {
+        for (const NetInfoEntry& entry : opt_proTx->netInfo->GetEntries()) {
             auto it = mapProTxAddresses.find(entry);
             if (it != mapProTxAddresses.end() && it->second != opt_proTx->proTxHash) {
                 return true;
diff --git a/src/util/pointer.h b/src/util/pointer.h
new file mode 100644
index 000000000000..71ec60e0217b
--- /dev/null
+++ b/src/util/pointer.h
@@ -0,0 +1,38 @@
+// Copyright (c) 2025 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_UTIL_POINTER_H
+#define BITCOIN_UTIL_POINTER_H
+
+#include <memory>
+
+namespace util {
+/* Deep equality comparison helper for std::shared_ptr<T> */
+template <typename T>
+bool shared_ptr_equal(const std::shared_ptr<T>& lhs, const std::shared_ptr<T>& rhs)
+    requires requires { *lhs == *rhs; }
+{
+    /* Same object or both blank */
+    if (lhs == rhs) return true;
+    /* Inequal initialization state */
+    if (!lhs || !rhs) return false;
+    /* Deep comparison */
+    return *lhs == *rhs;
+}
+
+/* Deep inequality comparison helper for std::shared_ptr<T> */
+template <typename T>
+bool shared_ptr_not_equal(const std::shared_ptr<T>& lhs, const std::shared_ptr<T>& rhs)
+    requires requires { *lhs != *rhs; }
+{
+    /* Same object or both blank */
+    if (lhs == rhs) return false;
+    /* Inequal initialization state */
+    if (!lhs || !rhs) return true;
+    /* Deep comparison */
+    return *lhs != *rhs;
+}
+} // namespace util
+
+#endif // BITCOIN_UTIL_POINTER_H
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index a1d7ef640e33..145dd7095031 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -46,6 +46,7 @@
     "evo/deterministicmns -> llmq/utils -> net -> evo/deterministicmns",
     "evo/deterministicmns -> validationinterface -> evo/deterministicmns",
     "evo/deterministicmns -> validationinterface -> governance/vote -> evo/deterministicmns",
+    "evo/netinfo -> evo/providertx -> evo/netinfo",
     "evo/simplifiedmns -> llmq/blockprocessor -> llmq/utils -> llmq/snapshot -> evo/simplifiedmns",
     "evo/specialtxman -> validation -> evo/specialtxman",
     "governance/governance -> governance/object -> governance/governance",
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 023444a0e690..a12d04314384 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -42,6 +42,7 @@ src/unordered_lru_cache.h
 src/util/edge.*
 src/util/enumerate.h
 src/util/irange.h
+src/util/pointer.h
 src/util/ranges.h
 src/util/ranges_set.*
 src/util/wpipe.*