From fa9d5292a179dc4326cdd490f606cacf40508755 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Wed, 29 Jul 2026 12:39:24 +0700
Subject: [PATCH 1/3] fix: multiple return undocumented or misdocumented JSON

---
 src/evo/core_write.cpp          |  7 +--
 src/governance/core_write.cpp   | 19 ++++---
 src/llmq/core_write.cpp         | 88 ++++++++++++---------------------
 src/rpc/blockchain.cpp          |  2 +-
 src/rpc/coinjoin.cpp            | 16 +++---
 src/rpc/evo.cpp                 | 17 +++----
 src/rpc/governance.cpp          | 12 ++---
 src/rpc/masternode.cpp          | 61 ++++++++++++++---------
 src/rpc/mempool.cpp             |  6 +--
 src/rpc/mining.cpp              |  3 +-
 src/rpc/net.cpp                 |  6 +--
 src/rpc/node.cpp                | 13 +++--
 src/rpc/quorums.cpp             | 18 ++++---
 src/rpc/rawtransaction.cpp      | 32 +++++++-----
 src/wallet/rpc/backup.cpp       |  9 +++-
 src/wallet/rpc/transactions.cpp | 19 ++++---
 src/wallet/rpc/wallet.cpp       | 13 ++---
 17 files changed, 178 insertions(+), 163 deletions(-)

diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index c668f65b0dc5..fd5917dafa42 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -275,9 +275,10 @@ UniValue CDeterministicMNState::ToJson(MnType nType) const
 // 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", "Version of 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),
@@ -468,8 +469,8 @@ RPCResult CSimplifiedMNListDiff::GetJsonHelp(const std::string& key, bool option
         GetRpcResult("merkleRootMNList", /*optional=*/true),
         GetRpcResult("merkleRootQuorums", /*optional=*/true),
         {RPCResult::Type::ARR, "quorumsCLSigs", "ChainLock signature details", {
-            {RPCResult::Type::OBJ, "", "", {
-                {RPCResult::Type::ARR, "<sig_hex>", "Array of quorum indices, keyed by BLS signature", {
+            {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"}
         }}}}}},
     }};
diff --git a/src/governance/core_write.cpp b/src/governance/core_write.cpp
index 4d90dd269c44..9f634ba76639 100644
--- a/src/governance/core_write.cpp
+++ b/src/governance/core_write.cpp
@@ -119,20 +119,23 @@ RPCResult Object::GetJsonHelp(const std::string& key, bool optional)
         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::STR, "end_epoch", /*optional=*/true, "Proposal end timestamp"},
-            {RPCResult::Type::STR, "name", /*optional=*/true, "Proposal name"},
-            {RPCResult::Type::STR, "payment_address", /*optional=*/true, "Proposal payment address"},
-            {RPCResult::Type::STR, "payment_amount", /*optional=*/true, "Proposal payment amount"},
-            {RPCResult::Type::STR, "start_epoch", /*optional=*/true, "Proposal start timestamp"},
-            {RPCResult::Type::STR, "type", /*optional=*/true, "Object type"},
-            {RPCResult::Type::STR, "url", /*optional=*/true, "Proposal URL"},
+            {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},
     }};
 }
 
diff --git a/src/llmq/core_write.cpp b/src/llmq/core_write.cpp
index 8110457e4824..243f8f1c0a3a 100644
--- a/src/llmq/core_write.cpp
+++ b/src/llmq/core_write.cpp
@@ -19,61 +19,37 @@ namespace llmq {
 // CDKGDebugSessionStatus::ToJson() defined in llmq/debug.cpp
 RPCResult CDKGDebugSessionStatus::GetJsonHelp(const std::string& key, bool optional)
 {
-    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The state of a DKG session",
+    // 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"),
-        GetRpcResult("quorumHash"),
-        {RPCResult::Type::NUM, "quorumHeight", "Block height of the quorum"},
-        {RPCResult::Type::NUM, "phase", "Active DKG phase"},
-        {RPCResult::Type::BOOL, "sentContributions", "Returns true if contributions sent"},
-        {RPCResult::Type::BOOL, "sentComplaint", "Returns true if complaints sent"},
-        {RPCResult::Type::BOOL, "sentJustification", "Returns true if justifications sent"},
-        {RPCResult::Type::BOOL, "sentPrematureCommitment", "Returns true if premature commitments sent"},
-        {RPCResult::Type::BOOL, "aborted", "Returns true if DKG session aborted"},
-        {RPCResult{"for detail_level = 0", RPCResult::Type::NUM, "badMembers", "Number of bad members"}},
-        {RPCResult{"for detail_level = 0", RPCResult::Type::NUM, "weComplain", "Number of complaints sent"}},
-        {RPCResult{"for detail_level = 0", RPCResult::Type::NUM, "receivedContributions", "Number of contributions received"}},
-        {RPCResult{"for detail_level = 0", RPCResult::Type::NUM, "receivedComplaints", "Number of complaints received"}},
-        {RPCResult{"for detail_level = 0", RPCResult::Type::NUM, "receivedJustifications", "Number of justifications received"}},
-        {RPCResult{"for detail_level = 0", RPCResult::Type::NUM, "receivedPrematureCommitments", "Number of premature commitments received"}},
-        {RPCResult{"for detail_level = 1", RPCResult::Type::ARR, "badMembers", "Array of indexes for each bad member", {
-            {RPCResult::Type::NUM, "", "Quorum member index"}}}},
-        {RPCResult{"for detail_level = 1", RPCResult::Type::ARR, "weComplain", "Array of indexes for each complaint sent", {
-            {RPCResult::Type::NUM, "", "Quorum member index"}}}},
-        {RPCResult{"for detail_level = 1", RPCResult::Type::ARR, "receivedContributions", "Array of indexes for each contribution received", {
-            {RPCResult::Type::NUM, "", "Quorum member index"}}}},
-        {RPCResult{"for detail_level = 1", RPCResult::Type::ARR, "receivedComplaints", "Array of indexes for each complaint received", {
-            {RPCResult::Type::NUM, "", "Quorum member index"}}}},
-        {RPCResult{"for detail_level = 1", RPCResult::Type::ARR, "receivedJustifications", "Array of indexes for each justification received", {
-            {RPCResult::Type::NUM, "", "Quorum member index"}}}},
-        {RPCResult{"for detail_level = 1", RPCResult::Type::ARR, "receivedPrematureCommitments", "Array of indexes for each commitment received", {
-            {RPCResult::Type::NUM, "", "Quorum member index"}}}},
-        {RPCResult{"for detail_level = 2", RPCResult::Type::ARR, "badMembers", "Array of objects for each bad member", {
-            {RPCResult::Type::OBJ, "", "", {
-                GetRpcResult("memberIndex"),
-                GetRpcResult("proTxHash", /*optional=*/true)}}}}},
-        {RPCResult{"for detail_level = 2", RPCResult::Type::ARR, "weComplain", "Array of objects for each complaint sent", {
-            {RPCResult::Type::OBJ, "", "", {
-                GetRpcResult("memberIndex"),
-                GetRpcResult("proTxHash", /*optional=*/true)}}}}},
-        {RPCResult{"for detail_level = 2", RPCResult::Type::ARR, "receivedContributions", "Array of objects for each contribution received", {
-            {RPCResult::Type::OBJ, "", "", {
-                GetRpcResult("memberIndex"),
-                GetRpcResult("proTxHash", /*optional=*/true)}}}}},
-        {RPCResult{"for detail_level = 2", RPCResult::Type::ARR, "receivedComplaints", "Array of objects for each complaint received", {
-            {RPCResult::Type::OBJ, "", "", {
-                GetRpcResult("memberIndex"),
-                GetRpcResult("proTxHash", /*optional=*/true)}}}}},
-        {RPCResult{"for detail_level = 2", RPCResult::Type::ARR, "receivedJustifications", "Array of objects for each justification received", {
-            {RPCResult::Type::OBJ, "", "", {
-                GetRpcResult("memberIndex"),
-                GetRpcResult("proTxHash", /*optional=*/true)}}}}},
-        {RPCResult{"for detail_level = 2", RPCResult::Type::ARR, "receivedPrematureCommitments", "Array of objects for each commitment received", {
-            {RPCResult::Type::OBJ, "", "", {
-                GetRpcResult("memberIndex"),
-                GetRpcResult("proTxHash", /*optional=*/true)}}}}},
-        {RPCResult{"for detail_level = 2", RPCResult::Type::ARR, "allMembers", "Array of provider registration transaction hash for all quorum members", {
-            GetRpcResult("proTxHash")}}},
+        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")}},
     }};
 }
 
@@ -86,7 +62,7 @@ RPCResult CDKGDebugManager::GetJsonHelp(const std::string& key, bool optional, b
         {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::NUM, "llmqType", "Name of quorum"},
+                {RPCResult::Type::STR, "llmqType", "Name of quorum"},
                 GetRpcResult("quorumIndex"),
                 CDKGDebugSessionStatus::GetJsonHelp(/*key=*/"status", /*optional=*/false)
             }},
@@ -258,7 +234,7 @@ RPCResult CRecoveredSig::GetJsonHelp(const std::string& key, bool optional)
     {
         GetRpcResult("llmqType"),
         GetRpcResult("quorumHash"),
-        {RPCResult::Type::NUM, "id", "Signing session ID"},
+        {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"},
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index f568751d01c9..fd3a4cbbe2f1 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -255,7 +255,7 @@ static RPCHelpMan getbestchainlock()
         RPCResult{
             RPCResult::Type::OBJ, "", "",
             {
-                {RPCResult::Type::STR_HEX, "hash", "The block hash hex-encoded"},
+                {RPCResult::Type::STR_HEX, "blockhash", "The block hash hex-encoded"},
                 {RPCResult::Type::NUM, "height", "The block height or index"},
                 {RPCResult::Type::STR_HEX, "signature", "The ChainLock's BLS signature"},
                 {RPCResult::Type::BOOL, "known_block", "True if the block is known by our node"},
diff --git a/src/rpc/coinjoin.cpp b/src/rpc/coinjoin.cpp
index bdb91b1da51d..b9a508f0c92e 100644
--- a/src/rpc/coinjoin.cpp
+++ b/src/rpc/coinjoin.cpp
@@ -427,17 +427,17 @@ static RPCHelpMan getcoinjoininfo()
                             {RPCResult::Type::NUM, "max_amount", "Target CoinJoin balance in " + CURRENCY_UNIT + ""},
                             {RPCResult::Type::NUM, "denoms_goal", "How many inputs of each denominated amount to target"},
                             {RPCResult::Type::NUM, "denoms_hardcap", "Maximum limit of how many inputs of each denominated amount to create"},
-                            {RPCResult::Type::NUM, "queue_size", "How many queues there are currently on the network"},
-                            {RPCResult::Type::BOOL, "running", "Whether mixing is currently running"},
+                            {RPCResult::Type::NUM, "queue_size", /*optional=*/true, "How many queues there are currently on the network"},
+                            {RPCResult::Type::BOOL, "running", /*optional=*/true, "Whether mixing is currently running (not returned when no wallet is loaded)"},
                             {RPCResult::Type::NUM, "pending_inputs", "The number of successfully mixed inputs kept locked until the transaction spending them is observed"},
-                            {RPCResult::Type::ARR, "sessions", "",
+                            {RPCResult::Type::ARR, "sessions", /*optional=*/true, "Not returned when no wallet is loaded",
                             {
                                 {RPCResult::Type::OBJ, "", "",
                                 {
-                                    {RPCResult::Type::STR_HEX, "protxhash", "The ProTxHash of the masternode"},
-                                    GetRpcResult("outpoint"),
-                                    {RPCResult::Type::STR, "service", "The IP address and port of the masternode (DEPRECATED, returned only if config option -deprecatedrpc=service is passed)"},
-                                    {RPCResult::Type::ARR, "addrs_core_p2p", "Network addresses of the masternode used for protocol P2P",
+                                    {RPCResult::Type::STR_HEX, "protxhash", /*optional=*/true, "The ProTxHash of the masternode (only while connected to one)"},
+                                    GetRpcResult("outpoint", /*optional=*/true),
+                                    {RPCResult::Type::STR, "service", /*optional=*/true, "The IP address and port of the masternode (DEPRECATED, returned only if config option -deprecatedrpc=service is passed)"},
+                                    {RPCResult::Type::ARR, "addrs_core_p2p", /*optional=*/true, "Network addresses of the masternode used for protocol P2P",
                                         {
                                             {RPCResult::Type::STR, "address", ""},
                                         }
@@ -448,7 +448,7 @@ static RPCHelpMan getcoinjoininfo()
                                 }},
                             }},
                             {RPCResult::Type::NUM, "keys_left", /*optional=*/true, "How many new keys are left since last automatic backup (if applicable)"},
-                            {RPCResult::Type::STR, "warnings", "Warnings if any"},
+                            {RPCResult::Type::STR, "warnings", /*optional=*/true, "Warnings if any (not returned when no wallet is loaded)"},
                         }},
                     RPCResult{"for masternodes",
                         RPCResult::Type::OBJ, "", "",
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index e15bc74a18ea..cdbc976919bd 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -1513,12 +1513,11 @@ static RPCHelpMan protx_list()
         RPCResult{
             RPCResult::Type::ARR, "", "List of masternodes",
             {
-                RPCResult{"when detailed=false", RPCResult::Type::STR, "", "ProTx hash"},
-                RPCResult{"when detailed=true", RPCResult::Type::OBJ, "", "",
-                    {
-                        // TODO: document fields of the detailed entry
-                        {RPCResult::Type::ELISION, "", ""}
-                    }},
+                // Array elements are matched against this doc by index, so the two shapes
+                // cannot be listed as alternatives here - the first entry would be applied
+                // to element 0 only and the second to every element after it.
+                // TODO: document fields of the detailed entry
+                {RPCResult::Type::ANY, "", "The ProTx hash when detailed=false, otherwise an object describing the masternode"},
             }},
         RPCExamples{""},
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
@@ -1772,11 +1771,11 @@ static RPCHelpMan protx_listdiff()
                         {RPCResult::Type::NUM, "blockHeight", "Height of target (ending) block"},
                         {RPCResult::Type::ARR, "addedMNs", "Added masternodes",
                             {CDeterministicMN::GetJsonHelp(/*key=*/"", /*optional=*/false)}},
-                        {RPCResult::Type::ARR, "removedMns", "Removed masternodes",
+                        {RPCResult::Type::ARR, "removedMNs", "Removed masternodes",
                             {{RPCResult::Type::STR_HEX, "protx", "ProTx of removed masternode"}}},
                         {RPCResult::Type::ARR, "updatedMNs", "Updated masternodes",
-                            {{RPCResult::Type::OBJ, "<protx_hash>", "",
-                                {CDeterministicMNStateDiff::GetJsonHelp(/*key=*/"", /*optional=*/false)}}}},
+                            {{RPCResult::Type::OBJ_DYN, "", "json object with ProTx hash as keys",
+                                {CDeterministicMNStateDiff::GetJsonHelp(/*key=*/"<protx_hash>", /*optional=*/false)}}}},
                     },
                 },
                 RPCExamples{""},
diff --git a/src/rpc/governance.cpp b/src/rpc/governance.cpp
index a4a97f6596cb..08818c4f5cc0 100644
--- a/src/rpc/governance.cpp
+++ b/src/rpc/governance.cpp
@@ -499,7 +499,7 @@ const RPCResult vote_results{
     RPCResult::Type::OBJ, "", "",
         {
             {RPCResult::Type::STR, "overall", "Total number of successful and failed votes"},
-            {RPCResult::Type::OBJ, "detail", "Detailed information for each vote",
+            {RPCResult::Type::OBJ_DYN, "detail", "Detailed information for each vote, keyed by the ProTx of the voting masternode",
             {
                 {RPCResult::Type::OBJ, "protx", "ProTx of masternode for voting",
                 {
@@ -679,7 +679,7 @@ static RPCHelpMan gobject_list_helper(const bool make_a_diff)
         },
         {
             RPCResult{"If request is valid",
-                RPCResult::Type::OBJ, "hash", "Object details", {ListObjectsHelp()},
+                RPCResult::Type::OBJ_DYN, "", "json object with governance object hash as keys", {ListObjectsHelp()},
             },
             RPCResult{"If request is invalid",
                 RPCResult::Type::STR, "", "Error string"
@@ -726,10 +726,10 @@ static RPCResult gobject_get_help()
 {
     auto ret = CGovernanceObject::GetStateJsonHelp(/*key=*/"", /*optional=*/false, /*local_valid_key=*/"fLocalValidity");
     auto mod_inner = ret.m_inner;
-    mod_inner.push_back({RPCResult::Type::OBJ, "FundingResult", "Funding vote details", {CGovernanceObject::GetVotesJsonHelp(/*key=*/"", /*optional=*/false)}});
-    mod_inner.push_back({RPCResult::Type::OBJ, "ValidResult", "Object validity vote details", {CGovernanceObject::GetVotesJsonHelp(/*key=*/"", /*optional=*/false)}});
-    mod_inner.push_back({RPCResult::Type::OBJ, "DeleteResult", "Delete vote details", {CGovernanceObject::GetVotesJsonHelp(/*key=*/"", /*optional=*/false)}});
-    mod_inner.push_back({RPCResult::Type::OBJ, "EndorsedResult", "Endorsed vote details", {CGovernanceObject::GetVotesJsonHelp(/*key=*/"", /*optional=*/false)}});
+    mod_inner.push_back(CGovernanceObject::GetVotesJsonHelp(/*key=*/"FundingResult", /*optional=*/false));
+    mod_inner.push_back(CGovernanceObject::GetVotesJsonHelp(/*key=*/"ValidResult", /*optional=*/false));
+    mod_inner.push_back(CGovernanceObject::GetVotesJsonHelp(/*key=*/"DeleteResult", /*optional=*/false));
+    mod_inner.push_back(CGovernanceObject::GetVotesJsonHelp(/*key=*/"EndorsedResult", /*optional=*/false));
     return RPCResult{ret.m_type, ret.m_key_name, ret.m_description, mod_inner};
 }
 
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 9417fee601b8..8d77072e3777 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -95,8 +95,7 @@ static RPCHelpMan masternode_count()
             {
                 {RPCResult::Type::NUM, "total", "Total number of Masternodes"},
                 {RPCResult::Type::NUM, "enabled", "Number of enabled Masternodes"},
-                {RPCResult::Type::OBJ, "details", "Breakdown of masternodes by type",
-                    {{RPCResult::Type::OBJ, "", "",
+                {RPCResult::Type::OBJ, "detailed", "Breakdown of masternodes by type",
                     {
                         {RPCResult::Type::OBJ, "regular", "Details for regular masternodes",
                             {
@@ -108,7 +107,6 @@ static RPCHelpMan masternode_count()
                                 {RPCResult::Type::NUM, "total", "Total number of Evo nodes"},
                                 {RPCResult::Type::NUM, "enabled", "Number of enabled Evo nodes"}
                         }},
-                    }},
                     }}
             }
         },
@@ -364,13 +362,19 @@ static RPCHelpMan masternode_payments()
                     {RPCResult::Type::NUM, "amount", "Amount received in this block by all masternodes"},
                     {RPCResult::Type::ARR, "masternodes", "Masternodes that received payments in this block",
                     {
-                        {RPCResult::Type::STR_HEX, "proTxHash", "The hash of the corresponding ProRegTx"},
-                        {RPCResult::Type::NUM, "amount", "Amount received by this masternode"},
-                        {RPCResult::Type::ARR, "payees", "Payees who received a share of this payment",
+                        {RPCResult::Type::OBJ, "", "",
                         {
-                            {RPCResult::Type::STR, "address", "Payee address"},
-                            {RPCResult::Type::STR_HEX, "script", "Payee scriptPubKey"},
-                            {RPCResult::Type::NUM, "amount", "Amount received by this payee"},
+                            {RPCResult::Type::STR_HEX, "proTxHash", "The hash of the corresponding ProRegTx"},
+                            {RPCResult::Type::NUM, "amount", "Amount received by this masternode"},
+                            {RPCResult::Type::ARR, "payees", "Payees who received a share of this payment",
+                            {
+                                {RPCResult::Type::OBJ, "", "",
+                                {
+                                    {RPCResult::Type::STR, "address", "Payee address"},
+                                    {RPCResult::Type::STR_HEX, "script", "Payee scriptPubKey"},
+                                    {RPCResult::Type::NUM, "amount", "Amount received by this payee"},
+                                }},
+                            }},
                         }},
                     }},
                 }},
@@ -553,12 +557,15 @@ static RPCHelpMan masternodelist_helper(bool is_composite)
             {"mode", RPCArg::Type::STR, RPCArg::DefaultHint{"json"}, "The mode to run list in"},
             {"filter", RPCArg::Type::STR, RPCArg::Default{""}, "Filter results. Partial match by outpoint by default in all modes, additional matches in some modes are also available"},
         },
-        RPCResult{
-            RPCResult::Type::OBJ, "<outpoint>", "", {
-                RPCResult{"for mode = addr", RPCResult::Type::STR, "<address>", "Flattened list of all addresses registered to masternode"},
-                RPCResult{"for mode = full", RPCResult::Type::STR, "<info>", "Flattened list of a masternode's status, payee address, last paid block's timestamp, height and service addresses"},
-                RPCResult{"for mode = info", RPCResult::Type::STR, "<info>", "Flattened list of a masternode's status, payee address and service addresses"},
-                RPCResult{"for mode = evo, json or recent", RPCResult::Type::OBJ, "", "", {
+        {
+            RPCResult{"for mode = addr", RPCResult::Type::OBJ_DYN, "", "json object with masternode outpoint as keys",
+                {{RPCResult::Type::STR, "<outpoint>", "Flattened list of all addresses registered to masternode"}}},
+            RPCResult{"for mode = full", RPCResult::Type::OBJ_DYN, "", "json object with masternode outpoint as keys",
+                {{RPCResult::Type::STR, "<outpoint>", "Flattened list of a masternode's status, payee address, last paid block's timestamp, height and service addresses"}}},
+            RPCResult{"for mode = info", RPCResult::Type::OBJ_DYN, "", "json object with masternode outpoint as keys",
+                {{RPCResult::Type::STR, "<outpoint>", "Flattened list of a masternode's status, payee address and service addresses"}}},
+            RPCResult{"for mode = evo, json or recent", RPCResult::Type::OBJ_DYN, "", "json object with masternode outpoint as keys",
+                {{RPCResult::Type::OBJ, "<outpoint>", "", {
                     GetRpcResult("proTxHash"),
                     GetRpcResult("service", /*optional=*/true, /*override_name=*/"address"),
                     GetRpcResult("addresses"),
@@ -576,15 +583,21 @@ static RPCHelpMan masternodelist_helper(bool is_composite)
                     GetRpcResult("votingAddress", /*optional=*/false, /*override_name=*/"votingaddress"),
                     GetRpcResult("collateralAddress", /*optional=*/false, /*override_name=*/"collateraladdress"),
                     GetRpcResult("pubKeyOperator", /*optional=*/false, /*override_name=*/"pubkeyoperator"),
-                }},
-                RPCResult{"for mode = lastpaidblock", RPCResult::Type::NUM, "<height>", "Height masternode was last paid"},
-                RPCResult{"for mode = lastpaidtime", RPCResult::Type::NUM, "<time>", "Timestamp of block the masternode was last paid"},
-                RPCResult{"for mode = payee", RPCResult::Type::STR, "<addr>", "Dash address used for masternode reward payments"},
-                RPCResult{"for mode = owneraddress", RPCResult::Type::STR, "<addr>", "Dash address used for payee updates and proposal voting"},
-                RPCResult{"for mode = pubkeyoperator", RPCResult::Type::STR, "<addr>", "BLS public key used for operator signing"},
-                RPCResult{"for mode = status", RPCResult::Type::STR, "<status>", "Masternode status (human-readable string)"},
-                RPCResult{"for mode = votingaddress", RPCResult::Type::STR, "<addr>", "Dash address used for voting"},
-            }
+                }}}},
+            RPCResult{"for mode = lastpaidblock", RPCResult::Type::OBJ_DYN, "", "json object with masternode outpoint as keys",
+                {{RPCResult::Type::NUM, "<outpoint>", "Height masternode was last paid"}}},
+            RPCResult{"for mode = lastpaidtime", RPCResult::Type::OBJ_DYN, "", "json object with masternode outpoint as keys",
+                {{RPCResult::Type::NUM, "<outpoint>", "Timestamp of block the masternode was last paid"}}},
+            RPCResult{"for mode = payee", RPCResult::Type::OBJ_DYN, "", "json object with masternode outpoint as keys",
+                {{RPCResult::Type::STR, "<outpoint>", "Dash address used for masternode reward payments"}}},
+            RPCResult{"for mode = owneraddress", RPCResult::Type::OBJ_DYN, "", "json object with masternode outpoint as keys",
+                {{RPCResult::Type::STR, "<outpoint>", "Dash address used for payee updates and proposal voting"}}},
+            RPCResult{"for mode = pubkeyoperator", RPCResult::Type::OBJ_DYN, "", "json object with masternode outpoint as keys",
+                {{RPCResult::Type::STR, "<outpoint>", "BLS public key used for operator signing"}}},
+            RPCResult{"for mode = status", RPCResult::Type::OBJ_DYN, "", "json object with masternode outpoint as keys",
+                {{RPCResult::Type::STR, "<outpoint>", "Masternode status (human-readable string)"}}},
+            RPCResult{"for mode = votingaddress", RPCResult::Type::OBJ_DYN, "", "json object with masternode outpoint as keys",
+                {{RPCResult::Type::STR, "<outpoint>", "Dash address used for voting"}}},
         },
         RPCExamples{""},
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index 789fcb1cd7c8..345e4417e003 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -273,7 +273,7 @@ static std::vector<RPCResult> MempoolEntryDescription()
             {RPCResult{RPCResult::Type::STR_HEX, "transactionid", "parent transaction id"}}},
         RPCResult{RPCResult::Type::ARR, "spentby", "unconfirmed transactions spending outputs from this transaction",
             {RPCResult{RPCResult::Type::STR_HEX, "transactionid", "child transaction id"}}},
-        RPCResult{RPCResult::Type::BOOL, "instantsend", "True if this transaction was locked via InstantSend"},
+        RPCResult{RPCResult::Type::STR, "instantlock", "\"true\" if this transaction was locked via InstantSend, \"unknown\" if InstantSend is unavailable"},
         RPCResult{RPCResult::Type::BOOL, "unbroadcast", "Whether this transaction is currently unbroadcast (initial broadcast not yet acknowledged by any peers)"}
     };
 }
@@ -797,8 +797,8 @@ static RPCHelpMan submitpackage()
                 {
                     {RPCResult::Type::OBJ, "txid", "transaction txid", {
                         {RPCResult::Type::STR_HEX, "txid", "The transaction hash in hex"},
-                        {RPCResult::Type::NUM, "size", "Size of transaction in bytes"},
-                        {RPCResult::Type::OBJ, "fees", "Transaction fees", {
+                        {RPCResult::Type::NUM, "size", /*optional=*/true, "Size of transaction in bytes"},
+                        {RPCResult::Type::OBJ, "fees", /*optional=*/true, "Transaction fees", {
                             {RPCResult::Type::STR_AMOUNT, "base", "transaction fee in " + CURRENCY_UNIT},
                         }},
                     }}
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 90eecbf6b4c4..ad840a28c35b 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -598,8 +598,7 @@ static RPCHelpMan getblocktemplate()
                 {RPCResult::Type::OBJ, "", "",
                     {
                         {RPCResult::Type::STR_HEX, "data", "transaction data encoded in hexadecimal (byte-for-byte)"},
-                        {RPCResult::Type::STR_HEX, "txid", "transaction id encoded in little-endian hexadecimal"},
-                        {RPCResult::Type::STR_HEX, "hash", "hash encoded in little-endian hexadecimal"},
+                        {RPCResult::Type::STR_HEX, "hash", "transaction id encoded in little-endian hexadecimal"},
                         {RPCResult::Type::ARR, "depends", "array of numbers",
                         {
                             {RPCResult::Type::NUM, "", "transactions before this one (by 1-based index in 'transactions' list) that must be present in the final block if this one is"},
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index 8542a5d3dd4e..15a1f6da8dd6 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -132,10 +132,10 @@ static RPCHelpMan getpeerinfo()
                     {
                         {RPCResult::Type::STR, "SERVICE_NAME", "the service name if it is recognised"}
                     }},
-                    {RPCResult::Type::STR_HEX, "verified_proregtx_hash", "Only present when the peer is a masternode and successfully "
+                    {RPCResult::Type::STR_HEX, "verified_proregtx_hash", /*optional=*/true, "Only present when the peer is a masternode and successfully "
                                                                         "authenticated via MNAUTH. In this case, this field contains the "
                                                                         "protx hash of the masternode"},
-                    {RPCResult::Type::STR_HEX, "verified_pubkey_hash", "Only present when the peer is a masternode and successfully "
+                    {RPCResult::Type::STR_HEX, "verified_pubkey_hash", /*optional=*/true, "Only present when the peer is a masternode and successfully "
                                                                         "authenticated via MNAUTH. In this case, this field contains the "
                                                                         "hash of the masternode's operator public key"},
                     {RPCResult::Type::BOOL, "relaytxes", /*optional=*/true, "Whether we relay transactions to this peer"},
@@ -156,7 +156,7 @@ static RPCHelpMan getpeerinfo()
                     {RPCResult::Type::BOOL, "bip152_hb_to", "Whether we selected peer as (compact blocks) high-bandwidth peer"},
                     {RPCResult::Type::BOOL, "bip152_hb_from", "Whether peer selected us as (compact blocks) high-bandwidth peer"},
                     {RPCResult::Type::BOOL, "masternode", "Whether connection was due to masternode connection attempt"},
-                    {RPCResult::Type::NUM, "banscore", "The ban score (DEPRECATED, returned only if config option -deprecatedrpc=banscore is passed)"},
+                    {RPCResult::Type::NUM, "banscore", /*optional=*/true, "The ban score (DEPRECATED, returned only if config option -deprecatedrpc=banscore is passed)"},
                     {RPCResult::Type::NUM, "startingheight", "The starting height (block) of the peer"},
                     {RPCResult::Type::NUM, "synced_headers", "The last header we have in common with this peer"},
                     {RPCResult::Type::NUM, "synced_blocks", "The last block we have in common with this peer"},
diff --git a/src/rpc/node.cpp b/src/rpc/node.cpp
index 18927c387441..22d0cdfbc4eb 100644
--- a/src/rpc/node.cpp
+++ b/src/rpc/node.cpp
@@ -166,6 +166,7 @@ static RPCHelpMan spork()
                 {
                     {RPCResult::Type::BOOL, "SPORK_NAME", "'true' for time-based sporks if spork is active and 'false' otherwise"},
                 }},
+            RPCResult{"For an unrecognized command", RPCResult::Type::NONE, "", ""},
         },
         RPCExamples {
             HelpExampleCli("spork", "show")
@@ -205,8 +206,9 @@ static RPCHelpMan sporkupdate()
             {"name", RPCArg::Type::STR, RPCArg::Optional::NO, "The name of the spork to update"},
             {"value", RPCArg::Type::NUM, RPCArg::Optional::NO, "The new desired value of the spork"},
         },
-        RPCResult{
-            RPCResult::Type::STR, "result", "\"success\" if spork value was updated or this help otherwise"
+        {
+            RPCResult{"if the spork value was updated", RPCResult::Type::STR, "result", "\"success\""},
+            RPCResult{"if the update was rejected", RPCResult::Type::NONE, "", ""},
         },
         RPCExamples{
             HelpExampleCli("sporkupdate", "SPORK_2_INSTANTSEND_ENABLED 4070908800")
@@ -401,8 +403,8 @@ static RPCHelpMan getaddressmempool()
                     {RPCResult::Type::NUM, "index", "The related input or output index"},
                     {RPCResult::Type::NUM, "satoshis", "The difference of duffs"},
                     {RPCResult::Type::NUM_TIME, "timestamp", "The time the transaction entered the mempool (seconds)"},
-                    {RPCResult::Type::STR_HEX, "prevtxid", "The previous txid (if spending)"},
-                    {RPCResult::Type::NUM, "prevout", "The previous transaction output index (if spending)"},
+                    {RPCResult::Type::STR_HEX, "prevtxid", /*optional=*/true, "The previous txid (if spending)"},
+                    {RPCResult::Type::NUM, "prevout", /*optional=*/true, "The previous transaction output index (if spending)"},
                 }},
             }},
         RPCExamples{
@@ -479,7 +481,7 @@ static RPCHelpMan getaddressutxos()
                 {
                     {RPCResult::Type::STR, "address", "The address base58check encoded"},
                     {RPCResult::Type::STR_HEX, "txid", "The output txid"},
-                    {RPCResult::Type::NUM, "index", "The output index"},
+                    {RPCResult::Type::NUM, "outputIndex", "The output index"},
                     {RPCResult::Type::STR_HEX, "script", "The script hex-encoded"},
                     {RPCResult::Type::NUM, "satoshis", "The number of duffs of the output"},
                     {RPCResult::Type::NUM, "height", "The block height"},
@@ -811,6 +813,7 @@ static RPCHelpMan getspentinfo()
             {
                 {RPCResult::Type::STR_HEX, "txid", "The transaction id"},
                 {RPCResult::Type::NUM, "index", "The spending input index"},
+                {RPCResult::Type::NUM, "height", "The block height of the spending transaction"},
             }},
         RPCExamples{
             HelpExampleCli("getspentinfo", "'{\"txid\": \"0437cd7f8525ceed2324359c2d0ba26006d92d856a9c20fa0241106ee5a597c9\", \"index\": 0}'")
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index 3b09ad18ed33..950f05e20e94 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -54,7 +54,7 @@ static RPCHelpMan quorum_list()
             },
         },
         RPCResult{
-            RPCResult::Type::OBJ, "", "",
+            RPCResult::Type::OBJ_DYN, "", "json object with quorum type name as keys",
             {
                 {RPCResult::Type::ARR, "quorumName", "List of quorum hashes per some quorum type",
                 {
@@ -110,19 +110,19 @@ static RPCHelpMan quorum_list_extended()
             {"height", RPCArg::Type::NUM, RPCArg::DefaultHint{"Tip height if not specified"}, "Active quorums at the height."},
         },
         RPCResult{
-            RPCResult::Type::OBJ, "", "",
+            RPCResult::Type::OBJ_DYN, "", "json object with quorum type name as keys",
             {
                 {RPCResult::Type::ARR, "quorumName", "List of quorum details per quorum type",
                 {
-                    {RPCResult::Type::OBJ, "", "",
+                    {RPCResult::Type::OBJ_DYN, "", "json object with quorum hash as keys. Note: most recent quorums come first.",
                     {
-                        {RPCResult::Type::OBJ, "xxxx", "Quorum hash. Note: most recent quorums come first.",
+                        {RPCResult::Type::OBJ, "xxxx", "Quorum details",
                         {
+                            {RPCResult::Type::NUM, "quorumIndex", /*optional=*/true, "Quorum index (applicable only to rotated quorums)."},
                             {RPCResult::Type::NUM, "creationHeight", "Block height where the DKG started."},
-                            {RPCResult::Type::NUM, "quorumIndex", "Quorum index (applicable only to rotated quorums)."},
                             {RPCResult::Type::STR_HEX, "minedBlockHash", "Blockhash where the commitment was mined."},
                             {RPCResult::Type::NUM, "numValidMembers", "The total of valid members."},
-                            {RPCResult::Type::STR_AMOUNT, "healthRatio", "The ratio of healthy members to quorum size. Range [0.0 - 1.0]."}
+                            {RPCResult::Type::STR, "healthRatio", "The ratio of healthy members to quorum size. Range [0.0 - 1.0]."}
                         }}
                     }}
                 }}
@@ -259,7 +259,7 @@ static RPCHelpMan quorum_info()
                 GetRpcResult("quorumHash"),
                 GetRpcResult("quorumIndex"),
                 {RPCResult::Type::STR_HEX, "minedBlock", "Blockhash where the commitment was mined."},
-                {RPCResult::Type::NUM, "previousConsecutiveDKGFailures", "Number of previous consecutive DKG failures. Only present for rotation-enabled quorums."},
+                {RPCResult::Type::NUM, "previousConsecutiveDKGFailures", /*optional=*/true, "Number of previous consecutive DKG failures. Only present for rotation-enabled quorums."},
                 {RPCResult::Type::ARR, "members", "Members of quorum",
                     {
                         {RPCResult::Type::OBJ, "", "",
@@ -273,6 +273,8 @@ static RPCHelpMan quorum_info()
                         }},
                     },
                 },
+                {RPCResult::Type::STR_HEX, "quorumPublicKey", "BLS public key of the quorum"},
+                {RPCResult::Type::STR_HEX, "secretKeyShare", /*optional=*/true, "Share of the BLS secret key of the quorum. Only present if includeSkShare is set and the share is valid."},
             },
         },
         RPCExamples{""},
@@ -308,7 +310,7 @@ static RPCResult quorum_dkgstatus_help()
     auto mod_inner = ret.m_inner;
     mod_inner.push_back({RPCResult::Type::ARR, "quorumConnections", "Array of objects containing quorum connection information", {
         {RPCResult::Type::OBJ, "", "", {
-            GetRpcResult("llmqType"),
+            {RPCResult::Type::STR, "llmqType", "Quorum type name"},
             GetRpcResult("quorumIndex"),
             {RPCResult::Type::NUM, "pQuorumBaseBlockIndex", /*optional=*/true, "Height of the quorum’s base block"},
             GetRpcResult("quorumHash", /*optional=*/true),
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index a8f60bbba753..f6dc92f1b6d0 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -185,6 +185,9 @@ static std::vector<RPCResult> DecodeTxDoc(const std::string& txid_field_doc)
                     {RPCResult::Type::STR, "asm", "Disassembly of the signature script"},
                     {RPCResult::Type::STR_HEX, "hex", "The raw signature script bytes, hex-encoded"},
                 }},
+                {RPCResult::Type::STR_AMOUNT, "value", /*optional=*/true, "The value of the spent output in " + CURRENCY_UNIT + " (only if spentindex is enabled)"},
+                {RPCResult::Type::NUM, "valueSat", /*optional=*/true, "The value of the spent output in duffs (only if spentindex is enabled)"},
+                {RPCResult::Type::STR, "address", /*optional=*/true, "The Dash address of the spent output (only if spentindex is enabled and a well-defined address exists)"},
                 {RPCResult::Type::NUM, "sequence", "The script sequence number"},
             }},
         }},
@@ -193,6 +196,7 @@ static std::vector<RPCResult> DecodeTxDoc(const std::string& txid_field_doc)
             {RPCResult::Type::OBJ, "", "",
             {
                 {RPCResult::Type::STR_AMOUNT, "value", "The value in " + CURRENCY_UNIT},
+                {RPCResult::Type::NUM, "valueSat", "The value in duffs"},
                 {RPCResult::Type::NUM, "n", "index"},
                 {RPCResult::Type::OBJ, "scriptPubKey", "",
                 {
@@ -202,6 +206,9 @@ static std::vector<RPCResult> DecodeTxDoc(const std::string& txid_field_doc)
                     {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"},
                     {RPCResult::Type::STR, "address", /*optional=*/true, "The Dash address (only if a well-defined address exists)"},
                 }},
+                {RPCResult::Type::STR_HEX, "spentTxId", /*optional=*/true, "The transaction id that spent this output (only if spentindex is enabled)"},
+                {RPCResult::Type::NUM, "spentIndex", /*optional=*/true, "The input index of the spending transaction (only if spentindex is enabled)"},
+                {RPCResult::Type::NUM, "spentHeight", /*optional=*/true, "The block height of the spending transaction (only if spentindex is enabled)"},
             }},
         }},
         {RPCResult::Type::NUM, "extraPayloadSize", /*optional=*/true, "Size of DIP2 extra payload. Only present if it's a special TX"},
@@ -348,7 +355,7 @@ static RPCHelpMan getrawtransaction()
                          {
                              {RPCResult::Type::BOOL, "in_active_chain", /*optional=*/true, "Whether specified block is in the active chain or not (only present with explicit \"blockhash\" argument)"},
                              {RPCResult::Type::STR_HEX, "blockhash", /*optional=*/true, "the block hash"},
-                             {RPCResult::Type::NUM, "height", "The block height"},
+                             {RPCResult::Type::NUM, "height", /*optional=*/true, "The block height (only present if the transaction is mined)"},
                              {RPCResult::Type::NUM, "confirmations", /*optional=*/true, "The confirmations"},
                              {RPCResult::Type::NUM_TIME, "blocktime", /*optional=*/true, "The block time expressed in " + UNIX_EPOCH_TIME},
                              {RPCResult::Type::NUM, "time", /*optional=*/true, "Same as \"blocktime\""},
@@ -460,16 +467,14 @@ static RPCHelpMan getrawtransactionmulti() {
                      "If false, return a string, otherwise return a json object"},
             },
             RPCResult{
-                RPCResult::Type::OBJ, "", "",
+                RPCResult::Type::OBJ_DYN, "", "json object with transaction id as keys",
                 {
-                    {"If verbose is not set or set to false",
-                        RPCResult::Type::STR_HEX, "txid", "The serialized, hex-encoded data for 'txid'"},
-                    {"if verbose is set to true",
-                        RPCResult::Type::OBJ, "txid", "The decoded network-serialized transaction.",
-                        {
-                            {RPCResult::Type::ELISION, "", "The layout is the same as the output of getrawtransaction."},
-                        }},
-                    {"If tx is unknown", RPCResult::Type::STR, "txid", "None"},
+                    // Conditional variants are only resolved for top-level results, so the
+                    // per-verbosity shapes cannot be spelled out as alternatives here.
+                    {RPCResult::Type::ANY, "txid", "The serialized, hex-encoded data for 'txid' if verbose is not set or "
+                                                   "set to false; the decoded transaction (same layout as the output of "
+                                                   "getrawtransaction) if verbose is set to true; the string \"None\" if "
+                                                   "the transaction is unknown"},
                 },
             },
             RPCExamples{
@@ -567,10 +572,10 @@ static RPCHelpMan getislocks()
                     {RPCResult::Type::STR_HEX, "cycleHash", "The Cycle Hash"},
                     {RPCResult::Type::STR_HEX, "signature", "The InstantSend's BLS signature"},
                     {RPCResult::Type::STR_HEX, "hex", "The serialized, hex-encoded data for 'txid'"},
-                }},
-                RPCResult{"if no InstantSend Lock is known for specified txid",
-                     RPCResult::Type::STR, "data", "Just 'None' string"
                 },
+                // An element is the plain string "None" when no InstantSend Lock is known for
+                // that txid, so the element type cannot be checked against this object.
+                /*skip_type_check=*/true},
             }},
         RPCExamples{
             HelpExampleCli("getislocks", "'[\"txid\",...]'")
@@ -920,6 +925,7 @@ static RPCHelpMan decodescript()
                 {RPCResult::Type::STR, "desc", "Inferred descriptor for the script"},
                 {RPCResult::Type::STR, "type", "The output type (e.g. " + GetAllOutputTypes() + ")"},
                 {RPCResult::Type::STR, "address", /*optional=*/true, "The Dash address (only if a well-defined address exists)"},
+                {RPCResult::Type::STR, "p2sh", /*optional=*/true, "address of P2SH script wrapping this redeem script (not returned for types that should not be wrapped)"},
             },
         },
         RPCExamples{
diff --git a/src/wallet/rpc/backup.cpp b/src/wallet/rpc/backup.cpp
index 80397cd37321..ce9e6b1dc3da 100644
--- a/src/wallet/rpc/backup.cpp
+++ b/src/wallet/rpc/backup.cpp
@@ -937,6 +937,11 @@ RPCHelpMan dumpwallet()
                 RPCResult{
                     RPCResult::Type::OBJ, "", "",
                     {
+                        {RPCResult::Type::STR, "dashcoreversion", "The Dash Core version that created the wallet dump"},
+                        {RPCResult::Type::NUM, "lastblockheight", "The height of the last block processed by the wallet"},
+                        {RPCResult::Type::STR_HEX, "lastblockhash", "The hash of the last block processed by the wallet"},
+                        {RPCResult::Type::NUM_TIME, "lastblocktime", "The time of the last block processed by the wallet, expressed in " + UNIX_EPOCH_TIME},
+                        {RPCResult::Type::NUM, "hdaccounts", /*optional=*/true, "The number of HD accounts contained in the wallet dump (only present if the wallet is HD)"},
                         {RPCResult::Type::NUM, "keys", "The number of keys contained in the wallet dump"},
                         {RPCResult::Type::STR, "filename", "The filename with full absolute path"},
                         {RPCResult::Type::STR, "warning", "A warning about not sharing the wallet dump with anyone"},
@@ -1992,8 +1997,8 @@ RPCHelpMan listdescriptors()
             {
                 {RPCResult::Type::OBJ, "", "", {
                     {RPCResult::Type::STR, "desc", "Descriptor string representation"},
-                    {RPCResult::Type::STR, "mnemonic", "The mnemonic for this descriptor wallet (BIP39, english words). Presented only if private=true and created with a mnemonic"},
-                    {RPCResult::Type::STR, "mnemonicpassphrase", "The mnemonic passphrase for this descriptor wallet (BIP39). Presented only if private=true and created with a mnemonic"},
+                    {RPCResult::Type::STR, "mnemonic", /*optional=*/true, "The mnemonic for this descriptor wallet (BIP39, english words). Presented only if private=true and created with a mnemonic"},
+                    {RPCResult::Type::STR, "mnemonicpassphrase", /*optional=*/true, "The mnemonic passphrase for this descriptor wallet (BIP39). Presented only if private=true and created with a mnemonic"},
                     {RPCResult::Type::NUM, "timestamp", "The creation time of the descriptor"},
                     {RPCResult::Type::BOOL, "active", "Whether this descriptor is currently used to generate new addresses"},
                     {RPCResult::Type::BOOL, "internal", /*optional=*/true, "True if this descriptor is used to generate change addresses. False if this descriptor is used to generate receiving addresses; defined only for active descriptors"},
diff --git a/src/wallet/rpc/transactions.cpp b/src/wallet/rpc/transactions.cpp
index 5fb6595dda19..0b12c37b1891 100644
--- a/src/wallet/rpc/transactions.cpp
+++ b/src/wallet/rpc/transactions.cpp
@@ -421,22 +421,28 @@ static std::vector<RPCResult> TransactionDescriptionString()
                "'receive' category of transactions. Negative confirmations indicate the\n"
                "transaction conflicts with the block chain"},
            {RPCResult::Type::BOOL, "instantlock", "Current transaction lock state. Available for 'send' and 'receive' category of transactions"},
-           {RPCResult::Type::BOOL, "instantlock-internal", "Current internal transaction lock state. Available for 'send' and 'receive' category of transactions"},
+           {RPCResult::Type::BOOL, "instantlock_internal", "Current internal transaction lock state. Available for 'send' and 'receive' category of transactions"},
            {RPCResult::Type::BOOL, "chainlock", "The state of the corresponding block ChainLock"},
            {RPCResult::Type::BOOL, "generated", /*optional=*/true, "Only present if the transaction's only input is a coinbase one."},
+           {RPCResult::Type::BOOL, "platform-transfer", /*optional=*/true, "Only present if the transaction is a Platform Transfer."},
            {RPCResult::Type::BOOL, "trusted", /*optional=*/true, "Whether we consider the transaction to be trusted and safe to spend from.\n"
                 "Only present when the transaction has 0 confirmations (or negative confirmations, if conflicted)."},
            {RPCResult::Type::STR_HEX, "blockhash", /*optional=*/true, "The block hash containing the transaction. Available for 'send' and 'receive'\n"
                                                   "category of transactions."},
-           {RPCResult::Type::STR_HEX, "blockheight", /*optional=*/true, "The block height containing the transaction."},
+           {RPCResult::Type::NUM, "blockheight", /*optional=*/true, "The block height containing the transaction."},
            {RPCResult::Type::NUM, "blockindex", /*optional=*/true, "The index of the transaction in the block that includes it. Available for 'send' and 'receive'\n"
                                                "category of transactions."},
            {RPCResult::Type::NUM_TIME, "blocktime", /*optional=*/true, "The block time expressed in " + UNIX_EPOCH_TIME + "."},
            {RPCResult::Type::STR_HEX, "txid", "The transaction id. Available for 'send' and 'receive' category of transactions."},
+           {RPCResult::Type::ARR, "walletconflicts", "Conflicting transaction ids.",
+           {
+               {RPCResult::Type::STR_HEX, "txid", "The transaction id."},
+           }},
            {RPCResult::Type::NUM_TIME, "time", "The transaction time expressed in " + UNIX_EPOCH_TIME + "."},
            {RPCResult::Type::NUM_TIME, "timereceived", "The time received expressed in " + UNIX_EPOCH_TIME + ". Available \n"
                                               "for 'send' and 'receive' category of transactions."},
-           {RPCResult::Type::STR, "comment", /*optional=*/true, "If a comment is associated with the transaction."}};
+           {RPCResult::Type::STR, "comment", /*optional=*/true, "If a comment is associated with the transaction."},
+           {RPCResult::Type::STR, "to", /*optional=*/true, "If a comment to is associated with the transaction."}};
 }
 
 RPCHelpMan listtransactions()
@@ -590,13 +596,12 @@ RPCHelpMan listsinceblock()
                             {
                                 {RPCResult::Type::BOOL, "abandoned", "'true' if the transaction has been abandoned (inputs are respendable)."},
                                 {RPCResult::Type::STR, "label", /*optional=*/true, "A comment for the address/transaction, if any."},
-                                {RPCResult::Type::STR, "to", "If a comment to is associated with the transaction."},
                             })},
                         }},
                         {RPCResult::Type::ARR, "removed", /*optional=*/true, "<structure is the same as \"transactions\" above, only present if include_removed=true>\n"
                             "Note: transactions that were re-added in the active chain will appear as-is in this array, and may thus have a positive confirmation count."
                         , {{RPCResult::Type::ELISION, "", ""},}},
-                        {RPCResult::Type::STR_HEX, "lastblockhash", "The hash of the block (target_confirmations-1) from the best block on the main chain, or the genesis hash if the referenced block does not exist yet. This is typically used to feed back into listsinceblock the next time you call it. So you would generally use a target_confirmations of say 6, so you will be continually re-notified of transactions until they've reached 6 confirmations plus any new ones."}
+                        {RPCResult::Type::STR_HEX, "lastblock", "The hash of the block (target_confirmations-1) from the best block on the main chain, or the genesis hash if the referenced block does not exist yet. This is typically used to feed back into listsinceblock the next time you call it. So you would generally use a target_confirmations of say 6, so you will be continually re-notified of transactions until they've reached 6 confirmations plus any new ones."}
                     }
                 },
                 RPCExamples{
@@ -858,7 +863,9 @@ RPCHelpMan rescanblockchain()
                     RPCResult::Type::OBJ, "", "",
                     {
                         {RPCResult::Type::NUM, "start_height", "The block height where the rescan started (the requested height or 0)"},
-                        {RPCResult::Type::NUM, "stop_height", "The height of the last rescanned block. May be null in rare cases if there was a reorg and the call didn't scan any blocks because they were already scanned in the background."},
+                        // Null, not absent, when nothing was scanned - so neither NUM nor an
+                        // optional NUM describes it.
+                        {RPCResult::Type::ANY, "stop_height", "The height of the last rescanned block. May be null in rare cases if there was a reorg and the call didn't scan any blocks because they were already scanned in the background."},
                     }
                 },
                 RPCExamples{
diff --git a/src/wallet/rpc/wallet.cpp b/src/wallet/rpc/wallet.cpp
index 2400fa93e3a0..f6518949cbd1 100644
--- a/src/wallet/rpc/wallet.cpp
+++ b/src/wallet/rpc/wallet.cpp
@@ -120,22 +120,23 @@ static RPCHelpMan getwalletinfo()
                         {RPCResult::Type::NUM, "unconfirmed_balance", "DEPRECATED. Identical to getbalances().mine.untrusted_pending"},
                         {RPCResult::Type::NUM, "immature_balance", "DEPRECATED. Identical to getbalances().mine.immature"},
                         {RPCResult::Type::NUM, "txcount", "the total number of transactions in the wallet"},
-                        {RPCResult::Type::NUM_TIME, "timefirstkey", "the " + UNIX_EPOCH_TIME + " of the oldest known key in the wallet"},
+                        {RPCResult::Type::NUM_TIME, "timefirstkey", /*optional=*/true, "the " + UNIX_EPOCH_TIME + " of the oldest known key in the wallet. Legacy wallets only"},
                         {RPCResult::Type::NUM_TIME, "keypoololdest", /*optional=*/true, "the " + UNIX_EPOCH_TIME + " of the oldest pre-generated key in the key pool. Legacy wallets only"},
                         {RPCResult::Type::NUM, "keypoolsize", "how many new keys are pre-generated (only counts external keys)"},
                         {RPCResult::Type::NUM, "keypoolsize_hd_internal", /*optional=*/ true, "how many new keys are pre-generated for internal use (used for change outputs and mobile coinjoin, only appears if the wallet is using this feature, otherwise external keys are used)"},
                         {RPCResult::Type::NUM, "keys_left", "how many new keys are left since last automatic backup"},
                         {RPCResult::Type::NUM_TIME, "unlocked_until", /*optional=*/true, "the " + UNIX_EPOCH_TIME + " until which the wallet is unlocked for transfers, or 0 if the wallet is locked (only present for passphrase-encrypted wallets)"},
                         {RPCResult::Type::STR_AMOUNT, "paytxfee", "the transaction fee configuration, set in " + CURRENCY_UNIT + "/kB"},
-                        {RPCResult::Type::STR_HEX, "hdchainid", "the ID of the HD chain"},
-                        {RPCResult::Type::NUM, "hdaccountcount", "how many accounts of the HD chain are in this wallet"},
-                        {RPCResult::Type::ARR, "hdaccounts", "",
+                        {RPCResult::Type::STR_HEX, "hdchainid", /*optional=*/true, "the ID of the HD chain. Only present if the wallet is HD"},
+                        {RPCResult::Type::NUM, "hdaccountcount", /*optional=*/true, "how many accounts of the HD chain are in this wallet. Only present if the wallet is HD"},
+                        {RPCResult::Type::ARR, "hdaccounts", /*optional=*/true, "Only present if the wallet is HD",
                             {
                             {RPCResult::Type::OBJ, "", "",
                                 {
                                     {RPCResult::Type::NUM, "hdaccountindex", "the index of the account"},
-                                    {RPCResult::Type::NUM, "hdexternalkeyindex", "current external childkey index"},
-                                    {RPCResult::Type::NUM, "hdinternalkeyindex", "current internal childkey index"},
+                                    {RPCResult::Type::NUM, "hdexternalkeyindex", /*optional=*/true, "current external childkey index"},
+                                    {RPCResult::Type::NUM, "hdinternalkeyindex", /*optional=*/true, "current internal childkey index"},
+                                    {RPCResult::Type::STR, "error", /*optional=*/true, "description of why the account could not be read"},
                             }},
                         }},
                         {RPCResult::Type::BOOL, "private_keys_enabled", "false if privatekeys are disabled for this wallet (enforced watch-only wallet)"},

From b8647e75e02f27fc86a4632086230b754d05753e Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Mon, 28 Mar 2022 11:51:39 +0100
Subject: [PATCH 2/3] Merge bitcoin/bitcoin#23083: rpc: Fail to return
 undocumented or misdocumented JSON

fc892c3a80091fbeaa2b5a6ec5bdaa31359b42de rpc: Fail to return undocumented or misdocumented JSON (MarcoFalke)
f4bc4a705addea3e60c3b69437913e6571df275d rpc: Add m_skip_type_check to RPCResult (MarcoFalke)

Pull request description:

  This avoids documentation shortcomings such as the ones fixed in commit e7b6272b305386a264adf2c04b7bebfb8499070f, 138d55e6a0241f126916fde6ac9177c7e2a119c4, 577bd51a4b8de066466a445192c1c653872657e2, f8c84e047c61200fae4cc1d85688e113bf270409, 0ee9a00f90e81a6978b30bdb250a37cbfa6da022, 13f41855c5fedf11d4a2525f2f0dd214533e5e62, or faecb2ee0a0ad3eb8303cfc84a87dc02ec553c43

ACKs for top commit:
  fanquake:
    ACK fc892c3a80091fbeaa2b5a6ec5bdaa31359b42de - tested that this catches issue, i.e #24691:

Tree-SHA512: 9d0d7e6291bfc6f67541a4ff746d374ad8751fefcff6d103d8621c0298b190ab1d209ce96cfc3a0d4a6a5460a9f9bb790eb96027b16e5ff91f2512e40c92ca84

Co-authored-by: fanquake <fanquake@gmail.com>
---
 src/rpc/util.cpp          | 54 ++++++++++++++++++++++++++++++++++-----
 src/rpc/util.h            | 11 +++++---
 src/wallet/rpc/wallet.cpp |  2 +-
 3 files changed, 57 insertions(+), 10 deletions(-)

diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 52236f164804..0649a1f4c5a0 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -762,7 +762,7 @@ void RPCResult::ToSections(Sections& sections, const OuterType outer_type, const
     // Elements in a JSON structure (dictionary or array) are separated by a comma
     const std::string maybe_separator{outer_type != OuterType::NONE ? "," : ""};
 
-    // The key name if recursed into an dictionary
+    // The key name if recursed into a dictionary
     const std::string maybe_key{
         outer_type == OuterType::OBJ ?
             "\"" + this->m_key_name + "\" : " :
@@ -853,10 +853,11 @@ void RPCResult::ToSections(Sections& sections, const OuterType outer_type, const
 
 bool RPCResult::MatchesType(const UniValue& result) const
 {
-    switch (m_type) {
-    case Type::ELISION: {
-        return false;
+    if (m_skip_type_check) {
+        return true;
     }
+    switch (m_type) {
+    case Type::ELISION:
     case Type::ANY: {
         return true;
     }
@@ -877,11 +878,52 @@ bool RPCResult::MatchesType(const UniValue& result) const
     }
     case Type::ARR_FIXED:
     case Type::ARR: {
-        return UniValue::VARR == result.getType();
+        if (UniValue::VARR != result.getType()) return false;
+        for (size_t i{0}; i < result.get_array().size(); ++i) {
+            // If there are more results than documented, re-use the last doc_inner.
+            const RPCResult& doc_inner{m_inner.at(std::min(m_inner.size() - 1, i))};
+            if (!doc_inner.MatchesType(result.get_array()[i])) return false;
+        }
+        return true; // empty result array is valid
     }
     case Type::OBJ_DYN:
     case Type::OBJ: {
-        return UniValue::VOBJ == result.getType();
+        if (UniValue::VOBJ != result.getType()) return false;
+        if (!m_inner.empty() && m_inner.at(0).m_type == Type::ELISION) return true;
+        if (m_type == Type::OBJ_DYN) {
+            const RPCResult& doc_inner{m_inner.at(0)}; // Assume all types are the same, randomly pick the first
+            for (size_t i{0}; i < result.get_obj().size(); ++i) {
+                if (!doc_inner.MatchesType(result.get_obj()[i])) {
+                    return false;
+                }
+            }
+            return true; // empty result obj is valid
+        }
+        std::set<std::string> doc_keys;
+        for (const auto& doc_entry : m_inner) {
+            doc_keys.insert(doc_entry.m_key_name);
+        }
+        std::map<std::string, UniValue> result_obj;
+        result.getObjMap(result_obj);
+        for (const auto& result_entry : result_obj) {
+            if (doc_keys.find(result_entry.first) == doc_keys.end()) {
+                return false; // missing documentation
+            }
+        }
+
+        for (const auto& doc_entry : m_inner) {
+            const auto result_it{result_obj.find(doc_entry.m_key_name)};
+            if (result_it == result_obj.end()) {
+                if (!doc_entry.m_optional) {
+                    return false; // result is missing a required key
+                }
+                continue;
+            }
+            if (!doc_entry.MatchesType(result_it->second)) {
+                return false; // wrong type
+            }
+        }
+        return true;
     }
     } // no default case, so the compiler can warn about missing cases
     NONFATAL_UNREACHABLE();
diff --git a/src/rpc/util.h b/src/rpc/util.h
index e73843981d0d..30c0a7065c78 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -277,6 +277,7 @@ struct RPCResult {
     const std::string m_key_name;         //!< Only used for dicts
     const std::vector<RPCResult> m_inner; //!< Only used for arrays or dicts
     const bool m_optional;
+    const bool m_skip_type_check;
     const std::string m_description;
     const std::string m_cond;
 
@@ -291,6 +292,7 @@ struct RPCResult {
           m_key_name{std::move(m_key_name)},
           m_inner{std::move(inner)},
           m_optional{optional},
+          m_skip_type_check{false},
           m_description{std::move(description)},
           m_cond{std::move(cond)}
     {
@@ -311,11 +313,13 @@ struct RPCResult {
         std::string m_key_name,
         bool optional,
         std::string description,
-        std::vector<RPCResult> inner = {})
+        std::vector<RPCResult> inner = {},
+        bool skip_type_check = false)
         : m_type{std::move(type)},
           m_key_name{std::move(m_key_name)},
           m_inner{std::move(inner)},
           m_optional{optional},
+          m_skip_type_check{skip_type_check},
           m_description{std::move(description)},
           m_cond{}
     {
@@ -326,8 +330,9 @@ struct RPCResult {
         Type type,
         std::string m_key_name,
         std::string description,
-        std::vector<RPCResult> inner = {})
-        : RPCResult{type, m_key_name, false, description, inner} {}
+        std::vector<RPCResult> inner = {},
+        bool skip_type_check = false)
+        : RPCResult{type, m_key_name, false, description, inner, skip_type_check} {}
 
     /** Append the sections of the result. */
     void ToSections(Sections& sections, OuterType outer_type = OuterType::NONE, const int current_indent = 0) const;
diff --git a/src/wallet/rpc/wallet.cpp b/src/wallet/rpc/wallet.cpp
index f6518949cbd1..b91582e25e2e 100644
--- a/src/wallet/rpc/wallet.cpp
+++ b/src/wallet/rpc/wallet.cpp
@@ -145,7 +145,7 @@ static RPCHelpMan getwalletinfo()
                         {
                             {RPCResult::Type::NUM, "duration", "elapsed seconds since scan start"},
                             {RPCResult::Type::NUM, "progress", "scanning progress percentage [0.0, 1.0]"},
-                        }},
+                        }, /*skip_type_check=*/true},
                         {RPCResult::Type::BOOL, "descriptors", "whether this wallet uses descriptors for scriptPubKey management"},
                         {RPCResult::Type::BOOL, "external_signer", "whether this wallet is configured to use an external signer such as a hardware wallet"},
                         RESULT_LAST_PROCESSED_BLOCK,

From 9f22c9ccc962c385514c841b37526f40e96f6d45 Mon Sep 17 00:00:00 2001
From: Konstantin Akimov <github@knstqq.com>
Date: Tue, 3 Mar 2026 21:04:38 +0000
Subject: [PATCH 3/3] partial Merge bitcoin/bitcoin#34683: rpc: support a
 formal description of our JSON-RPC interface

Includes 6a1a66c180cba5f2d4189e89327de23505c7f4dd rpc: render Type::ANY in help text instead of aborting

RPCResult::Type::ANY triggers NONFATAL_UNREACHABLE() in ToSections(),
which crashes the help() RPC when a command uses Type::ANY in a
nested result field.

Previously this was never hit because Type::ANY was only used as a
top-level alternate result type, filtered out before ToSections() is
called.

getopenrpcinfo() will use this result type, so render it like other
types allowing it to be used in nested result definitions like schema.

Co-authored-by: will <will@256k1.dev>
---
 src/rpc/util.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 0649a1f4c5a0..3af8f661d102 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -781,7 +781,8 @@ void RPCResult::ToSections(Sections& sections, const OuterType outer_type, const
         return;
     }
     case Type::ANY: {
-        NONFATAL_UNREACHABLE(); // Only for testing
+        sections.PushSection({indent + maybe_key + "xxx" + maybe_separator, Description("any")});
+        return;
     }
     case Type::NONE: {
         sections.PushSection({indent + "null" + maybe_separator, Description("json null")});