From f4e6aa2ce5bafa73fb57c547671238ef5cbc5414 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Tue, 18 Aug 2026 02:10:03 +0700
Subject: [PATCH 1/9] test: merge multiple core_write instances to one module
 for circular dependency linter

Division of core_write to submodules in evo/, llmq/, governance/ split out evo, llmq, governance
code and potentially is useful to reduce binaries size ; for instance the binary dash-tx links only
libbitcoin_common + consensus/util so main core_write should not have governance/ code.

This commit is fixing linter's bug and adds suppressions for existing circular dependencies.
---
 contrib/devtools/circular-dependencies.py | 3 +++
 test/lint/lint-circular-dependencies.py   | 7 ++++++-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/contrib/devtools/circular-dependencies.py b/contrib/devtools/circular-dependencies.py
index a6cdc343d5cb..e3ce1e4bcf6f 100755
--- a/contrib/devtools/circular-dependencies.py
+++ b/contrib/devtools/circular-dependencies.py
@@ -11,6 +11,9 @@
 MAPPING = {
     'core_read.cpp': 'core_io.cpp',
     'core_write.cpp': 'core_io.cpp',
+    'evo/core_write.cpp': 'core_io.cpp',
+    'governance/core_write.cpp': 'core_io.cpp',
+    'llmq/core_write.cpp': 'core_io.cpp',
 }
 
 # Directories with header-based modules, where the assumption that .cpp files
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 13d3b388c268..524e3b07d2e0 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -29,11 +29,16 @@
 )
 
 EXPECTED_DASH_CIRCULAR_DEPENDENCIES = (
+    "core_io -> evo/smldiff -> core_io",
+    "core_io -> governance/governance -> governance/superblock -> core_io",
+    "coinjoin/coinjoin -> core_io -> rpc/util -> node/transaction -> net_processing -> coinjoin/coinjoin",
+    "coinjoin/coinjoin -> core_io -> rpc/util -> node/transaction -> node/context -> coinjoin/coinjoin",
+    "coinjoin/client -> core_io -> rpc/util -> node/transaction -> net_processing -> coinjoin/walletman -> coinjoin/client",
+    "coinjoin/coinjoin -> core_io -> rpc/util -> node/transaction -> node/context -> dsnotificationinterface -> coinjoin/coinjoin",
     "index/addressindex -> index/base -> node/context -> index/addressindex",
     "index/base -> node/context -> index/spentindex -> index/base",
     "index/base -> node/context -> index/timestampindex -> index/base",
     "banman -> common/bloom -> evo/assetlocktx -> llmq/quorumsman -> llmq/blockprocessor -> net -> banman",
-    "coinjoin/client -> coinjoin/util -> wallet/wallet -> psbt -> node/transaction -> net_processing -> coinjoin/walletman -> coinjoin/client",
     "common/bloom -> evo/assetlocktx -> llmq/commitment -> evo/deterministicmns -> evo/simplifiedmns -> merkleblock -> common/bloom",
     "common/bloom -> evo/assetlocktx -> llmq/quorumsman -> llmq/blockprocessor -> net -> common/bloom",
     "consensus/tx_verify -> evo/assetlocktx -> llmq/commitment -> validation -> consensus/tx_verify",

From 6c67fc38d98c757f7a783e021c8660a5d1efa9e1 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Tue, 18 Aug 2026 18:09:55 +0700
Subject: [PATCH 2/9] refactor: drop unused core_io.h include from evo/smldiff

The include was left behind when CSimplifiedMNListDiff::ToJson() moved out to
evo/core_write.cpp; nothing in smldiff.cpp uses core_io anymore. Now that the
linter maps evo/core_write.cpp into the core_io module, the stale include
manifests as the circular dependency core_io -> evo/smldiff -> core_io.
---
 src/evo/smldiff.cpp                     | 1 -
 test/lint/lint-circular-dependencies.py | 1 -
 2 files changed, 2 deletions(-)

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/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 524e3b07d2e0..c573f0fe2529 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -29,7 +29,6 @@
 )
 
 EXPECTED_DASH_CIRCULAR_DEPENDENCIES = (
-    "core_io -> evo/smldiff -> core_io",
     "core_io -> governance/governance -> governance/superblock -> core_io",
     "coinjoin/coinjoin -> core_io -> rpc/util -> node/transaction -> net_processing -> coinjoin/coinjoin",
     "coinjoin/coinjoin -> core_io -> rpc/util -> node/transaction -> node/context -> coinjoin/coinjoin",

From 99464cfef5b593b5b6cf128845a8bcdfe1393fdc Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Wed, 19 Aug 2026 03:36:34 +0700
Subject: [PATCH 3/9] refactor: move RPC help definitions out of core_io module
 into rpc/

The GetJsonHelp()/GetRpcResult() definitions lived in the {evo,llmq,
governance}/core_write.cpp files, which form the core_io module and are built
into libbitcoin_common for the sake of their ToJson() halves (dash-tx prints
special-tx payloads via TxToUniv()). The help halves forced rpc/util.h into
core_io's dependency closure, creating four circular dependencies through
core_io -> rpc/util -> node/transaction, and shipped the help tables in
libbitcoin_common although every consumer (rpc/blockchain, rpc/coinjoin,
rpc/evo, rpc/governance, rpc/masternode, rpc/quorums, rpc/rawtransaction) is
in libbitcoin_node.

Move RPCRESULT_MAP, GetRpcResult() and all GetJsonHelp() definitions verbatim
into a new rpc/json_help.{h,cpp} in libbitcoin_node, and move the
GetRpcResult() declaration from core_io.h to the new header. The core_write
files keep only their ToJson() definitions. The help is RPC documentation
shared by several command files, so it gets its own translation unit rather
than being spliced into the generic machinery of rpc/util.cpp, which is part
of libbitcoin_common and would keep the tables in the common library.

The four coinjoin suppressions through core_io -> rpc/util are gone; the
longer pre-existing coinjoin/client -> coinjoin/util -> wallet/wallet cycle
they had been shadowing is visible to the linter again and returns to the
suppression list.
---
 src/Makefile.am                         |   2 +
 src/core_io.h                           |   4 -
 src/evo/core_write.cpp                  | 322 --------------
 src/governance/core_write.cpp           |  82 ----
 src/llmq/core_write.cpp                 | 145 +-----
 src/rpc/coinjoin.cpp                    |   1 +
 src/rpc/json_help.cpp                   | 568 ++++++++++++++++++++++++
 src/rpc/json_help.h                     |  16 +
 src/rpc/masternode.cpp                  |   1 +
 src/rpc/quorums.cpp                     |   1 +
 test/lint/lint-circular-dependencies.py |   5 +-
 test/util/data/non-backported.txt       |   1 +
 12 files changed, 593 insertions(+), 555 deletions(-)
 create mode 100644 src/rpc/json_help.cpp
 create mode 100644 src/rpc/json_help.h

diff --git a/src/Makefile.am b/src/Makefile.am
index 0cf8ce802fdb..1d505ab5d06b 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -373,6 +373,7 @@ BITCOIN_CORE_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 +639,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 \
diff --git a/src/core_io.h b/src/core_io.h
index 85deffd5c2fd..537067bf0952 100644
--- a/src/core_io.h
+++ b/src/core_io.h
@@ -18,7 +18,6 @@ class CTxUndo;
 class uint256;
 struct CMutableTransaction;
 struct CSpentIndexTxInfo;
-struct RPCResult;
 
 class UniValue;
 
@@ -57,7 +56,4 @@ std::string SighashToStr(unsigned char sighash_type);
 void ScriptToUniv(const CScript& script, UniValue& out, bool include_hex = true, bool include_address = false);
 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 = "");
-
 #endif // BITCOIN_CORE_IO_H
diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index 0aaafa6e545b..b01ebd5bce66 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -4,7 +4,6 @@
 
 #include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
-#include <evo/deterministicmns.h>
 #include <evo/dmnstate.h>
 #include <evo/mnhftx.h>
 #include <evo/netinfo.h>
@@ -17,75 +16,14 @@
 
 #include <core_io.h>
 #include <key_io.h>
-#include <rpc/util.h>
 #include <script/standard.h>
 #include <util/check.h>
 
 #include <univalue.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
-
 template <typename Obj>
 std::string GetDeprecatedServiceField(const Obj& obj)
 {
@@ -93,35 +31,6 @@ std::string GetDeprecatedServiceField(const Obj& obj)
 }
 } // 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)"},
-        }}}}
-    }};
-}
-
 UniValue CAssetLockPayload::ToJson() const
 {
     UniValue outputs(UniValue::VARR);
@@ -147,19 +56,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 +68,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 +85,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 +123,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 +154,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 +170,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 +180,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 +204,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 +267,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 +302,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 +311,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/governance/core_write.cpp b/src/governance/core_write.cpp
index 9f634ba76639..e3b0e0702838 100644
--- a/src/governance/core_write.cpp
+++ b/src/governance/core_write.cpp
@@ -2,29 +2,13 @@
 // 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);
@@ -57,48 +41,11 @@ UniValue CGovernanceManager::ToJson() const
     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);
@@ -110,35 +57,6 @@ UniValue CGovernanceObject::GetVotesJson(const CDeterministicMNList& tip_mn_list
 }
 
 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);
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/json_help.cpp b/src/rpc/json_help.cpp
new file mode 100644
index 000000000000..01feb4168ca6
--- /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 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),
+    }};
+}
+
+// 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..6933e6534589 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -10,6 +10,7 @@
 #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..c1a419b08053 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -22,6 +22,7 @@
 #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/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index c573f0fe2529..1a7f4d24b770 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -30,14 +30,11 @@
 
 EXPECTED_DASH_CIRCULAR_DEPENDENCIES = (
     "core_io -> governance/governance -> governance/superblock -> core_io",
-    "coinjoin/coinjoin -> core_io -> rpc/util -> node/transaction -> net_processing -> coinjoin/coinjoin",
-    "coinjoin/coinjoin -> core_io -> rpc/util -> node/transaction -> node/context -> coinjoin/coinjoin",
-    "coinjoin/client -> core_io -> rpc/util -> node/transaction -> net_processing -> coinjoin/walletman -> coinjoin/client",
-    "coinjoin/coinjoin -> core_io -> rpc/util -> node/transaction -> node/context -> dsnotificationinterface -> coinjoin/coinjoin",
     "index/addressindex -> index/base -> node/context -> index/addressindex",
     "index/base -> node/context -> index/spentindex -> index/base",
     "index/base -> node/context -> index/timestampindex -> index/base",
     "banman -> common/bloom -> evo/assetlocktx -> llmq/quorumsman -> llmq/blockprocessor -> net -> banman",
+    "coinjoin/client -> coinjoin/util -> wallet/wallet -> psbt -> node/transaction -> net_processing -> coinjoin/walletman -> coinjoin/client",
     "common/bloom -> evo/assetlocktx -> llmq/commitment -> evo/deterministicmns -> evo/simplifiedmns -> merkleblock -> common/bloom",
     "common/bloom -> evo/assetlocktx -> llmq/quorumsman -> llmq/blockprocessor -> net -> common/bloom",
     "consensus/tx_verify -> evo/assetlocktx -> llmq/commitment -> validation -> consensus/tx_verify",
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 84d49954a6a0..8c067dc2ad27 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -54,6 +54,7 @@ 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.*

From bbeeeb39a07bec46d044908522f38684479751b0 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Wed, 19 Aug 2026 03:39:08 +0700
Subject: [PATCH 4/9] refactor: dissolve governance/core_write.cpp into class
 home files

Unlike the evo and llmq JSON writers, nothing that links only
libbitcoin_common prints governance objects: dash-tx's TxToUniv() knows no
governance payload, and all callers of these ToJson() definitions sit in
libbitcoin_node. Keeping them in a libbitcoin_common file bought nothing and
forced governance/governance.h into the core_io module, creating the circular
dependency core_io -> governance/governance -> governance/superblock ->
core_io.

Move CGovernanceManager::ToJson() to governance/governance.cpp,
CGovernanceObject::GetInnerJson()/GetVotesJson() to governance/object.cpp and
Governance::Object::ToJson() to governance/common.cpp, and delete the file
along with its linter module mapping and the now-cleared suppression.
---
 contrib/devtools/circular-dependencies.py |  1 -
 src/Makefile.am                           |  1 -
 src/governance/common.cpp                 | 19 ++++++
 src/governance/core_write.cpp             | 78 -----------------------
 src/governance/governance.cpp             | 34 ++++++++++
 src/governance/object.cpp                 | 15 +++++
 test/lint/lint-circular-dependencies.py   |  1 -
 7 files changed, 68 insertions(+), 81 deletions(-)
 delete mode 100644 src/governance/core_write.cpp

diff --git a/contrib/devtools/circular-dependencies.py b/contrib/devtools/circular-dependencies.py
index e3ce1e4bcf6f..367c71a58c53 100755
--- a/contrib/devtools/circular-dependencies.py
+++ b/contrib/devtools/circular-dependencies.py
@@ -12,7 +12,6 @@
     'core_read.cpp': 'core_io.cpp',
     'core_write.cpp': 'core_io.cpp',
     'evo/core_write.cpp': 'core_io.cpp',
-    'governance/core_write.cpp': 'core_io.cpp',
     'llmq/core_write.cpp': 'core_io.cpp',
 }
 
diff --git a/src/Makefile.am b/src/Makefile.am
index 1d505ab5d06b..1d95e8a789cb 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -971,7 +971,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 \
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 e3b0e0702838..000000000000
--- a/src/governance/core_write.cpp
+++ /dev/null
@@ -1,78 +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 <governance/common.h>
-#include <governance/governance.h>
-#include <governance/object.h>
-#include <util/check.h>
-
-#include <univalue.h>
-
-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;
-}
-
-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;
-}
-
-namespace Governance {
-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/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 1a7f4d24b770..13d3b388c268 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -29,7 +29,6 @@
 )
 
 EXPECTED_DASH_CIRCULAR_DEPENDENCIES = (
-    "core_io -> governance/governance -> governance/superblock -> core_io",
     "index/addressindex -> index/base -> node/context -> index/addressindex",
     "index/base -> node/context -> index/spentindex -> index/base",
     "index/base -> node/context -> index/timestampindex -> index/base",

From 520a6690286c784c3365049a269195f8605fd0c7 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Wed, 19 Aug 2026 03:58:18 +0700
Subject: [PATCH 5/9] refactor: dissolve rpc/evo_util.cpp into rpc/evo.cpp

Also drop coinjoin/client.cpp's unused include of the header and correct the
stale note claiming CDeterministicMN::ToJson() lived in
evo/deterministicmns.cpp: it lived in rpc/evo_util.cpp and now lives in
rpc/evo.cpp.
---
 src/Makefile.am         |  1 -
 src/coinjoin/client.cpp |  1 -
 src/rpc/evo.cpp         | 27 +++++++++++++++++++++++++++
 src/rpc/evo_util.cpp    | 36 ------------------------------------
 src/rpc/json_help.cpp   |  2 +-
 5 files changed, 28 insertions(+), 39 deletions(-)
 delete mode 100644 src/rpc/evo_util.cpp

diff --git a/src/Makefile.am b/src/Makefile.am
index 1d95e8a789cb..1a843ebfa059 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -985,7 +985,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/rpc/evo.cpp b/src/rpc/evo.cpp
index 97a03921d4a8..90f94473de87 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,31 @@ using wallet::HELP_REQUIRING_PASSPHRASE;
 using wallet::isminetype;
 #endif // ENABLE_WALLET
 
+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/json_help.cpp b/src/rpc/json_help.cpp
index 01feb4168ca6..8bae35f01a2e 100644
--- a/src/rpc/json_help.cpp
+++ b/src/rpc/json_help.cpp
@@ -143,7 +143,7 @@ RPCResult CCbTx::GetJsonHelp(const std::string& key, bool optional)
     }};
 }
 
-// CDeterministicMN::ToJson() defined in evo/deterministicmns.cpp
+// 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",

From 8e5805e3148087fdc3652a5195bdd1936c2ed0f8 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Wed, 19 Aug 2026 04:44:54 +0700
Subject: [PATCH 6/9] docs: explain CDeterministicMN::ToJson() placement in
 rpc/evo.cpp

Re-land of pre-rebase 1df2394751, dropped during the rebase over PR 7600.
The function looks misplaced next to its siblings in evo/core_write.cpp, so
record why it lives here: dash-tx never prints a masternode entry, the
g_txindex lookup ties it to libbitcoin_node, and hosting it in
evo/deterministicmns.cpp would create four new circular dependencies.
---
 src/rpc/evo.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 90f94473de87..285cf857beab 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -52,6 +52,9 @@ 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);

From 7c1f653830ed2ec5449307789320117ff5716f1e Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Wed, 19 Aug 2026 04:23:33 +0700
Subject: [PATCH 7/9] refactor: absorb netinfo legacy-field helpers into the
 core_io module

GetNetInfoWithLegacyFields() and GetPlatformPort() are not RPC utilities:
they are JSON writers over netInfo and the legacy platform port fields,
consumed by the ToJson() definitions in evo/core_write.cpp plus two report
builders in rpc/masternode.cpp and rpc/quorums.cpp. After the previous commit
hollowed rpc/evo_util down to just these two templates, keeping a separate
rpc/ header for them was pure overhead.

Define them in evo/core_write.cpp next to their main users, declare them in
core_io.h (the module's header, like the other core_write writers), and add
explicit CDeterministicMNState instantiations for the two out-of-module
consumers. rpc/evo_util.h is deleted; the rpc/evo_util module is gone
entirely. No linter suppression changes: the module took part in no cycle.
---
 src/Makefile.am                   |  1 -
 src/core_io.h                     | 10 ++++
 src/evo/core_write.cpp            | 65 ++++++++++++++++++++++++-
 src/rpc/evo_util.h                | 80 -------------------------------
 src/rpc/masternode.cpp            |  1 -
 src/rpc/quorums.cpp               |  1 -
 test/util/data/non-backported.txt |  1 -
 7 files changed, 74 insertions(+), 85 deletions(-)
 delete mode 100644 src/rpc/evo_util.h

diff --git a/src/Makefile.am b/src/Makefile.am
index 1a843ebfa059..3150de83e809 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -372,7 +372,6 @@ 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 \
diff --git a/src/core_io.h b/src/core_io.h
index 537067bf0952..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,6 +19,7 @@ class CTxUndo;
 class uint256;
 struct CMutableTransaction;
 struct CSpentIndexTxInfo;
+enum class MnType : uint16_t;
 
 class UniValue;
 
@@ -56,4 +58,12 @@ std::string SighashToStr(unsigned char sighash_type);
 void ScriptToUniv(const CScript& script, UniValue& out, bool include_hex = true, bool include_address = false);
 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
+/** 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 b01ebd5bce66..4ebe78675f2d 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -4,6 +4,7 @@
 
 #include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
+#include <evo/dmn_types.h>
 #include <evo/dmnstate.h>
 #include <evo/mnhftx.h>
 #include <evo/netinfo.h>
@@ -11,17 +12,19 @@
 #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 <netaddress.h>
 #include <script/standard.h>
 #include <util/check.h>
 
 #include <univalue.h>
 
+#include <cstdint>
 #include <string>
+#include <type_traits>
 
 namespace {
 template <typename Obj>
@@ -31,6 +34,66 @@ std::string GetDeprecatedServiceField(const Obj& obj)
 }
 } // anonymous namespace
 
+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;
+}
+template UniValue GetNetInfoWithLegacyFields(const CDeterministicMNState& obj, const MnType& type);
+
+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();
+    }
+}
+template int32_t GetPlatformPort<true>(const CDeterministicMNState& obj);
+template int32_t GetPlatformPort<false>(const CDeterministicMNState& obj);
+
 UniValue CAssetLockPayload::ToJson() const
 {
     UniValue outputs(UniValue::VARR);
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/masternode.cpp b/src/rpc/masternode.cpp
index 6933e6534589..71ed202a234b 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -9,7 +9,6 @@
 #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>
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index c1a419b08053..0d88d735d2fa 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -21,7 +21,6 @@
 #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>
 
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 8c067dc2ad27..6c4ea8abce7b 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -52,7 +52,6 @@ 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

From ef7ba7b9772cf851ec8e7c016dd05a5f3b174e25 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Thu, 20 Aug 2026 00:03:26 +0700
Subject: [PATCH 8/9] fix: add one more splitted module: qt/guiutil +
 qqt/guiutil_font

The split between modules to avoid conflicts for backports which changes qt/guiutil
---
 contrib/devtools/circular-dependencies.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contrib/devtools/circular-dependencies.py b/contrib/devtools/circular-dependencies.py
index 367c71a58c53..247aa029973e 100755
--- a/contrib/devtools/circular-dependencies.py
+++ b/contrib/devtools/circular-dependencies.py
@@ -13,6 +13,7 @@
     'core_write.cpp': 'core_io.cpp',
     'evo/core_write.cpp': 'core_io.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

From 6f9a7adca93852f758184f81526c347d733e3be6 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Thu, 20 Aug 2026 00:07:10 +0700
Subject: [PATCH 9/9] fix: add one more module merge for circular linter:
 evo/providertx_util

Motivation to exist providertx_util are:

    Owner payout list helpers that operate purely on the serialized representation. They live in
    libbitcoin_common (rather than libbitcoin_node alongside the rest of providertx.cpp) so that
    common-layer consumers like the bloom filter and the JSON writers can use them without pulling
    in node-only dependencies.

This commit removes providertx's dependency on dmnstate
---
 contrib/devtools/circular-dependencies.py |  1 +
 src/evo/dmnstate.h                        |  2 ++
 src/evo/providertx.h                      |  5 ++++-
 src/evo/providertx_util.cpp               | 11 -----------
 4 files changed, 7 insertions(+), 12 deletions(-)

diff --git a/contrib/devtools/circular-dependencies.py b/contrib/devtools/circular-dependencies.py
index 247aa029973e..6cbbdb189eea 100755
--- a/contrib/devtools/circular-dependencies.py
+++ b/contrib/devtools/circular-dependencies.py
@@ -12,6 +12,7 @@
     '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',
 }
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;