diff --git a/contrib/devtools/circular-dependencies.py b/contrib/devtools/circular-dependencies.py
index a6cdc343d5cb..6cbbdb189eea 100755
--- a/contrib/devtools/circular-dependencies.py
+++ b/contrib/devtools/circular-dependencies.py
@@ -11,6 +11,10 @@
 MAPPING = {
     'core_read.cpp': 'core_io.cpp',
     'core_write.cpp': 'core_io.cpp',
+    'evo/core_write.cpp': 'core_io.cpp',
+    'evo/providertx_util.cpp': 'evo/providertx.cpp',
+    'llmq/core_write.cpp': 'core_io.cpp',
+    'qt/guiutil_font.cpp': 'qt/guiutil.cpp',
 }
 
 # Directories with header-based modules, where the assumption that .cpp files
diff --git a/src/Makefile.am b/src/Makefile.am
index 0cf8ce802fdb..3150de83e809 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -372,7 +372,7 @@ BITCOIN_CORE_H = \
   rest.h \
   rpc/blockchain.h \
   rpc/client.h \
-  rpc/evo_util.h \
+  rpc/json_help.h \
   rpc/mempool.h \
   rpc/mining.h \
   rpc/protocol.h \
@@ -638,6 +638,7 @@ libbitcoin_node_a_SOURCES = \
   rpc/evo.cpp \
   rpc/fees.cpp \
   rpc/governance.cpp \
+  rpc/json_help.cpp \
   rpc/masternode.cpp \
   rpc/mempool.cpp \
   rpc/mining.cpp \
@@ -969,7 +970,6 @@ libbitcoin_common_a_SOURCES = \
   evo/providertx_util.cpp \
   external_signer.cpp \
   governance/common.cpp \
-  governance/core_write.cpp \
   init/common.cpp \
   key.cpp \
   key_io.cpp \
@@ -984,7 +984,6 @@ libbitcoin_common_a_SOURCES = \
   policy/policy.cpp \
   protocol.cpp \
   psbt.cpp \
-  rpc/evo_util.cpp \
   rpc/external_signer.cpp \
   rpc/rawtransaction_util.cpp \
   rpc/request.cpp \
diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index de82104b8910..47a80c4c5be6 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -8,7 +8,6 @@
 #include <evo/deterministicmns.h>
 #include <masternode/meta.h>
 #include <masternode/sync.h>
-#include <rpc/evo_util.h>
 #include <util/helpers.h>
 #include <wallet/coinjoin.h>
 
diff --git a/src/core_io.h b/src/core_io.h
index 85deffd5c2fd..6785fab15a15 100644
--- a/src/core_io.h
+++ b/src/core_io.h
@@ -7,6 +7,7 @@
 
 #include <consensus/amount.h>
 
+#include <cstdint>
 #include <string>
 #include <vector>
 
@@ -18,7 +19,7 @@ class CTxUndo;
 class uint256;
 struct CMutableTransaction;
 struct CSpentIndexTxInfo;
-struct RPCResult;
+enum class MnType : uint16_t;
 
 class UniValue;
 
@@ -58,6 +59,11 @@ void ScriptToUniv(const CScript& script, UniValue& out, bool include_hex = true,
 void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry, bool include_hex = true, int serialize_flags = 0, const CTxUndo* txundo = nullptr, TxVerbosity verbosity = TxVerbosity::SHOW_DETAILS, const CSpentIndexTxInfo* ptxSpentInfo = nullptr);
 
 // evo/core_write.cpp
-RPCResult GetRpcResult(const std::string& key, bool optional = false, const std::string& override_name = "");
+/** Reads network info reporting and appends data from legacy fields if applicable */
+template <typename Obj>
+UniValue GetNetInfoWithLegacyFields(const Obj& obj, const MnType& type);
+/** Returns platform port based on purpose and network info version */
+template <bool is_p2p, typename Obj>
+int32_t GetPlatformPort(const Obj& obj);
 
 #endif // BITCOIN_CORE_IO_H
diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index 0aaafa6e545b..4ebe78675f2d 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -4,7 +4,7 @@
 
 #include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
-#include <evo/deterministicmns.h>
+#include <evo/dmn_types.h>
 #include <evo/dmnstate.h>
 #include <evo/mnhftx.h>
 #include <evo/netinfo.h>
@@ -12,80 +12,21 @@
 #include <evo/simplifiedmns.h>
 #include <evo/smldiff.h>
 #include <llmq/commitment.h>
-#include <rpc/evo_util.h>
 #include <util/std23.h>
 
 #include <core_io.h>
 #include <key_io.h>
-#include <rpc/util.h>
+#include <netaddress.h>
 #include <script/standard.h>
 #include <util/check.h>
 
 #include <univalue.h>
 
-#include <map>
+#include <cstdint>
 #include <string>
+#include <type_traits>
 
 namespace {
-#define RESULT_MAP_ENTRY(name, type, desc) {name, {type, name, desc}}
-const std::map<std::string, RPCResult> RPCRESULT_MAP{{
-    {"addresses",
-        {RPCResult::Type::OBJ, "addresses", "Network addresses of the masternode",
-    {
-        {RPCResult::Type::ARR, "core_p2p", /*optional=*/true, "Addresses used for protocol P2P",
-            {{RPCResult::Type::STR, "address", ""}}},
-        {RPCResult::Type::ARR, "platform_p2p", /*optional=*/true, "Addresses used for Platform P2P",
-            {{RPCResult::Type::STR, "address", ""}}},
-        {RPCResult::Type::ARR, "platform_https", /*optional=*/true, "Addresses used for Platform HTTPS API",
-            {{RPCResult::Type::STR, "address", ""}}},
-    }}},
-    RESULT_MAP_ENTRY("collateralAddress", RPCResult::Type::STR, "Dash address used for collateral"),
-    RESULT_MAP_ENTRY("collateralHash", RPCResult::Type::STR_HEX, "Collateral transaction hash"),
-    RESULT_MAP_ENTRY("collateralIndex", RPCResult::Type::NUM, "Collateral transaction output index"),
-    RESULT_MAP_ENTRY("consecutivePayments", RPCResult::Type::NUM, "Consecutive payments masternode has received in payment cycle"),
-    RESULT_MAP_ENTRY("height", RPCResult::Type::NUM, "Block height"),
-    RESULT_MAP_ENTRY("inputsHash", RPCResult::Type::STR_HEX, "Hash of all the outpoints of the transaction inputs"),
-    RESULT_MAP_ENTRY("lastPaidHeight", RPCResult::Type::NUM, "Height masternode was last paid"),
-    RESULT_MAP_ENTRY("llmqType", RPCResult::Type::NUM, "Quorum type"),
-    RESULT_MAP_ENTRY("memberIndex", RPCResult::Type::NUM, "Quorum member index"),
-    RESULT_MAP_ENTRY("merkleRootMNList", RPCResult::Type::STR_HEX, "Merkle root of the masternode list"),
-    RESULT_MAP_ENTRY("merkleRootQuorums", RPCResult::Type::STR_HEX, "Merkle root of the quorum list"),
-    RESULT_MAP_ENTRY("operatorPayoutAddress", RPCResult::Type::STR, "Dash address used for operator reward payments"),
-    RESULT_MAP_ENTRY("operatorReward", RPCResult::Type::NUM, "Fraction in %% of reward shared with the operator between 0 and 10000"),
-    RESULT_MAP_ENTRY("outpoint", RPCResult::Type::STR_HEX,"The outpoint of the masternode"),
-    RESULT_MAP_ENTRY("ownerAddress", RPCResult::Type::STR, "Dash address used for payee updates and proposal voting"),
-    RESULT_MAP_ENTRY("payoutAddress", RPCResult::Type::STR, "Dash address used for masternode reward payments"),
-    {"payouts",
-        {RPCResult::Type::ARR, "payouts", "Owner masternode reward payout shares",
-    {
-        {RPCResult::Type::OBJ, "", "",
-        {
-            {RPCResult::Type::STR, "address", "Dash address used for this owner payout"},
-            {RPCResult::Type::STR_HEX, "script", "Owner payout scriptPubKey"},
-            {RPCResult::Type::NUM, "reward", "Owner payout share in basis points"},
-        }},
-    }}},
-    RESULT_MAP_ENTRY("platformHTTPPort", RPCResult::Type::NUM, "TCP port of Platform HTTP API (DEPRECATED, returned only if config option -deprecatedrpc=service is passed)"),
-    RESULT_MAP_ENTRY("platformNodeID", RPCResult::Type::STR_HEX, "Node ID derived from P2P public key for Platform P2P"),
-    RESULT_MAP_ENTRY("platformP2PPort", RPCResult::Type::NUM, "TCP port of Platform P2P (DEPRECATED, returned only if config option -deprecatedrpc=service is passed)"),
-    RESULT_MAP_ENTRY("PoSeBanHeight", RPCResult::Type::NUM, "Height masternode was banned for Proof of Service violations"),
-    RESULT_MAP_ENTRY("PoSePenalty", RPCResult::Type::NUM, "Proof of Service penalty score"),
-    RESULT_MAP_ENTRY("PoSeRevivedHeight", RPCResult::Type::NUM, "Height masternode recovered from Proof of Service violations"),
-    RESULT_MAP_ENTRY("proTxHash", RPCResult::Type::STR_HEX, "Hash of the masternode's initial ProRegTx"),
-    RESULT_MAP_ENTRY("pubKeyOperator", RPCResult::Type::STR, "BLS public key used for operator signing"),
-    RESULT_MAP_ENTRY("quorumIndex", RPCResult::Type::NUM, "Quorum index. Relevant for rotation quorums only, 0 for non-rotating quorums"),
-    RESULT_MAP_ENTRY("quorumHash", RPCResult::Type::STR_HEX, "Hash of the quorum"),
-    RESULT_MAP_ENTRY("quorumSig", RPCResult::Type::STR_HEX, "BLS recovered threshold signature of quorum"),
-    RESULT_MAP_ENTRY("registeredHeight", RPCResult::Type::NUM, "Height masternode was registered"),
-    RESULT_MAP_ENTRY("revocationReason", RPCResult::Type::NUM, "Reason for ProUpRegTx revocation"),
-    RESULT_MAP_ENTRY("service", RPCResult::Type::STR, "IP address and port of the masternode (DEPRECATED, returned only if config option -deprecatedrpc=service is passed)"),
-    RESULT_MAP_ENTRY("type", RPCResult::Type::NUM, "Masternode type"),
-    RESULT_MAP_ENTRY("type_str", RPCResult::Type::STR, "Masternode type (human-readable string)"),
-    RESULT_MAP_ENTRY("version", RPCResult::Type::NUM, "Special transaction version"),
-    RESULT_MAP_ENTRY("votingAddress", RPCResult::Type::STR, "Dash address used for voting"),
-}};
-#undef RESULT_MAP_ENTRY
-
 template <typename Obj>
 std::string GetDeprecatedServiceField(const Obj& obj)
 {
@@ -93,34 +34,65 @@ std::string GetDeprecatedServiceField(const Obj& obj)
 }
 } // anonymous namespace
 
-RPCResult GetRpcResult(const std::string& key, bool optional, const std::string& override_name)
+template <typename Obj>
+UniValue GetNetInfoWithLegacyFields(const Obj& obj, const MnType& type)
 {
-    if (const auto it = RPCRESULT_MAP.find(key); it != RPCRESULT_MAP.end()) {
-        const auto& ret{it->second};
-        return RPCResult{ret.m_type, override_name.empty() ? ret.m_key_name : override_name, optional, ret.m_description, ret.m_inner};
+    UniValue ret{CHECK_NONFATAL(obj.netInfo)->ToJson()};
+
+    // Nothing to do here if not EvoNode, netInfo is empty or netInfo is capable of natively
+    // storing Platform fields
+    if (type != MnType::Evo || obj.netInfo->IsEmpty() || obj.netInfo->CanStorePlatform()) return ret;
+
+    CNetAddr addr{obj.netInfo->GetPrimary()};
+    ret.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_HTTPS).data(),
+               ArrFromService(CService(addr, obj.platformHTTPPort)));
+
+    if constexpr (!std::is_same_v<std::decay_t<Obj>, CSimplifiedMNListEntry>) {
+        // CSimplifiedMNListEntry doesn't store platformP2PPort
+        ret.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_P2P).data(),
+                   ArrFromService(CService(addr, obj.platformP2PPort)));
     }
-    throw NonFatalCheckError(strprintf("Requested invalid RPCResult for nonexistent key \"%s\"", key).c_str(),
-                             __FILE__, __LINE__, __func__);
+
+    return ret;
 }
+template UniValue GetNetInfoWithLegacyFields(const CDeterministicMNState& obj, const MnType& type);
 
-RPCResult CAssetLockPayload::GetJsonHelp(const std::string& key, bool optional)
+template <bool is_p2p, typename Obj>
+int32_t GetPlatformPort(const Obj& obj)
 {
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The asset lock special transaction",
-    {
-        GetRpcResult("version"),
-        {RPCResult::Type::ARR, "creditOutputs", "", {
-            {RPCResult::Type::OBJ, "", "", {
-                {RPCResult::Type::NUM, "value", "The value in Dash"},
-                {RPCResult::Type::NUM, "valueSat", "The value in duffs"},
-                {RPCResult::Type::OBJ, "scriptPubKey", "", {
-                    {RPCResult::Type::STR, "asm", "The asm"},
-                    {RPCResult::Type::STR_HEX, "hex", "The hex"},
-                    {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"},
-                }},
-                {RPCResult::Type::STR, "address", /*optional=*/true, "DIP-18 Platform address (version >= 2 only)"},
-        }}}}
-    }};
+    // Currently, there is nothing that prevents PLATFORM_{HTTPS,P2P} to be registered to
+    // an addr *different* from the primary addr for CORE_P2P. This breaks the assumptions
+    // under which platform{HTTP,P2P}Port operate under (i.e. all three are hosted with the
+    // same addr).
+    //
+    // TODO: Introduce restrictions that enforce this assumption *until* we remove legacy
+    //       fields for good.
+    //
+    bool is_legacy{!(CHECK_NONFATAL(obj.netInfo)->CanStorePlatform())};
+    if constexpr (is_p2p) {
+        static_assert(!std::is_same_v<std::decay_t<Obj>, CSimplifiedMNListEntry>,
+                      "CSimplifiedMNListEntry doesn't have platformP2PPort");
+        if (is_legacy) {
+            return obj.platformP2PPort;
+        }
+        if (obj.netInfo->IsEmpty()) {
+            return -1; // Blank entry, nothing to report
+        }
+        CHECK_NONFATAL(obj.netInfo->HasEntries(NetInfoPurpose::PLATFORM_P2P));
+        return obj.netInfo->GetEntries(NetInfoPurpose::PLATFORM_P2P)[0].GetPort();
+    } else {
+        if (is_legacy) {
+            return obj.platformHTTPPort;
+        }
+        if (obj.netInfo->IsEmpty()) {
+            return -1; // Blank entry, nothing to report
+        }
+        CHECK_NONFATAL(obj.netInfo->HasEntries(NetInfoPurpose::PLATFORM_HTTPS));
+        return obj.netInfo->GetEntries(NetInfoPurpose::PLATFORM_HTTPS)[0].GetPort();
+    }
 }
+template int32_t GetPlatformPort<true>(const CDeterministicMNState& obj);
+template int32_t GetPlatformPort<false>(const CDeterministicMNState& obj);
 
 UniValue CAssetLockPayload::ToJson() const
 {
@@ -147,19 +119,6 @@ UniValue CAssetLockPayload::ToJson() const
     return ret;
 }
 
-RPCResult CAssetUnlockPayload::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The asset unlock special transaction",
-    {
-        GetRpcResult("version"),
-        {RPCResult::Type::NUM, "index", "Index of the transaction"},
-        {RPCResult::Type::NUM, "fee", "Transaction fee in duffs awarded to the miner"},
-        {RPCResult::Type::NUM, "requestedHeight", "Payment chain block height known by Platform when signing the withdrawal"},
-        GetRpcResult("quorumHash"),
-        GetRpcResult("quorumSig"),
-    }};
-}
-
 UniValue CAssetUnlockPayload::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
@@ -172,20 +131,6 @@ UniValue CAssetUnlockPayload::ToJson() const
     return ret;
 }
 
-RPCResult CCbTx::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The coinbase special transaction",
-    {
-        GetRpcResult("version"),
-        GetRpcResult("height"),
-        GetRpcResult("merkleRootMNList"),
-        GetRpcResult("merkleRootQuorums", /*optional=*/true),
-        {RPCResult::Type::NUM, "bestCLHeightDiff", /*optional=*/true, "Blocks between the current block and the last known block with a ChainLock"},
-        {RPCResult::Type::STR_HEX, "bestCLSignature", /*optional=*/true, "Best ChainLock signature known by the miner"},
-        {RPCResult::Type::NUM, "creditPoolBalance", /*optional=*/true, "Balance in the Platform credit pool"},
-    }};
-}
-
 UniValue CCbTx::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
@@ -203,47 +148,6 @@ UniValue CCbTx::ToJson() const
     return ret;
 }
 
-// CDeterministicMN::ToJson() defined in evo/deterministicmns.cpp
-RPCResult CDeterministicMN::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode's details",
-    {
-        GetRpcResult("type_str", /*optional=*/false, /*override_name=*/"type"),
-        GetRpcResult("proTxHash"),
-        GetRpcResult("collateralHash"),
-        GetRpcResult("collateralIndex"),
-        GetRpcResult("collateralAddress", /*optional=*/true),
-        GetRpcResult("operatorReward"),
-        CDeterministicMNState::GetJsonHelp(/*key=*/"state", /*optional=*/false),
-    }};
-}
-
-RPCResult CDeterministicMNState::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode state",
-    {
-        {RPCResult::Type::NUM, "version", "Version of the masternode state"},
-        GetRpcResult("service", /*optional=*/true),
-        GetRpcResult("addresses"),
-        GetRpcResult("registeredHeight"),
-        GetRpcResult("lastPaidHeight"),
-        GetRpcResult("consecutivePayments"),
-        GetRpcResult("PoSePenalty"),
-        GetRpcResult("PoSeRevivedHeight"),
-        GetRpcResult("PoSeBanHeight"),
-        GetRpcResult("revocationReason"),
-        GetRpcResult("ownerAddress"),
-        GetRpcResult("votingAddress"),
-        GetRpcResult("platformNodeID", /*optional=*/true),
-        GetRpcResult("platformP2PPort", /*optional=*/true),
-        GetRpcResult("platformHTTPPort", /*optional=*/true),
-        GetRpcResult("payoutAddress", /*optional=*/true),
-        GetRpcResult("payouts", /*optional=*/true),
-        GetRpcResult("pubKeyOperator"),
-        GetRpcResult("operatorPayoutAddress", /*optional=*/true),
-    }};
-}
-
 UniValue CDeterministicMNState::ToJson(MnType nType) const
 {
     UniValue obj(UniValue::VOBJ);
@@ -282,57 +186,6 @@ UniValue CDeterministicMNState::ToJson(MnType nType) const
     return obj;
 }
 
-// CDeterministicMNStateDiff::ToJson() defined in evo/dmnstate.cpp
-RPCResult CDeterministicMNStateDiff::GetJsonHelp(const std::string& key, bool optional)
-{
-    // Every field is emitted only when the diff actually carries it, version included.
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode state diff",
-    {
-        {RPCResult::Type::NUM, "version", /*optional=*/true, "Version of the masternode state diff"},
-        GetRpcResult("service", /*optional=*/true),
-        GetRpcResult("registeredHeight", /*optional=*/true),
-        GetRpcResult("lastPaidHeight", /*optional=*/true),
-        GetRpcResult("consecutivePayments", /*optional=*/true),
-        GetRpcResult("PoSePenalty", /*optional=*/true),
-        GetRpcResult("PoSeRevivedHeight", /*optional=*/true),
-        GetRpcResult("PoSeBanHeight", /*optional=*/true),
-        GetRpcResult("revocationReason", /*optional=*/true),
-        GetRpcResult("ownerAddress", /*optional=*/true),
-        GetRpcResult("votingAddress", /*optional=*/true),
-        GetRpcResult("payoutAddress", /*optional=*/true),
-        GetRpcResult("payouts", /*optional=*/true),
-        GetRpcResult("operatorPayoutAddress", /*optional=*/true),
-        GetRpcResult("pubKeyOperator", /*optional=*/true),
-        GetRpcResult("platformNodeID", /*optional=*/true),
-        GetRpcResult("platformP2PPort", /*optional=*/true),
-        GetRpcResult("platformHTTPPort", /*optional=*/true),
-        GetRpcResult("addresses", /*optional=*/true),
-    }};
-}
-
-RPCResult CProRegTx::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode registration special transaction",
-    {
-        GetRpcResult("version"),
-        GetRpcResult("type"),
-        GetRpcResult("collateralHash"),
-        GetRpcResult("collateralIndex"),
-        GetRpcResult("service", /*optional=*/true),
-        GetRpcResult("addresses"),
-        GetRpcResult("ownerAddress"),
-        GetRpcResult("votingAddress"),
-        GetRpcResult("payoutAddress", /*optional=*/true),
-        GetRpcResult("payouts", /*optional=*/true),
-        GetRpcResult("pubKeyOperator"),
-        GetRpcResult("operatorReward"),
-        GetRpcResult("platformNodeID", /*optional=*/true),
-        GetRpcResult("platformP2PPort", /*optional=*/true),
-        GetRpcResult("platformHTTPPort", /*optional=*/true),
-        GetRpcResult("inputsHash"),
-    }};
-}
-
 UniValue CProRegTx::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
@@ -364,20 +217,6 @@ UniValue CProRegTx::ToJson() const
     return ret;
 }
 
-RPCResult CProUpRegTx::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode update registrar special transaction",
-    {
-        GetRpcResult("version"),
-        GetRpcResult("proTxHash"),
-        GetRpcResult("votingAddress"),
-        GetRpcResult("payoutAddress", /*optional=*/true),
-        GetRpcResult("payouts", /*optional=*/true),
-        GetRpcResult("pubKeyOperator"),
-        GetRpcResult("inputsHash"),
-    }};
-}
-
 UniValue CProUpRegTx::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
@@ -394,17 +233,6 @@ UniValue CProUpRegTx::ToJson() const
     return ret;
 }
 
-RPCResult CProUpRevTx::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode operator revocation special transaction",
-    {
-        GetRpcResult("version"),
-        GetRpcResult("proTxHash"),
-        {RPCResult::Type::NUM, "reason", "Reason for masternode service revocation"},
-        GetRpcResult("inputsHash", /*optional=*/true),
-    }};
-}
-
 UniValue CProUpRevTx::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
@@ -415,23 +243,6 @@ UniValue CProUpRevTx::ToJson() const
     return ret;
 }
 
-RPCResult CProUpServTx::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode update service special transaction",
-    {
-        GetRpcResult("version"),
-        GetRpcResult("type"),
-        GetRpcResult("proTxHash"),
-        GetRpcResult("service", /*optional=*/true),
-        GetRpcResult("addresses"),
-        GetRpcResult("operatorPayoutAddress", /*optional=*/true),
-        GetRpcResult("platformNodeID", /*optional=*/true),
-        GetRpcResult("platformP2PPort", /*optional=*/true),
-        GetRpcResult("platformHTTPPort", /*optional=*/true),
-        GetRpcResult("inputsHash"),
-    }};
-}
-
 UniValue CProUpServTx::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
@@ -456,36 +267,6 @@ UniValue CProUpServTx::ToJson() const
     return ret;
 }
 
-RPCResult CSimplifiedMNListDiff::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The simplified masternode list diff",
-    {
-        {RPCResult::Type::NUM, "nVersion", "Version of the diff"},
-        {RPCResult::Type::STR_HEX, "baseBlockHash", "Hash of the base block"},
-        {RPCResult::Type::STR_HEX, "blockHash", "Hash of the ending block"},
-        {RPCResult::Type::STR_HEX, "cbTxMerkleTree", "Coinbase transaction merkle tree"},
-        {RPCResult::Type::STR_HEX, "cbTx", "Coinbase raw transaction"},
-        {RPCResult::Type::ARR, "deletedMNs", "ProRegTx hashes of deleted masternodes",
-            {{RPCResult::Type::STR_HEX, "hash", ""}}},
-        {RPCResult::Type::ARR, "mnList", "Masternode list details",
-            {CSimplifiedMNListEntry::GetJsonHelp(/*key=*/"", /*optional=*/false)}},
-        {RPCResult::Type::ARR, "deletedQuorums", "Deleted quorums",
-            {{RPCResult::Type::OBJ, "", "", {
-                GetRpcResult("llmqType"),
-                GetRpcResult("quorumHash"),
-        }}}},
-        {RPCResult::Type::ARR, "newQuorums", "New quorums",
-            {llmq::CFinalCommitment::GetJsonHelp(/*key=*/"", /*optional=*/false)}},
-        GetRpcResult("merkleRootMNList", /*optional=*/true),
-        GetRpcResult("merkleRootQuorums", /*optional=*/true),
-        {RPCResult::Type::ARR, "quorumsCLSigs", "ChainLock signature details", {
-            {RPCResult::Type::OBJ_DYN, "", "json object with the BLS signature as key", {
-                {RPCResult::Type::ARR, "<sig_hex>", "Array of quorum indices signed by this BLS signature", {
-                    {RPCResult::Type::NUM, "", "Quorum index"}
-        }}}}}},
-    }};
-}
-
 UniValue CSimplifiedMNListDiff::ToJson(bool extended) const
 {
     UniValue obj(UniValue::VOBJ);
@@ -549,27 +330,6 @@ UniValue CSimplifiedMNListDiff::ToJson(bool extended) const
     return obj;
 }
 
-RPCResult CSimplifiedMNListEntry::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The simplified masternode list entry",
-    {
-        {RPCResult::Type::NUM, "nVersion", "Version of the entry"},
-        GetRpcResult("type", /*optional=*/false, /*override_name=*/"nType"),
-        {RPCResult::Type::STR_HEX, "proRegTxHash", "Hash of the ProRegTx identifying the masternode"},
-        {RPCResult::Type::STR_HEX, "confirmedHash", "Hash of the block where the masternode was confirmed"},
-        GetRpcResult("service", /*optional=*/true),
-        GetRpcResult("addresses"),
-        GetRpcResult("pubKeyOperator"),
-        GetRpcResult("votingAddress"),
-        {RPCResult::Type::BOOL, "isValid", "Returns true if the masternode is not Proof-of-Service banned"},
-        GetRpcResult("platformHTTPPort", /*optional=*/true),
-        GetRpcResult("platformNodeID", /*optional=*/true),
-        GetRpcResult("payoutAddress", /*optional=*/true),
-        GetRpcResult("payouts", /*optional=*/true),
-        GetRpcResult("operatorPayoutAddress", /*optional=*/true),
-    }};
-}
-
 UniValue CSimplifiedMNListEntry::ToJson(bool extended) const
 {
     UniValue obj(UniValue::VOBJ);
@@ -605,16 +365,6 @@ UniValue CSimplifiedMNListEntry::ToJson(bool extended) const
     return obj;
 }
 
-RPCResult MNHFTx::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode hard fork payload",
-    {
-        {RPCResult::Type::NUM, "versionBit", "Version bit associated with the hard fork"},
-        GetRpcResult("quorumHash"),
-        {RPCResult::Type::STR_HEX, "sig", "BLS signature by a quorum public key"},
-    }};
-}
-
 UniValue MNHFTx::ToJson() const
 {
     UniValue obj(UniValue::VOBJ);
@@ -624,15 +374,6 @@ UniValue MNHFTx::ToJson() const
     return obj;
 }
 
-RPCResult MNHFTxPayload::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode hard fork signal special transaction",
-    {
-        GetRpcResult("version"),
-        MNHFTx::GetJsonHelp(/*key=*/"signal", /*optional=*/false),
-    }};
-}
-
 UniValue MNHFTxPayload::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
diff --git a/src/evo/dmnstate.h b/src/evo/dmnstate.h
index 5d92dd899fdf..4e521a58a434 100644
--- a/src/evo/dmnstate.h
+++ b/src/evo/dmnstate.h
@@ -7,7 +7,9 @@
 
 #include <bls/bls.h>
 #include <crypto/sha256.h>
+#include <evo/netinfo.h>
 #include <evo/providertx.h>
+#include <evo/types.h>
 #include <netaddress.h>
 #include <pubkey.h>
 #include <script/script.h>
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index 0b6716af89b7..3e23af1fdcc4 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -48,7 +48,10 @@ using MasternodePayoutShares = std::vector<MasternodePayoutShare>;
 
 [[nodiscard]] MasternodePayoutShares LegacyPayoutAsList(const CScript& script_payout);
 template<class T>
-[[nodiscard]] MasternodePayoutShares GetOwnerPayouts(const T& protx);
+[[nodiscard]] MasternodePayoutShares GetOwnerPayouts(const T& protx)
+{
+    return protx.nVersion >= ProTxVersion::ExtAddr ? protx.payouts : LegacyPayoutAsList(protx.scriptPayout);
+}
 
 [[nodiscard]] bool IsPayoutListTriviallyValid(const MasternodePayoutShares& payouts, const CKeyID& keyIDOwner,
                                               const CKeyID& keyIDVoting, TxValidationState& state);
diff --git a/src/evo/providertx_util.cpp b/src/evo/providertx_util.cpp
index 478799ba1da7..c94ce53ac7cb 100644
--- a/src/evo/providertx_util.cpp
+++ b/src/evo/providertx_util.cpp
@@ -3,7 +3,6 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <evo/providertx.h>
-#include <evo/dmnstate.h>
 
 #include <key_io.h>
 #include <script/standard.h>
@@ -21,16 +20,6 @@ MasternodePayoutShares LegacyPayoutAsList(const CScript& script_payout)
     return {{script_payout, MasternodePayoutShare::MAX_REWARD}};
 }
 
-template<class T>
-MasternodePayoutShares GetOwnerPayouts(const T& protx)
-{
-    return protx.nVersion >= ProTxVersion::ExtAddr ? protx.payouts : LegacyPayoutAsList(protx.scriptPayout);
-}
-
-template MasternodePayoutShares GetOwnerPayouts(const CProRegTx& protx);
-template MasternodePayoutShares GetOwnerPayouts(const CProUpRegTx& protx);
-template MasternodePayoutShares GetOwnerPayouts(const CDeterministicMNState& protx);
-
 std::string PayoutListToString(const MasternodePayoutShares& payouts)
 {
     std::string ret;
diff --git a/src/evo/smldiff.cpp b/src/evo/smldiff.cpp
index f48467719c62..2fbf0fe2e821 100644
--- a/src/evo/smldiff.cpp
+++ b/src/evo/smldiff.cpp
@@ -13,7 +13,6 @@
 
 #include <chainparams.h>
 #include <consensus/merkle.h>
-#include <core_io.h>
 #include <deploymentstatus.h>
 #include <node/blockstorage.h>
 #include <serialize.h>
diff --git a/src/governance/common.cpp b/src/governance/common.cpp
index 7a9274540e10..063b4aba33c1 100644
--- a/src/governance/common.cpp
+++ b/src/governance/common.cpp
@@ -47,4 +47,23 @@ std::string Object::GetDataAsPlainString() const
 {
     return std::string(vchData.begin(), vchData.end());
 }
+
+UniValue Object::ToJson() const
+{
+    UniValue obj(UniValue::VOBJ);
+    obj.pushKV("objectHash", GetHash().ToString());
+    obj.pushKV("parentHash", hashParent.ToString());
+    obj.pushKV("collateralHash", collateralHash.ToString());
+    obj.pushKV("createdAt", time);
+    obj.pushKV("revision", revision);
+    UniValue data;
+    if (!data.read(GetDataAsPlainString())) {
+        data.clear();
+        data.setObject();
+        data.pushKV("plain", GetDataAsPlainString());
+    }
+    data.pushKV("hex", GetDataAsHexString());
+    obj.pushKV("data", data);
+    return obj;
+}
 } // namespace Governance
diff --git a/src/governance/core_write.cpp b/src/governance/core_write.cpp
deleted file mode 100644
index 9f634ba76639..000000000000
--- a/src/governance/core_write.cpp
+++ /dev/null
@@ -1,160 +0,0 @@
-// 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.
-
-#include <core_io.h>
-#include <governance/common.h>
-#include <governance/governance.h>
-#include <governance/object.h>
-#include <rpc/util.h>
-#include <tinyformat.h>
-#include <util/check.h>
-
-#include <univalue.h>
-
-RPCResult CGovernanceManager::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "Count of governance objects and votes",
-    {
-        {RPCResult::Type::NUM, "objects_total", "Total number of all governance objects"},
-        {RPCResult::Type::NUM, "proposals", "Number of governance proposals"},
-        {RPCResult::Type::NUM, "triggers", "Number of triggers"},
-        {RPCResult::Type::NUM, "other", "Total number of unknown governance objects"},
-        {RPCResult::Type::NUM, "erased", "Number of removed (expired) objects"},
-        {RPCResult::Type::NUM, "votes", "Total number of votes"},
-    }};
-}
-
-UniValue CGovernanceManager::ToJson() const
-{
-    LOCK(cs_store);
-
-    int nProposalCount = 0;
-    int nTriggerCount = 0;
-    int nOtherCount = 0;
-
-    for (const auto& [_, govobj] : mapObjects) {
-        switch (Assert(govobj)->GetObjectType()) {
-        case GovernanceObject::PROPOSAL:
-            nProposalCount++;
-            break;
-        case GovernanceObject::TRIGGER:
-            nTriggerCount++;
-            break;
-        default:
-            nOtherCount++;
-            break;
-        }
-    }
-
-    UniValue jsonObj(UniValue::VOBJ);
-    jsonObj.pushKV("objects_total", mapObjects.size());
-    jsonObj.pushKV("proposals", nProposalCount);
-    jsonObj.pushKV("triggers", nTriggerCount);
-    jsonObj.pushKV("other", nOtherCount);
-    jsonObj.pushKV("erased", mapErasedGovernanceObjects.size());
-    jsonObj.pushKV("votes", cmapVoteToObject.GetSize());
-    return jsonObj;
-}
-
-RPCResult CGovernanceObject::GetInnerJsonHelp(const std::string& key, bool optional)
-{
-    return Governance::Object::GetJsonHelp(key, optional);
-}
-
-UniValue CGovernanceObject::GetInnerJson() const
-{
-    return m_obj.ToJson();
-}
-
-// CGovernanceObject::GetStateJson() defined in governance/object.cpp
-RPCResult CGovernanceObject::GetStateJsonHelp(const std::string& key, bool optional, const std::string& local_valid_key)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "Object state info",
-    {
-        {RPCResult::Type::STR_HEX, "DataHex", "Governance object (hex)"},
-        {RPCResult::Type::STR, "DataString", "Governance object (string)"},
-        {RPCResult::Type::STR_HEX, "Hash", "Hash of governance object"},
-        GetRpcResult("collateralHash", /*optional=*/false, /*override_name=*/"CollateralHash"),
-        {RPCResult::Type::NUM, "ObjectType", "Object types"},
-        {RPCResult::Type::NUM, "CreationTime", "Object creation timestamp"},
-        {RPCResult::Type::STR_HEX, "SigningMasternode", /*optional=*/true, "Signing masternode’s vin (for triggers only)"},
-        {RPCResult::Type::BOOL, local_valid_key, "Returns true if valid"},
-        {RPCResult::Type::STR, "IsValidReason", strprintf("%s error (human-readable string, empty if %s true)", local_valid_key, local_valid_key)},
-        {RPCResult::Type::BOOL, "fCachedValid", "Returns true if minimum support has been reached flagging object as valid"},
-        {RPCResult::Type::BOOL, "fCachedFunding", "Returns true if minimum support has been reached flagging object as fundable"},
-        {RPCResult::Type::BOOL, "fCachedDelete", "Returns true if minimum support has been reached flagging object as marked for deletion"},
-        {RPCResult::Type::BOOL, "fCachedEndorsed", "Returns true if minimum support has been reached flagging object as endorsed"},
-    }};
-}
-
-RPCResult CGovernanceObject::GetVotesJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "Object vote counts",
-    {
-        {RPCResult::Type::NUM, "AbsoluteYesCount", "Number of Yes votes minus number of No votes"},
-        {RPCResult::Type::NUM, "YesCount", "Number of Yes votes"},
-        {RPCResult::Type::NUM, "NoCount", "Number of No votes"},
-        {RPCResult::Type::NUM, "AbstainCount", "Number of Abstain votes"},
-    }};
-}
-
-UniValue CGovernanceObject::GetVotesJson(const CDeterministicMNList& tip_mn_list, vote_signal_enum_t signal) const
-{
-    UniValue obj(UniValue::VOBJ);
-    obj.pushKV("AbsoluteYesCount", GetAbsoluteYesCount(tip_mn_list, signal));
-    obj.pushKV("YesCount", GetYesCount(tip_mn_list, signal));
-    obj.pushKV("NoCount", GetNoCount(tip_mn_list, signal));
-    obj.pushKV("AbstainCount", GetAbstainCount(tip_mn_list, signal));
-    return obj;
-}
-
-namespace Governance {
-RPCResult Object::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "Object info",
-    {
-        {RPCResult::Type::STR_HEX, "objectHash", "Hash of proposal object"},
-        {RPCResult::Type::STR_HEX, "parentHash", "Hash of the parent object (root node has a hash of 0)"},
-        GetRpcResult("collateralHash"),
-        {RPCResult::Type::NUM, "createdAt", "Proposal creation timestamp"},
-        {RPCResult::Type::NUM, "revision", "Proposal revision number"},
-        // Everything but "hex" is the submitter's own JSON echoed back verbatim, so neither the
-        // set of keys nor their types is ours to promise: a proposal may carry extra fields and
-        // may encode the numeric ones as strings. Hence the type check is skipped here.
-        {RPCResult::Type::OBJ, "data", "", {
-            // Fields emitted through GetDataAsPlainString(), read by CProposalValidator
-            {RPCResult::Type::ANY, "end_epoch", /*optional=*/true, "Proposal end timestamp"},
-            {RPCResult::Type::ANY, "name", /*optional=*/true, "Proposal name"},
-            {RPCResult::Type::ANY, "payment_address", /*optional=*/true, "Proposal payment address"},
-            {RPCResult::Type::ANY, "payment_amount", /*optional=*/true, "Proposal payment amount"},
-            {RPCResult::Type::ANY, "start_epoch", /*optional=*/true, "Proposal start timestamp"},
-            {RPCResult::Type::ANY, "type", /*optional=*/true, "Object type"},
-            {RPCResult::Type::ANY, "url", /*optional=*/true, "Proposal URL"},
-            // Failure case for GetDataAsPlainString()
-            {RPCResult::Type::STR, "plain", /*optional=*/true, "Governance object data as string"},
-            // Always emitted by ToJson()
-            {RPCResult::Type::STR_HEX, "hex", "Governance object data as hex"},
-        }, /*skip_type_check=*/true},
-    }};
-}
-
-UniValue Object::ToJson() const
-{
-    UniValue obj(UniValue::VOBJ);
-    obj.pushKV("objectHash", GetHash().ToString());
-    obj.pushKV("parentHash", hashParent.ToString());
-    obj.pushKV("collateralHash", collateralHash.ToString());
-    obj.pushKV("createdAt", time);
-    obj.pushKV("revision", revision);
-    UniValue data;
-    if (!data.read(GetDataAsPlainString())) {
-        data.clear();
-        data.setObject();
-        data.pushKV("plain", GetDataAsPlainString());
-    }
-    data.pushKV("hex", GetDataAsHexString());
-    obj.pushKV("data", data);
-    return obj;
-}
-} // namespace Governance
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
index 923a8a9e7007..a9fe430b4ec5 100644
--- a/src/governance/governance.cpp
+++ b/src/governance/governance.cpp
@@ -24,6 +24,8 @@
 #include <util/time.h>
 #include <validationinterface.h>
 
+#include <univalue.h>
+
 #include <ranges>
 
 const std::string GovernanceStore::SERIALIZATION_VERSION_STRING = "CGovernanceManager-Version-16";
@@ -1062,6 +1064,38 @@ std::string CGovernanceManager::ToString() const
     return strprintf("%s, Votes: %d", GovernanceStore::ToString(), static_cast<int>(cmapVoteToObject.GetSize()));
 }
 
+UniValue CGovernanceManager::ToJson() const
+{
+    LOCK(cs_store);
+
+    int nProposalCount = 0;
+    int nTriggerCount = 0;
+    int nOtherCount = 0;
+
+    for (const auto& [_, govobj] : mapObjects) {
+        switch (Assert(govobj)->GetObjectType()) {
+        case GovernanceObject::PROPOSAL:
+            nProposalCount++;
+            break;
+        case GovernanceObject::TRIGGER:
+            nTriggerCount++;
+            break;
+        default:
+            nOtherCount++;
+            break;
+        }
+    }
+
+    UniValue jsonObj(UniValue::VOBJ);
+    jsonObj.pushKV("objects_total", mapObjects.size());
+    jsonObj.pushKV("proposals", nProposalCount);
+    jsonObj.pushKV("triggers", nTriggerCount);
+    jsonObj.pushKV("other", nOtherCount);
+    jsonObj.pushKV("erased", mapErasedGovernanceObjects.size());
+    jsonObj.pushKV("votes", cmapVoteToObject.GetSize());
+    return jsonObj;
+}
+
 void CGovernanceManager::UpdatedBlockTip(const CBlockIndex* pindex)
 {
     AssertLockNotHeld(cs_store);
diff --git a/src/governance/object.cpp b/src/governance/object.cpp
index 59c512b1f58e..18c94abe4dd0 100644
--- a/src/governance/object.cpp
+++ b/src/governance/object.cpp
@@ -666,6 +666,21 @@ void CGovernanceObject::GetData(UniValue& objResult) const
     objResult = o;
 }
 
+UniValue CGovernanceObject::GetInnerJson() const
+{
+    return m_obj.ToJson();
+}
+
+UniValue CGovernanceObject::GetVotesJson(const CDeterministicMNList& tip_mn_list, vote_signal_enum_t signal) const
+{
+    UniValue obj(UniValue::VOBJ);
+    obj.pushKV("AbsoluteYesCount", GetAbsoluteYesCount(tip_mn_list, signal));
+    obj.pushKV("YesCount", GetYesCount(tip_mn_list, signal));
+    obj.pushKV("NoCount", GetNoCount(tip_mn_list, signal));
+    obj.pushKV("AbstainCount", GetAbstainCount(tip_mn_list, signal));
+    return obj;
+}
+
 /**
 *   GetData - As
 *   --------------------------------------------------------
diff --git a/src/llmq/core_write.cpp b/src/llmq/core_write.cpp
index 243f8f1c0a3a..f58a90d1f954 100644
--- a/src/llmq/core_write.cpp
+++ b/src/llmq/core_write.cpp
@@ -3,92 +3,15 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <llmq/commitment.h>
-#include <llmq/debug.h>
 #include <llmq/signing.h>
 #include <llmq/snapshot.h>
 
-#include <core_io.h>
-#include <rpc/util.h>
+#include <util/check.h>
+#include <util/std23.h>
 
 #include <univalue.h>
 
-#include <map>
-#include <string>
-
 namespace llmq {
-// CDKGDebugSessionStatus::ToJson() defined in llmq/debug.cpp
-RPCResult CDKGDebugSessionStatus::GetJsonHelp(const std::string& key, bool optional)
-{
-    // A member tally is a count for detail_level = 0, an array of member indexes for
-    // detail_level = 1, and an array of {memberIndex, proTxHash} objects for
-    // detail_level = 2. RPCResult can only express such a union as ANY: conditional
-    // variants are only resolved for top-level results, so listing one variant per
-    // detail level here would make every level fail the runtime doc check.
-    const auto member_tally{[](const std::string& name, const std::string& what) {
-        return RPCResult{RPCResult::Type::ANY, name,
-                         strprintf("Number of %s (detail_level = 0), array of quorum member indexes "
-                                   "(detail_level = 1), or array of {memberIndex, proTxHash} objects "
-                                   "(detail_level = 2)",
-                                   what)};
-    }};
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The state of a DKG session. Empty for an unknown LLMQ type or quorum hash",
-    {
-        GetRpcResult("llmqType", /*optional=*/true),
-        GetRpcResult("quorumHash", /*optional=*/true),
-        {RPCResult::Type::NUM, "quorumHeight", /*optional=*/true, "Block height of the quorum"},
-        {RPCResult::Type::NUM, "phase", /*optional=*/true, "Active DKG phase"},
-        {RPCResult::Type::BOOL, "sentContributions", /*optional=*/true, "Returns true if contributions sent"},
-        {RPCResult::Type::BOOL, "sentComplaint", /*optional=*/true, "Returns true if complaints sent"},
-        {RPCResult::Type::BOOL, "sentJustification", /*optional=*/true, "Returns true if justifications sent"},
-        {RPCResult::Type::BOOL, "sentPrematureCommitment", /*optional=*/true, "Returns true if premature commitments sent"},
-        {RPCResult::Type::BOOL, "aborted", /*optional=*/true, "Returns true if DKG session aborted"},
-        member_tally("badMembers", "bad members"),
-        member_tally("weComplain", "complaints sent"),
-        member_tally("receivedContributions", "contributions received"),
-        member_tally("receivedComplaints", "complaints received"),
-        member_tally("receivedJustifications", "justifications received"),
-        member_tally("receivedPrematureCommitments", "premature commitments received"),
-        {RPCResult::Type::ARR, "allMembers", /*optional=*/true, "Provider registration transaction hash for all quorum members. Only present for detail_level = 2", {
-            GetRpcResult("proTxHash")}},
-    }};
-}
-
-// CDKGDebugManager::ToJson() defined in llmq/debug.cpp
-RPCResult CDKGDebugManager::GetJsonHelp(const std::string& key, bool optional, bool inner_optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The state of the node's DKG sessions",
-    {
-        {RPCResult::Type::NUM, "time", inner_optional, "Adjusted time for the last update, timestamp"},
-        {RPCResult::Type::STR, "timeStr", inner_optional, "Adjusted time for the last update, human friendly"},
-        {RPCResult::Type::ARR, "session", inner_optional, "", {
-            {RPCResult::Type::OBJ, "", "", {
-                {RPCResult::Type::STR, "llmqType", "Name of quorum"},
-                GetRpcResult("quorumIndex"),
-                CDKGDebugSessionStatus::GetJsonHelp(/*key=*/"status", /*optional=*/false)
-            }},
-        }}
-    }};
-}
-
-RPCResult CFinalCommitment::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The quorum commitment payload",
-    {
-        {RPCResult::Type::NUM, "version", "Quorum commitment payload version"},
-        GetRpcResult("llmqType"),
-        GetRpcResult("quorumHash"),
-        {RPCResult::Type::NUM, "quorumIndex", "Index of the quorum"},
-        {RPCResult::Type::NUM, "signersCount", "Number of signers for the quorum"},
-        {RPCResult::Type::STR_HEX, "signers", "Bitset representing the aggregated signers"},
-        {RPCResult::Type::NUM, "validMembersCount", "Number of valid members in the quorum"},
-        {RPCResult::Type::STR_HEX, "validMembers", "Bitset of valid members"},
-        {RPCResult::Type::STR_HEX, "quorumPublicKey", "BLS public key of the quorum"},
-        {RPCResult::Type::STR_HEX, "quorumVvecHash", "Hash of the quorum verification vector"},
-        GetRpcResult("quorumSig"),
-        {RPCResult::Type::STR_HEX, "membersSig", "BLS signature from all included commitments"},
-    }};
-}
-
 UniValue CFinalCommitment::ToJson() const
 {
     UniValue obj(UniValue::VOBJ);
@@ -107,16 +30,6 @@ UniValue CFinalCommitment::ToJson() const
     return obj;
 }
 
-RPCResult CFinalCommitmentTxPayload::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The quorum commitment special transaction",
-    {
-        GetRpcResult("version"),
-        GetRpcResult("height"),
-        CFinalCommitment::GetJsonHelp(/*key=*/"commitment", /*optional=*/false),
-    }};
-}
-
 UniValue CFinalCommitmentTxPayload::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
@@ -126,33 +39,6 @@ UniValue CFinalCommitmentTxPayload::ToJson() const
     return ret;
 }
 
-RPCResult CQuorumRotationInfo::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The quorum rotation",
-    {
-        {RPCResult::Type::BOOL, "extraShare", "Returns true if an extra share is returned"},
-        CQuorumSnapshot::GetJsonHelp(/*key=*/"quorumSnapshotAtHMinusC", /*optional=*/false),
-        CQuorumSnapshot::GetJsonHelp(/*key=*/"quorumSnapshotAtHMinus2C", /*optional=*/false),
-        CQuorumSnapshot::GetJsonHelp(/*key=*/"quorumSnapshotAtHMinus3C", /*optional=*/false),
-        CQuorumSnapshot::GetJsonHelp(/*key=*/"quorumSnapshotAtHMinus4C", /*optional=*/true),
-        CSimplifiedMNListDiff::GetJsonHelp(/*key=*/"mnListDiffTip", /*optional=*/false),
-        CSimplifiedMNListDiff::GetJsonHelp(/*key=*/"mnListDiffH", /*optional=*/false),
-        CSimplifiedMNListDiff::GetJsonHelp(/*key=*/"mnListDiffAtHMinusC", /*optional=*/false),
-        CSimplifiedMNListDiff::GetJsonHelp(/*key=*/"mnListDiffAtHMinus2C", /*optional=*/false),
-        CSimplifiedMNListDiff::GetJsonHelp(/*key=*/"mnListDiffAtHMinus3C", /*optional=*/false),
-        CSimplifiedMNListDiff::GetJsonHelp(/*key=*/"mnListDiffAtHMinus4C", /*optional=*/true),
-        {RPCResult::Type::ARR, "lastCommitmentPerIndex", "Most recent commitment for each quorumIndex", {
-            CFinalCommitment::GetJsonHelp(/*key=*/"", /*optional=*/false),
-        }},
-        {RPCResult::Type::ARR, "quorumSnapshotList", "Snapshots required to reconstruct the quorums built at h' in lastCommitmentPerIndex", {
-            CQuorumSnapshot::GetJsonHelp(/*key=*/"", /*optional=*/false),
-        }},
-        {RPCResult::Type::ARR, "mnListDiffList", "MnListDiffs required to calculate older quorums", {
-            CSimplifiedMNListDiff::GetJsonHelp(/*key=*/"", /*optional=*/false),
-        }},
-    }};
-}
-
 UniValue CQuorumRotationInfo::ToJson() const
 {
     UniValue obj(UniValue::VOBJ);
@@ -195,20 +81,6 @@ UniValue CQuorumRotationInfo::ToJson() const
     return obj;
 }
 
-RPCResult CQuorumSnapshot::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The quorum snapshot",
-    {
-        {RPCResult::Type::ARR, "activeQuorumMembers", "Bitset of nodes already in quarters at the start of cycle", {
-            {RPCResult::Type::BOOL, "bit", ""}
-        }},
-        {RPCResult::Type::NUM, "mnSkipListMode", "Mode of the skip list"},
-        {RPCResult::Type::ARR, "mnSkipList", "Skiplist at height", {
-            {RPCResult::Type::NUM, "height", ""}
-        }},
-    }};
-}
-
 UniValue CQuorumSnapshot::ToJson() const
 {
     UniValue obj(UniValue::VOBJ);
@@ -228,19 +100,6 @@ UniValue CQuorumSnapshot::ToJson() const
     return obj;
 }
 
-RPCResult CRecoveredSig::GetJsonHelp(const std::string& key, bool optional)
-{
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The recovered signature",
-    {
-        GetRpcResult("llmqType"),
-        GetRpcResult("quorumHash"),
-        {RPCResult::Type::STR_HEX, "id", "Signing session ID"},
-        {RPCResult::Type::STR_HEX, "msgHash", "Hash of message"},
-        {RPCResult::Type::STR_HEX, "sig", "BLS signature recovered"},
-        {RPCResult::Type::STR_HEX, "hash", "Hash of the BLS signature recovered"},
-    }};
-}
-
 UniValue CRecoveredSig::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
diff --git a/src/rpc/coinjoin.cpp b/src/rpc/coinjoin.cpp
index d0e6de546201..3c50f1ba2409 100644
--- a/src/rpc/coinjoin.cpp
+++ b/src/rpc/coinjoin.cpp
@@ -3,6 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <node/context.h>
+#include <rpc/json_help.h>
 #include <rpc/server.h>
 #include <rpc/server_util.h>
 #include <rpc/util.h>
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 97a03921d4a8..285cf857beab 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -23,12 +23,14 @@
 #include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <util/check.h>
+#include <util/strencodings.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <wallet/rpc/util.h>
 #include <walletinitinterface.h>
 
 #include <limits>
+#include <string_view>
 
 #ifdef ENABLE_WALLET
 #include <wallet/wallet.h>
@@ -50,6 +52,34 @@ using wallet::HELP_REQUIRING_PASSPHRASE;
 using wallet::isminetype;
 #endif // ENABLE_WALLET
 
+// Defined here rather than with the other ToJson() in evo/core_write.cpp: dash-tx never prints
+// a masternode entry, and the g_txindex lookup below needs libbitcoin_node anyway. Hosting it
+// in evo/deterministicmns.cpp instead would create four new circular dependencies.
+UniValue CDeterministicMN::ToJson() const
+{
+    UniValue obj(UniValue::VOBJ);
+    obj.pushKV("type", std::string(GetMnType(nType).description));
+    obj.pushKV("proTxHash", proTxHash.ToString());
+    obj.pushKV("collateralHash", collateralOutpoint.hash.ToString());
+    obj.pushKV("collateralIndex", collateralOutpoint.n);
+
+    if (g_txindex) {
+        CTransactionRef collateralTx;
+        uint256 nBlockHash;
+        g_txindex->FindTx(collateralOutpoint.hash, nBlockHash, collateralTx);
+        if (collateralTx) {
+            CTxDestination dest;
+            if (ExtractDestination(collateralTx->vout[collateralOutpoint.n].scriptPubKey, dest)) {
+                obj.pushKV("collateralAddress", EncodeDestination(dest));
+            }
+        }
+    }
+
+    obj.pushKV("operatorReward", static_cast<double>(nOperatorReward) / 100);
+    obj.pushKV("state", pdmnState->ToJson(nType));
+    return obj;
+}
+
 static RPCArg GetRpcArg(const std::string& strParamName)
 {
     static const std::map<std::string, RPCArg> mapParamHelp = {
diff --git a/src/rpc/evo_util.cpp b/src/rpc/evo_util.cpp
deleted file mode 100644
index 6ffe07318a3e..000000000000
--- a/src/rpc/evo_util.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-// 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.
-
-#include <rpc/evo_util.h>
-
-#include <evo/deterministicmns.h>
-#include <index/txindex.h>
-
-#include <univalue.h>
-
-
-UniValue CDeterministicMN::ToJson() const
-{
-    UniValue obj(UniValue::VOBJ);
-    obj.pushKV("type", std::string(GetMnType(nType).description));
-    obj.pushKV("proTxHash", proTxHash.ToString());
-    obj.pushKV("collateralHash", collateralOutpoint.hash.ToString());
-    obj.pushKV("collateralIndex", collateralOutpoint.n);
-
-    if (g_txindex) {
-        CTransactionRef collateralTx;
-        uint256 nBlockHash;
-        g_txindex->FindTx(collateralOutpoint.hash, nBlockHash, collateralTx);
-        if (collateralTx) {
-            CTxDestination dest;
-            if (ExtractDestination(collateralTx->vout[collateralOutpoint.n].scriptPubKey, dest)) {
-                obj.pushKV("collateralAddress", EncodeDestination(dest));
-            }
-        }
-    }
-
-    obj.pushKV("operatorReward", static_cast<double>(nOperatorReward) / 100);
-    obj.pushKV("state", pdmnState->ToJson(nType));
-    return obj;
-}
diff --git a/src/rpc/evo_util.h b/src/rpc/evo_util.h
deleted file mode 100644
index 0a5e08c98225..000000000000
--- a/src/rpc/evo_util.h
+++ /dev/null
@@ -1,80 +0,0 @@
-// 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_RPC_EVO_UTIL_H
-#define BITCOIN_RPC_EVO_UTIL_H
-
-#include <netaddress.h>
-#include <util/check.h>
-
-#include <evo/dmn_types.h>
-#include <evo/netinfo.h>
-
-#include <cstdint>
-#include <type_traits>
-
-#include <univalue.h>
-
-class CSimplifiedMNListEntry;
-
-/** Reads network info reporting and appends data from legacy fields if applicable */
-template <typename Obj>
-UniValue GetNetInfoWithLegacyFields(const Obj& obj, const MnType& type)
-{
-    UniValue ret{CHECK_NONFATAL(obj.netInfo)->ToJson()};
-
-    // Nothing to do here if not EvoNode, netInfo is empty or netInfo is capable of natively
-    // storing Platform fields
-    if (type != MnType::Evo || obj.netInfo->IsEmpty() || obj.netInfo->CanStorePlatform()) return ret;
-
-    CNetAddr addr{obj.netInfo->GetPrimary()};
-    ret.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_HTTPS).data(),
-               ArrFromService(CService(addr, obj.platformHTTPPort)));
-
-    if constexpr (!std::is_same_v<std::decay_t<Obj>, CSimplifiedMNListEntry>) {
-        // CSimplifiedMNListEntry doesn't store platformP2PPort
-        ret.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_P2P).data(),
-                   ArrFromService(CService(addr, obj.platformP2PPort)));
-    }
-
-    return ret;
-}
-
-/** Returns platform port based on purpose and network info version */
-template <bool is_p2p, typename Obj>
-int32_t GetPlatformPort(const Obj& obj)
-{
-    // Currently, there is nothing that prevents PLATFORM_{HTTPS,P2P} to be registered to
-    // an addr *different* from the primary addr for CORE_P2P. This breaks the assumptions
-    // under which platform{HTTP,P2P}Port operate under (i.e. all three are hosted with the
-    // same addr).
-    //
-    // TODO: Introduce restrictions that enforce this assumption *until* we remove legacy
-    //       fields for good.
-    //
-    bool is_legacy{!(CHECK_NONFATAL(obj.netInfo)->CanStorePlatform())};
-    if constexpr (is_p2p) {
-        static_assert(!std::is_same_v<std::decay_t<Obj>, CSimplifiedMNListEntry>,
-                      "CSimplifiedMNListEntry doesn't have platformP2PPort");
-        if (is_legacy) {
-            return obj.platformP2PPort;
-        }
-        if (obj.netInfo->IsEmpty()) {
-            return -1; // Blank entry, nothing to report
-        }
-        CHECK_NONFATAL(obj.netInfo->HasEntries(NetInfoPurpose::PLATFORM_P2P));
-        return obj.netInfo->GetEntries(NetInfoPurpose::PLATFORM_P2P)[0].GetPort();
-    } else {
-        if (is_legacy) {
-            return obj.platformHTTPPort;
-        }
-        if (obj.netInfo->IsEmpty()) {
-            return -1; // Blank entry, nothing to report
-        }
-        CHECK_NONFATAL(obj.netInfo->HasEntries(NetInfoPurpose::PLATFORM_HTTPS));
-        return obj.netInfo->GetEntries(NetInfoPurpose::PLATFORM_HTTPS)[0].GetPort();
-    }
-}
-
-#endif // BITCOIN_RPC_EVO_UTIL_H
diff --git a/src/rpc/json_help.cpp b/src/rpc/json_help.cpp
new file mode 100644
index 000000000000..8bae35f01a2e
--- /dev/null
+++ b/src/rpc/json_help.cpp
@@ -0,0 +1,568 @@
+// Copyright (c) 2025-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 <rpc/json_help.h>
+
+#include <evo/assetlocktx.h>
+#include <evo/cbtx.h>
+#include <evo/deterministicmns.h>
+#include <evo/dmnstate.h>
+#include <evo/mnhftx.h>
+#include <evo/providertx.h>
+#include <evo/simplifiedmns.h>
+#include <evo/smldiff.h>
+#include <governance/common.h>
+#include <governance/governance.h>
+#include <governance/object.h>
+#include <llmq/commitment.h>
+#include <llmq/debug.h>
+#include <llmq/signing.h>
+#include <llmq/snapshot.h>
+#include <rpc/util.h>
+#include <tinyformat.h>
+#include <util/check.h>
+
+#include <map>
+#include <string>
+
+namespace {
+#define RESULT_MAP_ENTRY(name, type, desc) {name, {type, name, desc}}
+const std::map<std::string, RPCResult> RPCRESULT_MAP{{
+    {"addresses",
+        {RPCResult::Type::OBJ, "addresses", "Network addresses of the masternode",
+    {
+        {RPCResult::Type::ARR, "core_p2p", /*optional=*/true, "Addresses used for protocol P2P",
+            {{RPCResult::Type::STR, "address", ""}}},
+        {RPCResult::Type::ARR, "platform_p2p", /*optional=*/true, "Addresses used for Platform P2P",
+            {{RPCResult::Type::STR, "address", ""}}},
+        {RPCResult::Type::ARR, "platform_https", /*optional=*/true, "Addresses used for Platform HTTPS API",
+            {{RPCResult::Type::STR, "address", ""}}},
+    }}},
+    RESULT_MAP_ENTRY("collateralAddress", RPCResult::Type::STR, "Dash address used for collateral"),
+    RESULT_MAP_ENTRY("collateralHash", RPCResult::Type::STR_HEX, "Collateral transaction hash"),
+    RESULT_MAP_ENTRY("collateralIndex", RPCResult::Type::NUM, "Collateral transaction output index"),
+    RESULT_MAP_ENTRY("consecutivePayments", RPCResult::Type::NUM, "Consecutive payments masternode has received in payment cycle"),
+    RESULT_MAP_ENTRY("height", RPCResult::Type::NUM, "Block height"),
+    RESULT_MAP_ENTRY("inputsHash", RPCResult::Type::STR_HEX, "Hash of all the outpoints of the transaction inputs"),
+    RESULT_MAP_ENTRY("lastPaidHeight", RPCResult::Type::NUM, "Height masternode was last paid"),
+    RESULT_MAP_ENTRY("llmqType", RPCResult::Type::NUM, "Quorum type"),
+    RESULT_MAP_ENTRY("memberIndex", RPCResult::Type::NUM, "Quorum member index"),
+    RESULT_MAP_ENTRY("merkleRootMNList", RPCResult::Type::STR_HEX, "Merkle root of the masternode list"),
+    RESULT_MAP_ENTRY("merkleRootQuorums", RPCResult::Type::STR_HEX, "Merkle root of the quorum list"),
+    RESULT_MAP_ENTRY("operatorPayoutAddress", RPCResult::Type::STR, "Dash address used for operator reward payments"),
+    RESULT_MAP_ENTRY("operatorReward", RPCResult::Type::NUM, "Fraction in %% of reward shared with the operator between 0 and 10000"),
+    RESULT_MAP_ENTRY("outpoint", RPCResult::Type::STR_HEX,"The outpoint of the masternode"),
+    RESULT_MAP_ENTRY("ownerAddress", RPCResult::Type::STR, "Dash address used for payee updates and proposal voting"),
+    RESULT_MAP_ENTRY("payoutAddress", RPCResult::Type::STR, "Dash address used for masternode reward payments"),
+    {"payouts",
+        {RPCResult::Type::ARR, "payouts", "Owner masternode reward payout shares",
+    {
+        {RPCResult::Type::OBJ, "", "",
+        {
+            {RPCResult::Type::STR, "address", "Dash address used for this owner payout"},
+            {RPCResult::Type::STR_HEX, "script", "Owner payout scriptPubKey"},
+            {RPCResult::Type::NUM, "reward", "Owner payout share in basis points"},
+        }},
+    }}},
+    RESULT_MAP_ENTRY("platformHTTPPort", RPCResult::Type::NUM, "TCP port of Platform HTTP API (DEPRECATED, returned only if config option -deprecatedrpc=service is passed)"),
+    RESULT_MAP_ENTRY("platformNodeID", RPCResult::Type::STR_HEX, "Node ID derived from P2P public key for Platform P2P"),
+    RESULT_MAP_ENTRY("platformP2PPort", RPCResult::Type::NUM, "TCP port of Platform P2P (DEPRECATED, returned only if config option -deprecatedrpc=service is passed)"),
+    RESULT_MAP_ENTRY("PoSeBanHeight", RPCResult::Type::NUM, "Height masternode was banned for Proof of Service violations"),
+    RESULT_MAP_ENTRY("PoSePenalty", RPCResult::Type::NUM, "Proof of Service penalty score"),
+    RESULT_MAP_ENTRY("PoSeRevivedHeight", RPCResult::Type::NUM, "Height masternode recovered from Proof of Service violations"),
+    RESULT_MAP_ENTRY("proTxHash", RPCResult::Type::STR_HEX, "Hash of the masternode's initial ProRegTx"),
+    RESULT_MAP_ENTRY("pubKeyOperator", RPCResult::Type::STR, "BLS public key used for operator signing"),
+    RESULT_MAP_ENTRY("quorumIndex", RPCResult::Type::NUM, "Quorum index. Relevant for rotation quorums only, 0 for non-rotating quorums"),
+    RESULT_MAP_ENTRY("quorumHash", RPCResult::Type::STR_HEX, "Hash of the quorum"),
+    RESULT_MAP_ENTRY("quorumSig", RPCResult::Type::STR_HEX, "BLS recovered threshold signature of quorum"),
+    RESULT_MAP_ENTRY("registeredHeight", RPCResult::Type::NUM, "Height masternode was registered"),
+    RESULT_MAP_ENTRY("revocationReason", RPCResult::Type::NUM, "Reason for ProUpRegTx revocation"),
+    RESULT_MAP_ENTRY("service", RPCResult::Type::STR, "IP address and port of the masternode (DEPRECATED, returned only if config option -deprecatedrpc=service is passed)"),
+    RESULT_MAP_ENTRY("type", RPCResult::Type::NUM, "Masternode type"),
+    RESULT_MAP_ENTRY("type_str", RPCResult::Type::STR, "Masternode type (human-readable string)"),
+    RESULT_MAP_ENTRY("version", RPCResult::Type::NUM, "Special transaction version"),
+    RESULT_MAP_ENTRY("votingAddress", RPCResult::Type::STR, "Dash address used for voting"),
+}};
+#undef RESULT_MAP_ENTRY
+} // anonymous namespace
+
+RPCResult GetRpcResult(const std::string& key, bool optional, const std::string& override_name)
+{
+    if (const auto it = RPCRESULT_MAP.find(key); it != RPCRESULT_MAP.end()) {
+        const auto& ret{it->second};
+        return RPCResult{ret.m_type, override_name.empty() ? ret.m_key_name : override_name, optional, ret.m_description, ret.m_inner};
+    }
+    throw NonFatalCheckError(strprintf("Requested invalid RPCResult for nonexistent key \"%s\"", key).c_str(),
+                             __FILE__, __LINE__, __func__);
+}
+
+RPCResult CAssetLockPayload::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The asset lock special transaction",
+    {
+        GetRpcResult("version"),
+        {RPCResult::Type::ARR, "creditOutputs", "", {
+            {RPCResult::Type::OBJ, "", "", {
+                {RPCResult::Type::NUM, "value", "The value in Dash"},
+                {RPCResult::Type::NUM, "valueSat", "The value in duffs"},
+                {RPCResult::Type::OBJ, "scriptPubKey", "", {
+                    {RPCResult::Type::STR, "asm", "The asm"},
+                    {RPCResult::Type::STR_HEX, "hex", "The hex"},
+                    {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"},
+                }},
+                {RPCResult::Type::STR, "address", /*optional=*/true, "DIP-18 Platform address (version >= 2 only)"},
+        }}}}
+    }};
+}
+
+RPCResult CAssetUnlockPayload::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The asset unlock special transaction",
+    {
+        GetRpcResult("version"),
+        {RPCResult::Type::NUM, "index", "Index of the transaction"},
+        {RPCResult::Type::NUM, "fee", "Transaction fee in duffs awarded to the miner"},
+        {RPCResult::Type::NUM, "requestedHeight", "Payment chain block height known by Platform when signing the withdrawal"},
+        GetRpcResult("quorumHash"),
+        GetRpcResult("quorumSig"),
+    }};
+}
+
+RPCResult CCbTx::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The coinbase special transaction",
+    {
+        GetRpcResult("version"),
+        GetRpcResult("height"),
+        GetRpcResult("merkleRootMNList"),
+        GetRpcResult("merkleRootQuorums", /*optional=*/true),
+        {RPCResult::Type::NUM, "bestCLHeightDiff", /*optional=*/true, "Blocks between the current block and the last known block with a ChainLock"},
+        {RPCResult::Type::STR_HEX, "bestCLSignature", /*optional=*/true, "Best ChainLock signature known by the miner"},
+        {RPCResult::Type::NUM, "creditPoolBalance", /*optional=*/true, "Balance in the Platform credit pool"},
+    }};
+}
+
+// CDeterministicMN::ToJson() defined in rpc/evo.cpp
+RPCResult CDeterministicMN::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode's details",
+    {
+        GetRpcResult("type_str", /*optional=*/false, /*override_name=*/"type"),
+        GetRpcResult("proTxHash"),
+        GetRpcResult("collateralHash"),
+        GetRpcResult("collateralIndex"),
+        GetRpcResult("collateralAddress", /*optional=*/true),
+        GetRpcResult("operatorReward"),
+        CDeterministicMNState::GetJsonHelp(/*key=*/"state", /*optional=*/false),
+    }};
+}
+
+RPCResult CDeterministicMNState::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode state",
+    {
+        {RPCResult::Type::NUM, "version", "Version of the masternode state"},
+        GetRpcResult("service", /*optional=*/true),
+        GetRpcResult("addresses"),
+        GetRpcResult("registeredHeight"),
+        GetRpcResult("lastPaidHeight"),
+        GetRpcResult("consecutivePayments"),
+        GetRpcResult("PoSePenalty"),
+        GetRpcResult("PoSeRevivedHeight"),
+        GetRpcResult("PoSeBanHeight"),
+        GetRpcResult("revocationReason"),
+        GetRpcResult("ownerAddress"),
+        GetRpcResult("votingAddress"),
+        GetRpcResult("platformNodeID", /*optional=*/true),
+        GetRpcResult("platformP2PPort", /*optional=*/true),
+        GetRpcResult("platformHTTPPort", /*optional=*/true),
+        GetRpcResult("payoutAddress", /*optional=*/true),
+        GetRpcResult("payouts", /*optional=*/true),
+        GetRpcResult("pubKeyOperator"),
+        GetRpcResult("operatorPayoutAddress", /*optional=*/true),
+    }};
+}
+
+// CDeterministicMNStateDiff::ToJson() defined in evo/dmnstate.cpp
+RPCResult CDeterministicMNStateDiff::GetJsonHelp(const std::string& key, bool optional)
+{
+    // Every field is emitted only when the diff actually carries it, version included.
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode state diff",
+    {
+        {RPCResult::Type::NUM, "version", /*optional=*/true, "Version of the masternode state diff"},
+        GetRpcResult("service", /*optional=*/true),
+        GetRpcResult("registeredHeight", /*optional=*/true),
+        GetRpcResult("lastPaidHeight", /*optional=*/true),
+        GetRpcResult("consecutivePayments", /*optional=*/true),
+        GetRpcResult("PoSePenalty", /*optional=*/true),
+        GetRpcResult("PoSeRevivedHeight", /*optional=*/true),
+        GetRpcResult("PoSeBanHeight", /*optional=*/true),
+        GetRpcResult("revocationReason", /*optional=*/true),
+        GetRpcResult("ownerAddress", /*optional=*/true),
+        GetRpcResult("votingAddress", /*optional=*/true),
+        GetRpcResult("payoutAddress", /*optional=*/true),
+        GetRpcResult("payouts", /*optional=*/true),
+        GetRpcResult("operatorPayoutAddress", /*optional=*/true),
+        GetRpcResult("pubKeyOperator", /*optional=*/true),
+        GetRpcResult("platformNodeID", /*optional=*/true),
+        GetRpcResult("platformP2PPort", /*optional=*/true),
+        GetRpcResult("platformHTTPPort", /*optional=*/true),
+        GetRpcResult("addresses", /*optional=*/true),
+    }};
+}
+
+RPCResult CProRegTx::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode registration special transaction",
+    {
+        GetRpcResult("version"),
+        GetRpcResult("type"),
+        GetRpcResult("collateralHash"),
+        GetRpcResult("collateralIndex"),
+        GetRpcResult("service", /*optional=*/true),
+        GetRpcResult("addresses"),
+        GetRpcResult("ownerAddress"),
+        GetRpcResult("votingAddress"),
+        GetRpcResult("payoutAddress", /*optional=*/true),
+        GetRpcResult("payouts", /*optional=*/true),
+        GetRpcResult("pubKeyOperator"),
+        GetRpcResult("operatorReward"),
+        GetRpcResult("platformNodeID", /*optional=*/true),
+        GetRpcResult("platformP2PPort", /*optional=*/true),
+        GetRpcResult("platformHTTPPort", /*optional=*/true),
+        GetRpcResult("inputsHash"),
+    }};
+}
+
+RPCResult CProUpRegTx::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode update registrar special transaction",
+    {
+        GetRpcResult("version"),
+        GetRpcResult("proTxHash"),
+        GetRpcResult("votingAddress"),
+        GetRpcResult("payoutAddress", /*optional=*/true),
+        GetRpcResult("payouts", /*optional=*/true),
+        GetRpcResult("pubKeyOperator"),
+        GetRpcResult("inputsHash"),
+    }};
+}
+
+RPCResult CProUpRevTx::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode operator revocation special transaction",
+    {
+        GetRpcResult("version"),
+        GetRpcResult("proTxHash"),
+        {RPCResult::Type::NUM, "reason", "Reason for masternode service revocation"},
+        GetRpcResult("inputsHash", /*optional=*/true),
+    }};
+}
+
+RPCResult CProUpServTx::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode update service special transaction",
+    {
+        GetRpcResult("version"),
+        GetRpcResult("type"),
+        GetRpcResult("proTxHash"),
+        GetRpcResult("service", /*optional=*/true),
+        GetRpcResult("addresses"),
+        GetRpcResult("operatorPayoutAddress", /*optional=*/true),
+        GetRpcResult("platformNodeID", /*optional=*/true),
+        GetRpcResult("platformP2PPort", /*optional=*/true),
+        GetRpcResult("platformHTTPPort", /*optional=*/true),
+        GetRpcResult("inputsHash"),
+    }};
+}
+
+RPCResult CSimplifiedMNListDiff::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The simplified masternode list diff",
+    {
+        {RPCResult::Type::NUM, "nVersion", "Version of the diff"},
+        {RPCResult::Type::STR_HEX, "baseBlockHash", "Hash of the base block"},
+        {RPCResult::Type::STR_HEX, "blockHash", "Hash of the ending block"},
+        {RPCResult::Type::STR_HEX, "cbTxMerkleTree", "Coinbase transaction merkle tree"},
+        {RPCResult::Type::STR_HEX, "cbTx", "Coinbase raw transaction"},
+        {RPCResult::Type::ARR, "deletedMNs", "ProRegTx hashes of deleted masternodes",
+            {{RPCResult::Type::STR_HEX, "hash", ""}}},
+        {RPCResult::Type::ARR, "mnList", "Masternode list details",
+            {CSimplifiedMNListEntry::GetJsonHelp(/*key=*/"", /*optional=*/false)}},
+        {RPCResult::Type::ARR, "deletedQuorums", "Deleted quorums",
+            {{RPCResult::Type::OBJ, "", "", {
+                GetRpcResult("llmqType"),
+                GetRpcResult("quorumHash"),
+        }}}},
+        {RPCResult::Type::ARR, "newQuorums", "New quorums",
+            {llmq::CFinalCommitment::GetJsonHelp(/*key=*/"", /*optional=*/false)}},
+        GetRpcResult("merkleRootMNList", /*optional=*/true),
+        GetRpcResult("merkleRootQuorums", /*optional=*/true),
+        {RPCResult::Type::ARR, "quorumsCLSigs", "ChainLock signature details", {
+            {RPCResult::Type::OBJ_DYN, "", "json object with the BLS signature as key", {
+                {RPCResult::Type::ARR, "<sig_hex>", "Array of quorum indices signed by this BLS signature", {
+                    {RPCResult::Type::NUM, "", "Quorum index"}
+        }}}}}},
+    }};
+}
+
+RPCResult CSimplifiedMNListEntry::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The simplified masternode list entry",
+    {
+        {RPCResult::Type::NUM, "nVersion", "Version of the entry"},
+        GetRpcResult("type", /*optional=*/false, /*override_name=*/"nType"),
+        {RPCResult::Type::STR_HEX, "proRegTxHash", "Hash of the ProRegTx identifying the masternode"},
+        {RPCResult::Type::STR_HEX, "confirmedHash", "Hash of the block where the masternode was confirmed"},
+        GetRpcResult("service", /*optional=*/true),
+        GetRpcResult("addresses"),
+        GetRpcResult("pubKeyOperator"),
+        GetRpcResult("votingAddress"),
+        {RPCResult::Type::BOOL, "isValid", "Returns true if the masternode is not Proof-of-Service banned"},
+        GetRpcResult("platformHTTPPort", /*optional=*/true),
+        GetRpcResult("platformNodeID", /*optional=*/true),
+        GetRpcResult("payoutAddress", /*optional=*/true),
+        GetRpcResult("payouts", /*optional=*/true),
+        GetRpcResult("operatorPayoutAddress", /*optional=*/true),
+    }};
+}
+
+RPCResult MNHFTx::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode hard fork payload",
+    {
+        {RPCResult::Type::NUM, "versionBit", "Version bit associated with the hard fork"},
+        GetRpcResult("quorumHash"),
+        {RPCResult::Type::STR_HEX, "sig", "BLS signature by a quorum public key"},
+    }};
+}
+
+RPCResult MNHFTxPayload::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode hard fork signal special transaction",
+    {
+        GetRpcResult("version"),
+        MNHFTx::GetJsonHelp(/*key=*/"signal", /*optional=*/false),
+    }};
+}
+
+namespace llmq {
+// CDKGDebugSessionStatus::ToJson() defined in llmq/debug.cpp
+RPCResult CDKGDebugSessionStatus::GetJsonHelp(const std::string& key, bool optional)
+{
+    // A member tally is a count for detail_level = 0, an array of member indexes for
+    // detail_level = 1, and an array of {memberIndex, proTxHash} objects for
+    // detail_level = 2. RPCResult can only express such a union as ANY: conditional
+    // variants are only resolved for top-level results, so listing one variant per
+    // detail level here would make every level fail the runtime doc check.
+    const auto member_tally{[](const std::string& name, const std::string& what) {
+        return RPCResult{RPCResult::Type::ANY, name,
+                         strprintf("Number of %s (detail_level = 0), array of quorum member indexes "
+                                   "(detail_level = 1), or array of {memberIndex, proTxHash} objects "
+                                   "(detail_level = 2)",
+                                   what)};
+    }};
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The state of a DKG session. Empty for an unknown LLMQ type or quorum hash",
+    {
+        GetRpcResult("llmqType", /*optional=*/true),
+        GetRpcResult("quorumHash", /*optional=*/true),
+        {RPCResult::Type::NUM, "quorumHeight", /*optional=*/true, "Block height of the quorum"},
+        {RPCResult::Type::NUM, "phase", /*optional=*/true, "Active DKG phase"},
+        {RPCResult::Type::BOOL, "sentContributions", /*optional=*/true, "Returns true if contributions sent"},
+        {RPCResult::Type::BOOL, "sentComplaint", /*optional=*/true, "Returns true if complaints sent"},
+        {RPCResult::Type::BOOL, "sentJustification", /*optional=*/true, "Returns true if justifications sent"},
+        {RPCResult::Type::BOOL, "sentPrematureCommitment", /*optional=*/true, "Returns true if premature commitments sent"},
+        {RPCResult::Type::BOOL, "aborted", /*optional=*/true, "Returns true if DKG session aborted"},
+        member_tally("badMembers", "bad members"),
+        member_tally("weComplain", "complaints sent"),
+        member_tally("receivedContributions", "contributions received"),
+        member_tally("receivedComplaints", "complaints received"),
+        member_tally("receivedJustifications", "justifications received"),
+        member_tally("receivedPrematureCommitments", "premature commitments received"),
+        {RPCResult::Type::ARR, "allMembers", /*optional=*/true, "Provider registration transaction hash for all quorum members. Only present for detail_level = 2", {
+            GetRpcResult("proTxHash")}},
+    }};
+}
+
+// CDKGDebugManager::ToJson() defined in llmq/debug.cpp
+RPCResult CDKGDebugManager::GetJsonHelp(const std::string& key, bool optional, bool inner_optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The state of the node's DKG sessions",
+    {
+        {RPCResult::Type::NUM, "time", inner_optional, "Adjusted time for the last update, timestamp"},
+        {RPCResult::Type::STR, "timeStr", inner_optional, "Adjusted time for the last update, human friendly"},
+        {RPCResult::Type::ARR, "session", inner_optional, "", {
+            {RPCResult::Type::OBJ, "", "", {
+                {RPCResult::Type::STR, "llmqType", "Name of quorum"},
+                GetRpcResult("quorumIndex"),
+                CDKGDebugSessionStatus::GetJsonHelp(/*key=*/"status", /*optional=*/false)
+            }},
+        }}
+    }};
+}
+
+RPCResult CFinalCommitment::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The quorum commitment payload",
+    {
+        {RPCResult::Type::NUM, "version", "Quorum commitment payload version"},
+        GetRpcResult("llmqType"),
+        GetRpcResult("quorumHash"),
+        {RPCResult::Type::NUM, "quorumIndex", "Index of the quorum"},
+        {RPCResult::Type::NUM, "signersCount", "Number of signers for the quorum"},
+        {RPCResult::Type::STR_HEX, "signers", "Bitset representing the aggregated signers"},
+        {RPCResult::Type::NUM, "validMembersCount", "Number of valid members in the quorum"},
+        {RPCResult::Type::STR_HEX, "validMembers", "Bitset of valid members"},
+        {RPCResult::Type::STR_HEX, "quorumPublicKey", "BLS public key of the quorum"},
+        {RPCResult::Type::STR_HEX, "quorumVvecHash", "Hash of the quorum verification vector"},
+        GetRpcResult("quorumSig"),
+        {RPCResult::Type::STR_HEX, "membersSig", "BLS signature from all included commitments"},
+    }};
+}
+
+RPCResult CFinalCommitmentTxPayload::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The quorum commitment special transaction",
+    {
+        GetRpcResult("version"),
+        GetRpcResult("height"),
+        CFinalCommitment::GetJsonHelp(/*key=*/"commitment", /*optional=*/false),
+    }};
+}
+
+RPCResult CQuorumRotationInfo::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The quorum rotation",
+    {
+        {RPCResult::Type::BOOL, "extraShare", "Returns true if an extra share is returned"},
+        CQuorumSnapshot::GetJsonHelp(/*key=*/"quorumSnapshotAtHMinusC", /*optional=*/false),
+        CQuorumSnapshot::GetJsonHelp(/*key=*/"quorumSnapshotAtHMinus2C", /*optional=*/false),
+        CQuorumSnapshot::GetJsonHelp(/*key=*/"quorumSnapshotAtHMinus3C", /*optional=*/false),
+        CQuorumSnapshot::GetJsonHelp(/*key=*/"quorumSnapshotAtHMinus4C", /*optional=*/true),
+        CSimplifiedMNListDiff::GetJsonHelp(/*key=*/"mnListDiffTip", /*optional=*/false),
+        CSimplifiedMNListDiff::GetJsonHelp(/*key=*/"mnListDiffH", /*optional=*/false),
+        CSimplifiedMNListDiff::GetJsonHelp(/*key=*/"mnListDiffAtHMinusC", /*optional=*/false),
+        CSimplifiedMNListDiff::GetJsonHelp(/*key=*/"mnListDiffAtHMinus2C", /*optional=*/false),
+        CSimplifiedMNListDiff::GetJsonHelp(/*key=*/"mnListDiffAtHMinus3C", /*optional=*/false),
+        CSimplifiedMNListDiff::GetJsonHelp(/*key=*/"mnListDiffAtHMinus4C", /*optional=*/true),
+        {RPCResult::Type::ARR, "lastCommitmentPerIndex", "Most recent commitment for each quorumIndex", {
+            CFinalCommitment::GetJsonHelp(/*key=*/"", /*optional=*/false),
+        }},
+        {RPCResult::Type::ARR, "quorumSnapshotList", "Snapshots required to reconstruct the quorums built at h' in lastCommitmentPerIndex", {
+            CQuorumSnapshot::GetJsonHelp(/*key=*/"", /*optional=*/false),
+        }},
+        {RPCResult::Type::ARR, "mnListDiffList", "MnListDiffs required to calculate older quorums", {
+            CSimplifiedMNListDiff::GetJsonHelp(/*key=*/"", /*optional=*/false),
+        }},
+    }};
+}
+
+RPCResult CQuorumSnapshot::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The quorum snapshot",
+    {
+        {RPCResult::Type::ARR, "activeQuorumMembers", "Bitset of nodes already in quarters at the start of cycle", {
+            {RPCResult::Type::BOOL, "bit", ""}
+        }},
+        {RPCResult::Type::NUM, "mnSkipListMode", "Mode of the skip list"},
+        {RPCResult::Type::ARR, "mnSkipList", "Skiplist at height", {
+            {RPCResult::Type::NUM, "height", ""}
+        }},
+    }};
+}
+
+RPCResult CRecoveredSig::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The recovered signature",
+    {
+        GetRpcResult("llmqType"),
+        GetRpcResult("quorumHash"),
+        {RPCResult::Type::STR_HEX, "id", "Signing session ID"},
+        {RPCResult::Type::STR_HEX, "msgHash", "Hash of message"},
+        {RPCResult::Type::STR_HEX, "sig", "BLS signature recovered"},
+        {RPCResult::Type::STR_HEX, "hash", "Hash of the BLS signature recovered"},
+    }};
+}
+} // namespace llmq
+
+RPCResult CGovernanceManager::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "Count of governance objects and votes",
+    {
+        {RPCResult::Type::NUM, "objects_total", "Total number of all governance objects"},
+        {RPCResult::Type::NUM, "proposals", "Number of governance proposals"},
+        {RPCResult::Type::NUM, "triggers", "Number of triggers"},
+        {RPCResult::Type::NUM, "other", "Total number of unknown governance objects"},
+        {RPCResult::Type::NUM, "erased", "Number of removed (expired) objects"},
+        {RPCResult::Type::NUM, "votes", "Total number of votes"},
+    }};
+}
+
+RPCResult CGovernanceObject::GetInnerJsonHelp(const std::string& key, bool optional)
+{
+    return Governance::Object::GetJsonHelp(key, optional);
+}
+
+// CGovernanceObject::GetStateJson() defined in governance/object.cpp
+RPCResult CGovernanceObject::GetStateJsonHelp(const std::string& key, bool optional, const std::string& local_valid_key)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "Object state info",
+    {
+        {RPCResult::Type::STR_HEX, "DataHex", "Governance object (hex)"},
+        {RPCResult::Type::STR, "DataString", "Governance object (string)"},
+        {RPCResult::Type::STR_HEX, "Hash", "Hash of governance object"},
+        GetRpcResult("collateralHash", /*optional=*/false, /*override_name=*/"CollateralHash"),
+        {RPCResult::Type::NUM, "ObjectType", "Object types"},
+        {RPCResult::Type::NUM, "CreationTime", "Object creation timestamp"},
+        {RPCResult::Type::STR_HEX, "SigningMasternode", /*optional=*/true, "Signing masternode’s vin (for triggers only)"},
+        {RPCResult::Type::BOOL, local_valid_key, "Returns true if valid"},
+        {RPCResult::Type::STR, "IsValidReason", strprintf("%s error (human-readable string, empty if %s true)", local_valid_key, local_valid_key)},
+        {RPCResult::Type::BOOL, "fCachedValid", "Returns true if minimum support has been reached flagging object as valid"},
+        {RPCResult::Type::BOOL, "fCachedFunding", "Returns true if minimum support has been reached flagging object as fundable"},
+        {RPCResult::Type::BOOL, "fCachedDelete", "Returns true if minimum support has been reached flagging object as marked for deletion"},
+        {RPCResult::Type::BOOL, "fCachedEndorsed", "Returns true if minimum support has been reached flagging object as endorsed"},
+    }};
+}
+
+RPCResult CGovernanceObject::GetVotesJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "Object vote counts",
+    {
+        {RPCResult::Type::NUM, "AbsoluteYesCount", "Number of Yes votes minus number of No votes"},
+        {RPCResult::Type::NUM, "YesCount", "Number of Yes votes"},
+        {RPCResult::Type::NUM, "NoCount", "Number of No votes"},
+        {RPCResult::Type::NUM, "AbstainCount", "Number of Abstain votes"},
+    }};
+}
+
+namespace Governance {
+RPCResult Object::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "Object info",
+    {
+        {RPCResult::Type::STR_HEX, "objectHash", "Hash of proposal object"},
+        {RPCResult::Type::STR_HEX, "parentHash", "Hash of the parent object (root node has a hash of 0)"},
+        GetRpcResult("collateralHash"),
+        {RPCResult::Type::NUM, "createdAt", "Proposal creation timestamp"},
+        {RPCResult::Type::NUM, "revision", "Proposal revision number"},
+        // Everything but "hex" is the submitter's own JSON echoed back verbatim, so neither the
+        // set of keys nor their types is ours to promise: a proposal may carry extra fields and
+        // may encode the numeric ones as strings. Hence the type check is skipped here.
+        {RPCResult::Type::OBJ, "data", "", {
+            // Fields emitted through GetDataAsPlainString(), read by CProposalValidator
+            {RPCResult::Type::ANY, "end_epoch", /*optional=*/true, "Proposal end timestamp"},
+            {RPCResult::Type::ANY, "name", /*optional=*/true, "Proposal name"},
+            {RPCResult::Type::ANY, "payment_address", /*optional=*/true, "Proposal payment address"},
+            {RPCResult::Type::ANY, "payment_amount", /*optional=*/true, "Proposal payment amount"},
+            {RPCResult::Type::ANY, "start_epoch", /*optional=*/true, "Proposal start timestamp"},
+            {RPCResult::Type::ANY, "type", /*optional=*/true, "Object type"},
+            {RPCResult::Type::ANY, "url", /*optional=*/true, "Proposal URL"},
+            // Failure case for GetDataAsPlainString()
+            {RPCResult::Type::STR, "plain", /*optional=*/true, "Governance object data as string"},
+            // Always emitted by ToJson()
+            {RPCResult::Type::STR_HEX, "hex", "Governance object data as hex"},
+        }, /*skip_type_check=*/true},
+    }};
+}
+} // namespace Governance
diff --git a/src/rpc/json_help.h b/src/rpc/json_help.h
new file mode 100644
index 000000000000..d6e136a4f6b2
--- /dev/null
+++ b/src/rpc/json_help.h
@@ -0,0 +1,16 @@
+// Copyright (c) 2025-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_RPC_JSON_HELP_H
+#define BITCOIN_RPC_JSON_HELP_H
+
+#include <string>
+
+struct RPCResult;
+
+/** Return a commonly used RPCResult by field name, optionally overriding its
+ *  optional flag and key name. Throws for an unknown key. */
+RPCResult GetRpcResult(const std::string& key, bool optional = false, const std::string& override_name = "");
+
+#endif // BITCOIN_RPC_JSON_HELP_H
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 263daa178cd7..71ed202a234b 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -9,7 +9,7 @@
 #include <evo/deterministicmns.h>
 #include <governance/superblock.h>
 #include <masternode/payments.h>
-#include <rpc/evo_util.h>
+#include <rpc/json_help.h>
 
 #include <chainparams.h>
 #include <core_io.h>
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index 6c14b59f4e25..0d88d735d2fa 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -21,7 +21,7 @@
 #include <llmq/signing_shares.h>
 #include <llmq/snapshot.h>
 #include <llmq/utils.h>
-#include <rpc/evo_util.h>
+#include <rpc/json_help.h>
 #include <util/helpers.h>
 
 #include <chainparams.h>
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 84d49954a6a0..6c4ea8abce7b 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -52,8 +52,8 @@ src/qt/proposalmodel.*
 src/qt/proposalresume.*
 src/rpc/coinjoin.cpp
 src/rpc/evo.cpp
-src/rpc/evo_util.*
 src/rpc/governance.cpp
+src/rpc/json_help.*
 src/rpc/masternode.cpp
 src/rpc/quorums.cpp
 src/saltedhasher.*