From eda7bb09e46f90dddc79a7a39a12005abcde7506 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sun, 27 Feb 2022 13:16:53 +0530
Subject: [PATCH 01/16] partial bitcoin#16240: JSONRPCRequest-aware RPCHelpMan

---
 src/Makefile.am                       |  5 +--
 src/dash-cli.cpp                      |  1 +
 src/rest.cpp                          |  1 +
 src/rpc/protocol.h                    | 23 --------------
 src/rpc/rawtransaction_util.cpp       |  2 +-
 src/rpc/{protocol.cpp => request.cpp} | 44 ++++++++++++++++++++++++---
 src/rpc/request.h                     | 42 +++++++++++++++++++++++++
 src/rpc/server.cpp                    | 35 ---------------------
 src/rpc/server.h                      | 18 ++---------
 src/rpc/util.h                        | 10 ++++++
 10 files changed, 100 insertions(+), 81 deletions(-)
 rename src/rpc/{protocol.cpp => request.cpp} (74%)
 create mode 100644 src/rpc/request.h

diff --git a/src/Makefile.am b/src/Makefile.am
index 2b9f815fd9..d74d03a3b7 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -257,9 +257,10 @@ BITCOIN_CORE_H = \
   rpc/client.h \
   rpc/mining.h \
   rpc/protocol.h \
-  rpc/server.h \
   rpc/rawtransaction_util.h \
   rpc/register.h \
+  rpc/request.h \
+  rpc/server.h \
   rpc/util.h \
   saltedhasher.h \
   scheduler.h \
@@ -678,7 +679,7 @@ libdash_util_a_SOURCES = \
   interfaces/handler.cpp \
   logging.cpp \
   random.cpp \
-  rpc/protocol.cpp \
+  rpc/request.cpp \
   stacktraces.cpp \
   support/cleanse.cpp \
   sync.cpp \
diff --git a/src/dash-cli.cpp b/src/dash-cli.cpp
index 3d1ebce3a5..ac4a781e4f 100644
--- a/src/dash-cli.cpp
+++ b/src/dash-cli.cpp
@@ -12,6 +12,7 @@
 #include <clientversion.h>
 #include <rpc/client.h>
 #include <rpc/protocol.h>
+#include <rpc/request.h>
 #include <stacktraces.h>
 #include <util/system.h>
 #include <util/strencodings.h>
diff --git a/src/rest.cpp b/src/rest.cpp
index c985319f81..834195393a 100644
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -11,6 +11,7 @@
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <rpc/blockchain.h>
+#include <rpc/protocol.h>
 #include <rpc/server.h>
 #include <streams.h>
 #include <sync.h>
diff --git a/src/rpc/protocol.h b/src/rpc/protocol.h
index dfb0289219..37a4d83627 100644
--- a/src/rpc/protocol.h
+++ b/src/rpc/protocol.h
@@ -6,15 +6,6 @@
 #ifndef BITCOIN_RPC_PROTOCOL_H
 #define BITCOIN_RPC_PROTOCOL_H
 
-#include <fs.h>
-
-#include <list>
-#include <map>
-#include <stdint.h>
-#include <string>
-
-#include <univalue.h>
-
 //! HTTP status codes
 enum HTTPStatusCode
 {
@@ -93,18 +84,4 @@ enum RPCErrorCode
     RPC_FORBIDDEN_BY_SAFE_MODE      = -2,  //!< Server is in safe mode, and command is not allowed in safe mode
 };
 
-UniValue JSONRPCRequestObj(const std::string& strMethod, const UniValue& params, const UniValue& id);
-UniValue JSONRPCReplyObj(const UniValue& result, const UniValue& error, const UniValue& id);
-std::string JSONRPCReply(const UniValue& result, const UniValue& error, const UniValue& id);
-UniValue JSONRPCError(int code, const std::string& message);
-
-/** Generate a new RPC authentication cookie and write it to disk */
-bool GenerateAuthCookie(std::string *cookie_out);
-/** Read the RPC authentication cookie from disk */
-bool GetAuthCookie(std::string *cookie_out);
-/** Delete RPC authentication cookie from disk */
-void DeleteAuthCookie();
-/** Parse JSON-RPC batch reply into a vector */
-std::vector<UniValue> JSONRPCProcessBatchReply(const UniValue &in, size_t num);
-
 #endif // BITCOIN_RPC_PROTOCOL_H
diff --git a/src/rpc/rawtransaction_util.cpp b/src/rpc/rawtransaction_util.cpp
index a9335987c2..2718367f91 100644
--- a/src/rpc/rawtransaction_util.cpp
+++ b/src/rpc/rawtransaction_util.cpp
@@ -12,7 +12,7 @@
 #include <keystore.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
-#include <rpc/protocol.h>
+#include <rpc/request.h>
 #include <rpc/util.h>
 #include <univalue.h>
 #include <util/strencodings.h>
diff --git a/src/rpc/protocol.cpp b/src/rpc/request.cpp
similarity index 74%
rename from src/rpc/protocol.cpp
rename to src/rpc/request.cpp
index c5c32385a7..7c96b09152 100644
--- a/src/rpc/protocol.cpp
+++ b/src/rpc/request.cpp
@@ -1,15 +1,16 @@
 // Copyright (c) 2010 Satoshi Nakamoto
-// Copyright (c) 2009-2015 The Bitcoin Core developers
-// Copyright (c) 2014-2020 The Dash Core developers
+// Copyright (c) 2009-2019 The Bitcoin Core developers
+// Copyright (c) 2014-2022 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/protocol.h>
+#include <rpc/request.h>
 
+#include <fs.h>
 #include <random.h>
+#include <rpc/protocol.h>
 #include <util/system.h>
 #include <util/strencodings.h>
-#include <util/time.h>
 
 /**
  * JSON-RPC protocol.  Bitcoin speaks version 1.0 for maximum compatibility,
@@ -148,3 +149,38 @@ std::vector<UniValue> JSONRPCProcessBatchReply(const UniValue &in, size_t num)
     }
     return batch;
 }
+
+void JSONRPCRequest::parse(const UniValue& valRequest)
+{
+    // Parse request
+    if (!valRequest.isObject())
+        throw JSONRPCError(RPC_INVALID_REQUEST, "Invalid Request object");
+    const UniValue& request = valRequest.get_obj();
+
+    // Parse id now so errors from here on will have the id
+    id = find_value(request, "id");
+
+    // Parse method
+    UniValue valMethod = find_value(request, "method");
+    if (valMethod.isNull())
+        throw JSONRPCError(RPC_INVALID_REQUEST, "Missing method");
+    if (!valMethod.isStr())
+        throw JSONRPCError(RPC_INVALID_REQUEST, "Method must be a string");
+    strMethod = valMethod.get_str();
+    if (strMethod != "getblocktemplate") {
+        if (fLogIPs)
+            LogPrint(BCLog::RPC, "ThreadRPCServer method=%s user=%s peeraddr=%s\n", SanitizeString(strMethod),
+                this->authUser, this->peerAddr);
+        else
+            LogPrint(BCLog::RPC, "ThreadRPCServer method=%s user=%s\n", SanitizeString(strMethod), this->authUser);
+    }
+
+    // Parse params
+    UniValue valParams = find_value(request, "params");
+    if (valParams.isArray() || valParams.isObject())
+        params = valParams;
+    else if (valParams.isNull())
+        params = UniValue(UniValue::VARR);
+    else
+        throw JSONRPCError(RPC_INVALID_REQUEST, "Params must be an array or object");
+}
diff --git a/src/rpc/request.h b/src/rpc/request.h
new file mode 100644
index 0000000000..99eb4f9354
--- /dev/null
+++ b/src/rpc/request.h
@@ -0,0 +1,42 @@
+// Copyright (c) 2010 Satoshi Nakamoto
+// Copyright (c) 2009-2019 The Bitcoin 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_REQUEST_H
+#define BITCOIN_RPC_REQUEST_H
+
+#include <string>
+
+#include <univalue.h>
+
+UniValue JSONRPCRequestObj(const std::string& strMethod, const UniValue& params, const UniValue& id);
+UniValue JSONRPCReplyObj(const UniValue& result, const UniValue& error, const UniValue& id);
+std::string JSONRPCReply(const UniValue& result, const UniValue& error, const UniValue& id);
+UniValue JSONRPCError(int code, const std::string& message);
+
+/** Generate a new RPC authentication cookie and write it to disk */
+bool GenerateAuthCookie(std::string *cookie_out);
+/** Read the RPC authentication cookie from disk */
+bool GetAuthCookie(std::string *cookie_out);
+/** Delete RPC authentication cookie from disk */
+void DeleteAuthCookie();
+/** Parse JSON-RPC batch reply into a vector */
+std::vector<UniValue> JSONRPCProcessBatchReply(const UniValue &in, size_t num);
+
+class JSONRPCRequest
+{
+public:
+    UniValue id;
+    std::string strMethod;
+    UniValue params;
+    bool fHelp;
+    std::string URI;
+    std::string authUser;
+    std::string peerAddr;
+
+    JSONRPCRequest() : id(NullUniValue), params(NullUniValue), fHelp(false) {}
+    void parse(const UniValue& valRequest);
+};
+
+#endif // BITCOIN_RPC_REQUEST_H
diff --git a/src/rpc/server.cpp b/src/rpc/server.cpp
index 6b15fc1801..608810c5a6 100644
--- a/src/rpc/server.cpp
+++ b/src/rpc/server.cpp
@@ -341,41 +341,6 @@ bool RPCIsInWarmup(std::string *outStatus)
     return fRPCInWarmup;
 }
 
-void JSONRPCRequest::parse(const UniValue& valRequest)
-{
-    // Parse request
-    if (!valRequest.isObject())
-        throw JSONRPCError(RPC_INVALID_REQUEST, "Invalid Request object");
-    const UniValue& request = valRequest.get_obj();
-
-    // Parse id now so errors from here on will have the id
-    id = find_value(request, "id");
-
-    // Parse method
-    UniValue valMethod = find_value(request, "method");
-    if (valMethod.isNull())
-        throw JSONRPCError(RPC_INVALID_REQUEST, "Missing method");
-    if (!valMethod.isStr())
-        throw JSONRPCError(RPC_INVALID_REQUEST, "Method must be a string");
-    strMethod = valMethod.get_str();
-    if (strMethod != "getblocktemplate") {
-        if (fLogIPs)
-            LogPrint(BCLog::RPC, "ThreadRPCServer method=%s user=%s peeraddr=%s\n", SanitizeString(strMethod),
-                this->authUser, this->peerAddr);
-        else
-            LogPrint(BCLog::RPC, "ThreadRPCServer method=%s user=%s\n", SanitizeString(strMethod), this->authUser);
-    }
-
-    // Parse params
-    UniValue valParams = find_value(request, "params");
-    if (valParams.isArray() || valParams.isObject())
-        params = valParams;
-    else if (valParams.isNull())
-        params = UniValue(UniValue::VARR);
-    else
-        throw JSONRPCError(RPC_INVALID_REQUEST, "Params must be an array or object");
-}
-
 bool IsDeprecatedRPCEnabled(const std::string& method)
 {
     const std::vector<std::string> enabled_methods = gArgs.GetArgs("-deprecatedrpc");
diff --git a/src/rpc/server.h b/src/rpc/server.h
index 2b1f99d495..bfdead4f20 100644
--- a/src/rpc/server.h
+++ b/src/rpc/server.h
@@ -7,11 +7,12 @@
 #define BITCOIN_RPC_SERVER_H
 
 #include <amount.h>
-#include <rpc/protocol.h>
+#include <rpc/request.h>
 
 #include <map>
 #include <stdint.h>
 #include <string>
+#include <functional>
 
 #include <univalue.h>
 
@@ -23,21 +24,6 @@ namespace RPCServer
     void OnStopped(std::function<void ()> slot);
 }
 
-class JSONRPCRequest
-{
-public:
-    UniValue id;
-    std::string strMethod;
-    UniValue params;
-    bool fHelp;
-    std::string URI;
-    std::string authUser;
-    std::string peerAddr;
-
-    JSONRPCRequest() : id(NullUniValue), params(NullUniValue), fHelp(false) {}
-    void parse(const UniValue& valRequest);
-};
-
 /** Query whether RPC is running */
 bool IsRPCRunning();
 
diff --git a/src/rpc/util.h b/src/rpc/util.h
index 58eb4526cb..e9d6688946 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -9,6 +9,7 @@
 #include <pubkey.h>
 #include <protocol.h>
 #include <rpc/protocol.h>
+#include <rpc/request.h>
 #include <script/standard.h>
 #include <univalue.h>
 #include <util/strencodings.h>
@@ -243,6 +244,15 @@ public:
     std::string ToString() const;
     /** If the supplied number of args is neither too small nor too high */
     bool IsValidNumArgs(size_t num_args) const;
+    /**
+     * Check if the given request is valid according to this command or if
+     * the user is asking for help information, and throw help when appropriate.
+     */
+    inline void Check(const JSONRPCRequest& request) const {
+        if (request.fHelp || !IsValidNumArgs(request.params.size())) {
+            throw std::runtime_error(ToString());
+        }
+    }
 
 private:
     const std::string m_name;

From cd42b00ac901eaa77021f794343d79fde1b80640 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sun, 27 Feb 2022 13:14:07 +0530
Subject: [PATCH 02/16] rpc: adapt Dash-specific help messages to
 JSONRPCRequest-aware RPCHelpMan

---
 src/rpc/governance.cpp | 368 +++++++++++++-------------
 src/rpc/masternode.cpp | 286 ++++++++++-----------
 src/rpc/rpcevo.cpp     | 572 ++++++++++++++++++++---------------------
 src/rpc/rpcquorums.cpp | 451 ++++++++++++++++----------------
 src/rpc/util.h         |   4 +
 5 files changed, 816 insertions(+), 865 deletions(-)

diff --git a/src/rpc/governance.cpp b/src/rpc/governance.cpp
index b43e2b4320..f3d88f331e 100644
--- a/src/rpc/governance.cpp
+++ b/src/rpc/governance.cpp
@@ -24,23 +24,22 @@
 #include <wallet/wallet.h>
 #endif // ENABLE_WALLET
 
-static void gobject_count_help()
+static void gobject_count_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"gobject count",
-            "Count governance objects and votes\n",
-            {
-                {"mode", RPCArg::Type::STR, /* default */ "json", "Output format: json (\"json\") or string in free form (\"all\")"},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"gobject count",
+        "Count governance objects and votes\n",
+        {
+            {"mode", RPCArg::Type::STR, /* default */ "json", "Output format: json (\"json\") or string in free form (\"all\")"},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue gobject_count(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() > 2)
-        gobject_count_help();
+        gobject_count_help(request);
 
     std::string strMode{"json"};
 
@@ -49,28 +48,27 @@ static UniValue gobject_count(const JSONRPCRequest& request)
     }
 
     if (strMode != "json" && strMode != "all")
-        gobject_count_help();
+        gobject_count_help(request);
 
     return strMode == "json" ? governance.ToJson() : governance.ToString();
 }
 
-static void gobject_deserialize_help()
+static void gobject_deserialize_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan {"gobject deserialize",
-            "Deserialize governance object from hex string to JSON\n",
-            {
-                {"hex_data", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "data in hex string form"},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan {"gobject deserialize",
+        "Deserialize governance object from hex string to JSON\n",
+        {
+            {"hex_data", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "data in hex string form"},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue gobject_deserialize(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() != 2)
-        gobject_deserialize_help();
+        gobject_deserialize_help(request);
 
     std::string strHex = request.params[1].get_str();
 
@@ -83,23 +81,22 @@ static UniValue gobject_deserialize(const JSONRPCRequest& request)
     return u.write().c_str();
 }
 
-static void gobject_check_help()
+static void gobject_check_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"gobject check",
-            "Validate governance object data (proposal only)\n",
-            {
-                {"hex_data", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "data in hex string format"},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"gobject check",
+        "Validate governance object data (proposal only)\n",
+        {
+            {"hex_data", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "data in hex string format"},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue gobject_check(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() != 2)
-        gobject_check_help();
+        gobject_check_help(request);
 
     // ASSEMBLE NEW GOVERNANCE OBJECT FROM USER PARAMETERS
 
@@ -132,24 +129,23 @@ static UniValue gobject_check(const JSONRPCRequest& request)
 }
 
 #ifdef ENABLE_WALLET
-static void gobject_prepare_help(CWallet* const pwallet)
+static void gobject_prepare_help(const JSONRPCRequest& request, CWallet* const pwallet)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"gobject prepare",
-            "Prepare governance object by signing and creating tx\n"
-            + HelpRequiringPassphrase(pwallet) + "\n",
-            {
-                {"parent-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "hash of the parent object, \"0\" is root"},
-                {"revision", RPCArg::Type::NUM, RPCArg::Optional::NO, "object revision in the system"},
-                {"time", RPCArg::Type::NUM, RPCArg::Optional::NO, "time this object was created"},
-                {"data-hex", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "data in hex string form"},
-                {"use-IS", RPCArg::Type::BOOL, /* default */ "false", "Deprecated and ignored"},
-                {"outputHash", RPCArg::Type::STR_HEX, /* default */ "", "the single output to submit the proposal fee from"},
-                {"outputIndex", RPCArg::Type::NUM, /* default */ "", "The output index."},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"gobject prepare",
+        "Prepare governance object by signing and creating tx\n"
+        + HelpRequiringPassphrase(pwallet) + "\n",
+        {
+            {"parent-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "hash of the parent object, \"0\" is root"},
+            {"revision", RPCArg::Type::NUM, RPCArg::Optional::NO, "object revision in the system"},
+            {"time", RPCArg::Type::NUM, RPCArg::Optional::NO, "time this object was created"},
+            {"data-hex", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "data in hex string form"},
+            {"use-IS", RPCArg::Type::BOOL, /* default */ "false", "Deprecated and ignored"},
+            {"outputHash", RPCArg::Type::STR_HEX, /* default */ "", "the single output to submit the proposal fee from"},
+            {"outputIndex", RPCArg::Type::NUM, /* default */ "", "The output index."},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue gobject_prepare(const JSONRPCRequest& request)
@@ -160,7 +156,7 @@ static UniValue gobject_prepare(const JSONRPCRequest& request)
         return NullUniValue;
 
     if (request.fHelp || (request.params.size() != 5 && request.params.size() != 6 && request.params.size() != 8))
-        gobject_prepare_help(pwallet);
+        gobject_prepare_help(request, pwallet);
 
     EnsureWalletIsUnlocked(pwallet);
 
@@ -260,18 +256,17 @@ static UniValue gobject_prepare(const JSONRPCRequest& request)
     return tx->GetHash().ToString();
 }
 
-static void gobject_list_prepared_help(CWallet* const pwallet)
+static void gobject_list_prepared_help(const JSONRPCRequest& request, CWallet* const pwallet)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"gobject list-prepared",
-            "Returns a list of governance objects prepared by this wallet with \"gobject prepare\" sorted by their creation time.\n"
-            + HelpRequiringPassphrase(pwallet) + "\n",
-            {
-                {"count", RPCArg::Type::NUM, /* default */ "10", "Maximum number of objects to return."},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"gobject list-prepared",
+        "Returns a list of governance objects prepared by this wallet with \"gobject prepare\" sorted by their creation time.\n"
+        + HelpRequiringPassphrase(pwallet) + "\n",
+        {
+            {"count", RPCArg::Type::NUM, /* default */ "10", "Maximum number of objects to return."},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue gobject_list_prepared(const JSONRPCRequest& request)
@@ -282,7 +277,7 @@ static UniValue gobject_list_prepared(const JSONRPCRequest& request)
         return NullUniValue;
 
     if (request.fHelp || (request.params.size() > 2)) {
-        gobject_list_prepared_help(pwallet);
+        gobject_list_prepared_help(request, pwallet);
     }
 
     EnsureWalletIsUnlocked(pwallet);
@@ -312,27 +307,26 @@ static UniValue gobject_list_prepared(const JSONRPCRequest& request)
 }
 #endif // ENABLE_WALLET
 
-static void gobject_submit_help()
+static void gobject_submit_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"gobject submit",
-            "Submit governance object to network\n",
-            {
-                {"parent-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "hash of the parent object, \"0\" is root"},
-                {"revision", RPCArg::Type::NUM, RPCArg::Optional::NO, "object revision in the system"},
-                {"time", RPCArg::Type::NUM, RPCArg::Optional::NO, "time this object was created"},
-                {"data-hex", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "data in hex string form"},
-                {"fee-txid", RPCArg::Type::STR_HEX, /* default */ "", "fee-tx id, required for all objects except triggers"},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"gobject submit",
+        "Submit governance object to network\n",
+        {
+            {"parent-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "hash of the parent object, \"0\" is root"},
+            {"revision", RPCArg::Type::NUM, RPCArg::Optional::NO, "object revision in the system"},
+            {"time", RPCArg::Type::NUM, RPCArg::Optional::NO, "time this object was created"},
+            {"data-hex", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "data in hex string form"},
+            {"fee-txid", RPCArg::Type::STR_HEX, /* default */ "", "fee-tx id, required for all objects except triggers"},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue gobject_submit(const JSONRPCRequest& request)
 {
     if (request.fHelp || ((request.params.size() < 5) || (request.params.size() > 6)))
-        gobject_submit_help();
+        gobject_submit_help(request);
 
     if(!masternodeSync.IsBlockchainSynced()) {
         throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Must wait for client to sync with masternode network. Try again in a minute or so.");
@@ -430,25 +424,24 @@ static UniValue gobject_submit(const JSONRPCRequest& request)
     return govobj.GetHash().ToString();
 }
 
-static void gobject_vote_conf_help()
+static void gobject_vote_conf_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"gobject vote-conf",
-            "Vote on a governance object by masternode configured in dash.conf\n",
-            {
-                {"governance-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "hash of the governance object"},
-                {"vote", RPCArg::Type::STR, RPCArg::Optional::NO, "vote, possible values: [funding|valid|delete|endorsed]"},
-                {"vote-outcome", RPCArg::Type::STR, RPCArg::Optional::NO, "vote outcome, possible values: [yes|no|abstain]"},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"gobject vote-conf",
+        "Vote on a governance object by masternode configured in dash.conf\n",
+        {
+            {"governance-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "hash of the governance object"},
+            {"vote", RPCArg::Type::STR, RPCArg::Optional::NO, "vote, possible values: [funding|valid|delete|endorsed]"},
+            {"vote-outcome", RPCArg::Type::STR, RPCArg::Optional::NO, "vote outcome, possible values: [yes|no|abstain]"},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue gobject_vote_conf(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() != 4)
-        gobject_vote_conf_help();
+        gobject_vote_conf_help(request);
 
     uint256 hash;
 
@@ -604,20 +597,19 @@ static UniValue VoteWithMasternodes(const std::map<uint256, CKey>& keys,
 }
 
 #ifdef ENABLE_WALLET
-static void gobject_vote_many_help(CWallet* const pwallet)
+static void gobject_vote_many_help(const JSONRPCRequest& request, CWallet* const pwallet)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"gobject vote-many",
-            "Vote on a governance object by all masternodes for which the voting key is present in the local wallet\n"
-            + HelpRequiringPassphrase(pwallet) + "\n",
-            {
-                {"governance-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "hash of the governance object"},
-                {"vote", RPCArg::Type::STR, RPCArg::Optional::NO, "vote, possible values: [funding|valid|delete|endorsed]"},
-                {"vote-outcome", RPCArg::Type::STR, RPCArg::Optional::NO, "vote outcome, possible values: [yes|no|abstain]"},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"gobject vote-many",
+        "Vote on a governance object by all masternodes for which the voting key is present in the local wallet\n"
+        + HelpRequiringPassphrase(pwallet) + "\n",
+        {
+            {"governance-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "hash of the governance object"},
+            {"vote", RPCArg::Type::STR, RPCArg::Optional::NO, "vote, possible values: [funding|valid|delete|endorsed]"},
+            {"vote-outcome", RPCArg::Type::STR, RPCArg::Optional::NO, "vote outcome, possible values: [yes|no|abstain]"},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue gobject_vote_many(const JSONRPCRequest& request)
@@ -628,7 +620,7 @@ static UniValue gobject_vote_many(const JSONRPCRequest& request)
         return NullUniValue;
 
     if (request.fHelp || request.params.size() != 4)
-        gobject_vote_many_help(pwallet);
+        gobject_vote_many_help(request, pwallet);
 
     uint256 hash = ParseHashV(request.params[1], "Object hash");
     std::string strVoteSignal = request.params[2].get_str();
@@ -661,21 +653,20 @@ static UniValue gobject_vote_many(const JSONRPCRequest& request)
     return VoteWithMasternodes(votingKeys, hash, eVoteSignal, eVoteOutcome);
 }
 
-static void gobject_vote_alias_help(CWallet* const pwallet)
+static void gobject_vote_alias_help(const JSONRPCRequest& request, CWallet* const pwallet)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"gobject vote-alias",
-            "Vote on a governance object by masternode's voting key (if present in local wallet)\n"
-            + HelpRequiringPassphrase(pwallet) + "\n",
-            {
-                {"governance-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "hash of the governance object"},
-                {"vote", RPCArg::Type::STR, RPCArg::Optional::NO, "vote, possible values: [funding|valid|delete|endorsed]"},
-                {"vote-outcome", RPCArg::Type::STR, RPCArg::Optional::NO, "vote outcome, possible values: [yes|no|abstain]"},
-                {"protx-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "masternode's proTxHash"},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"gobject vote-alias",
+        "Vote on a governance object by masternode's voting key (if present in local wallet)\n"
+        + HelpRequiringPassphrase(pwallet) + "\n",
+        {
+            {"governance-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "hash of the governance object"},
+            {"vote", RPCArg::Type::STR, RPCArg::Optional::NO, "vote, possible values: [funding|valid|delete|endorsed]"},
+            {"vote-outcome", RPCArg::Type::STR, RPCArg::Optional::NO, "vote outcome, possible values: [yes|no|abstain]"},
+            {"protx-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "masternode's proTxHash"},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue gobject_vote_alias(const JSONRPCRequest& request)
@@ -686,7 +677,7 @@ static UniValue gobject_vote_alias(const JSONRPCRequest& request)
         return NullUniValue;
 
     if (request.fHelp || request.params.size() != 5)
-        gobject_vote_alias_help(pwallet);
+        gobject_vote_alias_help(request, pwallet);
 
     uint256 hash = ParseHashV(request.params[1], "Object hash");
     std::string strVoteSignal = request.params[2].get_str();
@@ -782,24 +773,23 @@ static UniValue ListObjects(const std::string& strCachedSignal, const std::strin
     return objResult;
 }
 
-static void gobject_list_help()
+static void gobject_list_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"gobject list",
-            "List governance objects (can be filtered by signal and/or object type)\n",
-            {
-                {"signal", RPCArg::Type::STR, /* default */ "valid", "cached signal, possible values: [valid|funding|delete|endorsed|all]"},
-                {"type", RPCArg::Type::STR, /* default */ "all", "object type, possible values: [proposals|triggers|all]"},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"gobject list",
+        "List governance objects (can be filtered by signal and/or object type)\n",
+        {
+            {"signal", RPCArg::Type::STR, /* default */ "valid", "cached signal, possible values: [valid|funding|delete|endorsed|all]"},
+            {"type", RPCArg::Type::STR, /* default */ "all", "object type, possible values: [proposals|triggers|all]"},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue gobject_list(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() > 3)
-        gobject_list_help();
+        gobject_list_help(request);
 
     std::string strCachedSignal = "valid";
     if (!request.params[1].isNull()) {
@@ -818,24 +808,23 @@ static UniValue gobject_list(const JSONRPCRequest& request)
     return ListObjects(strCachedSignal, strType, 0);
 }
 
-static void gobject_diff_help()
+static void gobject_diff_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"gobject diff",
-            "List differences since last diff or list\n",
-            {
-                {"signal", RPCArg::Type::STR, /* default */ "valid", "cached signal, possible values: [valid|funding|delete|endorsed|all]"},
-                {"type", RPCArg::Type::STR, /* default */ "all", "object type, possible values: [proposals|triggers|all]"},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"gobject diff",
+        "List differences since last diff or list\n",
+        {
+            {"signal", RPCArg::Type::STR, /* default */ "valid", "cached signal, possible values: [valid|funding|delete|endorsed|all]"},
+            {"type", RPCArg::Type::STR, /* default */ "all", "object type, possible values: [proposals|triggers|all]"},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue gobject_diff(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() > 3)
-        gobject_diff_help();
+        gobject_diff_help(request);
 
     std::string strCachedSignal = "valid";
     if (!request.params[1].isNull()) {
@@ -854,23 +843,22 @@ static UniValue gobject_diff(const JSONRPCRequest& request)
     return ListObjects(strCachedSignal, strType, governance.GetLastDiffTime());
 }
 
-static void gobject_get_help()
+static void gobject_get_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"gobject get",
-            "Get governance object by hash\n",
-            {
-                {"governance-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "object id"},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"gobject get",
+        "Get governance object by hash\n",
+        {
+            {"governance-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "object id"},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue gobject_get(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() != 2)
-        gobject_get_help();
+        gobject_get_help(request);
 
     // COLLECT VARIABLES FROM OUR USER
     uint256 hash = ParseHashV(request.params[1], "GovObj hash");
@@ -946,25 +934,24 @@ static UniValue gobject_get(const JSONRPCRequest& request)
     return objResult;
 }
 
-static void gobject_getcurrentvotes_help()
+static void gobject_getcurrentvotes_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"gobject getcurrentvotes",
-            "Get only current (tallying) votes for a governance object hash (does not include old votes)\n",
-            {
-                {"governance-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "object id"},
-                {"txid", RPCArg::Type::STR_HEX, /* default */ "", "masternode collateral txid"},
-                {"vout", RPCArg::Type::STR, /* default */ "", "masternode collateral output index, required if <txid> presents"},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"gobject getcurrentvotes",
+        "Get only current (tallying) votes for a governance object hash (does not include old votes)\n",
+        {
+            {"governance-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "object id"},
+            {"txid", RPCArg::Type::STR_HEX, /* default */ "", "masternode collateral txid"},
+            {"vout", RPCArg::Type::STR, /* default */ "", "masternode collateral output index, required if <txid> presents"},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue gobject_getcurrentvotes(const JSONRPCRequest& request)
 {
     if (request.fHelp || (request.params.size() != 2 && request.params.size() != 4))
-        gobject_getcurrentvotes_help();
+        gobject_getcurrentvotes_help(request);
 
     // COLLECT PARAMETERS FROM USER
 
@@ -1003,34 +990,33 @@ static UniValue gobject_getcurrentvotes(const JSONRPCRequest& request)
 
 [[ noreturn ]] static void gobject_help()
 {
-    throw std::runtime_error(
-        RPCHelpMan {"gobject",
-            "Set of commands to manage governance objects.\n"
-            "\nAvailable commands:\n"
-            "  check              - Validate governance object data (proposal only)\n"
+    RPCHelpMan {"gobject",
+        "Set of commands to manage governance objects.\n"
+        "\nAvailable commands:\n"
+        "  check              - Validate governance object data (proposal only)\n"
 #ifdef ENABLE_WALLET
-            "  prepare            - Prepare governance object by signing and creating tx\n"
-            "  list-prepared      - Returns a list of governance objects prepared by this wallet with \"gobject prepare\"\n"
+        "  prepare            - Prepare governance object by signing and creating tx\n"
+        "  list-prepared      - Returns a list of governance objects prepared by this wallet with \"gobject prepare\"\n"
 #endif // ENABLE_WALLET
-            "  submit             - Submit governance object to network\n"
-            "  deserialize        - Deserialize governance object from hex string to JSON\n"
-            "  count              - Count governance objects and votes (additional param: 'json' or 'all', default: 'json')\n"
-            "  get                - Get governance object by hash\n"
-            "  getcurrentvotes    - Get only current (tallying) votes for a governance object hash (does not include old votes)\n"
-            "  list               - List governance objects (can be filtered by signal and/or object type)\n"
-            "  diff               - List differences since last diff\n"
+        "  submit             - Submit governance object to network\n"
+        "  deserialize        - Deserialize governance object from hex string to JSON\n"
+        "  count              - Count governance objects and votes (additional param: 'json' or 'all', default: 'json')\n"
+        "  get                - Get governance object by hash\n"
+        "  getcurrentvotes    - Get only current (tallying) votes for a governance object hash (does not include old votes)\n"
+        "  list               - List governance objects (can be filtered by signal and/or object type)\n"
+        "  diff               - List differences since last diff\n"
 #ifdef ENABLE_WALLET
-            "  vote-alias         - Vote on a governance object by masternode proTxHash\n"
+        "  vote-alias         - Vote on a governance object by masternode proTxHash\n"
 #endif // ENABLE_WALLET
-            "  vote-conf          - Vote on a governance object by masternode configured in dash.conf\n"
+        "  vote-conf          - Vote on a governance object by masternode configured in dash.conf\n"
 #ifdef ENABLE_WALLET
-            "  vote-many          - Vote on a governance object by all masternodes for which the voting key is in the wallet\n"
+        "  vote-many          - Vote on a governance object by all masternodes for which the voting key is in the wallet\n"
 #endif // ENABLE_WALLET
-            ,
-            {},
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+        ,
+        {},
+        RPCResults{},
+        RPCExamples{""}
+    }.Throw();
 }
 
 static UniValue gobject(const JSONRPCRequest& request)
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index f97b2e9af4..b615a529c3 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -25,40 +25,39 @@
 
 static UniValue masternodelist(const JSONRPCRequest& request);
 
-static void masternode_list_help()
+static void masternode_list_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-            RPCHelpMan{"masternodelist",
-                "Get a list of masternodes in different modes. This call is identical to 'masternode list' call.\n"
-                "Available modes:\n"
-                "  addr           - Print ip address associated with a masternode (can be additionally filtered, partial match)\n"
-                "  full           - Print info in format 'status payee lastpaidtime lastpaidblock IP'\n"
-                "                   (can be additionally filtered, partial match)\n"
-                "  info           - Print info in format 'status payee IP'\n"
-                "                   (can be additionally filtered, partial match)\n"
-                "  json           - Print info in JSON format (can be additionally filtered, partial match)\n"
-                "  lastpaidblock  - Print the last block height a node was paid on the network\n"
-                "  lastpaidtime   - Print the last time a node was paid on the network\n"
-                "  owneraddress   - Print the masternode owner Dash address\n"
-                "  payee          - Print the masternode payout Dash address (can be additionally filtered,\n"
-                "                   partial match)\n"
-                "  pubKeyOperator - Print the masternode operator public key\n"
-                "  status         - Print masternode status: ENABLED / POSE_BANNED\n"
-                "                   (can be additionally filtered, partial match)\n"
-                "  votingaddress  - Print the masternode voting Dash address\n",
-                {
-                    {"mode", RPCArg::Type::STR, /* default */ "json", "The mode to run list in"},
-                    {"filter", RPCArg::Type::STR, /* default */ "", "Filter results. Partial match by outpoint by default in all modes, additional matches in some modes are also available"},
-                },
-                RPCResults{},
-                RPCExamples{""},
-            }.ToString());
+    RPCHelpMan{"masternodelist",
+        "Get a list of masternodes in different modes. This call is identical to 'masternode list' call.\n"
+        "Available modes:\n"
+        "  addr           - Print ip address associated with a masternode (can be additionally filtered, partial match)\n"
+        "  full           - Print info in format 'status payee lastpaidtime lastpaidblock IP'\n"
+        "                   (can be additionally filtered, partial match)\n"
+        "  info           - Print info in format 'status payee IP'\n"
+        "                   (can be additionally filtered, partial match)\n"
+        "  json           - Print info in JSON format (can be additionally filtered, partial match)\n"
+        "  lastpaidblock  - Print the last block height a node was paid on the network\n"
+        "  lastpaidtime   - Print the last time a node was paid on the network\n"
+        "  owneraddress   - Print the masternode owner Dash address\n"
+        "  payee          - Print the masternode payout Dash address (can be additionally filtered,\n"
+        "                   partial match)\n"
+        "  pubKeyOperator - Print the masternode operator public key\n"
+        "  status         - Print masternode status: ENABLED / POSE_BANNED\n"
+        "                   (can be additionally filtered, partial match)\n"
+        "  votingaddress  - Print the masternode voting Dash address\n",
+        {
+            {"mode", RPCArg::Type::STR, /* default */ "json", "The mode to run list in"},
+            {"filter", RPCArg::Type::STR, /* default */ "", "Filter results. Partial match by outpoint by default in all modes, additional matches in some modes are also available"},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
 static UniValue masternode_list(const JSONRPCRequest& request)
 {
     if (request.fHelp)
-        masternode_list_help();
+        masternode_list_help(request);
     JSONRPCRequest newRequest = request;
     newRequest.params.setArray();
     // forward params but skip "list"
@@ -68,23 +67,22 @@ static UniValue masternode_list(const JSONRPCRequest& request)
     return masternodelist(newRequest);
 }
 
-static void masternode_connect_help()
+static void masternode_connect_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"masternode connect",
-            "Connect to given masternode\n",
-            {
-                {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The address of the masternode to connect"},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"masternode connect",
+        "Connect to given masternode\n",
+        {
+            {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The address of the masternode to connect"},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue masternode_connect(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() < 2)
-        masternode_connect_help();
+        masternode_connect_help(request);
 
     std::string strAddress = request.params[1].get_str();
 
@@ -100,21 +98,20 @@ static UniValue masternode_connect(const JSONRPCRequest& request)
     return "successfully connected";
 }
 
-static void masternode_count_help()
+static void masternode_count_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"masternode count",
-            "Get information about number of masternodes.\n",
-            {},
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"masternode count",
+        "Get information about number of masternodes.\n",
+        {},
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue masternode_count(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() > 1)
-        masternode_count_help();
+        masternode_count_help(request);
 
     auto mnList = deterministicMNManager->GetListAtChainTip();
     int total = mnList.GetAllMNsCount();
@@ -148,62 +145,59 @@ static UniValue GetNextMasternodeForPayment(int heightShift)
     return obj;
 }
 
-static void masternode_winner_help()
+static void masternode_winner_help(const JSONRPCRequest& request)
 {
     if (!IsDeprecatedRPCEnabled("masternode_winner")) {
         throw std::runtime_error("DEPRECATED: set -deprecatedrpc=masternode_winner to enable it");
     }
 
-    throw std::runtime_error(
-        RPCHelpMan{"masternode winner",
-            "Print info on next masternode winner to vote for\n",
-            {},
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"masternode winner",
+        "Print info on next masternode winner to vote for\n",
+        {},
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue masternode_winner(const JSONRPCRequest& request)
 {
     if (request.fHelp || !IsDeprecatedRPCEnabled("masternode_winner"))
-        masternode_winner_help();
+        masternode_winner_help(request);
 
     return GetNextMasternodeForPayment(10);
 }
 
-static void masternode_current_help()
+static void masternode_current_help(const JSONRPCRequest& request)
 {
     if (!IsDeprecatedRPCEnabled("masternode_current")) {
         throw std::runtime_error("DEPRECATED: set -deprecatedrpc=masternode_current to enable it");
     }
 
-    throw std::runtime_error(
-        RPCHelpMan{"masternode current",
-            "Print info on current masternode winner to be paid the next block (calculated locally)\n",
-            {},
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"masternode current",
+        "Print info on current masternode winner to be paid the next block (calculated locally)\n",
+        {},
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue masternode_current(const JSONRPCRequest& request)
 {
     if (request.fHelp || !IsDeprecatedRPCEnabled("masternode_current"))
-        masternode_current_help();
+        masternode_current_help(request);
 
     return GetNextMasternodeForPayment(1);
 }
 
 #ifdef ENABLE_WALLET
-static void masternode_outputs_help()
+static void masternode_outputs_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"masternode outputs",
-            "Print masternode compatible outputs\n",
-            {},
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"masternode outputs",
+        "Print masternode compatible outputs\n",
+        {},
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue masternode_outputs(const JSONRPCRequest& request)
@@ -214,7 +208,7 @@ static UniValue masternode_outputs(const JSONRPCRequest& request)
         return NullUniValue;
 
     if (request.fHelp)
-        masternode_outputs_help();
+        masternode_outputs_help(request);
 
 
     // Find possible candidates
@@ -236,21 +230,20 @@ static UniValue masternode_outputs(const JSONRPCRequest& request)
 
 #endif // ENABLE_WALLET
 
-static void masternode_status_help()
+static void masternode_status_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"masternode status",
-            "Print masternode status information\n",
-            {},
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"masternode status",
+        "Print masternode status information\n",
+        {},
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue masternode_status(const JSONRPCRequest& request)
 {
     if (request.fHelp)
-        masternode_status_help();
+        masternode_status_help(request);
 
     if (!fMasternodeMode)
         throw JSONRPCError(RPC_INTERNAL_ERROR, "This is not a masternode");
@@ -316,24 +309,23 @@ static std::string GetRequiredPaymentsString(int nBlockHeight, const CDeterminis
     return strPayments;
 }
 
-static void masternode_winners_help()
+static void masternode_winners_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"masternode winners",
-            "Print list of masternode winners\n",
-            {
-                {"count", RPCArg::Type::NUM, /* default */ "", "number of last winners to return"},
-                {"filter", RPCArg::Type::STR, /* default */ "", "filter for returned winners"},
-            },
-            RPCResults{},
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"masternode winners",
+        "Print list of masternode winners\n",
+        {
+            {"count", RPCArg::Type::NUM, /* default */ "", "number of last winners to return"},
+            {"filter", RPCArg::Type::STR, /* default */ "", "filter for returned winners"},
+        },
+        RPCResults{},
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue masternode_winners(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() > 3)
-        masternode_winners_help();
+        masternode_winners_help(request);
 
     const CBlockIndex* pindexTip{nullptr};
     {
@@ -375,45 +367,44 @@ static UniValue masternode_winners(const JSONRPCRequest& request)
 
     return obj;
 }
-static void masternode_payments_help()
+static void masternode_payments_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"masternode payments",
-            "\nReturns an array of deterministic masternodes and their payments for the specified block\n",
-            {
-                {"blockhash", RPCArg::Type::STR_HEX, /* default */ "tip", "The hash of the starting block"},
-                {"count", RPCArg::Type::NUM, /* default */ "1", "The number of blocks to return. Will return <count> previous blocks if <count> is negative. Both 1 and -1 correspond to the chain tip."},
-            },
-            RPCResult {
-        "  [                                  (array) Blocks\n"
-        "    {\n"
-        "       \"height\" : n,                 (numeric) The height of the block\n"
-        "       \"blockhash\" : \"hash\",         (string) The hash of the block\n"
-        "       \"amount\": n                   (numeric) Amount received in this block by all masternodes\n"
-        "       \"masternodes\": [              (array) Masternodes that received payments in this block\n"
-        "          {\n"
-        "             \"proTxHash\": \"xxxx\",    (string) The hash of the corresponding ProRegTx\n"
-        "             \"amount\": n             (numeric) Amount received by this masternode\n"
-        "             \"payees\": [             (array) Payees who received a share of this payment\n"
-        "                {\n"
-        "                  \"address\" : \"xxx\", (string) Payee address\n"
-        "                  \"script\" : \"xxx\",  (string) Payee scriptPubKey\n"
-        "                  \"amount\": n        (numeric) Amount received by this payee\n"
-        "                },...\n"
-        "             ]\n"
-        "          },...\n"
-        "       ]\n"
-        "    },...\n"
-        "  ]"
-            },
-            RPCExamples{""}
-        }.ToString());
+    RPCHelpMan{"masternode payments",
+        "\nReturns an array of deterministic masternodes and their payments for the specified block\n",
+        {
+            {"blockhash", RPCArg::Type::STR_HEX, /* default */ "tip", "The hash of the starting block"},
+            {"count", RPCArg::Type::NUM, /* default */ "1", "The number of blocks to return. Will return <count> previous blocks if <count> is negative. Both 1 and -1 correspond to the chain tip."},
+        },
+        RPCResult {
+    "  [                                  (array) Blocks\n"
+    "    {\n"
+    "       \"height\" : n,                 (numeric) The height of the block\n"
+    "       \"blockhash\" : \"hash\",         (string) The hash of the block\n"
+    "       \"amount\": n                   (numeric) Amount received in this block by all masternodes\n"
+    "       \"masternodes\": [              (array) Masternodes that received payments in this block\n"
+    "          {\n"
+    "             \"proTxHash\": \"xxxx\",    (string) The hash of the corresponding ProRegTx\n"
+    "             \"amount\": n             (numeric) Amount received by this masternode\n"
+    "             \"payees\": [             (array) Payees who received a share of this payment\n"
+    "                {\n"
+    "                  \"address\" : \"xxx\", (string) Payee address\n"
+    "                  \"script\" : \"xxx\",  (string) Payee scriptPubKey\n"
+    "                  \"amount\": n        (numeric) Amount received by this payee\n"
+    "                },...\n"
+    "             ]\n"
+    "          },...\n"
+    "       ]\n"
+    "    },...\n"
+    "  ]"
+        },
+        RPCExamples{""}
+    }.Check(request);
 }
 
 static UniValue masternode_payments(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() > 3) {
-        masternode_payments_help();
+        masternode_payments_help(request);
     }
 
     CBlockIndex* pindex{nullptr};
@@ -522,26 +513,25 @@ static UniValue masternode_payments(const JSONRPCRequest& request)
 
 [[ noreturn ]] static void masternode_help()
 {
-    throw std::runtime_error(
-        RPCHelpMan{"masternode",
-            "Set of commands to execute masternode related actions\n"
-            "\nAvailable commands:\n"
-            "  count        - Get information about number of masternodes\n"
-            "  current      - DEPRECATED Print info on current masternode winner to be paid the next block (calculated locally)\n"
+    RPCHelpMan{"masternode",
+        "Set of commands to execute masternode related actions\n"
+        "\nAvailable commands:\n"
+        "  count        - Get information about number of masternodes\n"
+        "  current      - DEPRECATED Print info on current masternode winner to be paid the next block (calculated locally)\n"
 #ifdef ENABLE_WALLET
-            "  outputs      - Print masternode compatible outputs\n"
+        "  outputs      - Print masternode compatible outputs\n"
 #endif // ENABLE_WALLET
-            "  status       - Print masternode status information\n"
-            "  list         - Print list of all known masternodes (see masternodelist for more info)\n"
-            "  payments     - Return information about masternode payments in a mined block\n"
-            "  winner       - DEPRECATED Print info on next masternode winner to vote for\n"
-            "  winners      - Print list of masternode winners\n",
-            {
-                {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "The command to execute"},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+        "  status       - Print masternode status information\n"
+        "  list         - Print list of all known masternodes (see masternodelist for more info)\n"
+        "  payments     - Return information about masternode payments in a mined block\n"
+        "  winner       - DEPRECATED Print info on next masternode winner to vote for\n"
+        "  winners      - Print list of masternode winners\n",
+        {
+            {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "The command to execute"},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Throw();
 }
 
 static UniValue masternode(const JSONRPCRequest& request)
@@ -597,7 +587,7 @@ static UniValue masternodelist(const JSONRPCRequest& request)
                 strMode != "payee" && strMode != "pubkeyoperator" &&
                 strMode != "status"))
     {
-        masternode_list_help();
+        masternode_list_help(request);
     }
 
     UniValue obj(UniValue::VOBJ);
diff --git a/src/rpc/rpcevo.cpp b/src/rpc/rpcevo.cpp
index 9f227ff460..840976a68b 100644
--- a/src/rpc/rpcevo.cpp
+++ b/src/rpc/rpcevo.cpp
@@ -315,122 +315,118 @@ static std::string SignAndSendSpecialTx(const CMutableTransaction& tx, bool fSub
     return sendrawtransaction(sendRequest).get_str();
 }
 
-static void protx_register_fund_help(CWallet* const pwallet)
+static void protx_register_fund_help(const JSONRPCRequest& request, CWallet* const pwallet)
 {
-    throw std::runtime_error(
-            RPCHelpMan{"protx register_fund",
-                "\nCreates, funds and sends a ProTx to the network. The resulting transaction will move 1000 Dash\n"
-                "to the address specified by collateralAddress and will then function as the collateral of your\n"
-                "masternode.\n"
-                "A few of the limitations you see in the arguments are temporary and might be lifted after DIP3\n"
-                "is fully deployed.\n"
-                + HelpRequiringPassphrase(pwallet) + "\n",
-                {
-                    GetRpcArg("collateralAddress"),
-                    GetRpcArg("ipAndPort"),
-                    GetRpcArg("ownerAddress"),
-                    GetRpcArg("operatorPubKey_register"),
-                    GetRpcArg("votingAddress_register"),
-                    GetRpcArg("operatorReward"),
-                    GetRpcArg("payoutAddress_register"),
-                    GetRpcArg("fundAddress"),
-                    GetRpcArg("submit"),
-                },
-                RPCResults{
-                    {"if \"submit\" is not set or set to true",
-            "\"txid\"                        (string) The transaction id.\n"
-                    }, {"if \"submit\" is set to false",
-            "\"hex\"                         (string) The serialized signed ProTx in hex format.\n"
-                }},
-                RPCExamples{
-                    HelpExampleCli("protx", "register_fund \"XrVhS9LogauRJGJu2sHuryjhpuex4RNPSb\" \"1.2.3.4:1234\" \"Xt9AMWaYSz7tR7Uo7gzXA3m4QmeWgrR3rr\" \"93746e8731c57f87f79b3620a7982924e2931717d49540a85864bd543de11c43fb868fd63e501a1db37e19ed59ae6db4\" \"Xt9AMWaYSz7tR7Uo7gzXA3m4QmeWgrR3rr\" 0 \"XrVhS9LogauRJGJu2sHuryjhpuex4RNPSb\"")
-                },
-            }.ToString());
+    RPCHelpMan{"protx register_fund",
+        "\nCreates, funds and sends a ProTx to the network. The resulting transaction will move 1000 Dash\n"
+        "to the address specified by collateralAddress and will then function as the collateral of your\n"
+        "masternode.\n"
+        "A few of the limitations you see in the arguments are temporary and might be lifted after DIP3\n"
+        "is fully deployed.\n"
+        + HelpRequiringPassphrase(pwallet) + "\n",
+        {
+            GetRpcArg("collateralAddress"),
+            GetRpcArg("ipAndPort"),
+            GetRpcArg("ownerAddress"),
+            GetRpcArg("operatorPubKey_register"),
+            GetRpcArg("votingAddress_register"),
+            GetRpcArg("operatorReward"),
+            GetRpcArg("payoutAddress_register"),
+            GetRpcArg("fundAddress"),
+            GetRpcArg("submit"),
+        },
+        RPCResults{
+            {"if \"submit\" is not set or set to true",
+    "\"txid\"                        (string) The transaction id.\n"
+            }, {"if \"submit\" is set to false",
+    "\"hex\"                         (string) The serialized signed ProTx in hex format.\n"
+        }},
+        RPCExamples{
+            HelpExampleCli("protx", "register_fund \"XrVhS9LogauRJGJu2sHuryjhpuex4RNPSb\" \"1.2.3.4:1234\" \"Xt9AMWaYSz7tR7Uo7gzXA3m4QmeWgrR3rr\" \"93746e8731c57f87f79b3620a7982924e2931717d49540a85864bd543de11c43fb868fd63e501a1db37e19ed59ae6db4\" \"Xt9AMWaYSz7tR7Uo7gzXA3m4QmeWgrR3rr\" 0 \"XrVhS9LogauRJGJu2sHuryjhpuex4RNPSb\"")
+        },
+    }.Check(request);
 }
 
-static void protx_register_help(CWallet* const pwallet)
+static void protx_register_help(const JSONRPCRequest& request, CWallet* const pwallet)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"protx register",
-            "\nSame as \"protx register_fund\", but with an externally referenced collateral.\n"
-            "The collateral is specified through \"collateralHash\" and \"collateralIndex\" and must be an unspent\n"
-            "transaction output spendable by this wallet. It must also not be used by any other masternode.\n"
-            + HelpRequiringPassphrase(pwallet) + "\n",
-            {
-                GetRpcArg("collateralHash"),
-                GetRpcArg("collateralIndex"),
-                GetRpcArg("ipAndPort"),
-                GetRpcArg("ownerAddress"),
-                GetRpcArg("operatorPubKey_register"),
-                GetRpcArg("votingAddress_register"),
-                GetRpcArg("operatorReward"),
-                GetRpcArg("payoutAddress_register"),
-                GetRpcArg("feeSourceAddress"),
-                GetRpcArg("submit"),
-            },
-            RPCResults{
-                {"if \"submit\" is not set or set to true",
-        "\"txid\"                        (string) The transaction id.\n"
-                }, {"if \"submit\" is set to false",
-        "\"hex\"                         (string) The serialized signed ProTx in hex format.\n"
-            }},
-            RPCExamples{
-                HelpExampleCli("protx", "register \"0123456701234567012345670123456701234567012345670123456701234567\" 0 \"1.2.3.4:1234\" \"Xt9AMWaYSz7tR7Uo7gzXA3m4QmeWgrR3rr\" \"93746e8731c57f87f79b3620a7982924e2931717d49540a85864bd543de11c43fb868fd63e501a1db37e19ed59ae6db4\" \"Xt9AMWaYSz7tR7Uo7gzXA3m4QmeWgrR3rr\" 0 \"XrVhS9LogauRJGJu2sHuryjhpuex4RNPSb\"")
-            },
-        }.ToString());
+    RPCHelpMan{"protx register",
+        "\nSame as \"protx register_fund\", but with an externally referenced collateral.\n"
+        "The collateral is specified through \"collateralHash\" and \"collateralIndex\" and must be an unspent\n"
+        "transaction output spendable by this wallet. It must also not be used by any other masternode.\n"
+        + HelpRequiringPassphrase(pwallet) + "\n",
+        {
+            GetRpcArg("collateralHash"),
+            GetRpcArg("collateralIndex"),
+            GetRpcArg("ipAndPort"),
+            GetRpcArg("ownerAddress"),
+            GetRpcArg("operatorPubKey_register"),
+            GetRpcArg("votingAddress_register"),
+            GetRpcArg("operatorReward"),
+            GetRpcArg("payoutAddress_register"),
+            GetRpcArg("feeSourceAddress"),
+            GetRpcArg("submit"),
+        },
+        RPCResults{
+            {"if \"submit\" is not set or set to true",
+    "\"txid\"                        (string) The transaction id.\n"
+            }, {"if \"submit\" is set to false",
+    "\"hex\"                         (string) The serialized signed ProTx in hex format.\n"
+        }},
+        RPCExamples{
+            HelpExampleCli("protx", "register \"0123456701234567012345670123456701234567012345670123456701234567\" 0 \"1.2.3.4:1234\" \"Xt9AMWaYSz7tR7Uo7gzXA3m4QmeWgrR3rr\" \"93746e8731c57f87f79b3620a7982924e2931717d49540a85864bd543de11c43fb868fd63e501a1db37e19ed59ae6db4\" \"Xt9AMWaYSz7tR7Uo7gzXA3m4QmeWgrR3rr\" 0 \"XrVhS9LogauRJGJu2sHuryjhpuex4RNPSb\"")
+        },
+    }.Check(request);
 }
 
-static void protx_register_prepare_help()
+static void protx_register_prepare_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"protx register_prepare",
-            "\nCreates an unsigned ProTx and a message that must be signed externally\n"
-            "with the private key that corresponds to collateralAddress to prove collateral ownership.\n"
-            "The prepared transaction will also contain inputs and outputs to cover fees.\n",
-            {
-                GetRpcArg("collateralHash"),
-                GetRpcArg("collateralIndex"),
-                GetRpcArg("ipAndPort"),
-                GetRpcArg("ownerAddress"),
-                GetRpcArg("operatorPubKey_register"),
-                GetRpcArg("votingAddress_register"),
-                GetRpcArg("operatorReward"),
-                GetRpcArg("payoutAddress_register"),
-                GetRpcArg("feeSourceAddress"),
-            },
-            RPCResult{
-        "{                             (json object)\n"
-        "  \"tx\" :                      (string) The serialized unsigned ProTx in hex format.\n"
-        "  \"collateralAddress\" :       (string) The collateral address.\n"
-        "  \"signMessage\" :             (string) The string message that needs to be signed with\n"
-        "                              the collateral key.\n"
-        "}\n"
-            },
-            RPCExamples{
-                HelpExampleCli("protx", "register_prepare \"0123456701234567012345670123456701234567012345670123456701234567\" 0 \"1.2.3.4:1234\" \"Xt9AMWaYSz7tR7Uo7gzXA3m4QmeWgrR3rr\" \"93746e8731c57f87f79b3620a7982924e2931717d49540a85864bd543de11c43fb868fd63e501a1db37e19ed59ae6db4\" \"Xt9AMWaYSz7tR7Uo7gzXA3m4QmeWgrR3rr\" 0 \"XrVhS9LogauRJGJu2sHuryjhpuex4RNPSb\"")
-            },
-        }.ToString());
+    RPCHelpMan{"protx register_prepare",
+        "\nCreates an unsigned ProTx and a message that must be signed externally\n"
+        "with the private key that corresponds to collateralAddress to prove collateral ownership.\n"
+        "The prepared transaction will also contain inputs and outputs to cover fees.\n",
+        {
+            GetRpcArg("collateralHash"),
+            GetRpcArg("collateralIndex"),
+            GetRpcArg("ipAndPort"),
+            GetRpcArg("ownerAddress"),
+            GetRpcArg("operatorPubKey_register"),
+            GetRpcArg("votingAddress_register"),
+            GetRpcArg("operatorReward"),
+            GetRpcArg("payoutAddress_register"),
+            GetRpcArg("feeSourceAddress"),
+        },
+        RPCResult{
+    "{                             (json object)\n"
+    "  \"tx\" :                      (string) The serialized unsigned ProTx in hex format.\n"
+    "  \"collateralAddress\" :       (string) The collateral address.\n"
+    "  \"signMessage\" :             (string) The string message that needs to be signed with\n"
+    "                              the collateral key.\n"
+    "}\n"
+        },
+        RPCExamples{
+            HelpExampleCli("protx", "register_prepare \"0123456701234567012345670123456701234567012345670123456701234567\" 0 \"1.2.3.4:1234\" \"Xt9AMWaYSz7tR7Uo7gzXA3m4QmeWgrR3rr\" \"93746e8731c57f87f79b3620a7982924e2931717d49540a85864bd543de11c43fb868fd63e501a1db37e19ed59ae6db4\" \"Xt9AMWaYSz7tR7Uo7gzXA3m4QmeWgrR3rr\" 0 \"XrVhS9LogauRJGJu2sHuryjhpuex4RNPSb\"")
+        },
+    }.Check(request);
 }
 
-static void protx_register_submit_help(CWallet* const pwallet)
+static void protx_register_submit_help(const JSONRPCRequest& request, CWallet* const pwallet)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"protx register_submit",
-            "\nCombines the unsigned ProTx and a signature of the signMessage, signs all inputs\n"
-            "which were added to cover fees and submits the resulting transaction to the network.\n"
-            "Note: See \"help protx register_prepare\" for more info about creating a ProTx and a message to sign.\n"
-            + HelpRequiringPassphrase(pwallet) + "\n",
-            {
-                {"tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized unsigned ProTx in hex format."},
-                {"sig", RPCArg::Type::STR, RPCArg::Optional::NO, "The signature signed with the collateral key. Must be in base64 format."},
-            },
-            RPCResult{
-        "\"txid\"                  (string) The transaction id.\n"
-            },
-            RPCExamples{
-                HelpExampleCli("protx", "register_submit \"tx\" \"sig\"")
-            },
-        }.ToString());
+    RPCHelpMan{"protx register_submit",
+        "\nCombines the unsigned ProTx and a signature of the signMessage, signs all inputs\n"
+        "which were added to cover fees and submits the resulting transaction to the network.\n"
+        "Note: See \"help protx register_prepare\" for more info about creating a ProTx and a message to sign.\n"
+        + HelpRequiringPassphrase(pwallet) + "\n",
+        {
+            {"tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized unsigned ProTx in hex format."},
+            {"sig", RPCArg::Type::STR, RPCArg::Optional::NO, "The signature signed with the collateral key. Must be in base64 format."},
+        },
+        RPCResult{
+    "\"txid\"                  (string) The transaction id.\n"
+        },
+        RPCExamples{
+            HelpExampleCli("protx", "register_submit \"tx\" \"sig\"")
+        },
+    }.Check(request);
 }
 
 // handles register, register_prepare and register_fund in one method
@@ -446,11 +442,11 @@ static UniValue protx_register(const JSONRPCRequest& request)
     bool isPrepareRegister = request.params[0].get_str() == "register_prepare";
 
     if (isFundRegister && (request.fHelp || (request.params.size() < 8 || request.params.size() > 10))) {
-        protx_register_fund_help(pwallet);
+        protx_register_fund_help(request, pwallet);
     } else if (isExternalRegister && (request.fHelp || (request.params.size() < 9 || request.params.size() > 11))) {
-        protx_register_help(pwallet);
+        protx_register_help(request, pwallet);
     } else if (isPrepareRegister && (request.fHelp || (request.params.size() != 9 && request.params.size() != 10))) {
-        protx_register_prepare_help();
+        protx_register_prepare_help(request);
     }
 
     if (isExternalRegister || isFundRegister) {
@@ -604,7 +600,7 @@ static UniValue protx_register_submit(const JSONRPCRequest& request)
         return NullUniValue;
 
     if (request.fHelp || request.params.size() != 3) {
-        protx_register_submit_help(pwallet);
+        protx_register_submit_help(request, pwallet);
     }
 
     EnsureWalletIsUnlocked(pwallet);
@@ -630,28 +626,27 @@ static UniValue protx_register_submit(const JSONRPCRequest& request)
     return SignAndSendSpecialTx(tx);
 }
 
-static void protx_update_service_help(CWallet* const pwallet)
+static void protx_update_service_help(const JSONRPCRequest& request, CWallet* const pwallet)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"protx update_service",
-            "\nCreates and sends a ProUpServTx to the network. This will update the IP address\n"
-            "of a masternode.\n"
-            "If this is done for a masternode that got PoSe-banned, the ProUpServTx will also revive this masternode.\n"
-            + HelpRequiringPassphrase(pwallet) + "\n",
-            {
-                GetRpcArg("proTxHash"),
-                GetRpcArg("ipAndPort"),
-                GetRpcArg("operatorKey"),
-                GetRpcArg("operatorPayoutAddress"),
-                GetRpcArg("feeSourceAddress"),
-            },
-            RPCResult{
-        "\"txid\"                        (string) The transaction id.\n"
-            },
-            RPCExamples{
-                HelpExampleCli("protx", "update_service \"0123456701234567012345670123456701234567012345670123456701234567\" \"1.2.3.4:1234\" 5a2e15982e62f1e0b7cf9783c64cf7e3af3f90a52d6c40f6f95d624c0b1621cd")
-            },
-        }.ToString());
+    RPCHelpMan{"protx update_service",
+        "\nCreates and sends a ProUpServTx to the network. This will update the IP address\n"
+        "of a masternode.\n"
+        "If this is done for a masternode that got PoSe-banned, the ProUpServTx will also revive this masternode.\n"
+        + HelpRequiringPassphrase(pwallet) + "\n",
+        {
+            GetRpcArg("proTxHash"),
+            GetRpcArg("ipAndPort"),
+            GetRpcArg("operatorKey"),
+            GetRpcArg("operatorPayoutAddress"),
+            GetRpcArg("feeSourceAddress"),
+        },
+        RPCResult{
+    "\"txid\"                        (string) The transaction id.\n"
+        },
+        RPCExamples{
+            HelpExampleCli("protx", "update_service \"0123456701234567012345670123456701234567012345670123456701234567\" \"1.2.3.4:1234\" 5a2e15982e62f1e0b7cf9783c64cf7e3af3f90a52d6c40f6f95d624c0b1621cd")
+        },
+    }.Check(request);
 }
 
 static UniValue protx_update_service(const JSONRPCRequest& request)
@@ -662,7 +657,7 @@ static UniValue protx_update_service(const JSONRPCRequest& request)
         return NullUniValue;
 
     if (request.fHelp || (request.params.size() < 4 || request.params.size() > 6))
-        protx_update_service_help(pwallet);
+        protx_update_service_help(request, pwallet);
 
     EnsureWalletIsUnlocked(pwallet);
 
@@ -729,28 +724,27 @@ static UniValue protx_update_service(const JSONRPCRequest& request)
     return SignAndSendSpecialTx(tx);
 }
 
-static void protx_update_registrar_help(CWallet* const pwallet)
+static void protx_update_registrar_help(const JSONRPCRequest& request, CWallet* const pwallet)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"protx update_registrar",
-            "\nCreates and sends a ProUpRegTx to the network. This will update the operator key, voting key and payout\n"
-            "address of the masternode specified by \"proTxHash\".\n"
-            "The owner key of the masternode must be known to your wallet.\n"
-            + HelpRequiringPassphrase(pwallet) + "\n",
-            {
-                GetRpcArg("proTxHash"),
-                GetRpcArg("operatorPubKey_update"),
-                GetRpcArg("votingAddress_update"),
-                GetRpcArg("payoutAddress_update"),
-                GetRpcArg("feeSourceAddress"),
-            },
-            RPCResult{
-        "\"txid\"                        (string) The transaction id.\n"
-            },
-            RPCExamples{
-                HelpExampleCli("protx", "update_registrar \"0123456701234567012345670123456701234567012345670123456701234567\" \"982eb34b7c7f614f29e5c665bc3605f1beeef85e3395ca12d3be49d2868ecfea5566f11cedfad30c51b2403f2ad95b67\" \"XwnLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPwG\"")
-            },
-        }.ToString());
+    RPCHelpMan{"protx update_registrar",
+        "\nCreates and sends a ProUpRegTx to the network. This will update the operator key, voting key and payout\n"
+        "address of the masternode specified by \"proTxHash\".\n"
+        "The owner key of the masternode must be known to your wallet.\n"
+        + HelpRequiringPassphrase(pwallet) + "\n",
+        {
+            GetRpcArg("proTxHash"),
+            GetRpcArg("operatorPubKey_update"),
+            GetRpcArg("votingAddress_update"),
+            GetRpcArg("payoutAddress_update"),
+            GetRpcArg("feeSourceAddress"),
+        },
+        RPCResult{
+    "\"txid\"                        (string) The transaction id.\n"
+        },
+        RPCExamples{
+            HelpExampleCli("protx", "update_registrar \"0123456701234567012345670123456701234567012345670123456701234567\" \"982eb34b7c7f614f29e5c665bc3605f1beeef85e3395ca12d3be49d2868ecfea5566f11cedfad30c51b2403f2ad95b67\" \"XwnLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPwG\"")
+        },
+    }.Check(request);
 }
 
 static UniValue protx_update_registrar(const JSONRPCRequest& request)
@@ -761,7 +755,7 @@ static UniValue protx_update_registrar(const JSONRPCRequest& request)
         return NullUniValue;
 
     if (request.fHelp || (request.params.size() != 5 && request.params.size() != 6)) {
-        protx_update_registrar_help(pwallet);
+        protx_update_registrar_help(request, pwallet);
     }
 
     EnsureWalletIsUnlocked(pwallet);
@@ -821,28 +815,27 @@ static UniValue protx_update_registrar(const JSONRPCRequest& request)
     return SignAndSendSpecialTx(tx);
 }
 
-static void protx_revoke_help(CWallet* const pwallet)
+static void protx_revoke_help(const JSONRPCRequest& request, CWallet* const pwallet)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"protx revoke",
-            "\nCreates and sends a ProUpRevTx to the network. This will revoke the operator key of the masternode and\n"
-            "put it into the PoSe-banned state. It will also set the service field of the masternode\n"
-            "to zero. Use this in case your operator key got compromised or you want to stop providing your service\n"
-            "to the masternode owner.\n"
-            + HelpRequiringPassphrase(pwallet) + "\n",
-            {
-                GetRpcArg("proTxHash"),
-                GetRpcArg("operatorKey"),
-                GetRpcArg("reason"),
-                GetRpcArg("feeSourceAddress"),
-            },
-            RPCResult{
-            "\"txid\"                        (string) The transaction id.\n"
-            },
-            RPCExamples{
-                HelpExampleCli("protx", "revoke \"0123456701234567012345670123456701234567012345670123456701234567\" \"072f36a77261cdd5d64c32d97bac417540eddca1d5612f416feb07ff75a8e240\"")
-            },
-        }.ToString());
+    RPCHelpMan{"protx revoke",
+        "\nCreates and sends a ProUpRevTx to the network. This will revoke the operator key of the masternode and\n"
+        "put it into the PoSe-banned state. It will also set the service field of the masternode\n"
+        "to zero. Use this in case your operator key got compromised or you want to stop providing your service\n"
+        "to the masternode owner.\n"
+        + HelpRequiringPassphrase(pwallet) + "\n",
+        {
+            GetRpcArg("proTxHash"),
+            GetRpcArg("operatorKey"),
+            GetRpcArg("reason"),
+            GetRpcArg("feeSourceAddress"),
+        },
+        RPCResult{
+        "\"txid\"                        (string) The transaction id.\n"
+        },
+        RPCExamples{
+            HelpExampleCli("protx", "revoke \"0123456701234567012345670123456701234567012345670123456701234567\" \"072f36a77261cdd5d64c32d97bac417540eddca1d5612f416feb07ff75a8e240\"")
+        },
+    }.Check(request);
 }
 
 static UniValue protx_revoke(const JSONRPCRequest& request)
@@ -853,7 +846,7 @@ static UniValue protx_revoke(const JSONRPCRequest& request)
         return NullUniValue;
 
     if (request.fHelp || (request.params.size() < 3 || request.params.size() > 5)) {
-        protx_revoke_help(pwallet);
+        protx_revoke_help(request, pwallet);
     }
 
     EnsureWalletIsUnlocked(pwallet);
@@ -911,28 +904,27 @@ static UniValue protx_revoke(const JSONRPCRequest& request)
 }
 #endif//ENABLE_WALLET
 
-static void protx_list_help()
+static void protx_list_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"protx list",
-            "\nLists all ProTxs in your wallet or on-chain, depending on the given type.\n",
-            {
-                {"type", RPCArg::Type::STR, /* default */ "registered",
-        "\nAvailable types:\n"
-        "  registered   - List all ProTx which are registered at the given chain height.\n"
-        "                 This will also include ProTx which failed PoSe verification.\n"
-        "  valid        - List only ProTx which are active/valid at the given chain height.\n"
+    RPCHelpMan{"protx list",
+        "\nLists all ProTxs in your wallet or on-chain, depending on the given type.\n",
+        {
+            {"type", RPCArg::Type::STR, /* default */ "registered",
+    "\nAvailable types:\n"
+    "  registered   - List all ProTx which are registered at the given chain height.\n"
+    "                 This will also include ProTx which failed PoSe verification.\n"
+    "  valid        - List only ProTx which are active/valid at the given chain height.\n"
 #ifdef ENABLE_WALLET
-        "  wallet       - List only ProTx which are found in your wallet at the given chain height.\n"
-        "                 This will also include ProTx which failed PoSe verification.\n"
+    "  wallet       - List only ProTx which are found in your wallet at the given chain height.\n"
+    "                 This will also include ProTx which failed PoSe verification.\n"
 #endif
-                },
-                {"detailed", RPCArg::Type::BOOL, /* default */ "false", "If not specified, only the hashes of the ProTx will be returned."},
-                {"height", RPCArg::Type::NUM, /* default */ "current chain-tip", ""},
             },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+            {"detailed", RPCArg::Type::BOOL, /* default */ "false", "If not specified, only the hashes of the ProTx will be returned."},
+            {"height", RPCArg::Type::NUM, /* default */ "current chain-tip", ""},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
 #ifdef ENABLE_WALLET
@@ -1003,7 +995,7 @@ static UniValue BuildDMNListEntry(CWallet* pwallet, const CDeterministicMN& dmn,
 static UniValue protx_list(const JSONRPCRequest& request)
 {
     if (request.fHelp) {
-        protx_list_help();
+        protx_list_help(request);
     }
 
 #ifdef ENABLE_WALLET
@@ -1032,7 +1024,7 @@ static UniValue protx_list(const JSONRPCRequest& request)
         LOCK2(cs_main, pwallet->cs_wallet);
 
         if (request.params.size() > 4) {
-            protx_list_help();
+            protx_list_help(request);
         }
 
         bool detailed = !request.params[2].isNull() ? ParseBoolV(request.params[2], "detailed") : false;
@@ -1062,7 +1054,7 @@ static UniValue protx_list(const JSONRPCRequest& request)
 #endif
     } else if (type == "valid" || type == "registered") {
         if (request.params.size() > 4) {
-            protx_list_help();
+            protx_list_help(request);
         }
 
         LOCK(cs_main);
@@ -1086,28 +1078,27 @@ static UniValue protx_list(const JSONRPCRequest& request)
     return ret;
 }
 
-static void protx_info_help()
+static void protx_info_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"protx info",
-            "\nReturns detailed information about a deterministic masternode.\n",
-            {
-                GetRpcArg("proTxHash"),
-            },
-            RPCResult{
-        "{                             (json object) Details about a specific deterministic masternode\n"
-        "}\n"
-            },
-            RPCExamples{
-                HelpExampleCli("protx", "info \"0123456701234567012345670123456701234567012345670123456701234567\"")
-            },
-        }.ToString());
+    RPCHelpMan{"protx info",
+        "\nReturns detailed information about a deterministic masternode.\n",
+        {
+            GetRpcArg("proTxHash"),
+        },
+        RPCResult{
+    "{                             (json object) Details about a specific deterministic masternode\n"
+    "}\n"
+        },
+        RPCExamples{
+            HelpExampleCli("protx", "info \"0123456701234567012345670123456701234567012345670123456701234567\"")
+        },
+    }.Check(request);
 }
 
 static UniValue protx_info(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() != 2) {
-        protx_info_help();
+        protx_info_help(request);
     }
 
 #ifdef ENABLE_WALLET
@@ -1130,18 +1121,17 @@ static UniValue protx_info(const JSONRPCRequest& request)
     return BuildDMNListEntry(pwallet, *dmn, true);
 }
 
-static void protx_diff_help()
+static void protx_diff_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"protx diff",
-            "\nCalculates a diff between two deterministic masternode lists. The result also contains proof data.\n",
-            {
-                {"baseBlock", RPCArg::Type::NUM, RPCArg::Optional::NO, "The starting block height."},
-                {"block", RPCArg::Type::NUM, RPCArg::Optional::NO, "The ending block height."},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"protx diff",
+        "\nCalculates a diff between two deterministic masternode lists. The result also contains proof data.\n",
+        {
+            {"baseBlock", RPCArg::Type::NUM, RPCArg::Optional::NO, "The starting block height."},
+            {"block", RPCArg::Type::NUM, RPCArg::Optional::NO, "The ending block height."},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
 static uint256 ParseBlock(const UniValue& v, std::string strName) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
@@ -1161,7 +1151,7 @@ static uint256 ParseBlock(const UniValue& v, std::string strName) EXCLUSIVE_LOCK
 static UniValue protx_diff(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() != 3) {
-        protx_diff_help();
+        protx_diff_help(request);
     }
 
     LOCK(cs_main);
@@ -1181,31 +1171,30 @@ static UniValue protx_diff(const JSONRPCRequest& request)
 
 [[ noreturn ]] static void protx_help()
 {
-    throw std::runtime_error(
-        RPCHelpMan{"protx",
-            "Set of commands to execute ProTx related actions.\n"
-            "To get help on individual commands, use \"help protx command\".\n"
-            "\nAvailable commands:\n"
+    RPCHelpMan{"protx",
+        "Set of commands to execute ProTx related actions.\n"
+        "To get help on individual commands, use \"help protx command\".\n"
+        "\nAvailable commands:\n"
 #ifdef ENABLE_WALLET
-            "  register          - Create and send ProTx to network\n"
-            "  register_fund     - Fund, create and send ProTx to network\n"
-            "  register_prepare  - Create an unsigned ProTx\n"
-            "  register_submit   - Sign and submit a ProTx\n"
+        "  register          - Create and send ProTx to network\n"
+        "  register_fund     - Fund, create and send ProTx to network\n"
+        "  register_prepare  - Create an unsigned ProTx\n"
+        "  register_submit   - Sign and submit a ProTx\n"
 #endif
-            "  list              - List ProTxs\n"
-            "  info              - Return information about a ProTx\n"
+        "  list              - List ProTxs\n"
+        "  info              - Return information about a ProTx\n"
 #ifdef ENABLE_WALLET
-            "  update_service    - Create and send ProUpServTx to network\n"
-            "  update_registrar  - Create and send ProUpRegTx to network\n"
-            "  revoke            - Create and send ProUpRevTx to network\n"
+        "  update_service    - Create and send ProUpServTx to network\n"
+        "  update_registrar  - Create and send ProUpRegTx to network\n"
+        "  revoke            - Create and send ProUpRevTx to network\n"
 #endif
-            "  diff              - Calculate a diff and a proof between two masternode lists\n",
-            {
-                {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "The command to execute"},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+        "  diff              - Calculate a diff and a proof between two masternode lists\n",
+        {
+            {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "The command to execute"},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Throw();
 }
 
 static UniValue protx(const JSONRPCRequest& request)
@@ -1243,28 +1232,27 @@ static UniValue protx(const JSONRPCRequest& request)
     }
 }
 
-static void bls_generate_help()
+static void bls_generate_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"bls generate",
-            "\nReturns a BLS secret/public key pair.\n",
-            {},
-            RPCResult{
-        "{\n"
-        "  \"secret\": \"xxxx\",        (string) BLS secret key\n"
-        "  \"public\": \"xxxx\",        (string) BLS public key\n"
-        "}\n"
-            },
-            RPCExamples{
-                HelpExampleCli("bls generate", "")
-            },
-        }.ToString());
+    RPCHelpMan{"bls generate",
+        "\nReturns a BLS secret/public key pair.\n",
+        {},
+        RPCResult{
+    "{\n"
+    "  \"secret\": \"xxxx\",        (string) BLS secret key\n"
+    "  \"public\": \"xxxx\",        (string) BLS public key\n"
+    "}\n"
+        },
+        RPCExamples{
+            HelpExampleCli("bls generate", "")
+        },
+    }.Check(request);
 }
 
 static UniValue bls_generate(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() != 1) {
-        bls_generate_help();
+        bls_generate_help(request);
     }
 
     CBLSSecretKey sk;
@@ -1276,30 +1264,29 @@ static UniValue bls_generate(const JSONRPCRequest& request)
     return ret;
 }
 
-static void bls_fromsecret_help()
+static void bls_fromsecret_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"bls fromsecret",
-            "\nParses a BLS secret key and returns the secret/public key pair.\n",
-            {
-                {"secret", RPCArg::Type::STR, RPCArg::Optional::NO, "The BLS secret key"},
-            },
-            RPCResult{
-        "{\n"
-        "  \"secret\": \"xxxx\",        (string) BLS secret key\n"
-        "  \"public\": \"xxxx\",        (string) BLS public key\n"
-        "}\n"
-            },
-            RPCExamples{
-                HelpExampleCli("bls fromsecret", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f")
-            },
-        }.ToString());
+    RPCHelpMan{"bls fromsecret",
+        "\nParses a BLS secret key and returns the secret/public key pair.\n",
+        {
+            {"secret", RPCArg::Type::STR, RPCArg::Optional::NO, "The BLS secret key"},
+        },
+        RPCResult{
+    "{\n"
+    "  \"secret\": \"xxxx\",        (string) BLS secret key\n"
+    "  \"public\": \"xxxx\",        (string) BLS public key\n"
+    "}\n"
+        },
+        RPCExamples{
+            HelpExampleCli("bls fromsecret", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f")
+        },
+    }.Check(request);
 }
 
 static UniValue bls_fromsecret(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() != 2) {
-        bls_fromsecret_help();
+        bls_fromsecret_help(request);
     }
 
     CBLSSecretKey sk;
@@ -1315,19 +1302,18 @@ static UniValue bls_fromsecret(const JSONRPCRequest& request)
 
 [[ noreturn ]] static void bls_help()
 {
-    throw std::runtime_error(
-        RPCHelpMan{"bls",
-            "Set of commands to execute BLS related actions.\n"
-            "To get help on individual commands, use \"help bls command\".\n"
-            "\nAvailable commands:\n"
-            "  generate          - Create a BLS secret/public key pair\n"
-            "  fromsecret        - Parse a BLS secret key and return the secret/public key pair\n",
-            {
-                {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "The command to execute"},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"bls",
+        "Set of commands to execute BLS related actions.\n"
+        "To get help on individual commands, use \"help bls command\".\n"
+        "\nAvailable commands:\n"
+        "  generate          - Create a BLS secret/public key pair\n"
+        "  fromsecret        - Parse a BLS secret key and return the secret/public key pair\n",
+        {
+            {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "The command to execute"},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Throw();
 }
 
 static UniValue _bls(const JSONRPCRequest& request)
diff --git a/src/rpc/rpcquorums.cpp b/src/rpc/rpcquorums.cpp
index ccf73e7bc7..39b7173dca 100644
--- a/src/rpc/rpcquorums.cpp
+++ b/src/rpc/rpcquorums.cpp
@@ -23,34 +23,33 @@ namespace llmq {
 extern const std::string CLSIG_REQUESTID_PREFIX;
 }
 
-static void quorum_list_help()
+static void quorum_list_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"quorum list",
-            "List of on-chain quorums\n",
-            {
-                {"count", RPCArg::Type::NUM, /* default */ "", "Number of quorums to list. Will list active quorums if \"count\" is not specified."},
-            },
-            RPCResult{
-        "{\n"
-        "  \"quorumName\" : [                    (array of strings) List of quorum hashes per some quorum type.\n"
-        "     \"quorumHash\"                     (string) Quorum hash. Note: most recent quorums come first.\n"
-        "     ,...\n"
-        "  ],\n"
-        "}\n"
-            },
-            RPCExamples{
-                HelpExampleCli("quorum", "list")
-        + HelpExampleCli("quorum", "list 10")
-        + HelpExampleRpc("quorum", "list, 10")
-            },
-        }.ToString());
+    RPCHelpMan{"quorum list",
+        "List of on-chain quorums\n",
+        {
+            {"count", RPCArg::Type::NUM, /* default */ "", "Number of quorums to list. Will list active quorums if \"count\" is not specified."},
+        },
+        RPCResult{
+    "{\n"
+    "  \"quorumName\" : [                    (array of strings) List of quorum hashes per some quorum type.\n"
+    "     \"quorumHash\"                     (string) Quorum hash. Note: most recent quorums come first.\n"
+    "     ,...\n"
+    "  ],\n"
+    "}\n"
+        },
+        RPCExamples{
+            HelpExampleCli("quorum", "list")
+    + HelpExampleCli("quorum", "list 10")
+    + HelpExampleRpc("quorum", "list, 10")
+        },
+    }.Check(request);
 }
 
 static UniValue quorum_list(const JSONRPCRequest& request)
 {
     if (request.fHelp || (request.params.size() != 1 && request.params.size() != 2))
-        quorum_list_help();
+        quorum_list_help(request);
 
     int count = -1;
     if (!request.params[1].isNull()) {
@@ -80,19 +79,18 @@ static UniValue quorum_list(const JSONRPCRequest& request)
     return ret;
 }
 
-static void quorum_info_help()
+static void quorum_info_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"quorum info",
-            "Return information about a quorum\n",
-            {
-                {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "LLMQ type."},
-                {"quorumHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Block hash of quorum."},
-                {"includeSkShare", RPCArg::Type::BOOL, /* default */ "", "Include secret key share in output."},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"quorum info",
+        "Return information about a quorum\n",
+        {
+            {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "LLMQ type."},
+            {"quorumHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Block hash of quorum."},
+            {"includeSkShare", RPCArg::Type::BOOL, /* default */ "", "Include secret key share in output."},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
 static UniValue BuildQuorumInfo(const llmq::CQuorumCPtr& quorum, bool includeMembers, bool includeSkShare)
@@ -134,7 +132,7 @@ static UniValue BuildQuorumInfo(const llmq::CQuorumCPtr& quorum, bool includeMem
 static UniValue quorum_info(const JSONRPCRequest& request)
 {
     if (request.fHelp || (request.params.size() != 3 && request.params.size() != 4))
-        quorum_info_help();
+        quorum_info_help(request);
 
     Consensus::LLMQType llmqType = (Consensus::LLMQType)ParseInt32V(request.params[1], "llmqType");
     if (!Params().HasLLMQ(llmqType)) {
@@ -155,26 +153,25 @@ static UniValue quorum_info(const JSONRPCRequest& request)
     return BuildQuorumInfo(quorum, true, includeSkShare);
 }
 
-static void quorum_dkgstatus_help()
+static void quorum_dkgstatus_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"quorum dkgstatus",
-            "Return the status of the current DKG process.\n"
-            "Works only when SPORK_17_QUORUM_DKG_ENABLED spork is ON.\n",
-            {
-                {"detail_level", RPCArg::Type::NUM, /* default */ "0",
-                    "Detail level of output.\n"
-                    "0=Only show counts. 1=Show member indexes. 2=Show member's ProTxHashes."},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"quorum dkgstatus",
+        "Return the status of the current DKG process.\n"
+        "Works only when SPORK_17_QUORUM_DKG_ENABLED spork is ON.\n",
+        {
+            {"detail_level", RPCArg::Type::NUM, /* default */ "0",
+                "Detail level of output.\n"
+                "0=Only show counts. 1=Show member indexes. 2=Show member's ProTxHashes."},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
 static UniValue quorum_dkgstatus(const JSONRPCRequest& request)
 {
     if (request.fHelp || (request.params.size() < 1 || request.params.size() > 2)) {
-        quorum_dkgstatus_help();
+        quorum_dkgstatus_help(request);
     }
 
     int detailLevel = 0;
@@ -241,26 +238,25 @@ static UniValue quorum_dkgstatus(const JSONRPCRequest& request)
     return ret;
 }
 
-static void quorum_memberof_help()
+static void quorum_memberof_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"quorum memberof",
-            "Checks which quorums the given masternode is a member of.\n",
-            {
-                {"proTxHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "ProTxHash of the masternode."},
-                {"scanQuorumsCount", RPCArg::Type::NUM, /* default */ "",
-                    "Number of quorums to scan for. If not specified,\n"
-                    "the active quorum count for each specific quorum type is used."},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"quorum memberof",
+        "Checks which quorums the given masternode is a member of.\n",
+        {
+            {"proTxHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "ProTxHash of the masternode."},
+            {"scanQuorumsCount", RPCArg::Type::NUM, /* default */ "",
+                "Number of quorums to scan for. If not specified,\n"
+                "the active quorum count for each specific quorum type is used."},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
 static UniValue quorum_memberof(const JSONRPCRequest& request)
 {
     if (request.fHelp || (request.params.size() < 2 || request.params.size() > 3)) {
-        quorum_memberof_help();
+        quorum_memberof_help(request);
     }
 
     uint256 protxHash = ParseHashV(request.params[1], "proTxHash");
@@ -302,90 +298,85 @@ static UniValue quorum_memberof(const JSONRPCRequest& request)
     return result;
 }
 
-static void quorum_sign_help()
+static void quorum_sign_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"quorum sign",
-            "Threshold-sign a message\n",
-            {
-                {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "LLMQ type."},
-                {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Request id."},
-                {"msgHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Message hash."},
-                {"quorumHash", RPCArg::Type::STR_HEX, /* default */ "", "The quorum identifier."},
-                {"submit", RPCArg::Type::BOOL, /* default */ "true", "Submits the signature share to the network if this is true."},
-            },
-            RPCResult{
-        "\nReturns an object containing the signature share if this is false.\n"
-            },
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"quorum sign",
+        "Threshold-sign a message\n",
+        {
+            {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "LLMQ type."},
+            {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Request id."},
+            {"msgHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Message hash."},
+            {"quorumHash", RPCArg::Type::STR_HEX, /* default */ "", "The quorum identifier."},
+            {"submit", RPCArg::Type::BOOL, /* default */ "true", "Submits the signature share to the network if this is true."},
+        },
+        RPCResult{
+    "\nReturns an object containing the signature share if this is false.\n"
+        },
+        RPCExamples{""},
+    }.Check(request);
 }
 
-static void quorum_verify_help()
+static void quorum_verify_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"quorum verify",
-            "Test if a quorum signature is valid for a request id and a message hash\n",
-            {
-                {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "LLMQ type."},
-                {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Request id."},
-                {"msgHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Message hash."},
-                {"signature", RPCArg::Type::STR, RPCArg::Optional::NO, "Quorum signature to verify."},
-                {"quorumHash", RPCArg::Type::STR_HEX, /* default */ "",
-                    "The quorum identifier.\n"
-                    "Set to \"\" if you want to specify signHeight instead."},
-                {"signHeight", RPCArg::Type::NUM, /* default */ "",
-                    "The height at which the message was signed.\n"
-                    "Only works when quorumHash is \"\"."},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"quorum verify",
+        "Test if a quorum signature is valid for a request id and a message hash\n",
+        {
+            {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "LLMQ type."},
+            {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Request id."},
+            {"msgHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Message hash."},
+            {"signature", RPCArg::Type::STR, RPCArg::Optional::NO, "Quorum signature to verify."},
+            {"quorumHash", RPCArg::Type::STR_HEX, /* default */ "",
+                "The quorum identifier.\n"
+                "Set to \"\" if you want to specify signHeight instead."},
+            {"signHeight", RPCArg::Type::NUM, /* default */ "",
+                "The height at which the message was signed.\n"
+                "Only works when quorumHash is \"\"."},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
-static void quorum_hasrecsig_help()
+static void quorum_hasrecsig_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"quorum hasrecsig",
-            "Test if a valid recovered signature is present\n",
-            {
-                {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "LLMQ type."},
-                {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Request id."},
-                {"msgHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Message hash."},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"quorum hasrecsig",
+        "Test if a valid recovered signature is present\n",
+        {
+            {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "LLMQ type."},
+            {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Request id."},
+            {"msgHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Message hash."},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
-static void quorum_getrecsig_help()
+static void quorum_getrecsig_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"quorum getrecsig",
-            "Get a recovered signature\n",
-            {
-                {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "LLMQ type."},
-                {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Request id."},
-                {"msgHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Message hash."},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"quorum getrecsig",
+        "Get a recovered signature\n",
+        {
+            {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "LLMQ type."},
+            {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Request id."},
+            {"msgHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Message hash."},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
-static void quorum_isconflicting_help()
+static void quorum_isconflicting_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"quorum isconflicting",
-            "Test if a conflict exists\n",
-            {
-                {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "LLMQ type."},
-                {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Request id."},
-                {"msgHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Message hash."},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"quorum isconflicting",
+        "Test if a conflict exists\n",
+        {
+            {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "LLMQ type."},
+            {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Request id."},
+            {"msgHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Message hash."},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
 static UniValue quorum_sigs_cmd(const JSONRPCRequest& request)
@@ -394,18 +385,18 @@ static UniValue quorum_sigs_cmd(const JSONRPCRequest& request)
     if (request.fHelp || (request.params.size() != 4)) {
         if (cmd == "sign") {
             if ((request.params.size() < 4) || (request.params.size() > 6)) {
-                quorum_sign_help();
+                quorum_sign_help(request);
             }
         } else if (cmd == "verify") {
             if (request.params.size() < 5 || request.params.size() > 7) {
-                quorum_verify_help();
+                quorum_verify_help(request);
             }
         } else if (cmd == "hasrecsig") {
-            quorum_hasrecsig_help();
+            quorum_hasrecsig_help(request);
         } else if (cmd == "getrecsig") {
-            quorum_getrecsig_help();
+            quorum_getrecsig_help(request);
         } else if (cmd == "isconflicting") {
-            quorum_isconflicting_help();
+            quorum_isconflicting_help(request);
         } else {
             // shouldn't happen as it's already handled by the caller
             throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid cmd");
@@ -507,24 +498,23 @@ static UniValue quorum_sigs_cmd(const JSONRPCRequest& request)
     }
 }
 
-static void quorum_selectquorum_help()
+static void quorum_selectquorum_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"quorum selectquorum",
-            "Returns the quorum that would/should sign a request\n",
-            {
-                {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "LLMQ type."},
-                {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Request id."},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"quorum selectquorum",
+        "Returns the quorum that would/should sign a request\n",
+        {
+            {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "LLMQ type."},
+            {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Request id."},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
 static UniValue quorum_selectquorum(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() != 3) {
-        quorum_selectquorum_help();
+        quorum_selectquorum_help(request);
     }
 
     Consensus::LLMQType llmqType = (Consensus::LLMQType)ParseInt32V(request.params[1], "llmqType");
@@ -552,25 +542,24 @@ static UniValue quorum_selectquorum(const JSONRPCRequest& request)
     return ret;
 }
 
-static void quorum_dkgsimerror_help()
+static void quorum_dkgsimerror_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"quorum dkgsimerror",
-            "This enables simulation of errors and malicious behaviour in the DKG. Do NOT use this on mainnet\n"
-            "as you will get yourself very likely PoSe banned for this.\n",
-            {
-                {"type", RPCArg::Type::STR, RPCArg::Optional::NO, "Error type."},
-                {"rate", RPCArg::Type::NUM, RPCArg::Optional::NO, "Rate at which to simulate this error type."},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"quorum dkgsimerror",
+        "This enables simulation of errors and malicious behaviour in the DKG. Do NOT use this on mainnet\n"
+        "as you will get yourself very likely PoSe banned for this.\n",
+        {
+            {"type", RPCArg::Type::STR, RPCArg::Optional::NO, "Error type."},
+            {"rate", RPCArg::Type::NUM, RPCArg::Optional::NO, "Rate at which to simulate this error type."},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
 static UniValue quorum_dkgsimerror(const JSONRPCRequest& request)
 {
     if (request.fHelp || (request.params.size() != 3)) {
-        quorum_dkgsimerror_help();
+        quorum_dkgsimerror_help(request);
     }
 
     std::string type = request.params[1].get_str();
@@ -585,31 +574,30 @@ static UniValue quorum_dkgsimerror(const JSONRPCRequest& request)
     return UniValue();
 }
 
-static void quorum_getdata_help()
+static void quorum_getdata_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"quorum getdata",
-            "Send a QGETDATA message to the specified peer.\n",
-            {
-                {"nodeId", RPCArg::Type::NUM, RPCArg::Optional::NO, "The internal nodeId of the peer to request quorum data from."},
-                {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "The quorum type related to the quorum data being requested."},
-                {"quorumHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The quorum hash related to the quorum data being requested."},
-                {"dataMask", RPCArg::Type::NUM, RPCArg::Optional::NO,
-                    "Specify what data to request.\n"
-                    "Possible values: 1 - Request quorum verification vector\n"
-                    "2 - Request encrypted contributions for member defined by \"proTxHash\". \"proTxHash\" must be specified if this option is used.\n"
-                    "3 - Request both, 1 and 2"},
-                {"proTxHash", RPCArg::Type::STR_HEX, /* default */ "", "The proTxHash the contributions will be requested for. Must be member of the specified LLMQ."},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"quorum getdata",
+        "Send a QGETDATA message to the specified peer.\n",
+        {
+            {"nodeId", RPCArg::Type::NUM, RPCArg::Optional::NO, "The internal nodeId of the peer to request quorum data from."},
+            {"llmqType", RPCArg::Type::NUM, RPCArg::Optional::NO, "The quorum type related to the quorum data being requested."},
+            {"quorumHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The quorum hash related to the quorum data being requested."},
+            {"dataMask", RPCArg::Type::NUM, RPCArg::Optional::NO,
+                "Specify what data to request.\n"
+                "Possible values: 1 - Request quorum verification vector\n"
+                "2 - Request encrypted contributions for member defined by \"proTxHash\". \"proTxHash\" must be specified if this option is used.\n"
+                "3 - Request both, 1 and 2"},
+            {"proTxHash", RPCArg::Type::STR_HEX, /* default */ "", "The proTxHash the contributions will be requested for. Must be member of the specified LLMQ."},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
 static UniValue quorum_getdata(const JSONRPCRequest& request)
 {
     if (request.fHelp || (request.params.size() < 5 || request.params.size() > 6)) {
-        quorum_getdata_help();
+        quorum_getdata_help(request);
     }
 
     NodeId nodeId = ParseInt64V(request.params[1], "nodeId");
@@ -639,29 +627,28 @@ static UniValue quorum_getdata(const JSONRPCRequest& request)
 
 [[ noreturn ]] static void quorum_help()
 {
-    throw std::runtime_error(
-        RPCHelpMan{"quorum",
-            "Set of commands for quorums/LLMQs.\n"
-            "To get help on individual commands, use \"help quorum command\".\n"
-            "\nAvailable commands:\n"
-            "  list              - List of on-chain quorums\n"
-            "  info              - Return information about a quorum\n"
-            "  dkgsimerror       - Simulates DKG errors and malicious behavior\n"
-            "  dkgstatus         - Return the status of the current DKG process\n"
-            "  memberof          - Checks which quorums the given masternode is a member of\n"
-            "  sign              - Threshold-sign a message\n"
-            "  verify            - Test if a quorum signature is valid for a request id and a message hash\n"
-            "  hasrecsig         - Test if a valid recovered signature is present\n"
-            "  getrecsig         - Get a recovered signature\n"
-            "  isconflicting     - Test if a conflict exists\n"
-            "  selectquorum      - Return the quorum that would/should sign a request\n"
-            "  getdata           - Request quorum data from other masternodes in the quorum\n",
-            {
-                {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "The command to execute"},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"quorum",
+        "Set of commands for quorums/LLMQs.\n"
+        "To get help on individual commands, use \"help quorum command\".\n"
+        "\nAvailable commands:\n"
+        "  list              - List of on-chain quorums\n"
+        "  info              - Return information about a quorum\n"
+        "  dkgsimerror       - Simulates DKG errors and malicious behavior\n"
+        "  dkgstatus         - Return the status of the current DKG process\n"
+        "  memberof          - Checks which quorums the given masternode is a member of\n"
+        "  sign              - Threshold-sign a message\n"
+        "  verify            - Test if a quorum signature is valid for a request id and a message hash\n"
+        "  hasrecsig         - Test if a valid recovered signature is present\n"
+        "  getrecsig         - Get a recovered signature\n"
+        "  isconflicting     - Test if a conflict exists\n"
+        "  selectquorum      - Return the quorum that would/should sign a request\n"
+        "  getdata           - Request quorum data from other masternodes in the quorum\n",
+        {
+            {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "The command to execute"},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Throw();
 }
 
 static UniValue _quorum(const JSONRPCRequest& request)
@@ -696,25 +683,24 @@ static UniValue _quorum(const JSONRPCRequest& request)
     }
 }
 
-static void verifychainlock_help()
+static void verifychainlock_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"verifychainlock",
-            "Test if a quorum signature is valid for a ChainLock.\n",
-            {
-                {"blockHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The block hash of the ChainLock."},
-                {"signature", RPCArg::Type::STR, RPCArg::Optional::NO, "The signature of the ChainLock."},
-                {"blockHeight", RPCArg::Type::NUM, /* default */ "", "The height of the ChainLock. There will be an internal lookup of \"blockHash\" if this is not provided."},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"verifychainlock",
+        "Test if a quorum signature is valid for a ChainLock.\n",
+        {
+            {"blockHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The block hash of the ChainLock."},
+            {"signature", RPCArg::Type::STR, RPCArg::Optional::NO, "The signature of the ChainLock."},
+            {"blockHeight", RPCArg::Type::NUM, /* default */ "", "The height of the ChainLock. There will be an internal lookup of \"blockHash\" if this is not provided."},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
 static UniValue verifychainlock(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() < 2 || request.params.size() > 3) {
-        verifychainlock_help();
+        verifychainlock_help(request);
     }
 
     const uint256 nBlockHash = ParseHashV(request.params[0], "blockHash");
@@ -740,26 +726,25 @@ static UniValue verifychainlock(const JSONRPCRequest& request)
     return llmq::CSigningManager::VerifyRecoveredSig(llmqType, nBlockHeight, nRequestId, nBlockHash, chainLockSig);
 }
 
-static void verifyislock_help()
+static void verifyislock_help(const JSONRPCRequest& request)
 {
-    throw std::runtime_error(
-        RPCHelpMan{"verifyislock",
-            "Test if a quorum signature is valid for an InstantSend Lock\n",
-            {
-                {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Request id."},
-                {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id."},
-                {"signature", RPCArg::Type::STR, RPCArg::Optional::NO, "The InstantSend Lock signature to verify."},
-                {"maxHeight", RPCArg::Type::NUM, /* default */ "", "The maximum height to search quorums from."},
-            },
-            RPCResults{},
-            RPCExamples{""},
-        }.ToString());
+    RPCHelpMan{"verifyislock",
+        "Test if a quorum signature is valid for an InstantSend Lock\n",
+        {
+            {"id", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Request id."},
+            {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id."},
+            {"signature", RPCArg::Type::STR, RPCArg::Optional::NO, "The InstantSend Lock signature to verify."},
+            {"maxHeight", RPCArg::Type::NUM, /* default */ "", "The maximum height to search quorums from."},
+        },
+        RPCResults{},
+        RPCExamples{""},
+    }.Check(request);
 }
 
 static UniValue verifyislock(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() < 3 || request.params.size() > 4) {
-        verifyislock_help();
+        verifyislock_help(request);
     }
 
     uint256 id = ParseHashV(request.params[0], "id");
diff --git a/src/rpc/util.h b/src/rpc/util.h
index e9d6688946..423334f35a 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -254,6 +254,10 @@ public:
         }
     }
 
+    [[ noreturn ]] inline void Throw() const {
+        throw std::runtime_error(ToString());
+    }
+
 private:
     const std::string m_name;
     const std::string m_description;

From 61b96f7e674acadf58f535346516a68d95229be1 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Thu, 4 Apr 2019 10:43:22 -0400
Subject: [PATCH 03/16] merge bitcoin#15746: Always name dictionary keys

---
 src/rpc/util.cpp | 29 +++++++++++++++++++++++++----
 1 file changed, 25 insertions(+), 4 deletions(-)

diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 608b64005d..ccb2c56880 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -263,6 +263,10 @@ unsigned int ParseConfirmTarget(const UniValue& value, unsigned int max_target)
     return (unsigned int)target;
 }
 
+/**
+ * A pair of strings that can be aligned (through padding) with other Sections
+ * later on
+ */
 struct Section {
     Section(const std::string& left, const std::string& right)
         : m_left{left}, m_right{right} {}
@@ -270,6 +274,10 @@ struct Section {
     const std::string m_right;
 };
 
+/**
+ * Keeps track of RPCArgs by transforming them into sections for the purpose
+ * of serializing everything to a single string
+ */
 struct Sections {
     std::vector<Section> m_sections;
     size_t m_max_pad{0};
@@ -280,16 +288,26 @@ struct Sections {
         m_sections.push_back(s);
     }
 
+    /**
+     * Serializing RPCArgs depends on the outer type. Only arrays and
+     * dictionaries can be nested in json. The top-level outer type is "named
+     * arguments", a mix between a dictionary and arrays.
+     */
     enum class OuterType {
         ARR,
         OBJ,
         NAMED_ARG, // Only set on first recursion
     };
 
+    /**
+     * Recursive helper to translate an RPCArg into sections
+     */
     void Push(const RPCArg& arg, const size_t current_indent = 5, const OuterType outer_type = OuterType::NAMED_ARG)
     {
         const auto indent = std::string(current_indent, ' ');
         const auto indent_next = std::string(current_indent + 2, ' ');
+        const bool push_name{outer_type == OuterType::OBJ}; // Dictionary keys must have a name
+
         switch (arg.m_type) {
         case RPCArg::Type::STR_HEX:
         case RPCArg::Type::STR:
@@ -299,10 +317,10 @@ struct Sections {
         case RPCArg::Type::BOOL: {
             if (outer_type == OuterType::NAMED_ARG) return; // Nothing more to do for non-recursive types on first recursion
             auto left = indent;
-            if (arg.m_type_str.size() != 0 && outer_type == OuterType::OBJ) {
+            if (arg.m_type_str.size() != 0 && push_name) {
                 left += "\"" + arg.m_name + "\": " + arg.m_type_str.at(0);
             } else {
-                left += outer_type == OuterType::OBJ ? arg.ToStringObj(/* oneline */ false) : arg.ToString(/* oneline */ false);
+                left += push_name ? arg.ToStringObj(/* oneline */ false) : arg.ToString(/* oneline */ false);
             }
             left += ",";
             PushSection({left, arg.ToDescriptionString()});
@@ -311,7 +329,7 @@ struct Sections {
         case RPCArg::Type::OBJ:
         case RPCArg::Type::OBJ_USER_KEYS: {
             const auto right = outer_type == OuterType::NAMED_ARG ? "" : arg.ToDescriptionString();
-            PushSection({indent + "{", right});
+            PushSection({indent + (push_name ? "\"" + arg.m_name + "\": " : "") + "{", right});
             for (const auto& arg_inner : arg.m_inner) {
                 Push(arg_inner, current_indent + 2, OuterType::OBJ);
             }
@@ -323,7 +341,7 @@ struct Sections {
         }
         case RPCArg::Type::ARR: {
             auto left = indent;
-            left += outer_type == OuterType::OBJ ? "\"" + arg.m_name + "\": " : "";
+            left += push_name ? "\"" + arg.m_name + "\": " : "";
             left += "[";
             const auto right = outer_type == OuterType::NAMED_ARG ? "" : arg.ToDescriptionString();
             PushSection({left, right});
@@ -339,6 +357,9 @@ struct Sections {
         }
     }
 
+    /**
+     * Concatenate all sections with proper padding
+     */
     std::string ToString() const
     {
         std::string ret;

From 62cbb810015bb9242862174969b37632993917d7 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sun, 27 Feb 2022 13:35:32 +0530
Subject: [PATCH 04/16] merge bitcoin#17192: Add CHECK_NONFATAL and use it in
 src/rpc

---
 src/Makefile.am             |  1 +
 src/rpc/blockchain.cpp      |  5 ++---
 src/rpc/misc.cpp            |  6 +++++-
 src/rpc/util.h              | 13 ++++++------
 src/util/check.h            | 41 +++++++++++++++++++++++++++++++++++++
 test/functional/rpc_misc.py |  7 +++++++
 6 files changed, 63 insertions(+), 10 deletions(-)
 create mode 100644 src/util/check.h

diff --git a/src/Makefile.am b/src/Makefile.am
index d74d03a3b7..78b2544d2f 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -293,6 +293,7 @@ BITCOIN_CORE_H = \
   unordered_lru_cache.h \
   util/bip32.h \
   util/bytevectorhash.h \
+  util/check.h \
   util/error.h \
   util/fees.h \
   util/spanparsing.h \
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 08ba78b0b9..ec816470fb 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -11,12 +11,12 @@
 #include <chain.h>
 #include <chainparams.h>
 #include <coins.h>
-#include <node/coinstats.h>
 #include <core_io.h>
 #include <consensus/validation.h>
 #include <index/blockfilterindex.h>
-#include <key_io.h>
 #include <index/txindex.h>
+#include <key_io.h>
+#include <node/coinstats.h>
 #include <policy/feerate.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
@@ -40,7 +40,6 @@
 #include <llmq/chainlocks.h>
 #include <llmq/instantsend.h>
 
-#include <assert.h>
 #include <stdint.h>
 
 #include <univalue.h>
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index b0151dc7ec..2bfdc62c05 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -15,8 +15,9 @@
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <txmempool.h>
-#include <util/system.h>
+#include <util/check.h>
 #include <util/strencodings.h>
+#include <util/system.h>
 #include <validation.h>
 #include <util/validation.h>
 
@@ -1270,6 +1271,7 @@ static UniValue echo(const JSONRPCRequest& request)
         throw std::runtime_error(
             RPCHelpMan{"echo|echojson ...",
                 "\nSimply echo back the input arguments. This command is for testing.\n"
+                "\nIt will return an internal bug report when exactly 100 arguments are passed.\n"
                 "\nThe difference between echo and echojson is that echojson has argument conversion enabled in the client-side table in "
                 "dash-cli and the GUI. There is no server-side difference.",
                 {},
@@ -1278,6 +1280,8 @@ static UniValue echo(const JSONRPCRequest& request)
             }.ToString()
         );
 
+    CHECK_NONFATAL(request.params.size() != 100);
+
     return request.params;
 }
 
diff --git a/src/rpc/util.h b/src/rpc/util.h
index 423334f35a..7cdac2e1f0 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -6,12 +6,13 @@
 #define BITCOIN_RPC_UTIL_H
 
 #include <node/transaction.h>
-#include <pubkey.h>
 #include <protocol.h>
+#include <pubkey.h>
 #include <rpc/protocol.h>
 #include <rpc/request.h>
 #include <script/standard.h>
 #include <univalue.h>
+#include <util/check.h>
 #include <util/strencodings.h>
 
 #include <string>
@@ -143,7 +144,7 @@ struct RPCArg {
           m_oneline_description{oneline_description},
           m_type_str{type_str}
     {
-        assert(type != Type::ARR && type != Type::OBJ);
+        CHECK_NONFATAL(type != Type::ARR && type != Type::OBJ);
     }
 
     RPCArg(
@@ -162,7 +163,7 @@ struct RPCArg {
           m_oneline_description{oneline_description},
           m_type_str{type_str}
     {
-        assert(type == Type::ARR || type == Type::OBJ);
+        CHECK_NONFATAL(type == Type::ARR || type == Type::OBJ);
     }
 
     bool IsOptional() const;
@@ -191,14 +192,14 @@ struct RPCResult {
     explicit RPCResult(std::string result)
         : m_cond{}, m_result{std::move(result)}
     {
-        assert(!m_result.empty());
+        CHECK_NONFATAL(!m_result.empty());
     }
 
     RPCResult(std::string cond, std::string result)
         : m_cond{std::move(cond)}, m_result{std::move(result)}
     {
-        assert(!m_cond.empty());
-        assert(!m_result.empty());
+        CHECK_NONFATAL(!m_cond.empty());
+        CHECK_NONFATAL(!m_result.empty());
     }
 };
 
diff --git a/src/util/check.h b/src/util/check.h
new file mode 100644
index 0000000000..d18887ae95
--- /dev/null
+++ b/src/util/check.h
@@ -0,0 +1,41 @@
+// Copyright (c) 2019 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_UTIL_CHECK_H
+#define BITCOIN_UTIL_CHECK_H
+
+#include <tinyformat.h>
+
+#include <stdexcept>
+
+class NonFatalCheckError : public std::runtime_error
+{
+    using std::runtime_error::runtime_error;
+};
+
+/**
+ * Throw a NonFatalCheckError when the condition evaluates to false
+ *
+ * This should only be used
+ * - where the condition is assumed to be true, not for error handling or validating user input
+ * - where a failure to fulfill the condition is recoverable and does not abort the program
+ *
+ * For example in RPC code, where it is undersirable to crash the whole program, this can be generally used to replace
+ * asserts or recoverable logic errors. A NonFatalCheckError in RPC code is caught and passed as a string to the RPC
+ * caller, which can then report the issue to the developers.
+ */
+#define CHECK_NONFATAL(condition)                                 \
+    do {                                                          \
+        if (!(condition)) {                                       \
+            throw NonFatalCheckError(                             \
+                strprintf("%s:%d (%s)\n"                          \
+                          "Internal bug detected: '%s'\n"         \
+                          "You may report this issue here: %s\n", \
+                    __FILE__, __LINE__, __func__,                 \
+                    (#condition),                                 \
+                    PACKAGE_BUGREPORT));                          \
+        }                                                         \
+    } while (false)
+
+#endif // BITCOIN_UTIL_CHECK_H
diff --git a/test/functional/rpc_misc.py b/test/functional/rpc_misc.py
index 8a3f8c6f06..3da9f05ca5 100755
--- a/test/functional/rpc_misc.py
+++ b/test/functional/rpc_misc.py
@@ -23,6 +23,13 @@ class RpcMiscTest(BitcoinTestFramework):
     def run_test(self):
         node = self.nodes[0]
 
+        self.log.info("test CHECK_NONFATAL")
+        assert_raises_rpc_error(
+            -1,
+            "Internal bug detected: 'request.params.size() != 100'",
+            lambda: node.echo(*[0] * 100),
+        )
+
         self.log.info("test getmemoryinfo")
         memory = node.getmemoryinfo()['locked']
         assert_greater_than(memory['used'], 0)

From e1dd37c8bba31318af3a13750e2aaf5990b1dbf6 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sun, 27 Feb 2022 13:15:09 +0530
Subject: [PATCH 05/16] merge bitcoin#18098: Add missing spaces in RPCResult,
 Normalize type names

---
 src/rpc/blockchain.cpp     | 214 ++++++++++++++++++-------------------
 src/rpc/coinjoin.cpp       |  44 ++++----
 src/rpc/governance.cpp     |  10 +-
 src/rpc/masternode.cpp     |  14 +--
 src/rpc/mining.cpp         |  36 +++----
 src/rpc/misc.cpp           |  30 +++---
 src/rpc/net.cpp            | 144 ++++++++++++-------------
 src/rpc/rawtransaction.cpp |  42 ++++----
 src/rpc/rpcevo.cpp         |   8 +-
 src/wallet/rpcdump.cpp     |   8 +-
 src/wallet/rpcwallet.cpp   | 172 ++++++++++++++---------------
 src/zmq/zmqrpc.cpp         |   6 +-
 12 files changed, 364 insertions(+), 364 deletions(-)

diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index ec816470fb..77671f4891 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -279,7 +279,7 @@ static UniValue waitfornewblock(const JSONRPCRequest& request)
                 RPCResult{
             "{                           (json object)\n"
             "  \"hash\" : {       (string) The blockhash\n"
-            "  \"height\" : {     (int) Block height\n"
+            "  \"height\" : {     (numeric) Block height\n"
             "}\n"
                 },
                 RPCExamples{
@@ -321,7 +321,7 @@ static UniValue waitforblock(const JSONRPCRequest& request)
                 RPCResult{
             "{                           (json object)\n"
             "  \"hash\" : {       (string) The blockhash\n"
-            "  \"height\" : {     (int) Block height\n"
+            "  \"height\" : {     (numeric) Block height\n"
             "}\n"
                 },
                 RPCExamples{
@@ -367,7 +367,7 @@ static UniValue waitforblockheight(const JSONRPCRequest& request)
                 RPCResult{
             "{                           (json object)\n"
             "  \"hash\" : {       (string) The blockhash\n"
-            "  \"height\" : {     (int) Block height\n"
+            "  \"height\" : {     (numeric) Block height\n"
             "}\n"
                 },
                 RPCExamples{
@@ -457,10 +457,10 @@ static std::string EntryDescriptionString()
            "        \"ancestor\" : n,     (numeric) modified fees (see above) of in-mempool ancestors (including this one) in " + CURRENCY_UNIT + "\n"
            "        \"descendant\" : n,   (numeric) modified fees (see above) of in-mempool descendants (including this one) in " + CURRENCY_UNIT + "\n"
            "    }\n"
-           "    \"depends\" : [               (array) unconfirmed transactions used as inputs for this transaction\n"
+           "    \"depends\" : [               (json array) unconfirmed transactions used as inputs for this transaction\n"
            "        \"transactionid\",        (string) parent transaction id\n"
            "       ... ],\n"
-           "    \"spentby\" : [           (array) unconfirmed transactions spending outputs from this transaction\n"
+           "    \"spentby\" : [           (json array) unconfirmed transactions spending outputs from this transaction\n"
            "        \"transactionid\",    (string) child transaction id\n"
            "       ... ]\n"
            "    \"instantlock\" : true|false  (boolean) True if this transaction was locked via InstantSend\n";
@@ -1243,14 +1243,14 @@ static UniValue gettxoutsetinfo(const JSONRPCRequest& request)
                 {},
                 RPCResult{
             "{\n"
-            "  \"height\":n,     (numeric) The current block height (index)\n"
-            "  \"bestblock\": \"hex\",   (string) The hash of the block at the tip of the chain\n"
-            "  \"transactions\": n,      (numeric) The number of transactions with unspent outputs\n"
-            "  \"txouts\": n,            (numeric) The number of unspent transaction outputs\n"
-            "  \"bogosize\": n,          (numeric) A meaningless metric for UTXO set size\n"
+            "  \"height\" : n,     (numeric) The current block height (index)\n"
+            "  \"bestblock\" : \"hex\",   (string) The hash of the block at the tip of the chain\n"
+            "  \"transactions\" : n,      (numeric) The number of transactions with unspent outputs\n"
+            "  \"txouts\" : n,            (numeric) The number of unspent transaction outputs\n"
+            "  \"bogosize\" : n,          (numeric) A meaningless metric for UTXO set size\n"
             "  \"hash_serialized_2\": \"hash\", (string) The serialized hash\n"
-            "  \"disk_size\": n,         (numeric) The estimated size of the chainstate on disk\n"
-            "  \"total_amount\": x.xxx          (numeric) The total amount\n"
+            "  \"disk_size\" : n,         (numeric) The estimated size of the chainstate on disk\n"
+            "  \"total_amount\" : x.xxx          (numeric) The total amount\n"
             "}\n"
                 },
                 RPCExamples{
@@ -1293,7 +1293,7 @@ static UniValue gettxout(const JSONRPCRequest& request)
                 },
                 RPCResult{
             "{\n"
-            "  \"bestblock\":  \"hash\",    (string) The hash of the block at the tip of the chain\n"
+            "  \"bestblock\" :  \"hash\",    (string) The hash of the block at the tip of the chain\n"
             "  \"confirmations\" : n,       (numeric) The number of confirmations\n"
             "  \"value\" : x.xxx,           (numeric) The transaction value in " + CURRENCY_UNIT + "\n"
             "  \"scriptPubKey\" : {         (json object)\n"
@@ -1474,43 +1474,43 @@ UniValue getblockchaininfo(const JSONRPCRequest& request)
                 {},
                 RPCResult{
             "{\n"
-            "  \"chain\": \"xxxx\",              (string) current network name as defined in BIP70 (main, test, regtest) and\n"
+            "  \"chain\" : \"xxxx\",              (string) current network name as defined in BIP70 (main, test, regtest) and\n"
             "                                          devnet or devnet-<name> for \"-devnet\" and \"-devnet=<name>\" respectively\n"
-            "  \"blocks\": xxxxxx,             (numeric) the height of the most-work fully-validated chain. The genesis block has height 0\n"
-            "  \"headers\": xxxxxx,            (numeric) the current number of headers we have validated\n"
-            "  \"bestblockhash\": \"...\",       (string) the hash of the currently best block\n"
-            "  \"difficulty\": xxxxxx,         (numeric) the current difficulty\n"
-            "  \"mediantime\": xxxxxx,         (numeric) median time for the current best block\n"
-            "  \"verificationprogress\": xxxx, (numeric) estimate of verification progress [0..1]\n"
-            "  \"initialblockdownload\": xxxx, (bool) (debug information) estimate of whether this node is in Initial Block Download mode.\n"
-            "  \"chainwork\": \"xxxx\"           (string) total amount of work in active chain, in hexadecimal\n"
-            "  \"size_on_disk\": xxxxxx,       (numeric) the estimated size of the block and undo files on disk\n"
-            "  \"pruned\": xx,                 (boolean) if the blocks are subject to pruning\n"
-            "  \"pruneheight\": xxxxxx,        (numeric) lowest-height complete block stored (only present if pruning is enabled)\n"
-            "  \"automatic_pruning\": xx,      (boolean) whether automatic pruning is enabled (only present if pruning is enabled)\n"
-            "  \"prune_target_size\": xxxxxx,  (numeric) the target size used by pruning (only present if automatic pruning is enabled)\n"
-            "  \"softforks\": [                (array) status of softforks in progress\n"
+            "  \"blocks\" : xxxxxx,             (numeric) the height of the most-work fully-validated chain. The genesis block has height 0\n"
+            "  \"headers\" : xxxxxx,            (numeric) the current number of headers we have validated\n"
+            "  \"bestblockhash\" : \"...\",       (string) the hash of the currently best block\n"
+            "  \"difficulty\" : xxxxxx,         (numeric) the current difficulty\n"
+            "  \"mediantime\" : xxxxxx,         (numeric) median time for the current best block\n"
+            "  \"verificationprogress\" : xxxx, (numeric) estimate of verification progress [0..1]\n"
+            "  \"initialblockdownload\" : xxxx, (boolean) (debug information) estimate of whether this node is in Initial Block Download mode.\n"
+            "  \"chainwork\" : \"xxxx\"           (string) total amount of work in active chain, in hexadecimal\n"
+            "  \"size_on_disk\" : xxxxxx,       (numeric) the estimated size of the block and undo files on disk\n"
+            "  \"pruned\" : xx,                 (boolean) if the blocks are subject to pruning\n"
+            "  \"pruneheight\" : xxxxxx,        (numeric) lowest-height complete block stored (only present if pruning is enabled)\n"
+            "  \"automatic_pruning\" : xx,      (boolean) whether automatic pruning is enabled (only present if pruning is enabled)\n"
+            "  \"prune_target_size\" : xxxxxx,  (numeric) the target size used by pruning (only present if automatic pruning is enabled)\n"
+            "  \"softforks\" : [                (json array) status of softforks in progress\n"
             "     {\n"
-            "        \"id\": \"xxxx\",           (string) name of softfork\n"
-            "        \"version\": xx,          (numeric) block version\n"
-            "        \"reject\": {             (object) progress toward rejecting pre-softfork blocks\n"
-            "           \"status\": xx,        (boolean) true if threshold reached\n"
+            "        \"id\" : \"xxxx\",           (string) name of softfork\n"
+            "        \"version\" : xx,          (numeric) block version\n"
+            "        \"reject\" : {             (json object) progress toward rejecting pre-softfork blocks\n"
+            "           \"status\" : xx,        (boolean) true if threshold reached\n"
             "        },\n"
             "     }, ...\n"
             "  ],\n"
-            "  \"bip9_softforks\": {           (object) status of BIP9 softforks in progress\n"
+            "  \"bip9_softforks\": {           (json object) status of BIP9 softforks in progress\n"
             "     \"xxxx\" : {                 (string) name of the softfork\n"
-            "        \"status\": \"xxxx\",       (string) one of \"defined\", \"started\", \"locked_in\", \"active\", \"failed\"\n"
-            "        \"bit\": xx,              (numeric) the bit (0-28) in the block version field used to signal this softfork (only for \"started\" status)\n"
-            "        \"start_time\": xx,        (numeric) the minimum median time past of a block at which the bit gains its meaning\n"
-            "        \"timeout\": xx,          (numeric) the median time past of a block at which the deployment is considered failed if not yet locked in\n"
-            "        \"since\": xx,            (numeric) height of the first block to which the status applies\n"
-            "        \"statistics\": {         (object) numeric statistics about BIP9 signalling for a softfork (only for \"started\" status)\n"
-            "           \"period\": xx,        (numeric) the length in blocks of the BIP9 signalling period \n"
-            "           \"threshold\": xx,     (numeric) the number of blocks with the version bit set required to activate the feature \n"
-            "           \"elapsed\": xx,       (numeric) the number of blocks elapsed since the beginning of the current period \n"
-            "           \"count\": xx,         (numeric) the number of blocks with the version bit set in the current period \n"
-            "           \"possible\": xx       (boolean) returns false if there are not enough blocks left in this period to pass activation threshold \n"
+            "        \"status\" : \"xxxx\",       (string) one of \"defined\", \"started\", \"locked_in\", \"active\", \"failed\"\n"
+            "        \"bit\" : xx,              (numeric) the bit (0-28) in the block version field used to signal this softfork (only for \"started\" status)\n"
+            "        \"start_time\" : xx,        (numeric) the minimum median time past of a block at which the bit gains its meaning\n"
+            "        \"timeout\" : xx,          (numeric) the median time past of a block at which the deployment is considered failed if not yet locked in\n"
+            "        \"since\" : xx,            (numeric) height of the first block to which the status applies\n"
+            "        \"statistics\" : {         (json object) numeric statistics about BIP9 signalling for a softfork (only for \"started\" status)\n"
+            "           \"period\" : xx,        (numeric) the length in blocks of the BIP9 signalling period \n"
+            "           \"threshold\" : xx,     (numeric) the number of blocks with the version bit set required to activate the feature \n"
+            "           \"elapsed\" : xx,       (numeric) the number of blocks elapsed since the beginning of the current period \n"
+            "           \"count\" : xx,         (numeric) the number of blocks with the version bit set in the current period \n"
+            "           \"possible\" : xx       (boolean) returns false if there are not enough blocks left in this period to pass activation threshold \n"
             "        }\n"
             "     }\n"
             "  }\n"
@@ -1603,22 +1603,22 @@ static UniValue getchaintips(const JSONRPCRequest& request)
                 RPCResult{
             "[\n"
             "  {\n"
-            "    \"height\": xxxx,             (numeric) height of the chain tip\n"
-            "    \"hash\": \"xxxx\",             (string) block hash of the tip\n"
+            "    \"height\" : xxxx,             (numeric) height of the chain tip\n"
+            "    \"hash\" : \"xxxx\",             (string) block hash of the tip\n"
             "    \"difficulty\" : x.xxx,       (numeric) The difficulty\n"
             "    \"chainwork\" : \"0000...1f3\"  (string) Expected number of hashes required to produce the current chain (in hex)\n"
-            "    \"branchlen\": 0              (numeric) zero for main chain\n"
-            "    \"forkpoint\": \"xxxx\",        (string) same as \"hash\" for the main chain\n"
-            "    \"status\": \"active\"          (string) \"active\" for the main chain\n"
+            "    \"branchlen\" : 0              (numeric) zero for main chain\n"
+            "    \"forkpoint\" : \"xxxx\",        (string) same as \"hash\" for the main chain\n"
+            "    \"status\" : \"active\"          (string) \"active\" for the main chain\n"
             "  },\n"
             "  {\n"
-            "    \"height\": xxxx,\n"
-            "    \"hash\": \"xxxx\",\n"
+            "    \"height\" : xxxx,\n"
+            "    \"hash\" : \"xxxx\",\n"
             "    \"difficulty\" : x.xxx,\n"
             "    \"chainwork\" : \"0000...1f3\"\n"
-            "    \"branchlen\": 1              (numeric) length of branch connecting the tip to the main chain\n"
-            "    \"forkpoint\": \"xxxx\",        (string) block hash of the last common block between this tip and the main chain\n"
-            "    \"status\": \"xxxx\"            (string) status of the chain (active, valid-fork, valid-headers, headers-only, invalid)\n"
+            "    \"branchlen\" : 1              (numeric) length of branch connecting the tip to the main chain\n"
+            "    \"forkpoint\" : \"xxxx\",        (string) block hash of the last common block between this tip and the main chain\n"
+            "    \"status\" : \"xxxx\"            (string) status of the chain (active, valid-fork, valid-headers, headers-only, invalid)\n"
             "  }\n"
             "]\n"
             "Possible values for status:\n"
@@ -1750,14 +1750,14 @@ static UniValue getmempoolinfo(const JSONRPCRequest& request)
                 {},
                 RPCResult{
             "{\n"
-            "  \"loaded\": true|false         (boolean) True if the mempool is fully loaded\n"
-            "  \"size\": xxxxx,               (numeric) Current tx count\n"
-            "  \"bytes\": xxxxx,              (numeric) Sum of all tx sizes\n"
-            "  \"usage\": xxxxx,              (numeric) Total memory usage for the mempool\n"
-            "  \"maxmempool\": xxxxx,         (numeric) Maximum memory usage for the mempool\n"
-            "  \"mempoolminfee\": xxxxx       (numeric) Minimum fee rate in " + CURRENCY_UNIT + "/kB for tx to be accepted. Is the maximum of minrelaytxfee and minimum mempool fee\n"
-            "  \"minrelaytxfee\": xxxxx       (numeric) Current minimum relay fee for transactions\n"
-            "  \"instantsendlocks\": xxxxx,   (numeric) Number of unconfirmed instant send locks\n"
+            "  \"loaded\" : true|false         (boolean) True if the mempool is fully loaded\n"
+            "  \"size\" : xxxxx,               (numeric) Current tx count\n"
+            "  \"bytes\" : xxxxx,              (numeric) Sum of all tx sizes\n"
+            "  \"usage\" : xxxxx,              (numeric) Total memory usage for the mempool\n"
+            "  \"maxmempool\" : xxxxx,         (numeric) Maximum memory usage for the mempool\n"
+            "  \"mempoolminfee\" : xxxxx       (numeric) Minimum fee rate in " + CURRENCY_UNIT + "/kB for tx to be accepted. Is the maximum of minrelaytxfee and minimum mempool fee\n"
+            "  \"minrelaytxfee\" : xxxxx       (numeric) Current minimum relay fee for transactions\n"
+            "  \"instantsendlocks\" : xxxxx,   (numeric) Number of unconfirmed instant send locks\n"
             "}\n"
                 },
                 RPCExamples{
@@ -1902,14 +1902,14 @@ static UniValue getchaintxstats(const JSONRPCRequest& request)
                 },
                 RPCResult{
             "{\n"
-            "  \"time\": xxxxx,                         (numeric) The timestamp for the final block in the window in UNIX format.\n"
-            "  \"txcount\": xxxxx,                      (numeric) The total number of transactions in the chain up to that point.\n"
-            "  \"window_final_block_hash\": \"...\",      (string) The hash of the final block in the window.\n"
-            "  \"window_final_block_height\": xxxxx,    (numeric) The height of the final block in the window.\n"
-            "  \"window_block_count\": xxxxx,           (numeric) Size of the window in number of blocks.\n"
-            "  \"window_tx_count\": xxxxx,              (numeric) The number of transactions in the window. Only returned if \"window_block_count\" is > 0.\n"
-            "  \"window_interval\": xxxxx,              (numeric) The elapsed time in the window in seconds. Only returned if \"window_block_count\" is > 0.\n"
-            "  \"txrate\": x.xx,                        (numeric) The average rate of transactions per second in the window. Only returned if \"window_interval\" is > 0.\n"
+            "  \"time\" : xxxxx,                         (numeric) The timestamp for the final block in the window in UNIX format.\n"
+            "  \"txcount\" : xxxxx,                      (numeric) The total number of transactions in the chain up to that point.\n"
+            "  \"window_final_block_hash\" : \"...\",      (string) The hash of the final block in the window.\n"
+            "  \"window_final_block_height\" : xxxxx,    (numeric) The height of the final block in the window.\n"
+            "  \"window_block_count\" : xxxxx,           (numeric) Size of the window in number of blocks.\n"
+            "  \"window_tx_count\" : xxxxx,              (numeric) The number of transactions in the window. Only returned if \"window_block_count\" is > 0.\n"
+            "  \"window_interval\" : xxxxx,              (numeric) The elapsed time in the window in seconds. Only returned if \"window_block_count\" is > 0.\n"
+            "  \"txrate\" : x.xx,                        (numeric) The average rate of transactions per second in the window. Only returned if \"window_interval\" is > 0.\n"
             "}\n"
                 },
                 RPCExamples{
@@ -2042,37 +2042,37 @@ static UniValue getblockstats(const JSONRPCRequest& request)
                 },
                 RPCResult{
             "{                           (json object)\n"
-            "  \"avgfee\": xxxxx,          (numeric) Average fee in the block\n"
-            "  \"avgfeerate\": xxxxx,      (numeric) Average feerate (in duffs per byte)\n"
-            "  \"avgtxsize\": xxxxx,       (numeric) Average transaction size\n"
-            "  \"blockhash\": xxxxx,       (string) The block hash (to check for potential reorgs)\n"
-            "  \"feerate_percentiles\": [  (array of numeric) Feerates at the 10th, 25th, 50th, 75th, and 90th percentile weight unit (in duffs per byte)\n"
+            "  \"avgfee\" : xxxxx,          (numeric) Average fee in the block\n"
+            "  \"avgfeerate\" : xxxxx,      (numeric) Average feerate (in duffs per byte)\n"
+            "  \"avgtxsize\" : xxxxx,       (numeric) Average transaction size\n"
+            "  \"blockhash\" : xxxxx,       (string) The block hash (to check for potential reorgs)\n"
+            "  \"feerate_percentiles\" : [  (array of numeric) Feerates at the 10th, 25th, 50th, 75th, and 90th percentile weight unit (in duffs per byte)\n"
             "      \"10th_percentile_feerate\",      (numeric) The 10th percentile feerate\n"
             "      \"25th_percentile_feerate\",      (numeric) The 25th percentile feerate\n"
             "      \"50th_percentile_feerate\",      (numeric) The 50th percentile feerate\n"
             "      \"75th_percentile_feerate\",      (numeric) The 75th percentile feerate\n"
             "      \"90th_percentile_feerate\",      (numeric) The 90th percentile feerate\n"
             "  ],\n"
-            "  \"height\": xxxxx,          (numeric) The height of the block\n"
-            "  \"ins\": xxxxx,             (numeric) The number of inputs (excluding coinbase)\n"
-            "  \"maxfee\": xxxxx,          (numeric) Maximum fee in the block\n"
-            "  \"maxfeerate\": xxxxx,      (numeric) Maximum feerate (in duffs per byte)\n"
-            "  \"maxtxsize\": xxxxx,       (numeric) Maximum transaction size\n"
-            "  \"medianfee\": xxxxx,       (numeric) Truncated median fee in the block\n"
-            "  \"mediantime\": xxxxx,      (numeric) The block median time past\n"
-            "  \"mediantxsize\": xxxxx,    (numeric) Truncated median transaction size\n"
-            "  \"minfee\": xxxxx,          (numeric) Minimum fee in the block\n"
-            "  \"minfeerate\": xxxxx,      (numeric) Minimum feerate (in duffs per byte)\n"
-            "  \"mintxsize\": xxxxx,       (numeric) Minimum transaction size\n"
-            "  \"outs\": xxxxx,            (numeric) The number of outputs\n"
-            "  \"subsidy\": xxxxx,         (numeric) The block subsidy\n"
-            "  \"time\": xxxxx,            (numeric) The block time\n"
-            "  \"total_out\": xxxxx,       (numeric) Total amount in all outputs (excluding coinbase and thus reward [ie subsidy + totalfee])\n"
-            "  \"total_size\": xxxxx,      (numeric) Total size of all non-coinbase transactions\n"
-            "  \"totalfee\": xxxxx,        (numeric) The fee total\n"
-            "  \"txs\": xxxxx,             (numeric) The number of transactions (excluding coinbase)\n"
-            "  \"utxo_increase\": xxxxx,   (numeric) The increase/decrease in the number of unspent outputs\n"
-            "  \"utxo_size_inc\": xxxxx,   (numeric) The increase/decrease in size for the utxo index (not discounting op_return and similar)\n"
+            "  \"height\" : xxxxx,          (numeric) The height of the block\n"
+            "  \"ins\" : xxxxx,             (numeric) The number of inputs (excluding coinbase)\n"
+            "  \"maxfee\" : xxxxx,          (numeric) Maximum fee in the block\n"
+            "  \"maxfeerate\" : xxxxx,      (numeric) Maximum feerate (in duffs per byte)\n"
+            "  \"maxtxsize\" : xxxxx,       (numeric) Maximum transaction size\n"
+            "  \"medianfee\" : xxxxx,       (numeric) Truncated median fee in the block\n"
+            "  \"mediantime\" : xxxxx,      (numeric) The block median time past\n"
+            "  \"mediantxsize\" : xxxxx,    (numeric) Truncated median transaction size\n"
+            "  \"minfee\" : xxxxx,          (numeric) Minimum fee in the block\n"
+            "  \"minfeerate\" : xxxxx,      (numeric) Minimum feerate (in duffs per byte)\n"
+            "  \"mintxsize\" : xxxxx,       (numeric) Minimum transaction size\n"
+            "  \"outs\" : xxxxx,            (numeric) The number of outputs\n"
+            "  \"subsidy\" : xxxxx,         (numeric) The block subsidy\n"
+            "  \"time\" : xxxxx,            (numeric) The block time\n"
+            "  \"total_out\" : xxxxx,       (numeric) Total amount in all outputs (excluding coinbase and thus reward [ie subsidy + totalfee])\n"
+            "  \"total_size\" : xxxxx,      (numeric) Total size of all non-coinbase transactions\n"
+            "  \"totalfee\" : xxxxx,        (numeric) The fee total\n"
+            "  \"txs\" : xxxxx,             (numeric) The number of transactions (excluding coinbase)\n"
+            "  \"utxo_increase\" : xxxxx,   (numeric) The increase/decrease in the number of unspent outputs\n"
+            "  \"utxo_size_inc\" : xxxxx,   (numeric) The increase/decrease in size for the utxo index (not discounting op_return and similar)\n"
             "}\n"
                 },
                 RPCExamples{
@@ -2503,21 +2503,21 @@ UniValue scantxoutset(const JSONRPCRequest& request)
                 },
                 RPCResult{
             "{\n"
-            "  \"success\": true|false,         (boolean) Whether the scan was completed\n"
-            "  \"txouts\": n,                   (numeric) The number of unspent transaction outputs scanned\n"
-            "  \"height\": n,                   (numeric) The current block height (index)\n"
-            "  \"bestblock\": \"hex\",            (string) The hash of the block at the tip of the chain\n"
-            "  \"unspents\": [\n"
+            "  \"success\" : true|false,         (boolean) Whether the scan was completed\n"
+            "  \"txouts\" : n,                   (numeric) The number of unspent transaction outputs scanned\n"
+            "  \"height\" : n,                   (numeric) The current block height (index)\n"
+            "  \"bestblock\" : \"hex\",            (string) The hash of the block at the tip of the chain\n"
+            "  \"unspents\" : [\n"
             "   {\n"
-            "    \"txid\": \"hash\",              (string) The transaction id\n"
-            "    \"vout\": n,                   (numeric) The vout value\n"
-            "    \"scriptPubKey\": \"script\",    (string) The script key\n"
-            "    \"desc\": \"descriptor\",        (string) A specialized descriptor for the matched scriptPubKey\n"
-            "    \"amount\": x.xxx,             (numeric) The total amount in " + CURRENCY_UNIT + " of the unspent output\n"
-            "    \"height\": n,                 (numeric) Height of the unspent transaction output\n"
+            "    \"txid\" : \"hash\",              (string) The transaction id\n"
+            "    \"vout\" : n,                   (numeric) The vout value\n"
+            "    \"scriptPubKey\" : \"script\",    (string) The script key\n"
+            "    \"desc\" : \"descriptor\",        (string) A specialized descriptor for the matched scriptPubKey\n"
+            "    \"amount\" : x.xxx,             (numeric) The total amount in " + CURRENCY_UNIT + " of the unspent output\n"
+            "    \"height\" : n,                 (numeric) Height of the unspent transaction output\n"
             "   }\n"
             "   ,...],\n"
-            "  \"total_amount\": x.xxx,          (numeric) The total amount of all found unspent outputs in " + CURRENCY_UNIT + "\n"
+            "  \"total_amount\" : x.xxx,          (numeric) The total amount of all found unspent outputs in " + CURRENCY_UNIT + "\n"
             "]\n"
                 },
                 RPCExamples{""},
diff --git a/src/rpc/coinjoin.cpp b/src/rpc/coinjoin.cpp
index 58c0115937..306d7da448 100644
--- a/src/rpc/coinjoin.cpp
+++ b/src/rpc/coinjoin.cpp
@@ -103,36 +103,36 @@ static UniValue getcoinjoininfo(const JSONRPCRequest& request)
                 RPCResults{
                     {"for regular nodes",
             "{\n"
-            "  \"enabled\": true|false,             (bool) Whether mixing functionality is enabled\n"
-            "  \"multisession\": true|false,        (bool) Whether CoinJoin Multisession option is enabled\n"
-            "  \"max_sessions\": xxx,               (numeric) How many parallel mixing sessions can there be at once\n"
-            "  \"max_rounds\": xxx,                 (numeric) How many rounds to mix\n"
-            "  \"max_amount\": xxx,                 (numeric) Target CoinJoin balance in " + CURRENCY_UNIT + "\n"
-            "  \"denoms_goal\": xxx,                (numeric) How many inputs of each denominated amount to target\n"
-            "  \"denoms_hardcap\": xxx,             (numeric) Maximum limit of how many inputs of each denominated amount to create\n"
-            "  \"queue_size\": xxx,                 (numeric) How many queues there are currently on the network\n"
-            "  \"running\": true|false,             (bool) Whether mixing is currently running\n"
-            "  \"sessions\":                        (array of json objects)\n"
+            "  \"enabled\" : true|false,             (boolean) Whether mixing functionality is enabled\n"
+            "  \"multisession\" : true|false,        (boolean) Whether CoinJoin Multisession option is enabled\n"
+            "  \"max_sessions\" : xxx,               (numeric) How many parallel mixing sessions can there be at once\n"
+            "  \"max_rounds\" : xxx,                 (numeric) How many rounds to mix\n"
+            "  \"max_amount\" : xxx,                 (numeric) Target CoinJoin balance in " + CURRENCY_UNIT + "\n"
+            "  \"denoms_goal\" : xxx,                (numeric) How many inputs of each denominated amount to target\n"
+            "  \"denoms_hardcap\" : xxx,             (numeric) Maximum limit of how many inputs of each denominated amount to create\n"
+            "  \"queue_size\" : xxx,                 (numeric) How many queues there are currently on the network\n"
+            "  \"running\" : true|false,             (boolean) Whether mixing is currently running\n"
+            "  \"sessions\" :                        (array of json objects)\n"
             "    [\n"
             "      {\n"
-            "      \"protxhash\": \"...\",            (string) The ProTxHash of the masternode\n"
-            "      \"outpoint\": \"txid-index\",      (string) The outpoint of the masternode\n"
-            "      \"service\": \"host:port\",        (string) The IP address and port of the masternode\n"
-            "      \"denomination\": xxx,           (numeric) The denomination of the mixing session in " + CURRENCY_UNIT + "\n"
-            "      \"state\": \"...\",                (string) Current state of the mixing session\n"
-            "      \"entries_count\": xxx,          (numeric) The number of entries in the mixing session\n"
+            "      \"protxhash\" : \"...\",            (string) The ProTxHash of the masternode\n"
+            "      \"outpoint\" : \"txid-index\",      (string) The outpoint of the masternode\n"
+            "      \"service\" : \"host:port\",        (string) The IP address and port of the masternode\n"
+            "      \"denomination\" : xxx,           (numeric) The denomination of the mixing session in " + CURRENCY_UNIT + "\n"
+            "      \"state\" : \"...\",                (string) Current state of the mixing session\n"
+            "      \"entries_count\" : xxx,          (numeric) The number of entries in the mixing session\n"
             "      }\n"
             "      ,...\n"
             "    ],\n"
-            "  \"keys_left\": xxx,                  (numeric) How many new keys are left since last automatic backup\n"
-            "  \"warnings\": \"...\"                  (string) Warnings if any\n"
+            "  \"keys_left\" : xxx,                  (numeric) How many new keys are left since last automatic backup\n"
+            "  \"warnings\" : \"...\"                  (string) Warnings if any\n"
             "}\n"
                     }, {"for masternodes",
             "{\n"
-            "  \"queue_size\": xxx,                 (numeric) How many queues there are currently on the network\n"
-            "  \"denomination\": xxx,               (numeric) The denomination of the mixing session in " + CURRENCY_UNIT + "\n"
-            "  \"state\": \"...\",                    (string) Current state of the mixing session\n"
-            "  \"entries_count\": xxx,              (numeric) The number of entries in the mixing session\n"
+            "  \"queue_size\" : xxx,                 (numeric) How many queues there are currently on the network\n"
+            "  \"denomination\" : xxx,               (numeric) The denomination of the mixing session in " + CURRENCY_UNIT + "\n"
+            "  \"state\" : \"...\",                    (string) Current state of the mixing session\n"
+            "  \"entries_count\" : xxx,              (numeric) The number of entries in the mixing session\n"
             "}\n"
                 }},
                 RPCExamples{
diff --git a/src/rpc/governance.cpp b/src/rpc/governance.cpp
index f3d88f331e..4c8912f7f2 100644
--- a/src/rpc/governance.cpp
+++ b/src/rpc/governance.cpp
@@ -1167,11 +1167,11 @@ static UniValue getgovernanceinfo(const JSONRPCRequest& request)
                 {},
                 RPCResult{
             "{\n"
-            "  \"governanceminquorum\": xxxxx,           (numeric) the absolute minimum number of votes needed to trigger a governance action\n"
-            "  \"proposalfee\": xxx.xx,                  (numeric) the collateral transaction fee which must be paid to create a proposal in " + CURRENCY_UNIT + "\n"
-            "  \"superblockcycle\": xxxxx,               (numeric) the number of blocks between superblocks\n"
-            "  \"lastsuperblock\": xxxxx,                (numeric) the block number of the last superblock\n"
-            "  \"nextsuperblock\": xxxxx,                (numeric) the block number of the next superblock\n"
+            "  \"governanceminquorum\" : xxxxx,           (numeric) the absolute minimum number of votes needed to trigger a governance action\n"
+            "  \"proposalfee\" : xxx.xx,                  (numeric) the collateral transaction fee which must be paid to create a proposal in " + CURRENCY_UNIT + "\n"
+            "  \"superblockcycle\" : xxxxx,               (numeric) the number of blocks between superblocks\n"
+            "  \"lastsuperblock\" : xxxxx,                (numeric) the block number of the last superblock\n"
+            "  \"nextsuperblock\" : xxxxx,                (numeric) the block number of the next superblock\n"
             "}\n"
                 },
                 RPCExamples{
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index b615a529c3..60b888d3a4 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -376,20 +376,20 @@ static void masternode_payments_help(const JSONRPCRequest& request)
             {"count", RPCArg::Type::NUM, /* default */ "1", "The number of blocks to return. Will return <count> previous blocks if <count> is negative. Both 1 and -1 correspond to the chain tip."},
         },
         RPCResult {
-    "  [                                  (array) Blocks\n"
+    "  [                                  (json array) Blocks\n"
     "    {\n"
     "       \"height\" : n,                 (numeric) The height of the block\n"
     "       \"blockhash\" : \"hash\",         (string) The hash of the block\n"
-    "       \"amount\": n                   (numeric) Amount received in this block by all masternodes\n"
-    "       \"masternodes\": [              (array) Masternodes that received payments in this block\n"
+    "       \"amount\" : n                   (numeric) Amount received in this block by all masternodes\n"
+    "       \"masternodes\" : [              (json array) Masternodes that received payments in this block\n"
     "          {\n"
-    "             \"proTxHash\": \"xxxx\",    (string) The hash of the corresponding ProRegTx\n"
-    "             \"amount\": n             (numeric) Amount received by this masternode\n"
-    "             \"payees\": [             (array) Payees who received a share of this payment\n"
+    "             \"proTxHash\" : \"xxxx\",    (string) The hash of the corresponding ProRegTx\n"
+    "             \"amount\" : n             (numeric) Amount received by this masternode\n"
+    "             \"payees\" : [             (json array) Payees who received a share of this payment\n"
     "                {\n"
     "                  \"address\" : \"xxx\", (string) Payee address\n"
     "                  \"script\" : \"xxx\",  (string) Payee scriptPubKey\n"
-    "                  \"amount\": n        (numeric) Amount received by this payee\n"
+    "                  \"amount\" : n        (numeric) Amount received by this payee\n"
     "                },...\n"
     "             ]\n"
     "          },...\n"
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 0918a53db4..4a4250667e 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -166,7 +166,7 @@ static UniValue generatetoaddress(const JSONRPCRequest& request)
                     {"maxtries", RPCArg::Type::NUM, /* default */ "1000000", "How many iterations to try."},
                 },
                 RPCResult{
-            "[ blockhashes ]     (array) hashes of blocks generated\n"
+            "[ blockhashes ]     (json array) hashes of blocks generated\n"
                 },
                 RPCExamples{
             "\nGenerate 11 blocks to myaddress\n"
@@ -206,14 +206,14 @@ static UniValue getmininginfo(const JSONRPCRequest& request)
                 {},
                 RPCResult{
                     "{\n"
-                    "  \"blocks\": nnn,             (numeric) The current block\n"
-                    "  \"currentblocksize\": nnn,   (numeric, optional) The block size of the last assembled block (only present if a block was ever assembled)\n"
-                    "  \"currentblocktx\": nnn,     (numeric, optional) The number of block transactions of the last assembled block (only present if a block was ever assembled)\n"
-                    "  \"difficulty\": xxx.xxxxx    (numeric) The current difficulty\n"
-                    "  \"networkhashps\": nnn,      (numeric) The network hashes per second\n"
-                    "  \"pooledtx\": n              (numeric) The size of the mempool\n"
-                    "  \"chain\": \"xxxx\",           (string) current network name as defined in BIP70 (main, test, regtest)\n"
-                    "  \"warnings\": \"...\"          (string) any network and blockchain warnings\n"
+                    "  \"blocks\" : nnn,             (numeric) The current block\n"
+                    "  \"currentblocksize\" : nnn,   (numeric, optional) The block size of the last assembled block (only present if a block was ever assembled)\n"
+                    "  \"currentblocktx\" : nnn,     (numeric, optional) The number of block transactions of the last assembled block (only present if a block was ever assembled)\n"
+                    "  \"difficulty\" : xxx.xxxxx    (numeric) The current difficulty\n"
+                    "  \"networkhashps\" : nnn,      (numeric) The network hashes per second\n"
+                    "  \"pooledtx\" : n              (numeric) The size of the mempool\n"
+                    "  \"chain\" : \"xxxx\",           (string) current network name as defined in BIP70 (main, test, regtest)\n"
+                    "  \"warnings\" : \"...\"          (string) any network and blockchain warnings\n"
                     "}\n"
                 },
                 RPCExamples{
@@ -338,15 +338,15 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
             "  },\n"
             "  \"vbrequired\" : n,                 (numeric) bit mask of versionbits the server requires set in submissions\n"
             "  \"previousblockhash\" : \"xxxx\",     (string) The hash of current highest block\n"
-            "  \"transactions\" : [                (array) contents of non-coinbase transactions that should be included in the next block\n"
+            "  \"transactions\" : [                (json array) contents of non-coinbase transactions that should be included in the next block\n"
             "      {\n"
             "         \"data\" : \"xxxx\",             (string) transaction data encoded in hexadecimal (byte-for-byte)\n"
             "         \"hash\" : \"xxxx\",             (string) hash/id encoded in little-endian hexadecimal\n"
-            "         \"depends\" : [                (array) array of numbers \n"
+            "         \"depends\" : [                (json array) array of numbers \n"
             "             n                          (numeric) transactions before this one (by 1-based index in 'transactions' list) that must be present in the final block if this one is\n"
             "             ,...\n"
             "         ],\n"
-            "         \"fee\": n,                    (numeric) difference in value between transaction inputs and outputs (in duffs); for coinbase transactions, this is a negative Number of the total collected block fees (ie, not including the block subsidy); if key is not present, fee is unknown and clients MUST NOT assume there isn't one\n"
+            "         \"fee\" : n,                    (numeric) difference in value between transaction inputs and outputs (in duffs); for coinbase transactions, this is a negative Number of the total collected block fees (ie, not including the block subsidy); if key is not present, fee is unknown and clients MUST NOT assume there isn't one\n"
             "         \"sigops\" : n,                (numeric) total number of SigOps, as counted for purposes of block limits; if key is not present, sigop count is unknown and clients MUST NOT assume there aren't any\n"
             "      }\n"
             "      ,...\n"
@@ -367,20 +367,20 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
             "  \"bits\" : \"xxxxxxxx\",              (string) compressed target of next block\n"
             "  \"previousbits\" : \"xxxxxxxx\",      (string) compressed target of current highest block\n"
             "  \"height\" : n                      (numeric) The height of the next block\n"
-            "  \"masternode\" : [                  (array) required masternode payments that must be included in the next block\n"
+            "  \"masternode\" : [                  (json array) required masternode payments that must be included in the next block\n"
             "      {\n"
             "         \"payee\" : \"xxxx\",          (string) payee address\n"
             "         \"script\" : \"xxxx\",         (string) payee scriptPubKey\n"
-            "         \"amount\": n                (numeric) required amount to pay\n"
+            "         \"amount\" : n                (numeric) required amount to pay\n"
             "      }\n"
             "  },\n"
             "  \"masternode_payments_started\" :  true|false, (boolean) true, if masternode payments started\n"
             "  \"masternode_payments_enforced\" : true|false, (boolean) true, if masternode payments are enforced\n"
-            "  \"superblock\" : [                  (array) required superblock payees that must be included in the next block\n"
+            "  \"superblock\" : [                  (json array) required superblock payees that must be included in the next block\n"
             "      {\n"
             "         \"payee\" : \"xxxx\",          (string) payee address\n"
             "         \"script\" : \"xxxx\",         (string) payee scriptPubKey\n"
-            "         \"amount\": n                (numeric) required amount to pay\n"
+            "         \"amount\" : n                (numeric) required amount to pay\n"
             "      }\n"
             "      ,...\n"
             "  ],\n"
@@ -850,7 +850,7 @@ static UniValue estimatesmartfee(const JSONRPCRequest& request)
                 RPCResult{
             "{\n"
             "  \"feerate\" : x.x,     (numeric, optional) estimate fee rate in " + CURRENCY_UNIT + "/kB\n"
-            "  \"errors\": [ str... ] (json array of strings, optional) Errors encountered during processing\n"
+            "  \"errors\" : [ str... ] (json array of strings, optional) Errors encountered during processing\n"
             "  \"blocks\" : n         (numeric) block number where estimate was found\n"
             "}\n"
             "\n"
@@ -923,7 +923,7 @@ static UniValue estimaterawfee(const JSONRPCRequest& request)
             "          \"leftmempool\" : x.x,    (numeric) number of txs over history horizon in the feerate range that left mempool unconfirmed after target\n"
             "      },\n"
             "      \"fail\" : { ... },       (json object, optional) information about the highest range of feerates to fail to meet the threshold\n"
-            "      \"errors\":  [ str... ]   (json array of strings, optional) Errors encountered during processing\n"
+            "      \"errors\" :  [ str... ]   (json array of strings, optional) Errors encountered during processing\n"
             "  },\n"
             "  \"medium\" : { ... },    (json object, optional) estimate for medium time horizon\n"
             "  \"long\" : { ... }       (json object) estimate for long time horizon\n"
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 2bfdc62c05..f886481c9a 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -255,8 +255,8 @@ static UniValue createmultisig(const JSONRPCRequest& request)
                 },
                 RPCResult{
             "{\n"
-            "  \"address\":\"multisigaddress\",  (string) The value of the new multisig address.\n"
-            "  \"redeemScript\":\"script\"       (string) The string value of the hex-encoded redemption script.\n"
+            "  \"address\" : \"multisigaddress\",  (string) The value of the new multisig address.\n"
+            "  \"redeemScript\" : \"script\"       (string) The string value of the hex-encoded redemption script.\n"
             "}\n"
                 },
                 RPCExamples{
@@ -354,7 +354,7 @@ UniValue deriveaddresses(const JSONRPCRequest& request)
                     {"range", RPCArg::Type::RANGE, RPCArg::Optional::OMITTED_NAMED_ARG, "If a ranged descriptor is used, this specifies the end or the range (in [begin,end] notation) to derive."},
                 },
                 RPCResult{
-            "\"address\"        (array) A json array of the derived addresses\n"
+            "\"address\"        (json array) A json array of the derived addresses\n"
             "     [\n"
             "       ...\n"
             "     ]\n"
@@ -900,10 +900,10 @@ static UniValue getaddressbalance(const JSONRPCRequest& request)
                 },
                 RPCResult{
             "{\n"
-            "  \"balance\": xxxxx,              (numeric) The current total balance in duffs\n"
-            "  \"balance_immature\": xxxxx,     (numeric) The current immature balance in duffs\n"
-            "  \"balance_spendable\": xxxxx,    (numeric) The current spendable balance in duffs\n"
-            "  \"received\": xxxxx              (numeric) The total number of duffs received (including change)\n"
+            "  \"balance\" : xxxxx,              (numeric) The current total balance in duffs\n"
+            "  \"balance_immature\" : xxxxx,     (numeric) The current immature balance in duffs\n"
+            "  \"balance_spendable\" : xxxxx,    (numeric) The current spendable balance in duffs\n"
+            "  \"received\" : xxxxx              (numeric) The total number of duffs received (including change)\n"
             "}\n"
                 },
                 RPCExamples{
@@ -1138,13 +1138,13 @@ static UniValue getmemoryinfo(const JSONRPCRequest& request)
                 {
                     RPCResult{"mode \"stats\"",
             "{\n"
-            "  \"locked\": {               (json object) Information about locked memory manager\n"
-            "    \"used\": xxxxx,          (numeric) Number of bytes used\n"
-            "    \"free\": xxxxx,          (numeric) Number of bytes available in current arenas\n"
-            "    \"total\": xxxxxxx,       (numeric) Total number of bytes managed\n"
-            "    \"locked\": xxxxxx,       (numeric) Amount of bytes that succeeded locking. If this number is smaller than total, locking pages failed at some point and key data could be swapped to disk.\n"
-            "    \"chunks_used\": xxxxx,   (numeric) Number allocated chunks\n"
-            "    \"chunks_free\": xxxxx,   (numeric) Number unused chunks\n"
+            "  \"locked\" : {               (json object) Information about locked memory manager\n"
+            "    \"used\" : xxxxx,          (numeric) Number of bytes used\n"
+            "    \"free\" : xxxxx,          (numeric) Number of bytes available in current arenas\n"
+            "    \"total\" : xxxxxxx,       (numeric) Total number of bytes managed\n"
+            "    \"locked\" : xxxxxx,       (numeric) Amount of bytes that succeeded locking. If this number is smaller than total, locking pages failed at some point and key data could be swapped to disk.\n"
+            "    \"chunks_used\" : xxxxx,   (numeric) Number allocated chunks\n"
+            "    \"chunks_free\" : xxxxx,   (numeric) Number unused chunks\n"
             "  }\n"
             "}\n"
                     },
@@ -1221,7 +1221,7 @@ static UniValue logging(const JSONRPCRequest& request)
                 },
                 RPCResult{
             "{                   (json object where keys are the logging categories, and values indicates its status\n"
-            "  \"category\": true|false,  (bool) if being debug logged or not. false:inactive, true:active\n"
+            "  \"category\" : true|false,  (boolean) if being debug logged or not. false:inactive, true:active\n"
             "  ...\n"
             "}\n"
                 },
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index 5a86c29dd5..d4a7e8db3a 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -84,54 +84,54 @@ static UniValue getpeerinfo(const JSONRPCRequest& request)
                 RPCResult{
             "[\n"
             "  {\n"
-            "    \"id\": n,                   (numeric) Peer index\n"
-            "    \"addr\":\"host:port\",      (string) The IP address and port of the peer\n"
-            "    \"addrbind\":\"ip:port\",    (string) Bind address of the connection to the peer\n"
-            "    \"addrlocal\":\"ip:port\",   (string) Local address as reported by the peer\n"
-            "    \"mapped_as\":\"mapped_as\", (string) The AS in the BGP route to the peer used for diversifying peer selection\n"
-            "    \"services\":\"xxxxxxxxxxxxxxxx\",   (string) The services offered\n"
-            "    \"verified_proregtx_hash\": h, (hex) Only present when the peer is a masternode and successfully\n"
+            "    \"id\" : n,                   (numeric) Peer index\n"
+            "    \"addr\" : \"host:port\",      (string) The IP address and port of the peer\n"
+            "    \"addrbind\" : \"ip:port\",    (string) Bind address of the connection to the peer\n"
+            "    \"addrlocal\" : \"ip:port\",   (string) Local address as reported by the peer\n"
+            "    \"mapped_as\" : \"mapped_as\", (string) The AS in the BGP route to the peer used for diversifying peer selection\n"
+            "    \"services\" : \"xxxxxxxxxxxxxxxx\",   (string) The services offered\n"
+            "    \"verified_proregtx_hash\" : h, (hex) Only present when the peer is a masternode and successfully\n"
             "                               authenticated via MNAUTH. In this case, this field contains the\n"
             "                               protx hash of the masternode\n"
-            "    \"verified_pubkey_hash\":   h, (hex) Only present when the peer is a masternode and successfully\n"
+            "    \"verified_pubkey_hash\" :   h, (hex) Only present when the peer is a masternode and successfully\n"
             "                               authenticated via MNAUTH. In this case, this field contains the\n"
             "                               hash of the masternode's operator public key\n"
-            "    \"servicesnames\":[              (array) the services offered, in human-readable form\n"
+            "    \"servicesnames\" : [              (json array) the services offered, in human-readable form\n"
             "        \"SERVICE_NAME\",         (string) the service name if it is recognised\n"
             "         ...\n"
             "     ],\n"
-            "    \"relaytxes\":true|false,    (boolean) Whether peer has asked us to relay transactions to it\n"
-            "    \"lastsend\": ttt,           (numeric) The time in seconds since epoch (Jan 1 1970 GMT) of the last send\n"
-            "    \"lastrecv\": ttt,           (numeric) The time in seconds since epoch (Jan 1 1970 GMT) of the last receive\n"
-            "    \"bytessent\": n,            (numeric) The total bytes sent\n"
-            "    \"bytesrecv\": n,            (numeric) The total bytes received\n"
-            "    \"conntime\": ttt,           (numeric) The connection time in seconds since epoch (Jan 1 1970 GMT)\n"
-            "    \"timeoffset\": ttt,         (numeric) The time offset in seconds\n"
-            "    \"pingtime\": n,             (numeric) ping time (if available)\n"
-            "    \"minping\": n,              (numeric) minimum observed ping time (if any at all)\n"
-            "    \"pingwait\": n,             (numeric) ping wait (if non-zero)\n"
-            "    \"version\": v,              (numeric) The peer version, such as 70001\n"
-            "    \"subver\": \"/Dash Core:x.x.x/\",  (string) The string version\n"
-            "    \"inbound\": true|false,     (boolean) Inbound (true) or Outbound (false)\n"
-            "    \"addnode\": true|false,     (boolean) Whether connection was due to addnode/-connect or if it was an automatic/inbound connection\n"
-            "    \"masternode\": true|false,  (boolean) Whether connection was due to masternode connection attempt\n"
-            "    \"startingheight\": n,       (numeric) The starting height (block) of the peer\n"
-            "    \"banscore\": n,             (numeric) The ban score\n"
-            "    \"synced_headers\": n,       (numeric) The last header we have in common with this peer\n"
-            "    \"synced_blocks\": n,        (numeric) The last block we have in common with this peer\n"
-            "    \"inflight\": [\n"
+            "    \"relaytxes\" : true|false,    (boolean) Whether peer has asked us to relay transactions to it\n"
+            "    \"lastsend\" : ttt,           (numeric) The time in seconds since epoch (Jan 1 1970 GMT) of the last send\n"
+            "    \"lastrecv\" : ttt,           (numeric) The time in seconds since epoch (Jan 1 1970 GMT) of the last receive\n"
+            "    \"bytessent\" : n,            (numeric) The total bytes sent\n"
+            "    \"bytesrecv\" : n,            (numeric) The total bytes received\n"
+            "    \"conntime\" : ttt,           (numeric) The connection time in seconds since epoch (Jan 1 1970 GMT)\n"
+            "    \"timeoffset\" : ttt,         (numeric) The time offset in seconds\n"
+            "    \"pingtime\" : n,             (numeric) ping time (if available)\n"
+            "    \"minping\" : n,              (numeric) minimum observed ping time (if any at all)\n"
+            "    \"pingwait\" : n,             (numeric) ping wait (if non-zero)\n"
+            "    \"version\" : v,              (numeric) The peer version, such as 70001\n"
+            "    \"subver\" : \"/Dash Core:x.x.x/\",  (string) The string version\n"
+            "    \"inbound\" : true|false,     (boolean) Inbound (true) or Outbound (false)\n"
+            "    \"addnode\" : true|false,     (boolean) Whether connection was due to addnode/-connect or if it was an automatic/inbound connection\n"
+            "    \"masternode\" : true|false,  (boolean) Whether connection was due to masternode connection attempt\n"
+            "    \"startingheight\" : n,       (numeric) The starting height (block) of the peer\n"
+            "    \"banscore\" : n,             (numeric) The ban score\n"
+            "    \"synced_headers\" : n,       (numeric) The last header we have in common with this peer\n"
+            "    \"synced_blocks\" : n,        (numeric) The last block we have in common with this peer\n"
+            "    \"inflight\" : [\n"
             "       n,                        (numeric) The heights of blocks we're currently asking from this peer\n"
             "       ...\n"
             "    ],\n"
-            "    \"whitelisted\": true|false, (boolean) Whether the peer is whitelisted\n"
-            "    \"bytessent_per_msg\": {\n"
-            "       \"msg\": n,               (numeric) The total bytes sent aggregated by message type\n"
+            "    \"whitelisted\" : true|false, (boolean) Whether the peer is whitelisted\n"
+            "    \"bytessent_per_msg\" : {\n"
+            "       \"msg\" : n,               (numeric) The total bytes sent aggregated by message type\n"
             "                               When a message type is not listed in this json object, the bytes sent are 0.\n"
             "                               Only known message types can appear as keys in the object.\n"
             "       ...\n"
             "    },\n"
-            "    \"bytesrecv_per_msg\": {\n"
-            "       \"msg\": n,               (numeric) The total bytes received aggregated by message type\n"
+            "    \"bytesrecv_per_msg\" : {\n"
+            "       \"msg\" : n,               (numeric) The total bytes received aggregated by message type\n"
             "                               When a message type is not listed in this json object, the bytes received are 0.\n"
             "                               Only known message types can appear as keys in the object and all bytes received of unknown message types are listed under '"+NET_MESSAGE_COMMAND_OTHER+"'.\n"
             "       ...\n"
@@ -414,17 +414,17 @@ static UniValue getnettotals(const JSONRPCRequest& request)
                 {},
                 RPCResult{
             "{\n"
-            "  \"totalbytesrecv\": n,   (numeric) Total bytes received\n"
-            "  \"totalbytessent\": n,   (numeric) Total bytes sent\n"
-            "  \"timemillis\": t,       (numeric) Current UNIX time in milliseconds\n"
-            "  \"uploadtarget\":\n"
+            "  \"totalbytesrecv\" : n,   (numeric) Total bytes received\n"
+            "  \"totalbytessent\" : n,   (numeric) Total bytes sent\n"
+            "  \"timemillis\" : t,       (numeric) Current UNIX time in milliseconds\n"
+            "  \"uploadtarget\" : \n"
             "  {\n"
-            "    \"timeframe\": n,                         (numeric) Length of the measuring timeframe in seconds\n"
-            "    \"target\": n,                            (numeric) Target in bytes\n"
-            "    \"target_reached\": true|false,           (boolean) True if target is reached\n"
-            "    \"serve_historical_blocks\": true|false,  (boolean) True if serving historical blocks\n"
-            "    \"bytes_left_in_cycle\": t,               (numeric) Bytes left in current time cycle\n"
-            "    \"time_left_in_cycle\": t                 (numeric) Seconds left in current time cycle\n"
+            "    \"timeframe\" : n,                         (numeric) Length of the measuring timeframe in seconds\n"
+            "    \"target\" : n,                            (numeric) Target in bytes\n"
+            "    \"target_reached\" : true|false,           (boolean) True if target is reached\n"
+            "    \"serve_historical_blocks\" : true|false,  (boolean) True if serving historical blocks\n"
+            "    \"bytes_left_in_cycle\" : t,               (numeric) Bytes left in current time cycle\n"
+            "    \"time_left_in_cycle\" : t                 (numeric) Seconds left in current time cycle\n"
             "  }\n"
             "}\n"
                 },
@@ -482,41 +482,41 @@ static UniValue getnetworkinfo(const JSONRPCRequest& request)
                 {},
                 RPCResult{
             "{\n"
-            "  \"version\": xxxxx,                      (numeric) the server version\n"
-            "  \"buildversion\": \"x.x.x.x-xxx\",         (string) the server build version including RC info or commit as relevant\n"
-            "  \"subversion\": \"/Dash Core:x.x.x.x/\",   (string) the server subversion string\n"
-            "  \"protocolversion\": xxxxx,              (numeric) the protocol version\n"
-            "  \"localservices\": \"xxxxxxxxxxxxxxxx\", (string) the services we offer to the network\n"
-            "  \"localservicesnames\": [                (array) the services we offer to the network, in human-readable form\n"
+            "  \"version\" : xxxxx,                      (numeric) the server version\n"
+            "  \"buildversion\" : \"x.x.x.x-xxx\",         (string) the server build version including RC info or commit as relevant\n"
+            "  \"subversion\" : \"/Dash Core:x.x.x.x/\",   (string) the server subversion string\n"
+            "  \"protocolversion\" : xxxxx,              (numeric) the protocol version\n"
+            "  \"localservices\" : \"xxxxxxxxxxxxxxxx\", (string) the services we offer to the network\n"
+            "  \"localservicesnames\" : [                (json array) the services we offer to the network, in human-readable form\n"
             "      \"SERVICE_NAME\",                    (string) the service name\n"
             "       ...\n"
             "   ],\n"
-            "  \"localrelay\": true|false,              (bool) true if transaction relay is requested from peers\n"
-            "  \"timeoffset\": xxxxx,                   (numeric) the time offset\n"
-            "  \"connections\": xxxxx,                  (numeric) the number of connections\n"
-            "  \"networkactive\": true|false,           (bool) whether p2p networking is enabled\n"
-            "  \"socketevents\": \"xxx/\",              (string) the socket events mode, either kqueue, epoll, poll or select\n"
-            "  \"networks\": [                          (array) information per network\n"
+            "  \"localrelay\" : true|false,              (boolean) true if transaction relay is requested from peers\n"
+            "  \"timeoffset\" : xxxxx,                   (numeric) the time offset\n"
+            "  \"connections\" : xxxxx,                  (numeric) the number of connections\n"
+            "  \"networkactive\" : true|false,           (boolean) whether p2p networking is enabled\n"
+            "  \"socketevents\" : \"xxx/\",              (string) the socket events mode, either kqueue, epoll, poll or select\n"
+            "  \"networks\" : [                          (json array) information per network\n"
             "  {\n"
-            "    \"name\": \"xxx\",                     (string) network (ipv4, ipv6 or onion)\n"
-            "    \"limited\": true|false,               (boolean) is the network limited using -onlynet?\n"
-            "    \"reachable\": true|false,             (boolean) is the network reachable?\n"
-            "    \"proxy\": \"host:port\"               (string) the proxy that is used for this network, or empty if none\n"
-            "    \"proxy_randomize_credentials\": true|false,  (string) Whether randomized credentials are used\n"
+            "    \"name\" : \"xxx\",                     (string) network (ipv4, ipv6 or onion)\n"
+            "    \"limited\" : true|false,               (boolean) is the network limited using -onlynet?\n"
+            "    \"reachable\" : true|false,             (boolean) is the network reachable?\n"
+            "    \"proxy\" : \"host:port\"               (string) the proxy that is used for this network, or empty if none\n"
+            "    \"proxy_randomize_credentials\" : true|false,  (string) Whether randomized credentials are used\n"
             "  }\n"
             "  ,...\n"
             "  ],\n"
-            "  \"relayfee\": x.xxxxxxxx,                (numeric) minimum relay fee for transactions in " + CURRENCY_UNIT + "/kB\n"
-            "  \"incrementalfee\": x.xxxxxxxx,          (numeric) minimum fee increment for mempool limiting in " + CURRENCY_UNIT + "/kB\n"
-            "  \"localaddresses\": [                    (array) list of local addresses\n"
+            "  \"relayfee\" : x.xxxxxxxx,                (numeric) minimum relay fee for transactions in " + CURRENCY_UNIT + "/kB\n"
+            "  \"incrementalfee\" : x.xxxxxxxx,          (numeric) minimum fee increment for mempool limiting in " + CURRENCY_UNIT + "/kB\n"
+            "  \"localaddresses\" : [                    (json array) list of local addresses\n"
             "  {\n"
-            "    \"address\": \"xxxx\",                 (string) network address\n"
-            "    \"port\": xxx,                         (numeric) network port\n"
-            "    \"score\": xxx                         (numeric) relative score\n"
+            "    \"address\" : \"xxxx\",                 (string) network address\n"
+            "    \"port\" : xxx,                         (numeric) network port\n"
+            "    \"score\" : xxx                         (numeric) relative score\n"
             "  }\n"
             "  ,...\n"
             "  ]\n"
-            "  \"warnings\": \"...\"                    (string) any network and blockchain warnings\n"
+            "  \"warnings\" : \"...\"                    (string) any network and blockchain warnings\n"
             "}\n"
                 },
                 RPCExamples{
@@ -755,10 +755,10 @@ static UniValue getnodeaddresses(const JSONRPCRequest& request)
                 RPCResult{
             "[\n"
             "  {\n"
-            "    \"time\": ttt,                (numeric) Timestamp in seconds since epoch (Jan 1 1970 GMT) keeping track of when the node was last seen\n"
-            "    \"services\": n,              (numeric) The services offered\n"
-            "    \"address\": \"host\",          (string) The address of the node\n"
-            "    \"port\": n                   (numeric) The port of the node\n"
+            "    \"time\" : ttt,                (numeric) Timestamp in seconds since epoch (Jan 1 1970 GMT) keeping track of when the node was last seen\n"
+            "    \"services\" : n,              (numeric) The services offered\n"
+            "    \"address\" : \"host\",          (string) The address of the node\n"
+            "    \"port\" : n                   (numeric) The port of the node\n"
             "  }\n"
             "  ,....\n"
             "]\n"
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 09860cf7c4..0dc71f5c10 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -137,20 +137,20 @@ static UniValue getrawtransaction(const JSONRPCRequest& request)
                      },
                      RPCResult{"if verbose is set to true",
             "{\n"
-            "  \"in_active_chain\": b, (bool) Whether specified block is in the active chain or not (only present with explicit \"blockhash\" argument)\n"
+            "  \"in_active_chain\" : b, (boolean) Whether specified block is in the active chain or not (only present with explicit \"blockhash\" argument)\n"
             "  \"txid\" : \"id\",        (string) The transaction id (same as provided)\n"
             "  \"size\" : n,             (numeric) The transaction size\n"
             "  \"version\" : n,          (numeric) The version\n"
             "  \"locktime\" : ttt,       (numeric) The lock time\n"
             "  \"vin\" : [               (array of json objects)\n"
             "     {\n"
-            "       \"txid\": \"id\",    (string) The transaction id\n"
-            "       \"vout\": n,         (numeric) \n"
-            "       \"scriptSig\": {     (json object) The script\n"
-            "         \"asm\": \"asm\",  (string) asm\n"
-            "         \"hex\": \"hex\"   (string) hex\n"
+            "       \"txid\" : \"id\",    (string) The transaction id\n"
+            "       \"vout\" : n,         (numeric) \n"
+            "       \"scriptSig\" : {     (json object) The script\n"
+            "         \"asm\" : \"asm\",  (string) asm\n"
+            "         \"hex\" : \"hex\"   (string) hex\n"
             "       },\n"
-            "       \"sequence\": n      (numeric) The script sequence number\n"
+            "       \"sequence\" : n      (numeric) The script sequence number\n"
             "     }\n"
             "     ,...\n"
             "  ],\n"
@@ -179,9 +179,9 @@ static UniValue getrawtransaction(const JSONRPCRequest& request)
             "  \"confirmations\" : n,      (numeric) The confirmations\n"
             "  \"blocktime\" : ttt         (numeric) The block time in seconds since epoch (Jan 1 1970 GMT)\n"
             "  \"time\" : ttt,             (numeric) Same as \"blocktime\"\n"
-            "  \"instantlock\" : true|false, (bool) Current transaction lock state\n"
-            "  \"instantlock_internal\" : true|false, (bool) Current internal transaction lock state\n"
-            "  \"chainlock\" : true|false, (bool) The state of the corresponding block chainlock\n"
+            "  \"instantlock\" : true|false, (boolean) Current transaction lock state\n"
+            "  \"instantlock_internal\" : true|false, (boolean) Current internal transaction lock state\n"
+            "  \"chainlock\" : true|false, (boolean) The state of the corresponding block chainlock\n"
             "}\n"
                     },
                 },
@@ -487,13 +487,13 @@ static UniValue decoderawtransaction(const JSONRPCRequest& request)
             "  \"locktime\" : ttt,       (numeric) The lock time\n"
             "  \"vin\" : [               (array of json objects)\n"
             "     {\n"
-            "       \"txid\": \"id\",    (string) The transaction id\n"
-            "       \"vout\": n,         (numeric) The output number\n"
-            "       \"scriptSig\": {     (json object) The script\n"
-            "         \"asm\": \"asm\",  (string) asm\n"
-            "         \"hex\": \"hex\"   (string) hex\n"
+            "       \"txid\" : \"id\",    (string) The transaction id\n"
+            "       \"vout\" : n,         (numeric) The output number\n"
+            "       \"scriptSig\" : {     (json object) The script\n"
+            "         \"asm\" : \"asm\",  (string) asm\n"
+            "         \"hex\" : \"hex\"   (string) hex\n"
             "       },\n"
-            "       \"sequence\": n     (numeric) The script sequence number\n"
+            "       \"sequence\" : n     (numeric) The script sequence number\n"
             "     }\n"
             "     ,...\n"
             "  ],\n"
@@ -556,10 +556,10 @@ static UniValue decodescript(const JSONRPCRequest& request)
                 },
                 RPCResult{
             "{\n"
-            "  \"asm\":\"asm\",          (string) Script public key\n"
-            "  \"type\":\"type\",        (string) The output type (e.g. "+GetAllOutputTypes()+")\n"
-            "  \"reqSigs\": n,         (numeric) The required signatures\n"
-            "  \"addresses\": [        (json array of string)\n"
+            "  \"asm\" : \"asm\",          (string) Script public key\n"
+            "  \"type\" : \"type\",        (string) The output type (e.g. "+GetAllOutputTypes()+")\n"
+            "  \"reqSigs\" : n,         (numeric) The required signatures\n"
+            "  \"addresses\" : [        (json array of string)\n"
             "     \"address\"          (string) dash address\n"
             "     ,...\n"
             "  ],\n"
@@ -856,7 +856,7 @@ static UniValue testmempoolaccept(const JSONRPCRequest& request)
                     {"maxfeerate", RPCArg::Type::AMOUNT, /* default */ FormatMoney(DEFAULT_MAX_RAW_TX_FEE), "Reject transactions whose fee rate is higher than the specified value, expressed in " + CURRENCY_UNIT + "/kB\n"},
                 },
                 RPCResult{
-            "[                   (array) The result of the mempool acceptance test for each raw transaction in the input array.\n"
+            "[                   (json array) The result of the mempool acceptance test for each raw transaction in the input array.\n"
             "                            Length is exactly one for now.\n"
             " {\n"
             "  \"txid\"           (string) The transaction hash in hex\n"
diff --git a/src/rpc/rpcevo.cpp b/src/rpc/rpcevo.cpp
index 840976a68b..f8b0f93dcf 100644
--- a/src/rpc/rpcevo.cpp
+++ b/src/rpc/rpcevo.cpp
@@ -1239,8 +1239,8 @@ static void bls_generate_help(const JSONRPCRequest& request)
         {},
         RPCResult{
     "{\n"
-    "  \"secret\": \"xxxx\",        (string) BLS secret key\n"
-    "  \"public\": \"xxxx\",        (string) BLS public key\n"
+    "  \"secret\" : \"xxxx\",        (string) BLS secret key\n"
+    "  \"public\" : \"xxxx\",        (string) BLS public key\n"
     "}\n"
         },
         RPCExamples{
@@ -1273,8 +1273,8 @@ static void bls_fromsecret_help(const JSONRPCRequest& request)
         },
         RPCResult{
     "{\n"
-    "  \"secret\": \"xxxx\",        (string) BLS secret key\n"
-    "  \"public\": \"xxxx\",        (string) BLS public key\n"
+    "  \"secret\" : \"xxxx\",        (string) BLS secret key\n"
+    "  \"public\" : \"xxxx\",        (string) BLS public key\n"
     "}\n"
         },
         RPCExamples{
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index 6a4b49005b..8603424c9b 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -912,9 +912,9 @@ UniValue dumphdinfo(const JSONRPCRequest& request)
                 {},
                 RPCResult{
             "{\n"
-            "  \"hdseed\": \"seed\",                    (string) The HD seed (bip32, in hex)\n"
-            "  \"mnemonic\": \"words\",                 (string) The mnemonic for this HD wallet (bip39, english words) \n"
-            "  \"mnemonicpassphrase\": \"passphrase\",  (string) The mnemonic passphrase for this HD wallet (bip39)\n"
+            "  \"hdseed\" : \"seed\",                    (string) The HD seed (bip32, in hex)\n"
+            "  \"mnemonic\" : \"words\",                 (string) The mnemonic for this HD wallet (bip39, english words) \n"
+            "  \"mnemonicpassphrase\" : \"passphrase\",  (string) The mnemonic passphrase for this HD wallet (bip39)\n"
             "}\n"
                 },
                 RPCExamples{
@@ -966,7 +966,7 @@ UniValue dumpwallet(const JSONRPCRequest& request)
                 },
                 RPCResult{
             "{                           (json object)\n"
-            "  \"keys\" : {            (int) The number of keys contained in the wallet dump\n"
+            "  \"keys\" : {            (numeric) The number of keys contained in the wallet dump\n"
             "  \"filename\" : {        (string) The filename with full absolute path\n"
             "  \"warning\" : {         (string) A warning about not sharing the wallet dump with anyone\n"
             "}\n"
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 2578148503..2260f112d4 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -511,7 +511,7 @@ static UniValue listaddressbalances(const JSONRPCRequest& request)
                 },
                 RPCResult{
             "{\n"
-            "  \"address\": amount,       (string) The dash address and the amount in " + CURRENCY_UNIT + "\n"
+            "  \"address\" : amount,       (string) The dash address and the amount in " + CURRENCY_UNIT + "\n"
             "  ,...\n"
             "}\n"
                 },
@@ -1030,8 +1030,8 @@ static UniValue addmultisigaddress(const JSONRPCRequest& request)
                 },
                 RPCResult{
             "{\n"
-            "  \"address\":\"multisigaddress\",    (string) The value of the new multisig address.\n"
-            "  \"redeemScript\":\"script\"         (string) The string value of the hex-encoded redemption script.\n"
+            "  \"address\" : \"multisigaddress\",    (string) The value of the new multisig address.\n"
+            "  \"redeemScript\" : \"script\"         (string) The string value of the hex-encoded redemption script.\n"
             "}\n"
                 },
                 RPCExamples{
@@ -1263,14 +1263,14 @@ static UniValue listreceivedbyaddress(const JSONRPCRequest& request)
                 RPCResult{
             "[\n"
             "  {\n"
-            "    \"involvesWatchonly\" : true,        (bool) Only returned if imported addresses were involved in transaction\n"
+            "    \"involvesWatchonly\" : true,        (boolean) Only returned if imported addresses were involved in transaction\n"
             "    \"address\" : \"receivingaddress\",    (string) The receiving address\n"
             "    \"amount\" : x.xxx,                  (numeric) The total amount in " + CURRENCY_UNIT + " received by the address\n"
             "    \"confirmations\" : n                (numeric) The number of confirmations of the most recent transaction included.\n"
             "                                                 If 'addlocked' is true, the number of confirmations can be less than\n"
             "                                                 configured for transactions locked via InstantSend\n"
             "    \"label\" : \"label\",               (string) The label of the receiving address. The default label is \"\".\n"
-            "    \"txids\": [\n"
+            "    \"txids\" : [\n"
             "       \"txid\",                         (string) The ids of transactions received with the address \n"
             "       ...\n"
             "    ]\n"
@@ -1318,7 +1318,7 @@ static UniValue listreceivedbylabel(const JSONRPCRequest& request)
                 RPCResult{
             "[\n"
             "  {\n"
-            "    \"involvesWatchonly\" : true,   (bool) Only returned if imported addresses were involved in transaction\n"
+            "    \"involvesWatchonly\" : true,   (boolean) Only returned if imported addresses were involved in transaction\n"
             "    \"amount\" : x.xxx,             (numeric) The total amount received by addresses with this label\n"
             "    \"confirmations\" : n           (numeric) The number of blockchain confirmations of the most recent transaction included\n"
             "    \"label\" : \"label\"             (string) The label of the receiving address. The default label is \"\".\n"
@@ -1462,37 +1462,37 @@ static UniValue listtransactions(const JSONRPCRequest& request)
                 RPCResult{
             "[\n"
             "  {\n"
-            "    \"address\":\"address\",    (string) The dash address of the transaction. Not present for \n"
+            "    \"address\" : \"address\",    (string) The dash address of the transaction. Not present for \n"
             "                                                move transactions (category = move).\n"
-            "    \"category\":\"send|receive|move\", (string) The transaction category. 'move' is a local (off blockchain)\n"
+            "    \"category\" : \"send|receive|move\", (string) The transaction category. 'move' is a local (off blockchain)\n"
             "                                                transaction between accounts, and not associated with an address,\n"
             "                                                transaction id or block. 'send' and 'receive' transactions are \n"
             "                                                associated with an address, transaction id and block details\n"
-            "    \"amount\": x.xxx,          (numeric) The amount in " + CURRENCY_UNIT + ". This is negative for the 'send' category, and for the\n"
+            "    \"amount\" : x.xxx,          (numeric) The amount in " + CURRENCY_UNIT + ". This is negative for the 'send' category, and for the\n"
             "                                         'move' category for moves outbound. It is positive for the 'receive' category,\n"
             "                                         and for the 'move' category for inbound funds.\n"
-            "    \"label\": \"label\",       (string) A comment for the address/transaction, if any\n"
-            "    \"vout\": n,                (numeric) the vout value\n"
-            "    \"fee\": x.xxx,             (numeric) The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the \n"
+            "    \"label\" : \"label\",       (string) A comment for the address/transaction, if any\n"
+            "    \"vout\" : n,                (numeric) the vout value\n"
+            "    \"fee\" : x.xxx,             (numeric) The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the \n"
             "                                         'send' category of transactions.\n"
-            "    \"confirmations\": n,       (numeric) The number of blockchain confirmations for the transaction. Available for 'send' and \n"
+            "    \"confirmations\" : n,       (numeric) The number of blockchain confirmations for the transaction. Available for 'send' and \n"
             "                                         'receive' category of transactions. Negative confirmations indicate the\n"
             "                                         transaction conflicts with the block chain\n"
-            "    \"instantlock\" : true|false, (bool) Current transaction lock state. Available for 'send' and 'receive' category of transactions\n"
-            "    \"instantlock_internal\" : true|false, (bool) Current internal transaction lock state. Available for 'send' and 'receive' category of transactions\n"
-            "    \"chainlock\" : true|false, (bool) The state of the corresponding block chainlock\n"
-            "    \"trusted\": xxx,           (bool) Whether we consider the outputs of this unconfirmed transaction safe to spend.\n"
-            "    \"blockhash\": \"hashvalue\", (string) The block hash containing the transaction. Available for 'send' and 'receive'\n"
+            "    \"instantlock\" : true|false, (boolean) Current transaction lock state. Available for 'send' and 'receive' category of transactions\n"
+            "    \"instantlock_internal\" : true|false, (boolean) Current internal transaction lock state. Available for 'send' and 'receive' category of transactions\n"
+            "    \"chainlock\" : true|false, (boolean) The state of the corresponding block chainlock\n"
+            "    \"trusted\" : xxx,           (boolean) Whether we consider the outputs of this unconfirmed transaction safe to spend.\n"
+            "    \"blockhash\" : \"hashvalue\", (string) The block hash containing the transaction. Available for 'send' and 'receive'\n"
             "                                          category of transactions.\n"
-            "    \"blockindex\": n,          (numeric) The index of the transaction in the block that includes it. Available for 'send' and 'receive'\n"
+            "    \"blockindex\" : n,          (numeric) The index of the transaction in the block that includes it. Available for 'send' and 'receive'\n"
             "                                          category of transactions.\n"
-            "    \"blocktime\": xxx,         (numeric) The block time in seconds since epoch (1 Jan 1970 GMT).\n"
-            "    \"txid\": \"transactionid\",  (string) The transaction id. Available for 'send' and 'receive' category of transactions.\n"
-            "    \"time\": xxx,              (numeric) The transaction time in seconds since epoch (midnight Jan 1 1970 GMT).\n"
-            "    \"timereceived\": xxx,      (numeric) The time received in seconds since epoch (midnight Jan 1 1970 GMT). Available \n"
+            "    \"blocktime\" : xxx,         (numeric) The block time in seconds since epoch (1 Jan 1970 GMT).\n"
+            "    \"txid\" : \"transactionid\",  (string) The transaction id. Available for 'send' and 'receive' category of transactions.\n"
+            "    \"time\" : xxx,              (numeric) The transaction time in seconds since epoch (midnight Jan 1 1970 GMT).\n"
+            "    \"timereceived\" : xxx,      (numeric) The time received in seconds since epoch (midnight Jan 1 1970 GMT). Available \n"
             "                                          for 'send' and 'receive' category of transactions.\n"
-            "    \"comment\": \"...\",         (string) If a comment is associated with the transaction.\n"
-            "    \"abandoned\": xxx          (bool) 'true' if the transaction has been abandoned (inputs are respendable). Only available for the \n"
+            "    \"comment\" : \"...\",         (string) If a comment is associated with the transaction.\n"
+            "    \"abandoned\" : xxx          (boolean) 'true' if the transaction has been abandoned (inputs are respendable). Only available for the \n"
             "                                         'send' category of transactions.\n"
             "  }\n"
             "]\n"
@@ -1588,34 +1588,34 @@ static UniValue listsinceblock(const JSONRPCRequest& request)
                 },
                 RPCResult{
             "{\n"
-            "  \"transactions\": [\n"
-            "    \"address\":\"address\",    (string) The dash address of the transaction. Not present for move transactions (category = move).\n"
-            "    \"category\":\"send|receive\",  (string) The transaction category. 'send' has negative amounts, 'receive' has positive amounts.\n"
-            "    \"amount\": x.xxx,          (numeric) The amount in " + CURRENCY_UNIT + ". This is negative for the 'send' category, and for the 'move' category for moves \n"
+            "  \"transactions\" : [\n"
+            "    \"address\" : \"address\",    (string) The dash address of the transaction. Not present for move transactions (category = move).\n"
+            "    \"category\" : \"send|receive\",  (string) The transaction category. 'send' has negative amounts, 'receive' has positive amounts.\n"
+            "    \"amount\" : x.xxx,          (numeric) The amount in " + CURRENCY_UNIT + ". This is negative for the 'send' category, and for the 'move' category for moves \n"
             "                                          outbound. It is positive for the 'receive' category, and for the 'move' category for inbound funds.\n"
             "    \"vout\" : n,               (numeric) the vout value\n"
-            "    \"fee\": x.xxx,             (numeric) The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the 'send' category of transactions.\n"
+            "    \"fee\" : x.xxx,             (numeric) The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the 'send' category of transactions.\n"
             "    \"confirmations\" : n,      (numeric) The number of blockchain confirmations for the transaction. Available for 'send' and 'receive' category of transactions.\n"
             "                                          When it's < 0, it means the transaction conflicted that many blocks ago.\n"
-            "    \"instantlock\" : true|false, (bool) Current transaction lock state. Available for 'send' and 'receive' category of transactions\n"
-            "    \"instantlock_internal\" : true|false, (bool) Current internal transaction lock state. Available for 'send' and 'receive' category of transactions\n"
-            "    \"chainlock\" : true|false, (bool) The state of the corresponding block chainlock\n"
-            "    \"blockhash\": \"hashvalue\", (string) The block hash containing the transaction. Available for 'send' and 'receive' category of transactions.\n"
-            "    \"blockindex\": n,          (numeric) The index of the transaction in the block that includes it. Available for 'send' and 'receive' category of transactions.\n"
-            "    \"blocktime\": xxx,         (numeric) The block time in seconds since epoch (1 Jan 1970 GMT).\n"
-            "    \"txid\": \"transactionid\",  (string) The transaction id. Available for 'send' and 'receive' category of transactions.\n"
-            "    \"time\": xxx,              (numeric) The transaction time in seconds since epoch (Jan 1 1970 GMT).\n"
-            "    \"timereceived\": xxx,      (numeric) The time received in seconds since epoch (Jan 1 1970 GMT). Available for 'send' and 'receive' category of transactions.\n"
-            "    \"abandoned\": xxx,         (bool) 'true' if the transaction has been abandoned (inputs are respendable). Only available for the 'send' category of transactions.\n"
-            "    \"comment\": \"...\",         (string) If a comment is associated with the transaction.\n"
+            "    \"instantlock\" : true|false, (boolean) Current transaction lock state. Available for 'send' and 'receive' category of transactions\n"
+            "    \"instantlock_internal\" : true|false, (boolean) Current internal transaction lock state. Available for 'send' and 'receive' category of transactions\n"
+            "    \"chainlock\" : true|false, (boolean) The state of the corresponding block chainlock\n"
+            "    \"blockhash\" : \"hashvalue\", (string) The block hash containing the transaction. Available for 'send' and 'receive' category of transactions.\n"
+            "    \"blockindex\" : n,          (numeric) The index of the transaction in the block that includes it. Available for 'send' and 'receive' category of transactions.\n"
+            "    \"blocktime\" : xxx,         (numeric) The block time in seconds since epoch (1 Jan 1970 GMT).\n"
+            "    \"txid\" : \"transactionid\",  (string) The transaction id. Available for 'send' and 'receive' category of transactions.\n"
+            "    \"time\" : xxx,              (numeric) The transaction time in seconds since epoch (Jan 1 1970 GMT).\n"
+            "    \"timereceived\" : xxx,      (numeric) The time received in seconds since epoch (Jan 1 1970 GMT). Available for 'send' and 'receive' category of transactions.\n"
+            "    \"abandoned\" : xxx,         (boolean) 'true' if the transaction has been abandoned (inputs are respendable). Only available for the 'send' category of transactions.\n"
+            "    \"comment\" : \"...\",         (string) If a comment is associated with the transaction.\n"
             "    \"label\" : \"label\"         (string) A comment for the address/transaction, if any\n"
-            "    \"to\": \"...\",              (string) If a comment to is associated with the transaction.\n"
+            "    \"to\" : \"...\",              (string) If a comment to is associated with the transaction.\n"
             "  ],\n"
-            "  \"removed\": [\n"
+            "  \"removed\" : [\n"
             "    <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.\n"
             "  ],\n"
-            "  \"lastblock\": \"lastblockhash\"  (string) The hash of the block (target_confirmations-1) from the best block on the main chain. 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\n"
+            "  \"lastblock\" : \"lastblockhash\"  (string) The hash of the block (target_confirmations-1) from the best block on the main chain. 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\n"
             "}\n"
                 },
                 RPCExamples{
@@ -1727,11 +1727,11 @@ static UniValue gettransaction(const JSONRPCRequest& request)
                 RPCResult{
             "{\n"
             "  \"amount\" : x.xxx,        (numeric) The transaction amount in " + CURRENCY_UNIT + "\n"
-            "  \"fee\": x.xxx,            (numeric) The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the \n"
+            "  \"fee\" : x.xxx,            (numeric) The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the \n"
             "                              'send' category of transactions.\n"
-            "  \"instantlock\" : true|false, (bool) Current transaction lock state\n"
-            "  \"instantlock_internal\" : true|false, (bool) Current internal transaction lock state\n"
-            "  \"chainlock\" : true|false, (bool) The state of the corresponding block chainlock\n"
+            "  \"instantlock\" : true|false, (boolean) Current transaction lock state\n"
+            "  \"instantlock_internal\" : true|false, (boolean) Current internal transaction lock state\n"
+            "  \"chainlock\" : true|false, (boolean) The state of the corresponding block chainlock\n"
             "  \"confirmations\" : n,     (numeric) The number of blockchain confirmations\n"
             "  \"blockhash\" : \"hash\",    (string) The block hash\n"
             "  \"blockindex\" : xx,       (numeric) The index of the transaction in the block that includes it\n"
@@ -1746,9 +1746,9 @@ static UniValue gettransaction(const JSONRPCRequest& request)
             "      \"amount\" : x.xxx,               (numeric) The amount in " + CURRENCY_UNIT + "\n"
             "      \"label\" : \"label\",              (string) A comment for the address/transaction, if any\n"
             "      \"vout\" : n,                     (numeric) the vout value\n"
-            "      \"fee\": x.xxx,                     (numeric) The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the \n"
+            "      \"fee\" : x.xxx,                     (numeric) The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the \n"
             "                                           'send' category of transactions.\n"
-            "      \"abandoned\": xxx                  (bool) 'true' if the transaction has been abandoned (inputs are respendable). Only available for the \n"
+            "      \"abandoned\" : xxx                  (boolean) 'true' if the transaction has been abandoned (inputs are respendable). Only available for the \n"
             "                                           'send' category of transactions.\n"
             "    }\n"
             "    ,...\n"
@@ -2521,36 +2521,36 @@ static UniValue getwalletinfo(const JSONRPCRequest& request)
                 {},
                 RPCResult{
             "{\n"
-            "  \"walletname\": xxxxx,               (string) the wallet name\n"
-            "  \"walletversion\": xxxxx,            (numeric) the wallet version\n"
-            "  \"balance\": xxxxxxx,                (numeric) the total confirmed balance of the wallet in " + CURRENCY_UNIT + "\n"
-            "  \"coinjoin_balance\": xxxxxx,        (numeric) the CoinJoin balance in " + CURRENCY_UNIT + "\n"
-            "  \"unconfirmed_balance\": xxx,        (numeric) the total unconfirmed balance of the wallet in " + CURRENCY_UNIT + "\n"
-            "  \"immature_balance\": xxxxxx,        (numeric) the total immature balance of the wallet in " + CURRENCY_UNIT + "\n"
-            "  \"txcount\": xxxxxxx,                (numeric) the total number of transactions in the wallet\n"
-            "  \"timefirstkey\": xxxxxx,            (numeric) the timestamp (seconds since Unix epoch) of the oldest known key in the wallet\n"
-            "  \"keypoololdest\": xxxxxx,           (numeric) the timestamp (seconds since Unix epoch) of the oldest pre-generated key in the key pool\n"
-            "  \"keypoolsize\": xxxx,               (numeric) how many new keys are pre-generated (only counts external keys)\n"
-            "  \"keypoolsize_hd_internal\": xxxx,   (numeric) how many new keys are pre-generated for internal use (used for change outputs, only appears if the wallet is using this feature, otherwise external keys are used)\n"
-            "  \"keys_left\": xxxx,                 (numeric) how many new keys are left since last automatic backup\n"
-            "  \"unlocked_until\": ttt,             (numeric) the timestamp in seconds since epoch (midnight Jan 1 1970 GMT) that the wallet is unlocked for transfers, or 0 if the wallet is locked\n"
-            "  \"paytxfee\": x.xxxx,                (numeric) the transaction fee configuration, set in " + CURRENCY_UNIT + "/kB\n"
-            "  \"hdchainid\": \"<hash>\",             (string) the ID of the HD chain\n"
-            "  \"hdaccountcount\": xxx,             (numeric) how many accounts of the HD chain are in this wallet\n"
+            "  \"walletname\" : xxxxx,               (string) the wallet name\n"
+            "  \"walletversion\" : xxxxx,            (numeric) the wallet version\n"
+            "  \"balance\" : xxxxxxx,                (numeric) the total confirmed balance of the wallet in " + CURRENCY_UNIT + "\n"
+            "  \"coinjoin_balance\" : xxxxxx,        (numeric) the CoinJoin balance in " + CURRENCY_UNIT + "\n"
+            "  \"unconfirmed_balance\" : xxx,        (numeric) the total unconfirmed balance of the wallet in " + CURRENCY_UNIT + "\n"
+            "  \"immature_balance\" : xxxxxx,        (numeric) the total immature balance of the wallet in " + CURRENCY_UNIT + "\n"
+            "  \"txcount\" : xxxxxxx,                (numeric) the total number of transactions in the wallet\n"
+            "  \"timefirstkey\" : xxxxxx,            (numeric) the timestamp (seconds since Unix epoch) of the oldest known key in the wallet\n"
+            "  \"keypoololdest\" : xxxxxx,           (numeric) the timestamp (seconds since Unix epoch) of the oldest pre-generated key in the key pool\n"
+            "  \"keypoolsize\" : xxxx,               (numeric) how many new keys are pre-generated (only counts external keys)\n"
+            "  \"keypoolsize_hd_internal\" : xxxx,   (numeric) how many new keys are pre-generated for internal use (used for change outputs, only appears if the wallet is using this feature, otherwise external keys are used)\n"
+            "  \"keys_left\" : xxxx,                 (numeric) how many new keys are left since last automatic backup\n"
+            "  \"unlocked_until\" : ttt,             (numeric) the timestamp in seconds since epoch (midnight Jan 1 1970 GMT) that the wallet is unlocked for transfers, or 0 if the wallet is locked\n"
+            "  \"paytxfee\" : x.xxxx,                (numeric) the transaction fee configuration, set in " + CURRENCY_UNIT + "/kB\n"
+            "  \"hdchainid\" : \"<hash>\",             (string) the ID of the HD chain\n"
+            "  \"hdaccountcount\" : xxx,             (numeric) how many accounts of the HD chain are in this wallet\n"
             "    [\n"
             "      {\n"
-            "      \"hdaccountindex\": xxx,         (numeric) the index of the account\n"
-            "      \"hdexternalkeyindex\": xxxx,    (numeric) current external childkey index\n"
-            "      \"hdinternalkeyindex\": xxxx,    (numeric) current internal childkey index\n"
+            "      \"hdaccountindex\" : xxx,         (numeric) the index of the account\n"
+            "      \"hdexternalkeyindex\" : xxxx,    (numeric) current external childkey index\n"
+            "      \"hdinternalkeyindex\" : xxxx,    (numeric) current internal childkey index\n"
             "      }\n"
             "      ,...\n"
             "    ]\n"
-            "  \"scanning\":                        (json object) current scanning details, or false if no scan is in progress\n"
+            "  \"scanning\" :                        (json object) current scanning details, or false if no scan is in progress\n"
             "    {\n"
             "      \"duration\" : xxxx              (numeric) elapsed seconds since scan start\n"
             "      \"progress\" : x.xxxx,           (numeric) scanning progress percentage [0.0, 1.0]\n"
             "    }\n"
-            "  \"private_keys_enabled\": true|false (boolean) false if privatekeys are disabled for this wallet (enforced watch-only wallet)\n"
+            "  \"private_keys_enabled\" : true|false (boolean) false if privatekeys are disabled for this wallet (enforced watch-only wallet)\n"
             "}\n"
                 },
                 RPCExamples{
@@ -3037,10 +3037,10 @@ static UniValue listunspent(const JSONRPCRequest& request)
             "    \"amount\" : x.xxx,         (numeric) the transaction output amount in " + CURRENCY_UNIT + "\n"
             "    \"confirmations\" : n,      (numeric) The number of confirmations\n"
             "    \"redeemScript\" : n        (string) The redeemScript if scriptPubKey is P2SH\n"
-            "    \"spendable\" : xxx,        (bool) Whether we have the private keys to spend this output\n"
-            "    \"solvable\" : xxx,         (bool) Whether we know how to spend this output, ignoring the lack of keys\n"
+            "    \"spendable\" : xxx,        (boolean) Whether we have the private keys to spend this output\n"
+            "    \"solvable\" : xxx,         (boolean) Whether we know how to spend this output, ignoring the lack of keys\n"
             "    \"desc\" : xxx,             (string, only when solvable) A descriptor for spending this output\n"
-            "    \"safe\" : xxx              (bool) Whether this output is considered safe to spend. Unconfirmed transactions\n"
+            "    \"safe\" : xxx              (boolean) Whether this output is considered safe to spend. Unconfirmed transactions\n"
             "                              from outside keys and unconfirmed replacement transactions are considered unsafe\n"
             "                              and are not eligible for spending by fundrawtransaction and sendtoaddress.\n"
             "    \"coinjoin_rounds\" : n     (numeric) The number of CoinJoin rounds\n"
@@ -3351,9 +3351,9 @@ static UniValue fundrawtransaction(const JSONRPCRequest& request)
                 },
                 RPCResult{
                             "{\n"
-                            "  \"hex\":       \"value\", (string)  The resulting raw transaction (hex-encoded string)\n"
-                            "  \"fee\":       n,         (numeric) Fee in " + CURRENCY_UNIT + " the resulting transaction pays\n"
-                            "  \"changepos\": n          (numeric) The position of the added change output, or -1\n"
+                            "  \"hex\" :       \"value\", (string)  The resulting raw transaction (hex-encoded string)\n"
+                            "  \"fee\" :       n,         (numeric) Fee in " + CURRENCY_UNIT + " the resulting transaction pays\n"
+                            "  \"changepos\" : n          (numeric) The position of the added change output, or -1\n"
                             "}\n"
                                 },
                                 RPCExamples{
@@ -3491,7 +3491,7 @@ UniValue generate(const JSONRPCRequest& request)
                     {"maxtries", RPCArg::Type::NUM, /* default */ "1000000", "How many iterations to try."},
                 },
                 RPCResult{
-            "[ blockhashes ]     (array) hashes of blocks generated\n"
+            "[ blockhashes ]     (json array) hashes of blocks generated\n"
                 },
                 RPCExamples{
             "\nGenerate 11 blocks\n"
@@ -3726,11 +3726,11 @@ UniValue getaddressinfo(const JSONRPCRequest& request)
             "  \"hdchainid\" : \"<hash>\"        (string, optional) The ID of the HD chain\n"
             "  \"hdkeypath\" : \"keypath\"       (string, optional) The HD keypath if the key is HD and available\n"
             "  \"hdmasterfingerprint\" : \"<hash160>\" (string, optional) The fingperint of the master key.\n"
-            "  \"labels\"                      (object) Array of labels associated with the address.\n"
+            "  \"labels\"                      (json object) Array of labels associated with the address.\n"
             "    [\n"
             "      { (json object of label data)\n"
-            "        \"name\": \"labelname\" (string) The label\n"
-            "        \"purpose\": \"string\" (string) Purpose of address (\"send\" for sending address, \"receive\" for receiving address)\n"
+            "        \"name\" : \"labelname\" (string) The label\n"
+            "        \"purpose\" : \"string\" (string) Purpose of address (\"send\" for sending address, \"receive\" for receiving address)\n"
             "      },...\n"
             "    ]\n"
             "}\n"
@@ -3829,8 +3829,8 @@ static UniValue getaddressesbylabel(const JSONRPCRequest& request)
                 },
                 RPCResult{
             "{ (json object with addresses as keys)\n"
-            "  \"address\": { (json object with information about address)\n"
-            "    \"purpose\": \"string\" (string)  Purpose of address (\"send\" for sending address, \"receive\" for receiving address)\n"
+            "  \"address\" : { (json object with information about address)\n"
+            "    \"purpose\" : \"string\" (string)  Purpose of address (\"send\" for sending address, \"receive\" for receiving address)\n"
             "  },...\n"
             "}\n"
                 },
@@ -4083,9 +4083,9 @@ UniValue walletcreatefundedpsbt(const JSONRPCRequest& request)
                 },
                 RPCResult{
                             "{\n"
-                            "  \"psbt\": \"value\",        (string)  The resulting raw transaction (base64-encoded string)\n"
-                            "  \"fee\":       n,         (numeric) Fee in " + CURRENCY_UNIT + " the resulting transaction pays\n"
-                            "  \"changepos\": n          (numeric) The position of the added change output, or -1\n"
+                            "  \"psbt\" : \"value\",        (string)  The resulting raw transaction (base64-encoded string)\n"
+                            "  \"fee\" :       n,         (numeric) Fee in " + CURRENCY_UNIT + " the resulting transaction pays\n"
+                            "  \"changepos\" : n          (numeric) The position of the added change output, or -1\n"
                             "}\n"
                                 },
                                 RPCExamples{
diff --git a/src/zmq/zmqrpc.cpp b/src/zmq/zmqrpc.cpp
index a34968ef7d..1579529a09 100644
--- a/src/zmq/zmqrpc.cpp
+++ b/src/zmq/zmqrpc.cpp
@@ -23,9 +23,9 @@ UniValue getzmqnotifications(const JSONRPCRequest& request)
                 RPCResult{
             "[\n"
             "  {                        (json object)\n"
-            "    \"type\": \"pubhashtx\",   (string) Type of notification\n"
-            "    \"address\": \"...\",      (string) Address of the publisher\n"
-            "    \"hwm\": n                 (numeric) Outbound message high water mark\n"
+            "    \"type\" : \"pubhashtx\",   (string) Type of notification\n"
+            "    \"address\" : \"...\",      (string) Address of the publisher\n"
+            "    \"hwm\" : n                 (numeric) Outbound message high water mark\n"
             "  },\n"
             "  ...\n"
             "]\n"

From 14585f31a31bcf744a40eb26b83d55c8b357dde0 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Thu, 26 Dec 2019 03:26:59 +0700
Subject: [PATCH 06/16] partial bitcoin#17809: Auto-format RPCResult

---
 src/rpc/util.cpp | 114 ++++++++++++++++++++++++++++++------
 src/rpc/util.h   | 147 +++++++++++++++++++++++++++++++++++------------
 2 files changed, 207 insertions(+), 54 deletions(-)

diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index ccb2c56880..3c45163c53 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -288,21 +288,10 @@ struct Sections {
         m_sections.push_back(s);
     }
 
-    /**
-     * Serializing RPCArgs depends on the outer type. Only arrays and
-     * dictionaries can be nested in json. The top-level outer type is "named
-     * arguments", a mix between a dictionary and arrays.
-     */
-    enum class OuterType {
-        ARR,
-        OBJ,
-        NAMED_ARG, // Only set on first recursion
-    };
-
     /**
      * Recursive helper to translate an RPCArg into sections
      */
-    void Push(const RPCArg& arg, const size_t current_indent = 5, const OuterType outer_type = OuterType::NAMED_ARG)
+    void Push(const RPCArg& arg, const size_t current_indent = 5, const OuterType outer_type = OuterType::NONE)
     {
         const auto indent = std::string(current_indent, ' ');
         const auto indent_next = std::string(current_indent + 2, ' ');
@@ -315,7 +304,7 @@ struct Sections {
         case RPCArg::Type::AMOUNT:
         case RPCArg::Type::RANGE:
         case RPCArg::Type::BOOL: {
-            if (outer_type == OuterType::NAMED_ARG) return; // Nothing more to do for non-recursive types on first recursion
+            if (outer_type == OuterType::NONE) return; // Nothing more to do for non-recursive types on first recursion
             auto left = indent;
             if (arg.m_type_str.size() != 0 && push_name) {
                 left += "\"" + arg.m_name + "\": " + arg.m_type_str.at(0);
@@ -328,7 +317,7 @@ struct Sections {
         }
         case RPCArg::Type::OBJ:
         case RPCArg::Type::OBJ_USER_KEYS: {
-            const auto right = outer_type == OuterType::NAMED_ARG ? "" : arg.ToDescriptionString();
+            const auto right = outer_type == OuterType::NONE ? "" : arg.ToDescriptionString();
             PushSection({indent + (push_name ? "\"" + arg.m_name + "\": " : "") + "{", right});
             for (const auto& arg_inner : arg.m_inner) {
                 Push(arg_inner, current_indent + 2, OuterType::OBJ);
@@ -336,20 +325,20 @@ struct Sections {
             if (arg.m_type != RPCArg::Type::OBJ) {
                 PushSection({indent_next + "...", ""});
             }
-            PushSection({indent + "}" + (outer_type != OuterType::NAMED_ARG ? "," : ""), ""});
+            PushSection({indent + "}" + (outer_type != OuterType::NONE ? "," : ""), ""});
             break;
         }
         case RPCArg::Type::ARR: {
             auto left = indent;
             left += push_name ? "\"" + arg.m_name + "\": " : "";
             left += "[";
-            const auto right = outer_type == OuterType::NAMED_ARG ? "" : arg.ToDescriptionString();
+            const auto right = outer_type == OuterType::NONE ? "" : arg.ToDescriptionString();
             PushSection({left, right});
             for (const auto& arg_inner : arg.m_inner) {
                 Push(arg_inner, current_indent + 2, OuterType::ARR);
             }
             PushSection({indent_next + "...", ""});
-            PushSection({indent + "]" + (outer_type != OuterType::NAMED_ARG ? "," : ""), ""});
+            PushSection({indent + "]" + (outer_type != OuterType::NONE ? "," : ""), ""});
             break;
         }
 
@@ -421,7 +410,9 @@ std::string RPCResults::ToDescriptionString() const
         } else {
             result += "\nResult (" + r.m_cond + "):\n";
         }
-        result += r.m_result;
+        Sections sections;
+        r.ToSections(sections);
+        result += sections.ToString();
     }
     return result;
 }
@@ -568,6 +559,93 @@ std::string RPCArg::ToDescriptionString() const
     return ret;
 }
 
+void RPCResult::ToSections(Sections& sections, const OuterType outer_type, const int current_indent) const
+{
+    // Indentation
+    const std::string indent(current_indent, ' ');
+    const std::string indent_next(current_indent + 2, ' ');
+
+    // 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
+    const std::string maybe_key{
+        outer_type == OuterType::OBJ ?
+            "\"" + this->m_key_name + "\" : " :
+            ""};
+
+    // Format description with type
+    const auto Description = [&](const std::string& type) {
+        return "(" + type + (this->m_optional ? ", optional" : "") + ")" +
+               (this->m_description.empty() ? "" : " " + this->m_description);
+    };
+
+    switch (m_type) {
+    case Type::ELISION: {
+        // If the inner result is empty, use three dots for elision
+        sections.PushSection({indent_next + "...", m_description});
+        return;
+    }
+    case Type::NONE: {
+        sections.PushSection({indent + "None", Description("json null")});
+        return;
+    }
+    case Type::STR: {
+        sections.PushSection({indent + maybe_key + "\"str\"" + maybe_separator, Description("string")});
+        return;
+    }
+    case Type::STR_AMOUNT: {
+        sections.PushSection({indent + maybe_key + "n" + maybe_separator, Description("numeric")});
+        return;
+    }
+    case Type::STR_HEX: {
+        sections.PushSection({indent + maybe_key + "\"hex\"" + maybe_separator, Description("string")});
+        return;
+    }
+    case Type::NUM: {
+        sections.PushSection({indent + maybe_key + "n" + maybe_separator, Description("numeric")});
+        return;
+    }
+    case Type::NUM_TIME: {
+        sections.PushSection({indent + maybe_key + "xxx" + maybe_separator, Description("numeric")});
+        return;
+    }
+    case Type::BOOL: {
+        sections.PushSection({indent + maybe_key + "true|false" + maybe_separator, Description("boolean")});
+        return;
+    }
+    case Type::ARR_FIXED:
+    case Type::ARR: {
+        sections.PushSection({indent + maybe_key + "[", Description("json array")});
+        for (const auto& i : m_inner) {
+            i.ToSections(sections, OuterType::ARR, current_indent + 2);
+        }
+        if (m_type == Type::ARR) {
+            sections.PushSection({indent_next + "...", ""});
+        }
+        sections.PushSection({indent + "]" + maybe_separator, ""});
+        return;
+    }
+    case Type::OBJ_DYN:
+    case Type::OBJ: {
+        sections.PushSection({indent + maybe_key + "{", Description("json object")});
+        for (const auto& i : m_inner) {
+            i.ToSections(sections, OuterType::OBJ, current_indent + 2);
+        }
+        if (m_type == Type::OBJ_DYN) {
+            // If the dictionary keys are dynamic, use three dots for continuation
+            sections.PushSection({indent_next + "...", ""});
+        }
+        sections.PushSection({indent + "}" + maybe_separator, ""});
+        return;
+    }
+
+        // no default case, so the compiler can warn about missing cases
+    }
+
+    CHECK_NONFATAL(false);
+}
+
 std::string RPCArg::ToStringObj(const bool oneline) const
 {
     std::string res;
diff --git a/src/rpc/util.h b/src/rpc/util.h
index 7cdac2e1f0..92626fef95 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -23,6 +23,7 @@
 class CKeyStore;
 class CPubKey;
 class CScript;
+struct Sections;
 struct InitInterfaces;
 
 //! Pointers to interfaces that need to be accessible from RPC methods. Due to
@@ -92,6 +93,16 @@ UniValue GetServicesNames(ServiceFlags services);
 //! Parse a JSON range specified as int64, or [int64, int64]
 std::pair<int64_t, int64_t> ParseDescriptorRange(const UniValue& value);
 
+/**
+ * Serializing JSON objects depends on the outer type. Only arrays and
+ * dictionaries can be nested in json. The top-level outer type is "NONE".
+ */
+enum class OuterType {
+    ARR,
+    OBJ,
+    NONE, // Only set on first recursion
+};
+
 struct RPCArg {
     enum class Type {
         OBJ,
@@ -131,37 +142,37 @@ struct RPCArg {
     const std::vector<std::string> m_type_str; //!< Should be empty unless it is supposed to override the auto-generated type strings. Vector length is either 0 or 2, m_type_str.at(0) will override the type of the value in a key-value pair, m_type_str.at(1) will override the type in the argument description.
 
     RPCArg(
-        const std::string& name,
-        const Type& type,
-        const Fallback& fallback,
-        const std::string& description,
-        const std::string& oneline_description = "",
-        const std::vector<std::string>& type_str = {})
-        : m_name{name},
-          m_type{type},
-          m_fallback{fallback},
-          m_description{description},
-          m_oneline_description{oneline_description},
-          m_type_str{type_str}
+        const std::string name,
+        const Type type,
+        const Fallback fallback,
+        const std::string description,
+        const std::string oneline_description = "",
+        const std::vector<std::string> type_str = {})
+        : m_name{std::move(name)},
+          m_type{std::move(type)},
+          m_fallback{std::move(fallback)},
+          m_description{std::move(description)},
+          m_oneline_description{std::move(oneline_description)},
+          m_type_str{std::move(type_str)}
     {
         CHECK_NONFATAL(type != Type::ARR && type != Type::OBJ);
     }
 
     RPCArg(
-        const std::string& name,
-        const Type& type,
-        const Fallback& fallback,
-        const std::string& description,
-        const std::vector<RPCArg>& inner,
-        const std::string& oneline_description = "",
-        const std::vector<std::string>& type_str = {})
-        : m_name{name},
-          m_type{type},
-          m_inner{inner},
-          m_fallback{fallback},
-          m_description{description},
-          m_oneline_description{oneline_description},
-          m_type_str{type_str}
+        const std::string name,
+        const Type type,
+        const Fallback fallback,
+        const std::string description,
+        const std::vector<RPCArg> inner,
+        const std::string oneline_description = "",
+        const std::vector<std::string> type_str = {})
+        : m_name{std::move(name)},
+          m_type{std::move(type)},
+          m_inner{std::move(inner)},
+          m_fallback{std::move(fallback)},
+          m_description{std::move(description)},
+          m_oneline_description{std::move(oneline_description)},
+          m_type_str{std::move(type_str)}
     {
         CHECK_NONFATAL(type == Type::ARR || type == Type::OBJ);
     }
@@ -186,21 +197,85 @@ struct RPCArg {
 };
 
 struct RPCResult {
+    enum class Type {
+        OBJ,
+        ARR,
+        STR,
+        NUM,
+        BOOL,
+        NONE,
+        STR_AMOUNT, //!< Special string to represent a floating point amount
+        STR_HEX,    //!< Special string with only hex chars
+        OBJ_DYN,    //!< Special dictionary with keys that are not literals
+        ARR_FIXED,  //!< Special array that has a fixed number of entries
+        NUM_TIME,   //!< Special numeric to denote unix epoch time
+        ELISION,    //!< Special type to denote elision (...)
+    };
+
+    const Type m_type;
+    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 std::string m_description;
     const std::string m_cond;
-    const std::string m_result;
 
-    explicit RPCResult(std::string result)
-        : m_cond{}, m_result{std::move(result)}
-    {
-        CHECK_NONFATAL(!m_result.empty());
-    }
-
-    RPCResult(std::string cond, std::string result)
-        : m_cond{std::move(cond)}, m_result{std::move(result)}
+    RPCResult(
+        const std::string cond,
+        const Type type,
+        const std::string m_key_name,
+        const bool optional,
+        const std::string description,
+        const std::vector<RPCResult> inner = {})
+        : m_type{std::move(type)},
+          m_key_name{std::move(m_key_name)},
+          m_inner{std::move(inner)},
+          m_optional{optional},
+          m_description{std::move(description)},
+          m_cond{std::move(cond)}
     {
         CHECK_NONFATAL(!m_cond.empty());
-        CHECK_NONFATAL(!m_result.empty());
+        const bool inner_needed{type == Type::ARR || type == Type::ARR_FIXED || type == Type::OBJ || type == Type::OBJ_DYN};
+        CHECK_NONFATAL(inner_needed != inner.empty());
     }
+
+    RPCResult(
+        const std::string cond,
+        const Type type,
+        const std::string m_key_name,
+        const std::string description,
+        const std::vector<RPCResult> inner = {})
+        : RPCResult{cond, type, m_key_name, false, description, inner} {}
+
+    RPCResult(
+        const Type type,
+        const std::string m_key_name,
+        const bool optional,
+        const std::string description,
+        const std::vector<RPCResult> inner = {})
+        : m_type{std::move(type)},
+          m_key_name{std::move(m_key_name)},
+          m_inner{std::move(inner)},
+          m_optional{optional},
+          m_description{std::move(description)},
+          m_cond{}
+    {
+        const bool inner_needed{type == Type::ARR || type == Type::ARR_FIXED || type == Type::OBJ || type == Type::OBJ_DYN};
+        CHECK_NONFATAL(inner_needed != inner.empty());
+    }
+
+    RPCResult(
+        const Type type,
+        const std::string m_key_name,
+        const std::string description,
+        const std::vector<RPCResult> inner = {})
+        : RPCResult{type, m_key_name, false, description, inner} {}
+
+    /** Append the sections of the result. */
+    void ToSections(Sections& sections, OuterType outer_type = OuterType::NONE, const int current_indent = 0) const;
+    /** Return the type string of the result when it is in an object (dict). */
+    std::string ToStringObj() const;
+    /** Return the description string, including the result type. */
+    std::string ToDescriptionString() const;
 };
 
 struct RPCResults {

From c014b7df92c1496c458841bea925487d3d8872a4 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Fri, 4 Mar 2022 20:19:24 +0530
Subject: [PATCH 07/16] rpc: restore legacy RPCResult support

---
 src/rpc/util.cpp | 10 +++++++---
 src/rpc/util.h   | 39 +++++++++++++++++++++++++++++++++++++--
 2 files changed, 44 insertions(+), 5 deletions(-)

diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 3c45163c53..101c9fe8d1 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -410,9 +410,13 @@ std::string RPCResults::ToDescriptionString() const
         } else {
             result += "\nResult (" + r.m_cond + "):\n";
         }
-        Sections sections;
-        r.ToSections(sections);
-        result += sections.ToString();
+        if (r.m_legacy) {
+            result += r.m_result;
+        } else {
+            Sections sections;
+            r.ToSections(sections);
+            result += sections.ToString();
+        }
     }
     return result;
 }
diff --git a/src/rpc/util.h b/src/rpc/util.h
index 92626fef95..8ba48db3b6 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -218,6 +218,8 @@ struct RPCResult {
     const bool m_optional;
     const std::string m_description;
     const std::string m_cond;
+    const bool m_legacy;                  //!< Used for legacy support
+    const std::string m_result;           //!< Used for legacy support
 
     RPCResult(
         const std::string cond,
@@ -231,13 +233,44 @@ struct RPCResult {
           m_inner{std::move(inner)},
           m_optional{optional},
           m_description{std::move(description)},
-          m_cond{std::move(cond)}
+          m_cond{std::move(cond)},
+          m_result{},
+          m_legacy{false}
     {
         CHECK_NONFATAL(!m_cond.empty());
         const bool inner_needed{type == Type::ARR || type == Type::ARR_FIXED || type == Type::OBJ || type == Type::OBJ_DYN};
         CHECK_NONFATAL(inner_needed != inner.empty());
     }
 
+    // start legacy support logic
+    RPCResult(std::string cond, std::string result)
+        : m_type{Type::NONE},
+          m_key_name{},
+          m_inner{},
+          m_optional{false},
+          m_description{},
+          m_cond{std::move(cond)},
+          m_result{std::move(result)},
+          m_legacy{true}
+    {
+        CHECK_NONFATAL(!m_cond.empty());
+        CHECK_NONFATAL(!m_result.empty());
+    }
+
+    RPCResult(std::string result)
+        : m_type{Type::NONE},
+          m_key_name{},
+          m_inner{},
+          m_optional{false},
+          m_description{},
+          m_cond{},
+          m_result{std::move(result)},
+          m_legacy{true}
+    {
+        CHECK_NONFATAL(!m_result.empty());
+    }
+    // end legacy support logic
+
     RPCResult(
         const std::string cond,
         const Type type,
@@ -257,7 +290,9 @@ struct RPCResult {
           m_inner{std::move(inner)},
           m_optional{optional},
           m_description{std::move(description)},
-          m_cond{}
+          m_cond{},
+          m_result{},
+          m_legacy{false}
     {
         const bool inner_needed{type == Type::ARR || type == Type::ARR_FIXED || type == Type::OBJ || type == Type::OBJ_DYN};
         CHECK_NONFATAL(inner_needed != inner.empty());

From a2917af201887f714908332544c5ec6a5fb9c300 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Fri, 10 Jan 2020 00:00:57 +0700
Subject: [PATCH 08/16] rpc: Import conflict-free RPCResult formatting from
 fa6b061fc118995eec41766519a11bc0dd1a901d

---
 src/rpc/blockchain.cpp     | 111 +++++++++++++--------------
 src/rpc/mining.cpp         |  33 ++++----
 src/rpc/misc.cpp           |  51 +++++++------
 src/rpc/net.cpp            |  31 ++++----
 src/rpc/rawtransaction.cpp |  73 ++++++++++--------
 src/rpc/server.cpp         |   4 +-
 src/wallet/rpcdump.cpp     |   2 +-
 src/wallet/rpcwallet.cpp   | 152 ++++++++++++++++++++-----------------
 src/zmq/zmqrpc.cpp         |  17 +++--
 9 files changed, 247 insertions(+), 227 deletions(-)

diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 77671f4891..3a4c425c37 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -189,8 +189,7 @@ static UniValue getblockcount(const JSONRPCRequest& request)
                 "The genesis block has height 0.\n",
                 {},
                 RPCResult{
-            "n    (numeric) The current block count\n"
-                },
+                    RPCResult::Type::NUM, "", "The current block count"},
                 RPCExamples{
                     HelpExampleCli("getblockcount", "")
             + HelpExampleRpc("getblockcount", "")
@@ -209,8 +208,7 @@ static UniValue getbestblockhash(const JSONRPCRequest& request)
                 "\nReturns the hash of the best (tip) block in the most-work fully-validated chain.\n",
                 {},
                 RPCResult{
-            "\"hex\"      (string) the block hash, hex-encoded\n"
-                },
+                    RPCResult::Type::STR_HEX, "", "the block hash, hex-encoded"},
                 RPCExamples{
                     HelpExampleCli("getbestblockhash", "")
             + HelpExampleRpc("getbestblockhash", "")
@@ -277,11 +275,11 @@ static UniValue waitfornewblock(const JSONRPCRequest& request)
                     {"timeout", RPCArg::Type::NUM, /* default */ "0", "Time in milliseconds to wait for a response. 0 indicates no timeout."},
                 },
                 RPCResult{
-            "{                           (json object)\n"
-            "  \"hash\" : {       (string) The blockhash\n"
-            "  \"height\" : {     (numeric) Block height\n"
-            "}\n"
-                },
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
+                        {RPCResult::Type::NUM, "height", "Block height"},
+                    }},
                 RPCExamples{
                     HelpExampleCli("waitfornewblock", "1000")
             + HelpExampleRpc("waitfornewblock", "1000")
@@ -319,11 +317,11 @@ static UniValue waitforblock(const JSONRPCRequest& request)
                     {"timeout", RPCArg::Type::NUM, /* default */ "0", "Time in milliseconds to wait for a response. 0 indicates no timeout."},
                 },
                 RPCResult{
-            "{                           (json object)\n"
-            "  \"hash\" : {       (string) The blockhash\n"
-            "  \"height\" : {     (numeric) Block height\n"
-            "}\n"
-                },
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
+                        {RPCResult::Type::NUM, "height", "Block height"},
+                    }},
                 RPCExamples{
                     HelpExampleCli("waitforblock", "\"0000000000079f8ef3d2c688c244eb7a4570b24c9ed7b4a8c619eb02596f8862\" 1000")
             + HelpExampleRpc("waitforblock", "\"0000000000079f8ef3d2c688c244eb7a4570b24c9ed7b4a8c619eb02596f8862\", 1000")
@@ -365,11 +363,11 @@ static UniValue waitforblockheight(const JSONRPCRequest& request)
                     {"timeout", RPCArg::Type::NUM, /* default */ "0", "Time in milliseconds to wait for a response. 0 indicates no timeout."},
                 },
                 RPCResult{
-            "{                           (json object)\n"
-            "  \"hash\" : {       (string) The blockhash\n"
-            "  \"height\" : {     (numeric) Block height\n"
-            "}\n"
-                },
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
+                        {RPCResult::Type::NUM, "height", "Block height"},
+                    }},
                 RPCExamples{
                     HelpExampleCli("waitforblockheight", "100 1000")
             + HelpExampleRpc("waitforblockheight", "100, 1000")
@@ -424,8 +422,7 @@ static UniValue getdifficulty(const JSONRPCRequest& request)
                 "\nReturns the proof-of-work difficulty as a multiple of the minimum difficulty.\n",
                 {},
                 RPCResult{
-            "n.nnn       (numeric) the proof-of-work difficulty as a multiple of the minimum difficulty.\n"
-                },
+                    RPCResult::Type::NUM, "", "the proof-of-work difficulty as a multiple of the minimum difficulty."},
                 RPCExamples{
                     HelpExampleCli("getdifficulty", "")
             + HelpExampleRpc("getdifficulty", "")
@@ -801,8 +798,7 @@ static UniValue getblockhash(const JSONRPCRequest& request)
                     {"height", RPCArg::Type::NUM, RPCArg::Optional::NO, "The height index"},
                 },
                 RPCResult{
-            "\"hash\"         (string) The block hash\n"
-                },
+                    RPCResult::Type::STR_HEX, "", "The block hash"},
                 RPCExamples{
                     HelpExampleCli("getblockhash", "1000")
             + HelpExampleRpc("getblockhash", "1000")
@@ -1096,8 +1092,7 @@ static UniValue getblock(const JSONRPCRequest& request)
                 },
                 {
                     RPCResult{"for verbosity = 0",
-            "\"data\"             (string) A string that is serialized, hex-encoded data for block 'hash'.\n"
-                    },
+                RPCResult::Type::STR_HEX, "", "A string that is serialized, hex-encoded data for block 'hash'"},
                     RPCResult{"for verbosity = 1",
             "{\n"
             "  \"hash\" : \"hash\",     (string) the block hash (same as provided)\n"
@@ -1185,8 +1180,7 @@ static UniValue pruneblockchain(const JSONRPCRequest& request)
             "                  to prune blocks whose block time is at least 2 hours older than the provided timestamp."},
                 },
                 RPCResult{
-            "n    (numeric) Height of the last block pruned.\n"
-                },
+                    RPCResult::Type::NUM, "", "Height of the last block pruned"},
                 RPCExamples{
                     HelpExampleCli("pruneblockchain", "1000")
             + HelpExampleRpc("pruneblockchain", "1000")
@@ -1242,17 +1236,17 @@ static UniValue gettxoutsetinfo(const JSONRPCRequest& request)
                 "Note this call may take some time.\n",
                 {},
                 RPCResult{
-            "{\n"
-            "  \"height\" : n,     (numeric) The current block height (index)\n"
-            "  \"bestblock\" : \"hex\",   (string) The hash of the block at the tip of the chain\n"
-            "  \"transactions\" : n,      (numeric) The number of transactions with unspent outputs\n"
-            "  \"txouts\" : n,            (numeric) The number of unspent transaction outputs\n"
-            "  \"bogosize\" : n,          (numeric) A meaningless metric for UTXO set size\n"
-            "  \"hash_serialized_2\": \"hash\", (string) The serialized hash\n"
-            "  \"disk_size\" : n,         (numeric) The estimated size of the chainstate on disk\n"
-            "  \"total_amount\" : x.xxx          (numeric) The total amount\n"
-            "}\n"
-                },
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::NUM, "height", "The current block height (index)"},
+                        {RPCResult::Type::STR_HEX, "bestblock", "The hash of the block at the tip of the chain"},
+                        {RPCResult::Type::NUM, "transactions", "The number of transactions with unspent outputs"},
+                        {RPCResult::Type::NUM, "txouts", "The number of unspent transaction outputs"},
+                        {RPCResult::Type::NUM, "bogosize", "A meaningless metric for UTXO set size"},
+                        {RPCResult::Type::STR_HEX, "hash_serialized_2", "The serialized hash"},
+                        {RPCResult::Type::NUM, "disk_size", "The estimated size of the chainstate on disk"},
+                        {RPCResult::Type::STR_AMOUNT, "total_amount", "The total amount"},
+                    }},
                 RPCExamples{
                     HelpExampleCli("gettxoutsetinfo", "")
             + HelpExampleRpc("gettxoutsetinfo", "")
@@ -1375,8 +1369,7 @@ static UniValue verifychain(const JSONRPCRequest& request)
                     {"nblocks", RPCArg::Type::NUM, /* default */ strprintf("%d, 0=all", nCheckDepth), "The number of blocks to check."},
                 },
                 RPCResult{
-            "true|false       (boolean) Verified or not\n"
-                },
+                    RPCResult::Type::BOOL, "", "Verified or not"},
                 RPCExamples{
                     HelpExampleCli("verifychain", "")
             + HelpExampleRpc("verifychain", "")
@@ -2502,24 +2495,26 @@ UniValue scantxoutset(const JSONRPCRequest& request)
                         "[scanobjects,...]"},
                 },
                 RPCResult{
-            "{\n"
-            "  \"success\" : true|false,         (boolean) Whether the scan was completed\n"
-            "  \"txouts\" : n,                   (numeric) The number of unspent transaction outputs scanned\n"
-            "  \"height\" : n,                   (numeric) The current block height (index)\n"
-            "  \"bestblock\" : \"hex\",            (string) The hash of the block at the tip of the chain\n"
-            "  \"unspents\" : [\n"
-            "   {\n"
-            "    \"txid\" : \"hash\",              (string) The transaction id\n"
-            "    \"vout\" : n,                   (numeric) The vout value\n"
-            "    \"scriptPubKey\" : \"script\",    (string) The script key\n"
-            "    \"desc\" : \"descriptor\",        (string) A specialized descriptor for the matched scriptPubKey\n"
-            "    \"amount\" : x.xxx,             (numeric) The total amount in " + CURRENCY_UNIT + " of the unspent output\n"
-            "    \"height\" : n,                 (numeric) Height of the unspent transaction output\n"
-            "   }\n"
-            "   ,...],\n"
-            "  \"total_amount\" : x.xxx,          (numeric) The total amount of all found unspent outputs in " + CURRENCY_UNIT + "\n"
-            "]\n"
-                },
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::BOOL, "success", "Whether the scan was completed"},
+                        {RPCResult::Type::NUM, "txouts", "The number of unspent transaction outputs scanned"},
+                        {RPCResult::Type::NUM, "height", "The current block height (index)"},
+                        {RPCResult::Type::STR_HEX, "bestblock", "The hash of the block at the tip of the chain"},
+                        {RPCResult::Type::ARR, "unspents", "",
+                            {
+                                {RPCResult::Type::OBJ, "", "",
+                                    {
+                                        {RPCResult::Type::STR_HEX, "txid", "The transaction id"},
+                                        {RPCResult::Type::NUM, "vout", "The vout value"},
+                                        {RPCResult::Type::STR_HEX, "scriptPubKey", "The script key"},
+                                        {RPCResult::Type::STR, "desc", "A specialized descriptor for the matched scriptPubKey"},
+                                        {RPCResult::Type::STR_AMOUNT, "amount", "The total amount in " + CURRENCY_UNIT + " of the unspent output"},
+                                        {RPCResult::Type::NUM, "height", "Height of the unspent transaction output"},
+                                    }},
+                            }},
+                        {RPCResult::Type::STR_AMOUNT, "total_amount", "The total amount of all found unspent outputs in " + CURRENCY_UNIT},
+                    }},
                 RPCExamples{""},
             }.ToString()
         );
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 4a4250667e..3762e55392 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -93,8 +93,7 @@ static UniValue getnetworkhashps(const JSONRPCRequest& request)
                     {"height", RPCArg::Type::NUM, /* default */ "-1", "To estimate at the time of the given height."},
                 },
                 RPCResult{
-            "x             (numeric) Hashes per second estimated\n"
-                },
+                    RPCResult::Type::NUM, "", "Hashes per second estimated"},
                 RPCExamples{
                     HelpExampleCli("getnetworkhashps", "")
             + HelpExampleRpc("getnetworkhashps", "")
@@ -166,8 +165,10 @@ static UniValue generatetoaddress(const JSONRPCRequest& request)
                     {"maxtries", RPCArg::Type::NUM, /* default */ "1000000", "How many iterations to try."},
                 },
                 RPCResult{
-            "[ blockhashes ]     (json array) hashes of blocks generated\n"
-                },
+                    RPCResult::Type::ARR, "", "hashes of blocks generated",
+                    {
+                        {RPCResult::Type::STR_HEX, "", "blockhash"},
+                    }},
                 RPCExamples{
             "\nGenerate 11 blocks to myaddress\n"
             + HelpExampleCli("generatetoaddress", "11 \"myaddress\"")
@@ -253,8 +254,7 @@ static UniValue prioritisetransaction(const JSONRPCRequest& request)
             "                  considers the transaction as it would have paid a higher (or lower) fee."},
                 },
                 RPCResult{
-            "true              (boolean) Returns true\n"
-                },
+                    RPCResult::Type::BOOL, "", "Returns true"},
                 RPCExamples{
                     HelpExampleCli("prioritisetransaction", "\"txid\" 10000")
             + HelpExampleRpc("prioritisetransaction", "\"txid\", 10000")
@@ -798,8 +798,7 @@ static UniValue submitheader(const JSONRPCRequest& request)
                     {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block header data"},
                 },
                 RPCResult{
-            "None"
-                },
+                    RPCResult::Type::NONE, "", "None"},
                 RPCExamples{
                     HelpExampleCli("submitheader", "\"aabbcc\"") +
                     HelpExampleRpc("submitheader", "\"aabbcc\"")
@@ -848,17 +847,19 @@ static UniValue estimatesmartfee(const JSONRPCRequest& request)
             "       \"CONSERVATIVE\""},
                 },
                 RPCResult{
-            "{\n"
-            "  \"feerate\" : x.x,     (numeric, optional) estimate fee rate in " + CURRENCY_UNIT + "/kB\n"
-            "  \"errors\" : [ str... ] (json array of strings, optional) Errors encountered during processing\n"
-            "  \"blocks\" : n         (numeric) block number where estimate was found\n"
-            "}\n"
-            "\n"
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::NUM, "feerate", /* optional */ true, "estimate fee rate in " + CURRENCY_UNIT + "/kB (only present if no errors were encountered)"},
+                        {RPCResult::Type::ARR, "errors", "Errors encountered during processing",
+                            {
+                                {RPCResult::Type::STR, "", "error"},
+                            }},
+                        {RPCResult::Type::NUM, "blocks", "block number where estimate was found\n"
             "The request target will be clamped between 2 and the highest target\n"
             "fee estimation is able to return based on how long it has been running.\n"
             "An error is returned if not enough transactions and blocks\n"
-            "have been observed to make an estimate for any number of blocks.\n"
-                },
+            "have been observed to make an estimate for any number of blocks."},
+                    }},
                 RPCExamples{
                     HelpExampleCli("estimatesmartfee", "6")
                 },
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index f886481c9a..8db23379da 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -303,13 +303,14 @@ UniValue getdescriptorinfo(const JSONRPCRequest& request)
                 {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor"},
             },
             RPCResult{
-            "{\n"
-            "  \"descriptor\" : \"desc\",         (string) The descriptor in canonical form, without private keys\n"
-            "  \"checksum\" : \"chksum\",         (string) The checksum for the input descriptor\n"
-            "  \"isrange\" : true|false,        (boolean) Whether the descriptor is ranged\n"
-            "  \"issolvable\" : true|false,     (boolean) Whether the descriptor is solvable\n"
-            "  \"hasprivatekeys\" : true|false, (boolean) Whether the input descriptor contained at least one private key\n"
-            "}\n"
+                RPCResult::Type::OBJ, "", "",
+                {
+                    {RPCResult::Type::STR, "descriptor", "The descriptor in canonical form, without private keys"},
+                    {RPCResult::Type::STR, "checksum", "The checksum for the input descriptor"},
+                    {RPCResult::Type::BOOL, "isrange", "Whether the descriptor is ranged"},
+                    {RPCResult::Type::BOOL, "issolvable", "Whether the descriptor is solvable"},
+                    {RPCResult::Type::BOOL, "hasprivatekeys", "Whether the input descriptor contained at least one private key"},
+                }
             },
             RPCExamples{
             "\nAnalyse a descriptor\n"
@@ -430,7 +431,7 @@ static UniValue verifymessage(const JSONRPCRequest& request)
                     {"message", RPCArg::Type::STR, RPCArg::Optional::NO, "The message that was signed."},
                 },
                 RPCResult{
-            "true|false   (boolean) If the signature is verified or not.\n"
+                    RPCResult::Type::BOOL, "", "If the signature is verified or not."
                 },
                 RPCExamples{
             "\nUnlock the wallet for 30 seconds\n"
@@ -488,7 +489,7 @@ static UniValue signmessagewithprivkey(const JSONRPCRequest& request)
                     {"message", RPCArg::Type::STR, RPCArg::Optional::NO, "The message to create a signature of."},
                 },
                 RPCResult{
-            "\"signature\"          (string) The signature of the message encoded in base 64\n"
+                    RPCResult::Type::STR, "signature", "The signature of the message encoded in base 64"
                 },
                 RPCExamples{
             "\nCreate the signature\n"
@@ -1137,19 +1138,21 @@ static UniValue getmemoryinfo(const JSONRPCRequest& request)
                 },
                 {
                     RPCResult{"mode \"stats\"",
-            "{\n"
-            "  \"locked\" : {               (json object) Information about locked memory manager\n"
-            "    \"used\" : xxxxx,          (numeric) Number of bytes used\n"
-            "    \"free\" : xxxxx,          (numeric) Number of bytes available in current arenas\n"
-            "    \"total\" : xxxxxxx,       (numeric) Total number of bytes managed\n"
-            "    \"locked\" : xxxxxx,       (numeric) Amount of bytes that succeeded locking. If this number is smaller than total, locking pages failed at some point and key data could be swapped to disk.\n"
-            "    \"chunks_used\" : xxxxx,   (numeric) Number allocated chunks\n"
-            "    \"chunks_free\" : xxxxx,   (numeric) Number unused chunks\n"
-            "  }\n"
-            "}\n"
+                        RPCResult::Type::OBJ, "", "",
+                        {
+                            {RPCResult::Type::OBJ, "locked", "Information about locked memory manager",
+                            {
+                                {RPCResult::Type::NUM, "used", "Number of bytes used"},
+                                {RPCResult::Type::NUM, "free", "Number of bytes available in current arenas"},
+                                {RPCResult::Type::NUM, "total", "Total number of bytes managed"},
+                                {RPCResult::Type::NUM, "locked", "Amount of bytes that succeeded locking. If this number is smaller than total, locking pages failed at some point and key data could be swapped to disk."},
+                                {RPCResult::Type::NUM, "chunks_used", "Number allocated chunks"},
+                                {RPCResult::Type::NUM, "chunks_free", "Number unused chunks"},
+                            }},
+                        }
                     },
                     RPCResult{"mode \"mallocinfo\"",
-            "\"<malloc version=\"1\">...\"\n"
+                        RPCResult::Type::STR, "", "\"<malloc version=\"1\">...\""
                     },
                 },
                 RPCExamples{
@@ -1220,10 +1223,10 @@ static UniValue logging(const JSONRPCRequest& request)
                         }},
                 },
                 RPCResult{
-            "{                   (json object where keys are the logging categories, and values indicates its status\n"
-            "  \"category\" : true|false,  (boolean) if being debug logged or not. false:inactive, true:active\n"
-            "  ...\n"
-            "}\n"
+                    RPCResult::Type::OBJ_DYN, "", "keys are the logging categories, and values indicates its status",
+                    {
+                        {RPCResult::Type::BOOL, "category", "if being debug logged or not. false:inactive, true:active"},
+                    }
                 },
                 RPCExamples{
                     HelpExampleCli("logging", "\"[\\\"all\\\"]\" \"[\\\"http\\\"]\"")
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index d4a7e8db3a..d8a2d3eda8 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -34,7 +34,7 @@ static UniValue getconnectioncount(const JSONRPCRequest& request)
                 "\nReturns the number of connections to other nodes.\n",
                 {},
                 RPCResult{
-            "n          (numeric) The connection count\n"
+                    RPCResult::Type::NUM, "", "The connection count"
                 },
                 RPCExamples{
                     HelpExampleCli("getconnectioncount", "")
@@ -413,20 +413,21 @@ static UniValue getnettotals(const JSONRPCRequest& request)
                 "and current time.\n",
                 {},
                 RPCResult{
-            "{\n"
-            "  \"totalbytesrecv\" : n,   (numeric) Total bytes received\n"
-            "  \"totalbytessent\" : n,   (numeric) Total bytes sent\n"
-            "  \"timemillis\" : t,       (numeric) Current UNIX time in milliseconds\n"
-            "  \"uploadtarget\" : \n"
-            "  {\n"
-            "    \"timeframe\" : n,                         (numeric) Length of the measuring timeframe in seconds\n"
-            "    \"target\" : n,                            (numeric) Target in bytes\n"
-            "    \"target_reached\" : true|false,           (boolean) True if target is reached\n"
-            "    \"serve_historical_blocks\" : true|false,  (boolean) True if serving historical blocks\n"
-            "    \"bytes_left_in_cycle\" : t,               (numeric) Bytes left in current time cycle\n"
-            "    \"time_left_in_cycle\" : t                 (numeric) Seconds left in current time cycle\n"
-            "  }\n"
-            "}\n"
+                   RPCResult::Type::OBJ, "", "",
+                   {
+                       {RPCResult::Type::NUM, "totalbytesrecv", "Total bytes received"},
+                       {RPCResult::Type::NUM, "totalbytessent", "Total bytes sent"},
+                       {RPCResult::Type::NUM_TIME, "timemillis", "Current UNIX time in milliseconds"},
+                       {RPCResult::Type::OBJ, "uploadtarget", "",
+                       {
+                           {RPCResult::Type::NUM, "timeframe", "Length of the measuring timeframe in seconds"},
+                           {RPCResult::Type::NUM, "target", "Target in bytes"},
+                           {RPCResult::Type::BOOL, "target_reached", "True if target is reached"},
+                           {RPCResult::Type::BOOL, "serve_historical_blocks", "True if serving historical blocks"},
+                           {RPCResult::Type::NUM, "bytes_left_in_cycle", "Bytes left in current time cycle"},
+                           {RPCResult::Type::NUM, "time_left_in_cycle", "Seconds left in current time cycle"},
+                        }},
+                    }
                 },
                 RPCExamples{
                     HelpExampleCli("getnettotals", "")
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 0dc71f5c10..6346190ad2 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -133,7 +133,7 @@ static UniValue getrawtransaction(const JSONRPCRequest& request)
                 },
                 {
                     RPCResult{"if verbose is not set or set to false",
-            "\"data\"      (string) The serialized, hex-encoded data for 'txid'\n"
+                         RPCResult::Type::STR, "data", "The serialized, hex-encoded data for 'txid'"
                      },
                      RPCResult{"if verbose is set to true",
             "{\n"
@@ -273,7 +273,7 @@ static UniValue gettxoutproof(const JSONRPCRequest& request)
                     {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED_NAMED_ARG, "If specified, looks for txid in the block with this hash"},
                 },
                 RPCResult{
-            "\"data\"           (string) A string that is a serialized, hex-encoded data for the proof.\n"
+                    RPCResult::Type::STR, "data", "A string that is a serialized, hex-encoded data for the proof."
                 },
                 RPCExamples{
                     HelpExampleCli("gettxoutproof", "'[\"mytxid\",...]'")
@@ -367,7 +367,10 @@ static UniValue verifytxoutproof(const JSONRPCRequest& request)
                     {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex-encoded proof generated by gettxoutproof"},
                 },
                 RPCResult{
-            "[\"txid\"]      (array, strings) The txid(s) which the proof commits to, or empty array if the proof can not be validated.\n"
+                    RPCResult::Type::ARR, "", "",
+                    {
+                        {RPCResult::Type::STR_HEX, "txid", "The txid(s) which the proof commits to, or empty array if the proof can not be validated."},
+                    }
                 },
                 RPCExamples{
                     HelpExampleCli("verifytxoutproof", "\"proof\"")
@@ -446,7 +449,7 @@ static UniValue createrawtransaction(const JSONRPCRequest& request)
                     {"locktime", RPCArg::Type::NUM, /* default */ "0", "Raw locktime. Non-0 value also locktime-activates inputs"},
                 },
                 RPCResult{
-            "\"transaction\"              (string) hex string of the transaction\n"
+                    RPCResult::Type::STR_HEX, "transaction", "hex string of the transaction"
                 },
                 RPCExamples{
                     HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"address\\\":0.01}]\"")
@@ -617,7 +620,7 @@ static UniValue combinerawtransaction(const JSONRPCRequest& request)
                         },
                 },
                 RPCResult{
-            "\"hex\"            (string) The hex-encoded raw transaction with signature(s)\n"
+                    RPCResult::Type::STR, "", "The hex-encoded raw transaction with signature(s)"
                 },
                 RPCExamples{
                     HelpExampleCli("combinerawtransaction", "'[\"myhex1\", \"myhex2\", \"myhex3\"]'")
@@ -725,20 +728,22 @@ static UniValue signrawtransactionwithkey(const JSONRPCRequest& request)
                     },
                 },
                 RPCResult{
-            "{\n"
-            "  \"hex\" : \"value\",                  (string) The hex-encoded raw transaction with signature(s)\n"
-            "  \"complete\" : true|false,          (boolean) If the transaction has a complete set of signatures\n"
-            "  \"errors\" : [                      (json array of objects) Script verification errors (if there are any)\n"
-            "    {\n"
-            "      \"txid\" : \"hash\",              (string) The hash of the referenced, previous transaction\n"
-            "      \"vout\" : n,                   (numeric) The index of the output to spent and used as input\n"
-            "      \"scriptSig\" : \"hex\",          (string) The hex-encoded signature script\n"
-            "      \"sequence\" : n,               (numeric) Script sequence number\n"
-            "      \"error\" : \"text\"              (string) Verification or signing error related to the input\n"
-            "    }\n"
-            "    ,...\n"
-            "  ]\n"
-            "}\n"
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::STR_HEX, "hex", "The hex-encoded raw transaction with signature(s)"},
+                        {RPCResult::Type::BOOL, "complete", "If the transaction has a complete set of signatures"},
+                        {RPCResult::Type::ARR, "errors", "Script verification errors (if there are any)",
+                        {
+                            {RPCResult::Type::OBJ, "", "",
+                            {
+                                {RPCResult::Type::STR_HEX, "txid", "The hash of the referenced, previous transaction"},
+                                {RPCResult::Type::NUM, "vout", "The index of the output to spent and used as input"},
+                                {RPCResult::Type::STR_HEX, "scriptSig", "The hex-encoded signature script"},
+                                {RPCResult::Type::NUM, "sequence", "Script sequence number"},
+                                {RPCResult::Type::STR, "error", "Verification or signing error related to the input"},
+                            }},
+                        }},
+                    }
                 },
                 RPCExamples{
                     HelpExampleCli("signrawtransactionwithkey", "\"myhex\" \"[\\\"key1\\\",\\\"key2\\\"]\"")
@@ -788,7 +793,7 @@ UniValue sendrawtransaction(const JSONRPCRequest& request)
                     {"bypasslimits", RPCArg::Type::BOOL, /* default_val */ "false", "Bypass transaction policy limits"},
                 },
                 RPCResult{
-            "\"hex\"             (string) The transaction hash in hex\n"
+                    RPCResult::Type::STR_HEX, "", "The transaction hash in hex"
                 },
                 RPCExamples{
             "\nCreate a transaction\n"
@@ -856,14 +861,16 @@ static UniValue testmempoolaccept(const JSONRPCRequest& request)
                     {"maxfeerate", RPCArg::Type::AMOUNT, /* default */ FormatMoney(DEFAULT_MAX_RAW_TX_FEE), "Reject transactions whose fee rate is higher than the specified value, expressed in " + CURRENCY_UNIT + "/kB\n"},
                 },
                 RPCResult{
-            "[                   (json array) The result of the mempool acceptance test for each raw transaction in the input array.\n"
-            "                            Length is exactly one for now.\n"
-            " {\n"
-            "  \"txid\"           (string) The transaction hash in hex\n"
-            "  \"allowed\"        (boolean) If the mempool allows this tx to be inserted\n"
-            "  \"reject-reason\"  (string) Rejection string (only present when 'allowed' is false)\n"
-            " }\n"
-            "]\n"
+                    RPCResult::Type::ARR, "", "The result of the mempool acceptance test for each raw transaction in the input array.\n"
+                        "Length is exactly one for now.",
+                    {
+                        {RPCResult::Type::OBJ, "", "",
+                        {
+                            {RPCResult::Type::STR_HEX, "txid", "The transaction hash in hex"},
+                            {RPCResult::Type::BOOL, "allowed", "If the mempool allows this tx to be inserted"},
+                            {RPCResult::Type::STR, "reject-reason", "Rejection string (only present when 'allowed' is false)"},
+                        }},
+                    }
                 },
                 RPCExamples{
             "\nCreate a transaction\n"
@@ -1195,7 +1202,7 @@ UniValue combinepsbt(const JSONRPCRequest& request)
                         },
                 },
                 RPCResult{
-            "  \"psbt\"          (string) The base64-encoded partially signed transaction\n"
+                    RPCResult::Type::STR, "", "The base64-encoded partially signed transaction"
                 },
                 RPCExamples{
                     HelpExampleCli("combinepsbt", "[\"mybase64_1\", \"mybase64_2\", \"mybase64_3\"]")
@@ -1328,7 +1335,7 @@ UniValue createpsbt(const JSONRPCRequest& request)
                     {"locktime", RPCArg::Type::NUM, /* default */ "0", "Raw locktime. Non-0 value also locktime-activates inputs"},
                 },
                 RPCResult{
-                            "  \"psbt\"        (string)  The resulting raw transaction (base64-encoded string)\n"
+                    RPCResult::Type::STR, "", "The resulting raw transaction (base64-encoded string)"
                 },
                 RPCExamples{
                     HelpExampleCli("createpsbt", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"")
@@ -1375,7 +1382,7 @@ UniValue converttopsbt(const JSONRPCRequest& request)
                             "                              will continue. If false, RPC will fail if any signatures are present."},
                 },
                 RPCResult{
-                            "  \"psbt\"        (string)  The resulting raw transaction (base64-encoded string)\n"
+                    RPCResult::Type::STR, "", "The resulting raw transaction (base64-encoded string)"
                 },
                 RPCExamples{
                             "\nCreate a transaction\n"
@@ -1430,7 +1437,7 @@ UniValue utxoupdatepsbt(const JSONRPCRequest& request)
                 {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "A base64 string of a PSBT"}
             },
             RPCResult {
-                "  \"psbt\"          (string) The base64-encoded partially signed transaction with inputs updated\n"
+                    RPCResult::Type::STR, "", "The base64-encoded partially signed transaction with inputs updated"
             },
             RPCExamples {
                 HelpExampleCli("utxoupdatepsbt", "\"psbt\"")
@@ -1495,7 +1502,7 @@ UniValue joinpsbts(const JSONRPCRequest& request)
                     }}
             },
             RPCResult {
-                "  \"psbt\"          (string) The base64-encoded partially signed transaction\n"
+                    RPCResult::Type::STR, "", "The base64-encoded partially signed transaction"
             },
             RPCExamples {
                 HelpExampleCli("joinpsbts", "\"psbt\"")
diff --git a/src/rpc/server.cpp b/src/rpc/server.cpp
index 608810c5a6..54168ab2be 100644
--- a/src/rpc/server.cpp
+++ b/src/rpc/server.cpp
@@ -161,7 +161,7 @@ UniValue help(const JSONRPCRequest& jsonRequest)
                     {"subcommand", RPCArg::Type::STR, /* default */ "all subcommands", "The subcommand to get help on. Please note that not all subcommands support this at the moment"},
                 },
                 RPCResult{
-            "\"text\"     (string) The help text\n"
+                    RPCResult::Type::STR, "", "The help text"
                 },
                 RPCExamples{""},
             }.ToString()
@@ -208,7 +208,7 @@ static UniValue uptime(const JSONRPCRequest& jsonRequest)
                 "\nReturns the total uptime of the server.\n",
                             {},
                             RPCResult{
-                        "ttt        (numeric) The number of seconds that the server has been running\n"
+                                RPCResult::Type::NUM, "", "The number of seconds that the server has been running"
                             },
                 RPCExamples{
                     HelpExampleCli("uptime", "")
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index 8603424c9b..7ba1b57d4a 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -868,7 +868,7 @@ UniValue dumpprivkey(const JSONRPCRequest& request)
                     {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The dash address for the private key"},
                 },
                 RPCResult{
-            "\"key\"                (string) The private key\n"
+                    RPCResult::Type::STR, "key", "The private key"
                 },
                 RPCExamples{
                     HelpExampleCli("dumpprivkey", "\"myaddress\"")
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 2260f112d4..db8ecc14d7 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -24,6 +24,7 @@
 #include <util/moneystr.h>
 #include <util/url.h>
 #include <util/validation.h>
+#include <util/vector.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/psbtwallet.h>
@@ -211,7 +212,7 @@ static UniValue getrawchangeaddress(const JSONRPCRequest& request)
                 "This is for use with raw transactions, NOT normal use.\n",
                 {},
                 RPCResult{
-            "\"address\"    (string) The address\n"
+                    RPCResult::Type::STR, "address", "The address"
                 },
                 RPCExamples{
                     HelpExampleCli("getrawchangeaddress", "")
@@ -361,7 +362,7 @@ static UniValue sendtoaddress(const JSONRPCRequest& request)
             "       \"CONSERVATIVE\""},
                 },
                 RPCResult{
-            "\"txid\"                  (string) The transaction id.\n"
+                    RPCResult::Type::STR_HEX, "txid", "The transaction id."
                 },
                 RPCExamples{
                     HelpExampleCli("sendtoaddress", "\"XwnLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPwG\" 0.1")
@@ -561,7 +562,7 @@ static UniValue signmessage(const JSONRPCRequest& request)
                     {"message", RPCArg::Type::STR, RPCArg::Optional::NO, "The message to create a signature of."},
                 },
                 RPCResult{
-            "\"signature\"          (string) The signature of the message encoded in base 64\n"
+                    RPCResult::Type::STR, "signature", "The signature of the message encoded in base 64"
                 },
                 RPCExamples{
             "\nUnlock the wallet for 30 seconds\n"
@@ -628,7 +629,7 @@ static UniValue getreceivedbyaddress(const JSONRPCRequest& request)
                     {"addlocked", RPCArg::Type::BOOL, /* default */ "false", "Whether to include transactions locked via InstantSend."},
                 },
                 RPCResult{
-            "amount   (numeric) The total amount in " + CURRENCY_UNIT + " received at this address.\n"
+                    RPCResult::Type::STR_AMOUNT, "amount", "The total amount in " + CURRENCY_UNIT + " received at this address."
                 },
                 RPCExamples{
             "\nThe amount from transactions with at least 1 confirmation\n"
@@ -702,7 +703,7 @@ static UniValue getreceivedbylabel(const JSONRPCRequest& request)
                     {"addlocked", RPCArg::Type::BOOL, /* default */ "false", "Whether to include transactions locked via InstantSend."},
                 },
                 RPCResult{
-            "amount              (numeric) The total amount in " + CURRENCY_UNIT + " received for this label.\n"
+                    RPCResult::Type::STR_AMOUNT, "amount", "The total amount in " + CURRENCY_UNIT + " received for this label."
                 },
                 RPCExamples{
             "\nAmount received by the default label with at least 1 confirmation\n"
@@ -776,7 +777,7 @@ static UniValue getbalance(const JSONRPCRequest& request)
                     {"include_watchonly", RPCArg::Type::BOOL, /* default */ "false", "Also include balance in watch-only addresses (see 'importaddress')"},
                 },
                 RPCResult{
-            "amount              (numeric) The total amount in " + CURRENCY_UNIT + " received for this wallet.\n"
+                    RPCResult::Type::STR_AMOUNT, "amount", "The total amount in " + CURRENCY_UNIT + " received for this wallet."
                 },
                 RPCExamples{
             "\nThe total amount in the wallet with 0 or more confirmations\n"
@@ -889,8 +890,8 @@ static UniValue sendmany(const JSONRPCRequest& request)
             "       \"CONSERVATIVE\""},
                 },
                  RPCResult{
-            "\"txid\"                   (string) The transaction id for the send. Only 1 transaction is created regardless of \n"
-            "                                    the number of addresses.\n"
+                     RPCResult::Type::STR_HEX, "txid", "The transaction id for the send. Only 1 transaction is created regardless of\n"
+            "the number of addresses."
                  },
                 RPCExamples{
             "\nSend two amounts to two different addresses:\n"
@@ -2240,7 +2241,7 @@ static UniValue lockunspent(const JSONRPCRequest& request)
                     },
                 },
                 RPCResult{
-            "true|false    (boolean) Whether the command was successful or not\n"
+                    RPCResult::Type::BOOL, "", "Whether the command was successful or not"
                 },
                 RPCExamples{
             "\nList the unspent transactions\n"
@@ -2356,13 +2357,14 @@ static UniValue listlockunspent(const JSONRPCRequest& request)
                 "See the lockunspent call to lock and unlock transactions for spending.\n",
                 {},
                 RPCResult{
-            "[\n"
-            "  {\n"
-            "    \"txid\" : \"transactionid\",     (string) The transaction id locked\n"
-            "    \"vout\" : n                      (numeric) The vout value\n"
-            "  }\n"
-            "  ,...\n"
-            "]\n"
+                    RPCResult::Type::ARR, "", "",
+                    {
+                        {RPCResult::Type::OBJ, "", "",
+                        {
+                            {RPCResult::Type::STR_HEX, "txid", "The transaction id locked"},
+                            {RPCResult::Type::NUM, "vout", "The vout value"},
+                        }},
+                    }
                 },
                 RPCExamples{
             "\nList the unspent transactions\n"
@@ -2414,7 +2416,7 @@ static UniValue settxfee(const JSONRPCRequest& request)
                     {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "The transaction fee in " + CURRENCY_UNIT + "/kB"},
                 },
                 RPCResult{
-            "true|false        (boolean) Returns true if successful\n"
+                    RPCResult::Type::BOOL, "", "Returns true if successful"
                 },
                 RPCExamples{
                     HelpExampleCli("settxfee", "0.00001")
@@ -2625,14 +2627,16 @@ static UniValue listwalletdir(const JSONRPCRequest& request)
                 "Returns a list of wallets in the wallet directory.\n",
                 {},
                 RPCResult{
-            "{\n"
-            "  \"wallets\" : [                (json array of objects)\n"
-            "    {\n"
-            "      \"name\" : \"name\"          (string) The wallet name\n"
-            "    }\n"
-            "    ,...\n"
-            "  ]\n"
-            "}\n"
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::ARR, "wallets", "",
+                        {
+                            {RPCResult::Type::OBJ, "", "",
+                            {
+                                {RPCResult::Type::STR, "name", "The wallet name"},
+                            }},
+                        }},
+                    }
                 },
                 RPCExamples{
                     HelpExampleCli("listwalletdir", "")
@@ -2662,10 +2666,10 @@ static UniValue listwallets(const JSONRPCRequest& request)
                 "For full information on the wallet, use \"getwalletinfo\"\n",
                 {},
                 RPCResult{
-            "[                         (json array of strings)\n"
-            "  \"walletname\"            (string) the wallet name\n"
-            "   ...\n"
-            "]\n"
+                    RPCResult::Type::ARR, "", "",
+                    {
+                        {RPCResult::Type::STR, "walletname", "the wallet name"},
+                    }
                 },
                 RPCExamples{
                     HelpExampleCli("listwallets", "")
@@ -2852,10 +2856,11 @@ static UniValue createwallet(const JSONRPCRequest& request)
             {"passphrase", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Encrypt the wallet with this passphrase."},
         },
         RPCResult{
-            "{\n"
-            "  \"name\" :    <wallet_name>,        (string) The wallet name if created successfully. If the wallet was created using a full path, the wallet_name will be the full path.\n"
-            "  \"warning\" : <warning>,            (string) Warning message if wallet was not loaded cleanly.\n"
-            "}\n"
+            RPCResult::Type::OBJ, "", "",
+            {
+                {RPCResult::Type::STR, "name", "The wallet name if created successfully. If the wallet was created using a full path, the wallet_name will be the full path."},
+                {RPCResult::Type::STR, "warning", "Warning message if wallet was not loaded cleanly."},
+            }
         },
         RPCExamples{
             HelpExampleCli("createwallet", "\"testwallet\"")
@@ -3350,11 +3355,12 @@ static UniValue fundrawtransaction(const JSONRPCRequest& request)
                         "options"},
                 },
                 RPCResult{
-                            "{\n"
-                            "  \"hex\" :       \"value\", (string)  The resulting raw transaction (hex-encoded string)\n"
-                            "  \"fee\" :       n,         (numeric) Fee in " + CURRENCY_UNIT + " the resulting transaction pays\n"
-                            "  \"changepos\" : n          (numeric) The position of the added change output, or -1\n"
-                            "}\n"
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::STR_HEX, "hex", "The resulting raw transaction (hex-encoded string)"},
+                        {RPCResult::Type::STR_AMOUNT, "fee", "Fee in " + CURRENCY_UNIT + " the resulting transaction pays"},
+                        {RPCResult::Type::NUM, "changepos", "The position of the added change output, or -1"},
+                    }
                                 },
                                 RPCExamples{
                             "\nCreate a transaction with no inputs\n"
@@ -3428,20 +3434,22 @@ UniValue signrawtransactionwithwallet(const JSONRPCRequest& request)
             "       \"SINGLE|ANYONECANPAY\""},
                 },
                 RPCResult{
-            "{\n"
-            "  \"hex\" : \"value\",                  (string) The hex-encoded raw transaction with signature(s)\n"
-            "  \"complete\" : true|false,          (boolean) If the transaction has a complete set of signatures\n"
-            "  \"errors\" : [                      (json array of objects) Script verification errors (if there are any)\n"
-            "    {\n"
-            "      \"txid\" : \"hash\",              (string) The hash of the referenced, previous transaction\n"
-            "      \"vout\" : n,                   (numeric) The index of the output to spent and used as input\n"
-            "      \"scriptSig\" : \"hex\",          (string) The hex-encoded signature script\n"
-            "      \"sequence\" : n,               (numeric) Script sequence number\n"
-            "      \"error\" : \"text\"              (string) Verification or signing error related to the input\n"
-            "    }\n"
-            "    ,...\n"
-            "  ]\n"
-            "}\n"
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::STR_HEX, "hex", "The hex-encoded raw transaction with signature(s)"},
+                        {RPCResult::Type::BOOL, "complete", "If the transaction has a complete set of signatures"},
+                        {RPCResult::Type::ARR, "errors", "Script verification errors (if there are any)",
+                        {
+                            {RPCResult::Type::OBJ, "", "",
+                            {
+                                {RPCResult::Type::STR_HEX, "txid", "The hash of the referenced, previous transaction"},
+                                {RPCResult::Type::NUM, "vout", "The index of the output to spent and used as input"},
+                                {RPCResult::Type::STR_HEX, "scriptSig", "The hex-encoded signature script"},
+                                {RPCResult::Type::NUM, "sequence", "Script sequence number"},
+                                {RPCResult::Type::STR, "error", "Verification or signing error related to the input"},
+                            }},
+                        }},
+                    }
                 },
                 RPCExamples{
                     HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"")
@@ -3547,10 +3555,11 @@ static UniValue rescanblockchain(const JSONRPCRequest& request)
                     {"stop_height", RPCArg::Type::NUM, RPCArg::Optional::OMITTED_NAMED_ARG, "the last block height that should be scanned. If none is provided it will rescan up to the tip at return time of this call."},
                 },
                 RPCResult{
-            "{\n"
-            "  \"start_height\"     (numeric) The block height where the rescan started (the requested height or 0)\n"
-            "  \"stop_height\"      (numeric) 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.\n"
-            "}\n"
+                    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."},
+                    }
                 },
                 RPCExamples{
                     HelpExampleCli("rescanblockchain", "100000 120000")
@@ -3828,11 +3837,13 @@ static UniValue getaddressesbylabel(const JSONRPCRequest& request)
                     {"label", RPCArg::Type::STR, RPCArg::Optional::NO, "The label."},
                 },
                 RPCResult{
-            "{ (json object with addresses as keys)\n"
-            "  \"address\" : { (json object with information about address)\n"
-            "    \"purpose\" : \"string\" (string)  Purpose of address (\"send\" for sending address, \"receive\" for receiving address)\n"
-            "  },...\n"
-            "}\n"
+                    RPCResult::Type::OBJ_DYN, "", "json object with addresses as keys",
+                    {
+                        {RPCResult::Type::OBJ, "address", "json object with information about address",
+                        {
+                            {RPCResult::Type::STR, "purpose", "Purpose of address (\"send\" for sending address, \"receive\" for receiving address)"},
+                        }},
+                    }
                 },
                 RPCExamples{
                     HelpExampleCli("getaddressesbylabel", "\"tabby\"")
@@ -3887,10 +3898,10 @@ static UniValue listlabels(const JSONRPCRequest& request)
                     {"purpose", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG, "Address purpose to list labels for ('send','receive'). An empty string is the same as not providing this argument."},
                 },
                 RPCResult{
-            "[               (json array of string)\n"
-            "  \"label\",      (string) Label name\n"
-            "  ...\n"
-            "]\n"
+                    RPCResult::Type::ARR, "", "",
+                    {
+                        {RPCResult::Type::STR, "label", "Label name"},
+                    }
                 },
                 RPCExamples{
             "\nList all labels\n"
@@ -4082,11 +4093,12 @@ UniValue walletcreatefundedpsbt(const JSONRPCRequest& request)
                     {"bip32derivs", RPCArg::Type::BOOL, /* default */ "false", "If true, includes the BIP 32 derivation paths for public keys if we know them"},
                 },
                 RPCResult{
-                            "{\n"
-                            "  \"psbt\" : \"value\",        (string)  The resulting raw transaction (base64-encoded string)\n"
-                            "  \"fee\" :       n,         (numeric) Fee in " + CURRENCY_UNIT + " the resulting transaction pays\n"
-                            "  \"changepos\" : n          (numeric) The position of the added change output, or -1\n"
-                            "}\n"
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::STR, "psbt", "The resulting raw transaction (base64-encoded string)"},
+                        {RPCResult::Type::STR_AMOUNT, "fee", "Fee in " + CURRENCY_UNIT + " the resulting transaction pays"},
+                        {RPCResult::Type::NUM, "changepos", "The position of the added change output, or -1"},
+                    }
                                 },
                                 RPCExamples{
                             "\nCreate a transaction with no inputs\n"
diff --git a/src/zmq/zmqrpc.cpp b/src/zmq/zmqrpc.cpp
index 1579529a09..7265c766e5 100644
--- a/src/zmq/zmqrpc.cpp
+++ b/src/zmq/zmqrpc.cpp
@@ -21,14 +21,15 @@ UniValue getzmqnotifications(const JSONRPCRequest& request)
                 "\nReturns information about the active ZeroMQ notifications.\n",
                 {},
                 RPCResult{
-            "[\n"
-            "  {                        (json object)\n"
-            "    \"type\" : \"pubhashtx\",   (string) Type of notification\n"
-            "    \"address\" : \"...\",      (string) Address of the publisher\n"
-            "    \"hwm\" : n                 (numeric) Outbound message high water mark\n"
-            "  },\n"
-            "  ...\n"
-            "]\n"
+                    RPCResult::Type::ARR, "", "",
+                    {
+                        {RPCResult::Type::OBJ, "", "",
+                        {
+                            {RPCResult::Type::STR, "type", "Type of notification"},
+                            {RPCResult::Type::STR, "address", "Address of the publisher"},
+                            {RPCResult::Type::NUM, "hwm", "Outbound message high water mark"},
+                        }},
+                    }
                 },
                 RPCExamples{
                     HelpExampleCli("getzmqnotifications", "")

From 792b73c7de3ed2fab42150bad1dcb7b49ae4a118 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Thu, 26 Mar 2020 20:28:38 +0000
Subject: [PATCH 09/16] merge bitcoin#18444: Remove final comma for last entry
 of fixed-size Arrays and Objects in RPCResult

---
 src/rpc/util.cpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 101c9fe8d1..705ac807b3 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -270,7 +270,7 @@ unsigned int ParseConfirmTarget(const UniValue& value, unsigned int max_target)
 struct Section {
     Section(const std::string& left, const std::string& right)
         : m_left{left}, m_right{right} {}
-    const std::string m_left;
+    std::string m_left;
     const std::string m_right;
 };
 
@@ -626,6 +626,10 @@ void RPCResult::ToSections(Sections& sections, const OuterType outer_type, const
         }
         if (m_type == Type::ARR) {
             sections.PushSection({indent_next + "...", ""});
+        } else {
+            CHECK_NONFATAL(!m_inner.empty());
+            // Remove final comma, which would be invalid JSON
+            sections.m_sections.back().m_left.pop_back();
         }
         sections.PushSection({indent + "]" + maybe_separator, ""});
         return;
@@ -639,6 +643,10 @@ void RPCResult::ToSections(Sections& sections, const OuterType outer_type, const
         if (m_type == Type::OBJ_DYN) {
             // If the dictionary keys are dynamic, use three dots for continuation
             sections.PushSection({indent_next + "...", ""});
+        } else {
+            CHECK_NONFATAL(!m_inner.empty());
+            // Remove final comma, which would be invalid JSON
+            sections.m_sections.back().m_left.pop_back();
         }
         sections.PushSection({indent + "}" + maybe_separator, ""});
         return;

From a9e82ad6aaec4a2375204c9790581c0a1c7efc22 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Thu, 28 May 2020 11:31:02 -0400
Subject: [PATCH 10/16] merge bitcoin#19100: Combine GetWalletForJSONRPCRequest
 and EnsureWalletIsAvailable functions

---
 src/wallet/rpcwallet.cpp | 28 +++++++++++-----------------
 src/wallet/rpcwallet.h   |  1 -
 2 files changed, 11 insertions(+), 18 deletions(-)

diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index db8ecc14d7..7646d6a7e3 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -56,6 +56,13 @@ bool GetWalletNameFromJSONRPCRequest(const JSONRPCRequest& request, std::string&
     return false;
 }
 
+std::string HelpRequiringPassphrase(CWallet * const pwallet)
+{
+    return pwallet && pwallet->IsCrypted()
+        ? "\nRequires wallet passphrase to be set with walletpassphrase call."
+        : "";
+}
+
 std::shared_ptr<CWallet> GetWalletForJSONRPCRequest(const JSONRPCRequest& request)
 {
     std::string wallet_name;
@@ -66,20 +73,12 @@ std::shared_ptr<CWallet> GetWalletForJSONRPCRequest(const JSONRPCRequest& reques
     }
 
     std::vector<std::shared_ptr<CWallet>> wallets = GetWallets();
-    return wallets.size() == 1 || (request.fHelp && wallets.size() > 0) ? wallets[0] : nullptr;
-}
+    if (wallets.size() == 1 || (request.fHelp && wallets.size() > 0)) {
+        return wallets[0];
+    }
 
-std::string HelpRequiringPassphrase(CWallet * const pwallet)
-{
-    return pwallet && pwallet->IsCrypted()
-        ? "\nRequires wallet passphrase to be set with walletpassphrase call."
-        : "";
-}
+    if (request.fHelp) return nullptr;
 
-bool EnsureWalletIsAvailable(CWallet * const pwallet, bool avoidException)
-{
-    if (pwallet) return true;
-    if (avoidException) return false;
     if (!HasWallets()) {
         throw JSONRPCError(
             RPC_WALLET_NOT_FOUND, "No wallet is loaded. Load a wallet using loadwallet or create a new one with createwallet. (Note: A default wallet is no longer automatically created)");
@@ -2680,12 +2679,7 @@ static UniValue listwallets(const JSONRPCRequest& request)
     UniValue obj(UniValue::VARR);
 
     for (const std::shared_ptr<CWallet>& wallet : GetWallets()) {
-        if (!EnsureWalletIsAvailable(wallet.get(), request.fHelp)) {
-            return NullUniValue;
-        }
-
         LOCK(wallet->cs_wallet);
-
         obj.push_back(wallet->GetName());
     }
 
diff --git a/src/wallet/rpcwallet.h b/src/wallet/rpcwallet.h
index ddb2f139cc..8a4d745a1c 100644
--- a/src/wallet/rpcwallet.h
+++ b/src/wallet/rpcwallet.h
@@ -33,7 +33,6 @@ std::shared_ptr<CWallet> GetWalletForJSONRPCRequest(const JSONRPCRequest& reques
 
 std::string HelpRequiringPassphrase(CWallet *);
 void EnsureWalletIsUnlocked(CWallet *);
-bool EnsureWalletIsAvailable(CWallet *, bool avoidException);
 
 UniValue getaddressinfo(const JSONRPCRequest& request);
 UniValue signrawtransactionwithwallet(const JSONRPCRequest& request);

From e5bea93bf921d8d58d95e22b7aaf0c38f425b74e Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sun, 27 Feb 2022 14:44:48 +0530
Subject: [PATCH 11/16] rpc: Refactor code to no longer use removed
 EnsureWalletIsAvailable

---
 src/rpc/coinjoin.cpp     |   3 +-
 src/rpc/governance.cpp   |  12 +--
 src/rpc/masternode.cpp   |   3 +-
 src/rpc/rpcevo.cpp       |  15 +--
 src/wallet/rpcdump.cpp   |  46 +++------
 src/wallet/rpcwallet.cpp | 204 ++++++++-------------------------------
 6 files changed, 65 insertions(+), 218 deletions(-)

diff --git a/src/rpc/coinjoin.cpp b/src/rpc/coinjoin.cpp
index 306d7da448..ec3e53c5b1 100644
--- a/src/rpc/coinjoin.cpp
+++ b/src/rpc/coinjoin.cpp
@@ -19,9 +19,8 @@
 static UniValue coinjoin(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
diff --git a/src/rpc/governance.cpp b/src/rpc/governance.cpp
index 4c8912f7f2..d2f8013775 100644
--- a/src/rpc/governance.cpp
+++ b/src/rpc/governance.cpp
@@ -151,9 +151,8 @@ static void gobject_prepare_help(const JSONRPCRequest& request, CWallet* const p
 static UniValue gobject_prepare(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp || (request.params.size() != 5 && request.params.size() != 6 && request.params.size() != 8))
         gobject_prepare_help(request, pwallet);
@@ -272,9 +271,8 @@ static void gobject_list_prepared_help(const JSONRPCRequest& request, CWallet* c
 static UniValue gobject_list_prepared(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp || (request.params.size() > 2)) {
         gobject_list_prepared_help(request, pwallet);
@@ -615,9 +613,8 @@ static void gobject_vote_many_help(const JSONRPCRequest& request, CWallet* const
 static UniValue gobject_vote_many(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp || request.params.size() != 4)
         gobject_vote_many_help(request, pwallet);
@@ -672,9 +669,8 @@ static void gobject_vote_alias_help(const JSONRPCRequest& request, CWallet* cons
 static UniValue gobject_vote_alias(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp || request.params.size() != 5)
         gobject_vote_alias_help(request, pwallet);
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 60b888d3a4..0c57a686d8 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -203,9 +203,8 @@ static void masternode_outputs_help(const JSONRPCRequest& request)
 static UniValue masternode_outputs(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp)
         masternode_outputs_help(request);
diff --git a/src/rpc/rpcevo.cpp b/src/rpc/rpcevo.cpp
index f8b0f93dcf..3d147b60e4 100644
--- a/src/rpc/rpcevo.cpp
+++ b/src/rpc/rpcevo.cpp
@@ -433,9 +433,8 @@ static void protx_register_submit_help(const JSONRPCRequest& request, CWallet* c
 static UniValue protx_register(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     bool isExternalRegister = request.params[0].get_str() == "register";
     bool isFundRegister = request.params[0].get_str() == "register_fund";
@@ -595,9 +594,8 @@ static UniValue protx_register(const JSONRPCRequest& request)
 static UniValue protx_register_submit(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp || request.params.size() != 3) {
         protx_register_submit_help(request, pwallet);
@@ -652,9 +650,8 @@ static void protx_update_service_help(const JSONRPCRequest& request, CWallet* co
 static UniValue protx_update_service(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp || (request.params.size() < 4 || request.params.size() > 6))
         protx_update_service_help(request, pwallet);
@@ -750,9 +747,8 @@ static void protx_update_registrar_help(const JSONRPCRequest& request, CWallet*
 static UniValue protx_update_registrar(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp || (request.params.size() != 5 && request.params.size() != 6)) {
         protx_update_registrar_help(request, pwallet);
@@ -841,9 +837,8 @@ static void protx_revoke_help(const JSONRPCRequest& request, CWallet* const pwal
 static UniValue protx_revoke(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp || (request.params.size() < 3 || request.params.size() > 5)) {
         protx_revoke_help(request, pwallet);
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index 7ba1b57d4a..2ffb0fa068 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -84,10 +84,8 @@ static void RescanWallet(CWallet& wallet, const WalletRescanReserver& reserver,
 UniValue importprivkey(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
 
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 3)
         throw std::runtime_error(
@@ -185,10 +183,8 @@ UniValue importprivkey(const JSONRPCRequest& request)
 UniValue abortrescan(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
 
     if (request.fHelp || request.params.size() > 0)
         throw std::runtime_error(
@@ -252,10 +248,8 @@ static void ImportAddress(CWallet * const pwallet, const CTxDestination& dest, c
 UniValue importaddress(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
 
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 4)
         throw std::runtime_error(
@@ -344,10 +338,8 @@ UniValue importaddress(const JSONRPCRequest& request)
 UniValue importprunedfunds(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
 
     if (request.fHelp || request.params.size() != 2)
         throw std::runtime_error(
@@ -413,10 +405,8 @@ UniValue importprunedfunds(const JSONRPCRequest& request)
 UniValue removeprunedfunds(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
 
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
@@ -456,10 +446,8 @@ UniValue removeprunedfunds(const JSONRPCRequest& request)
 UniValue importpubkey(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
 
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 3)
         throw std::runtime_error(
@@ -537,10 +525,8 @@ UniValue importpubkey(const JSONRPCRequest& request)
 UniValue importwallet(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
 
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
@@ -703,9 +689,8 @@ UniValue importwallet(const JSONRPCRequest& request)
 UniValue importelectrumwallet(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 2)
         throw std::runtime_error(
@@ -854,10 +839,8 @@ UniValue importelectrumwallet(const JSONRPCRequest& request)
 UniValue dumpprivkey(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
 
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
@@ -901,9 +884,8 @@ UniValue dumpprivkey(const JSONRPCRequest& request)
 UniValue dumphdinfo(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp || request.params.size() != 0)
         throw std::runtime_error(
@@ -949,10 +931,8 @@ UniValue dumphdinfo(const JSONRPCRequest& request)
 UniValue dumpwallet(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
 
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
@@ -1488,10 +1468,8 @@ static int64_t GetImportTimestamp(const UniValue& data, int64_t now)
 UniValue importmulti(const JSONRPCRequest& mainRequest)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(mainRequest);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, mainRequest.fHelp)) {
-        return NullUniValue;
-    }
 
     if (mainRequest.fHelp || mainRequest.params.size() < 1 || mainRequest.params.size() > 2)
         throw std::runtime_error(
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 7646d6a7e3..ed5de24b5b 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -144,12 +144,9 @@ static std::string LabelFromValue(const UniValue& value)
 UniValue getnewaddress(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() > 1)
         throw std::runtime_error(
             RPCHelpMan{"getnewaddress",
@@ -198,12 +195,9 @@ UniValue getnewaddress(const JSONRPCRequest& request)
 static UniValue getrawchangeaddress(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() > 0)
         throw std::runtime_error(
             RPCHelpMan{"getrawchangeaddress",
@@ -245,12 +239,9 @@ static UniValue getrawchangeaddress(const JSONRPCRequest& request)
 static UniValue setlabel(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() != 2)
         throw std::runtime_error(
             RPCHelpMan{"setlabel",
@@ -331,12 +322,9 @@ static CTransactionRef SendMoney(interfaces::Chain::Lock& locked_chain, CWallet
 static UniValue sendtoaddress(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() < 2 || request.params.size() > 9)
         throw std::runtime_error(
             RPCHelpMan{"sendtoaddress",
@@ -435,12 +423,9 @@ static UniValue instantsendtoaddress(const JSONRPCRequest& request)
 static UniValue listaddressgroupings(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() != 0)
         throw std::runtime_error(
             RPCHelpMan{"listaddressgroupings",
@@ -498,9 +483,8 @@ static UniValue listaddressgroupings(const JSONRPCRequest& request)
 static UniValue listaddressbalances(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp || request.params.size() > 1)
         throw std::runtime_error(
@@ -545,12 +529,9 @@ static UniValue listaddressbalances(const JSONRPCRequest& request)
 static UniValue signmessage(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() != 2)
         throw std::runtime_error(
             RPCHelpMan{"signmessage",
@@ -612,12 +593,9 @@ static UniValue signmessage(const JSONRPCRequest& request)
 static UniValue getreceivedbyaddress(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 3)
         throw std::runtime_error(
             RPCHelpMan{"getreceivedbyaddress",
@@ -686,12 +664,9 @@ static UniValue getreceivedbyaddress(const JSONRPCRequest& request)
 static UniValue getreceivedbylabel(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 3)
         throw std::runtime_error(
             RPCHelpMan{"getreceivedbylabel",
@@ -757,12 +732,9 @@ static UniValue getreceivedbylabel(const JSONRPCRequest& request)
 static UniValue getbalance(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || (request.params.size() > 4))
         throw std::runtime_error(
             RPCHelpMan{"getbalance",
@@ -824,12 +796,9 @@ static UniValue getbalance(const JSONRPCRequest& request)
 static UniValue getunconfirmedbalance(const JSONRPCRequest &request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() > 0)
         throw std::runtime_error(
             RPCHelpMan{"getunconfirmedbalance",
@@ -853,12 +822,9 @@ static UniValue getunconfirmedbalance(const JSONRPCRequest &request)
 static UniValue sendmany(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     const RPCHelpMan help{"sendmany",
                 "\nSend multiple times. Amounts are double-precision floating point numbers." +
                     HelpRequiringPassphrase(pwallet) + "\n",
@@ -1004,12 +970,9 @@ static UniValue sendmany(const JSONRPCRequest& request)
 static UniValue addmultisigaddress(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() < 2 || request.params.size() > 3)
     {
         std::string msg =
@@ -1243,12 +1206,9 @@ static UniValue ListReceived(interfaces::Chain::Lock& locked_chain, CWallet * co
 static UniValue listreceivedbyaddress(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() > 5)
         throw std::runtime_error(
             RPCHelpMan{"listreceivedbyaddress",
@@ -1299,12 +1259,9 @@ static UniValue listreceivedbyaddress(const JSONRPCRequest& request)
 static UniValue listreceivedbylabel(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() > 4)
         throw std::runtime_error(
             RPCHelpMan{"listreceivedbylabel",
@@ -1441,12 +1398,9 @@ static void ListTransactions(interfaces::Chain::Lock& locked_chain, CWallet* con
 static UniValue listtransactions(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() > 4)
         throw std::runtime_error(
             RPCHelpMan{"listtransactions",
@@ -1567,12 +1521,9 @@ static UniValue listtransactions(const JSONRPCRequest& request)
 static UniValue listsinceblock(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() > 4)
         throw std::runtime_error(
             RPCHelpMan{"listsinceblock",
@@ -1710,12 +1661,9 @@ static UniValue listsinceblock(const JSONRPCRequest& request)
 static UniValue gettransaction(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 2)
         throw std::runtime_error(
             RPCHelpMan{"gettransaction",
@@ -1809,12 +1757,9 @@ static UniValue gettransaction(const JSONRPCRequest& request)
 static UniValue abandontransaction(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"abandontransaction",
@@ -1858,12 +1803,9 @@ static UniValue abandontransaction(const JSONRPCRequest& request)
 static UniValue backupwallet(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
             RPCHelpMan{"backupwallet",
@@ -1897,12 +1839,9 @@ static UniValue backupwallet(const JSONRPCRequest& request)
 static UniValue keypoolrefill(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() > 1)
         throw std::runtime_error(
             RPCHelpMan{"keypoolrefill",
@@ -1947,12 +1886,9 @@ static UniValue keypoolrefill(const JSONRPCRequest& request)
 static UniValue walletpassphrase(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() < 2 || request.params.size() > 3) {
         throw std::runtime_error(
             RPCHelpMan{"walletpassphrase",
@@ -2048,12 +1984,9 @@ static UniValue walletpassphrase(const JSONRPCRequest& request)
 static UniValue walletpassphrasechange(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() != 2) {
         throw std::runtime_error(
             RPCHelpMan{"walletpassphrasechange",
@@ -2102,12 +2035,9 @@ static UniValue walletpassphrasechange(const JSONRPCRequest& request)
 static UniValue walletlock(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(
             RPCHelpMan{"walletlock",
@@ -2146,12 +2076,9 @@ static UniValue walletlock(const JSONRPCRequest& request)
 static UniValue encryptwallet(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"encryptwallet",
@@ -2210,12 +2137,9 @@ static UniValue encryptwallet(const JSONRPCRequest& request)
 static UniValue lockunspent(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 2)
         throw std::runtime_error(
             RPCHelpMan{"lockunspent",
@@ -2343,12 +2267,9 @@ static UniValue lockunspent(const JSONRPCRequest& request)
 static UniValue listlockunspent(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() > 0)
         throw std::runtime_error(
             RPCHelpMan{"listlockunspent",
@@ -2401,12 +2322,9 @@ static UniValue listlockunspent(const JSONRPCRequest& request)
 static UniValue settxfee(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 1) {
         throw std::runtime_error(
             RPCHelpMan{"settxfee",
@@ -2444,9 +2362,8 @@ static UniValue settxfee(const JSONRPCRequest& request)
 static UniValue setcoinjoinrounds(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
@@ -2477,9 +2394,8 @@ static UniValue setcoinjoinrounds(const JSONRPCRequest& request)
 static UniValue setcoinjoinamount(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
-        return NullUniValue;
 
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
@@ -2510,10 +2426,8 @@ static UniValue setcoinjoinamount(const JSONRPCRequest& request)
 static UniValue getwalletinfo(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
 
     if (request.fHelp || request.params.size() != 0)
         throw std::runtime_error(
@@ -2689,12 +2603,9 @@ static UniValue listwallets(const JSONRPCRequest& request)
 static UniValue upgradetohd(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp)
         throw std::runtime_error(
             RPCHelpMan{"upgradetohd",
@@ -2991,12 +2902,9 @@ static UniValue unloadwallet(const JSONRPCRequest& request)
 static UniValue listunspent(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() > 5)
         throw std::runtime_error(
             RPCHelpMan{"listunspent",
@@ -3301,12 +3209,9 @@ void FundTransaction(CWallet* const pwallet, CMutableTransaction& tx, CAmount& f
 static UniValue fundrawtransaction(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 3)
         throw std::runtime_error(
             RPCHelpMan{"fundrawtransaction",
@@ -3391,12 +3296,9 @@ static UniValue fundrawtransaction(const JSONRPCRequest& request)
 UniValue signrawtransactionwithwallet(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 3)
         throw std::runtime_error(
             RPCHelpMan{"signrawtransactionwithwallet",
@@ -3477,13 +3379,9 @@ UniValue signrawtransactionwithwallet(const JSONRPCRequest& request)
 UniValue generate(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{"generate",
@@ -3533,12 +3431,9 @@ UniValue generate(const JSONRPCRequest& request)
 static UniValue rescanblockchain(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{"rescanblockchain",
@@ -3690,12 +3585,9 @@ static UniValue AddressBookDataToJSON(const CAddressBookData& data, const bool v
 UniValue getaddressinfo(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"getaddressinfo",
@@ -3817,12 +3709,9 @@ UniValue getaddressinfo(const JSONRPCRequest& request)
 static UniValue getaddressesbylabel(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
             RPCHelpMan{"getaddressesbylabel",
@@ -3878,12 +3767,9 @@ static UniValue getaddressesbylabel(const JSONRPCRequest& request)
 static UniValue listlabels(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() > 1)
         throw std::runtime_error(
             RPCHelpMan{"listlabels",
@@ -3948,12 +3834,9 @@ UniValue importelectrumwallet(const JSONRPCRequest& request);
 UniValue walletprocesspsbt(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 4)
         throw std::runtime_error(
             RPCHelpMan{"walletprocesspsbt",
@@ -4021,12 +3904,9 @@ UniValue walletprocesspsbt(const JSONRPCRequest& request)
 UniValue walletcreatefundedpsbt(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
-        return NullUniValue;
-    }
-
     if (request.fHelp || request.params.size() < 2 || request.params.size() > 5)
         throw std::runtime_error(
             RPCHelpMan{"walletcreatefundedpsbt",

From 9cadff843e7dfaa7f74ad6e032dc605d6134c988 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sun, 27 Feb 2022 15:46:35 +0530
Subject: [PATCH 12/16] merge bitcoin#17318: replace asserts in RPC code with
 CHECK_NONFATAL and add linter

---
 src/rpc/blockchain.cpp       | 18 +++++++++---------
 src/rpc/masternode.cpp       |  4 ++--
 src/rpc/mining.cpp           |  2 +-
 src/rpc/net.cpp              |  2 +-
 src/rpc/rpcevo.cpp           |  6 +++---
 src/rpc/util.cpp             |  8 ++++----
 src/wallet/rpcdump.cpp       | 10 +++++-----
 src/wallet/rpcwallet.cpp     |  4 ++--
 test/lint/lint-assertions.sh | 11 +++++++++++
 9 files changed, 38 insertions(+), 27 deletions(-)

diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 3a4c425c37..332e2f54e4 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -66,7 +66,7 @@ extern void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue&
  */
 double GetDifficulty(const CBlockIndex* blockindex)
 {
-    assert(blockindex);
+    CHECK_NONFATAL(blockindex);
 
     int nShift = (blockindex->nBits >> 24) & 0xff;
     double dDiff =
@@ -1220,7 +1220,7 @@ static UniValue pruneblockchain(const JSONRPCRequest& request)
 
     PruneBlockFilesManual(height);
     const CBlockIndex* block = ::ChainActive().Tip();
-    assert(block);
+    CHECK_NONFATAL(block);
     while (block->pprev && (block->pprev->nStatus & BLOCK_HAVE_DATA)) {
         block = block->pprev;
     }
@@ -1535,7 +1535,7 @@ UniValue getblockchaininfo(const JSONRPCRequest& request)
     obj.pushKV("pruned",                fPruneMode);
     if (fPruneMode) {
         const CBlockIndex* block = tip;
-        assert(block);
+        CHECK_NONFATAL(block);
         while (block->pprev && (block->pprev->nStatus & BLOCK_HAVE_DATA)) {
             block = block->pprev;
         }
@@ -1929,7 +1929,7 @@ static UniValue getchaintxstats(const JSONRPCRequest& request)
         }
     }
 
-    assert(pindex != nullptr);
+    CHECK_NONFATAL(pindex != nullptr);
 
     if (request.params[0].isNull()) {
         blockcount = std::max(0, std::min(blockcount, pindex->nHeight - 1));
@@ -2111,7 +2111,7 @@ static UniValue getblockstats(const JSONRPCRequest& request)
         }
     }
 
-    assert(pindex != nullptr);
+    CHECK_NONFATAL(pindex != nullptr);
 
     std::set<std::string> stats;
     if (!request.params[1].isNull()) {
@@ -2200,7 +2200,7 @@ static UniValue getblockstats(const JSONRPCRequest& request)
             }
 
             CAmount txfee = tx_total_in - tx_total_out;
-            assert(MoneyRange(txfee));
+            CHECK_NONFATAL(MoneyRange(txfee));
             if (do_medianfee) {
                 fee_array.push_back(txfee);
             }
@@ -2440,7 +2440,7 @@ public:
     explicit CoinsViewScanReserver() : m_could_reserve(false) {}
 
     bool reserve() {
-        assert (!m_could_reserve);
+        CHECK_NONFATAL(!m_could_reserve);
         std::lock_guard<std::mutex> lock(g_utxosetscan);
         if (g_scan_in_progress) {
             return false;
@@ -2607,9 +2607,9 @@ UniValue scantxoutset(const JSONRPCRequest& request)
             LOCK(cs_main);
             ::ChainstateActive().ForceFlushStateToDisk();
             pcursor = std::unique_ptr<CCoinsViewCursor>(::ChainstateActive().CoinsDB().Cursor());
-            assert(pcursor);
+            CHECK_NONFATAL(pcursor);
             tip = ::ChainActive().Tip();
-            assert(tip);
+            CHECK_NONFATAL(tip);
         }
         bool res = FindScriptPubKey(g_scan_progress, g_should_abort_scan, count, pcursor.get(), needles, coins);
         result.pushKV("success", res);
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 0c57a686d8..43bfafbeb8 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -278,12 +278,12 @@ static std::string GetRequiredPaymentsString(int nBlockHeight, const CDeterminis
     if (payee) {
         CTxDestination dest;
         if (!ExtractDestination(payee->pdmnState->scriptPayout, dest)) {
-            assert(false);
+            CHECK_NONFATAL(false);
         }
         strPayments = EncodeDestination(dest);
         if (payee->nOperatorReward != 0 && payee->pdmnState->scriptOperatorPayout != CScript()) {
             if (!ExtractDestination(payee->pdmnState->scriptOperatorPayout, dest)) {
-                assert(false);
+                CHECK_NONFATAL(false);
             }
             strPayments += ", " + EncodeDestination(dest);
         }
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 3762e55392..378b4afa7f 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -549,7 +549,7 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
         // Need to update only after we know CreateNewBlock succeeded
         pindexPrev = pindexPrevNew;
     }
-    assert(pindexPrev);
+    CHECK_NONFATAL(pindexPrev);
     CBlock* pblock = &pblocktemplate->block; // pointer for convenience
     const Consensus::Params& consensusParams = Params().GetConsensus();
 
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index d8a2d3eda8..96c1c51e93 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -557,7 +557,7 @@ static UniValue getnetworkinfo(const JSONRPCRequest& request)
                 strSocketEvents = "kqueue";
                 break;
             default:
-                assert(false);
+                CHECK_NONFATAL(false);
         }
         obj.pushKV("socketevents", strSocketEvents);
     }
diff --git a/src/rpc/rpcevo.cpp b/src/rpc/rpcevo.cpp
index 3d147b60e4..68bb1e18bb 100644
--- a/src/rpc/rpcevo.cpp
+++ b/src/rpc/rpcevo.cpp
@@ -175,7 +175,7 @@ static CBLSSecretKey ParseBLSSecretKey(const std::string& hexKey, const std::str
 template<typename SpecialTxPayload>
 static void FundSpecialTx(CWallet* pwallet, CMutableTransaction& tx, const SpecialTxPayload& payload, const CTxDestination& fundDest)
 {
-    assert(pwallet != nullptr);
+    CHECK_NONFATAL(pwallet != nullptr);
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
@@ -242,7 +242,7 @@ static void FundSpecialTx(CWallet* pwallet, CMutableTransaction& tx, const Speci
         // CreateTransaction added a change output, so we don't need the dummy txout anymore.
         // Removing it results in slight overpayment of fees, but we ignore this for now (as it's a very low amount).
         auto it = std::find(tx.vout.begin(), tx.vout.end(), dummyTxOut);
-        assert(it != tx.vout.end());
+        CHECK_NONFATAL(it != tx.vout.end());
         tx.vout.erase(it);
     }
 }
@@ -549,7 +549,7 @@ static UniValue protx_register(const JSONRPCRequest& request)
                 break;
             }
         }
-        assert(collateralIndex != (uint32_t) -1);
+        CHECK_NONFATAL(collateralIndex != (uint32_t) -1);
         ptx.collateralOutpoint.n = collateralIndex;
 
         SetTxPayload(tx, ptx);
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 705ac807b3..a7c05b9302 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -397,7 +397,7 @@ RPCHelpMan::RPCHelpMan(std::string name, std::string description, std::vector<RP
     std::set<std::string> named_args;
     for (const auto& arg : m_args) {
         // Should have unique named arguments
-        assert(named_args.insert(arg.m_name).second);
+        CHECK_NONFATAL(named_args.insert(arg.m_name).second);
     }
 }
 
@@ -690,11 +690,11 @@ std::string RPCArg::ToStringObj(const bool oneline) const
     case Type::OBJ:
     case Type::OBJ_USER_KEYS:
         // Currently unused, so avoid writing dead code
-        assert(false);
+        CHECK_NONFATAL(false);
 
         // no default case, so the compiler can warn about missing cases
     }
-    assert(false);
+    CHECK_NONFATAL(false);
 }
 
 std::string RPCArg::ToString(const bool oneline) const
@@ -735,7 +735,7 @@ std::string RPCArg::ToString(const bool oneline) const
 
         // no default case, so the compiler can warn about missing cases
     }
-    assert(false);
+    CHECK_NONFATAL(false);
 }
 
 static std::pair<int64_t, int64_t> ParseRange(const UniValue& value)
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index 2ffb0fa068..8290ace978 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -151,7 +151,7 @@ UniValue importprivkey(const JSONRPCRequest& request)
         if (!key.IsValid()) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key encoding");
 
         CPubKey pubkey = key.GetPubKey();
-        assert(key.VerifyPubKey(pubkey));
+        CHECK_NONFATAL(key.VerifyPubKey(pubkey));
         CKeyID vchAddress = pubkey.GetID();
         {
             pwallet->MarkDirty();
@@ -636,7 +636,7 @@ UniValue importwallet(const JSONRPCRequest& request)
             std::string label = std::get<3>(key_tuple);
 
             CPubKey pubkey = key.GetPubKey();
-            assert(key.VerifyPubKey(pubkey));
+            CHECK_NONFATAL(key.VerifyPubKey(pubkey));
             CKeyID keyid = pubkey.GetID();
             if (pwallet->HaveKey(keyid)) {
                 pwallet->WalletLogPrintf("Skipping import of %s (key already present)\n", EncodeDestination(keyid));
@@ -762,7 +762,7 @@ UniValue importelectrumwallet(const JSONRPCRequest& request)
                 continue;
             }
             CPubKey pubkey = key.GetPubKey();
-            assert(key.VerifyPubKey(pubkey));
+            CHECK_NONFATAL(key.VerifyPubKey(pubkey));
             CKeyID keyid = pubkey.GetID();
             if (pwallet->HaveKey(keyid)) {
                 pwallet->WalletLogPrintf("Skipping import of %s (key already present)\n", EncodeDestination(keyid));
@@ -794,7 +794,7 @@ UniValue importelectrumwallet(const JSONRPCRequest& request)
                 continue;
             }
             CPubKey pubkey = key.GetPubKey();
-            assert(key.VerifyPubKey(pubkey));
+            CHECK_NONFATAL(key.VerifyPubKey(pubkey));
             CKeyID keyid = pubkey.GetID();
             if (pwallet->HaveKey(keyid)) {
                 pwallet->WalletLogPrintf("Skipping import of %s (key already present)\n", EncodeDestination(keyid));
@@ -1133,7 +1133,7 @@ static std::string RecurseImportData(const CScript& script, ImportData& import_d
     }
     case TX_SCRIPTHASH: {
         if (script_ctx == ScriptContext::P2SH) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Trying to nest P2SH inside another P2SH");
-        assert(script_ctx == ScriptContext::TOP);
+        CHECK_NONFATAL(script_ctx == ScriptContext::TOP);
         CScriptID id = CScriptID(uint160(solverdata[0]));
         auto subscript = std::move(import_data.redeemscript); // Remove redeemscript from import_data to check for superfluous script later.
         if (!subscript) return "missing redeemscript";
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index ed5de24b5b..dcd28907b8 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -115,7 +115,7 @@ static void WalletTxToJSON(interfaces::Chain& chain, interfaces::Chain::Lock& lo
         entry.pushKV("blockindex", wtx.nIndex);
         int64_t block_time;
         bool found_block = chain.findBlock(wtx.hashBlock, nullptr /* block */, &block_time);
-        assert(found_block);
+        CHECK_NONFATAL(found_block);
         entry.pushKV("blocktime", block_time);
     } else {
         entry.pushKV("trusted", wtx.IsTrusted(locked_chain));
@@ -3748,7 +3748,7 @@ static UniValue getaddressesbylabel(const JSONRPCRequest& request)
             // address strings, but build a separate set as a precaution just in
             // case it does.
             bool unique = addresses.emplace(address).second;
-            assert(unique);
+            CHECK_NONFATAL(unique);
             // UniValue::pushKV checks if the key exists in O(N)
             // and since duplicate addresses are unexpected (checked with
             // std::set in O(log(N))), UniValue::__pushKV is used instead,
diff --git a/test/lint/lint-assertions.sh b/test/lint/lint-assertions.sh
index 5bbcae79eb..a4c6f0a8d4 100755
--- a/test/lint/lint-assertions.sh
+++ b/test/lint/lint-assertions.sh
@@ -20,4 +20,15 @@ if [[ ${OUTPUT} != "" ]]; then
     EXIT_CODE=1
 fi
 
+# Macro CHECK_NONFATAL(condition) should be used instead of assert for RPC code, where it
+# is undesirable to crash the whole program. See: src/util/check.h
+# src/rpc/server.cpp is excluded from this check since it's mostly meta-code.
+OUTPUT=$(git grep -nE 'assert *\(.*\);' -- "src/rpc/" "src/wallet/rpc*" ":(exclude)src/rpc/server.cpp")
+if [[ ${OUTPUT} != "" ]]; then
+    echo "CHECK_NONFATAL(condition) should be used instead of assert for RPC code."
+    echo
+    echo "${OUTPUT}"
+    EXIT_CODE=1
+fi
+
 exit ${EXIT_CODE}

From f1eea61bbac8f70deb481ed310fa9a9e8cdebb64 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Tue, 1 Mar 2022 12:00:23 +0530
Subject: [PATCH 13/16] merge bitcoin#18607: Fix named arguments in
 documentation

---
 src/rpc/blockchain.cpp                     |  2 +-
 src/rpc/util.cpp                           | 34 +++++++++++++++++-----
 src/rpc/util.h                             | 12 ++++++--
 src/wallet/rpcwallet.cpp                   |  4 +--
 test/functional/wallet_listtransactions.py |  4 ++-
 5 files changed, 41 insertions(+), 15 deletions(-)

diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 332e2f54e4..5d05d1bf7e 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1088,7 +1088,7 @@ static UniValue getblock(const JSONRPCRequest& request)
                 "If verbosity is 2, returns an Object with information about block <hash> and information about each transaction. \n",
                 {
                     {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The block hash"},
-                    {"verbosity", RPCArg::Type::NUM, /* default */ "1", "0 for hex-encoded data, 1 for a json object, and 2 for json object with transaction data"},
+                    {"verbosity|verbose", RPCArg::Type::NUM, /* default */ "1", "0 for hex-encoded data, 1 for a json object, and 2 for json object with transaction data"},
                 },
                 {
                     RPCResult{"for verbosity = 0",
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index a7c05b9302..3a961eae74 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -13,6 +13,9 @@
 
 #include <tuple>
 
+#include <boost/algorithm/string/classification.hpp>
+#include <boost/algorithm/string/split.hpp>
+
 InitInterfaces* g_rpc_interfaces = nullptr;
 
 void RPCTypeCheck(const UniValue& params,
@@ -307,7 +310,7 @@ struct Sections {
             if (outer_type == OuterType::NONE) return; // Nothing more to do for non-recursive types on first recursion
             auto left = indent;
             if (arg.m_type_str.size() != 0 && push_name) {
-                left += "\"" + arg.m_name + "\": " + arg.m_type_str.at(0);
+                left += "\"" + arg.GetName() + "\": " + arg.m_type_str.at(0);
             } else {
                 left += push_name ? arg.ToStringObj(/* oneline */ false) : arg.ToString(/* oneline */ false);
             }
@@ -318,7 +321,7 @@ struct Sections {
         case RPCArg::Type::OBJ:
         case RPCArg::Type::OBJ_USER_KEYS: {
             const auto right = outer_type == OuterType::NONE ? "" : arg.ToDescriptionString();
-            PushSection({indent + (push_name ? "\"" + arg.m_name + "\": " : "") + "{", right});
+            PushSection({indent + (push_name ? "\"" + arg.GetName() + "\": " : "") + "{", right});
             for (const auto& arg_inner : arg.m_inner) {
                 Push(arg_inner, current_indent + 2, OuterType::OBJ);
             }
@@ -330,7 +333,7 @@ struct Sections {
         }
         case RPCArg::Type::ARR: {
             auto left = indent;
-            left += push_name ? "\"" + arg.m_name + "\": " : "";
+            left += push_name ? "\"" + arg.GetName() + "\": " : "";
             left += "[";
             const auto right = outer_type == OuterType::NONE ? "" : arg.ToDescriptionString();
             PushSection({left, right});
@@ -396,8 +399,12 @@ RPCHelpMan::RPCHelpMan(std::string name, std::string description, std::vector<RP
 {
     std::set<std::string> named_args;
     for (const auto& arg : m_args) {
+        std::vector<std::string> names;
+        boost::split(names, arg.m_names, boost::is_any_of("|"));
         // Should have unique named arguments
-        CHECK_NONFATAL(named_args.insert(arg.m_name).second);
+        for (const std::string& name : names) {
+            CHECK_NONFATAL(named_args.insert(name).second);
+        }
     }
 }
 
@@ -470,7 +477,7 @@ std::string RPCHelpMan::ToString() const
         if (i == 0) ret += "\nArguments:\n";
 
         // Push named argument name and description
-        sections.m_sections.emplace_back(std::to_string(i + 1) + ". " + arg.m_name, arg.ToDescriptionString());
+        sections.m_sections.emplace_back(std::to_string(i + 1) + ". " + arg.GetFirstName(), arg.ToDescriptionString());
         sections.m_max_pad = std::max(sections.m_max_pad, sections.m_sections.back().m_left.size());
 
         // Recursively push nested args
@@ -487,6 +494,17 @@ std::string RPCHelpMan::ToString() const
     return ret;
 }
 
+std::string RPCArg::GetFirstName() const
+{
+    return m_names.substr(0, m_names.find("|"));
+}
+
+std::string RPCArg::GetName() const
+{
+    CHECK_NONFATAL(std::string::npos == m_names.find("|"));
+    return m_names;
+}
+
 bool RPCArg::IsOptional() const
 {
     if (m_fallback.which() == 1) {
@@ -662,7 +680,7 @@ std::string RPCArg::ToStringObj(const bool oneline) const
 {
     std::string res;
     res += "\"";
-    res += m_name;
+    res += GetFirstName();
     if (oneline) {
         res += "\":";
     } else {
@@ -704,13 +722,13 @@ std::string RPCArg::ToString(const bool oneline) const
     switch (m_type) {
     case Type::STR_HEX:
     case Type::STR: {
-        return "\"" + m_name + "\"";
+        return "\"" + GetFirstName() + "\"";
     }
     case Type::NUM:
     case Type::RANGE:
     case Type::AMOUNT:
     case Type::BOOL: {
-        return m_name;
+        return GetFirstName();
     }
     case Type::OBJ:
     case Type::OBJ_USER_KEYS: {
diff --git a/src/rpc/util.h b/src/rpc/util.h
index 8ba48db3b6..de14f5c0ad 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -133,7 +133,7 @@ struct RPCArg {
         OMITTED,
     };
     using Fallback = boost::variant<Optional, /* default value for optional args */ std::string>;
-    const std::string m_name; //!< The name of the arg (can be empty for inner args)
+    const std::string m_names; //!< The name of the arg (can be empty for inner args, can contain multiple aliases separated by | for named request arguments)
     const Type m_type;
     const std::vector<RPCArg> m_inner; //!< Only used for arrays or dicts
     const Fallback m_fallback;
@@ -148,7 +148,7 @@ struct RPCArg {
         const std::string description,
         const std::string oneline_description = "",
         const std::vector<std::string> type_str = {})
-        : m_name{std::move(name)},
+        : m_names{std::move(name)},
           m_type{std::move(type)},
           m_fallback{std::move(fallback)},
           m_description{std::move(description)},
@@ -166,7 +166,7 @@ struct RPCArg {
         const std::vector<RPCArg> inner,
         const std::string oneline_description = "",
         const std::vector<std::string> type_str = {})
-        : m_name{std::move(name)},
+        : m_names{std::move(name)},
           m_type{std::move(type)},
           m_inner{std::move(inner)},
           m_fallback{std::move(fallback)},
@@ -179,6 +179,12 @@ struct RPCArg {
 
     bool IsOptional() const;
 
+    /** Return the first of all aliases */
+    std::string GetFirstName() const;
+
+    /** Return the name, throws when there are aliases */
+    std::string GetName() const;
+
     /**
      * Return the type string of the argument.
      * Set oneline to allow it to be overridden by a custom oneline type string (m_oneline_description).
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index dcd28907b8..63afd0b76c 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -1407,8 +1407,8 @@ static UniValue listtransactions(const JSONRPCRequest& request)
                 "\nIf a label name is provided, this will return only incoming transactions paying to addresses with the specified label.\n"
                 "\nReturns up to 'count' most recent transactions skipping the first 'from' transactions.\n",
                 {
-                    {"label", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG, "If set, should be a valid label name to return only incoming transactions\n"
-            "              with the specified label, or \"*\" to disable filtering and return all transactions."},
+                    {"label|dummy", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG, "If set, should be a valid label name to return only incoming transactions\n"
+                          "with the specified label, or \"*\" to disable filtering and return all transactions."},
                     {"count", RPCArg::Type::NUM, /* default */ "10", "The number of transactions to return"},
                     {"skip", RPCArg::Type::NUM, /* default */ "0", "The number of transactions to skip"},
                     {"include_watchonly", RPCArg::Type::BOOL, /* default */ "false", "Include transactions to watch-only addresses (see 'importaddress')"},
diff --git a/test/functional/wallet_listtransactions.py b/test/functional/wallet_listtransactions.py
index 62a393ac14..dac8a4aa64 100755
--- a/test/functional/wallet_listtransactions.py
+++ b/test/functional/wallet_listtransactions.py
@@ -6,7 +6,7 @@
 from decimal import Decimal
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_array_result
+from test_framework.util import assert_array_result, assert_equal
 
 class ListTransactionsTest(BitcoinTestFramework):
     def set_test_params(self):
@@ -83,6 +83,8 @@ class ListTransactionsTest(BitcoinTestFramework):
         txid = self.nodes[1].sendtoaddress(multisig["address"], 0.1)
         self.nodes[1].generate(1)
         self.sync_all()
+        assert_equal(len(self.nodes[0].listtransactions(label="watchonly", include_watchonly=True)), 1)
+        assert_equal(len(self.nodes[0].listtransactions(dummy="watchonly", include_watchonly=True)), 1)
         assert len(self.nodes[0].listtransactions(label="watchonly", count=100, include_watchonly=False)) == 0
         assert_array_result(self.nodes[0].listtransactions(label="watchonly", count=100, include_watchonly=True),
                             {"category": "receive", "amount": Decimal("0.1")},

From 3ac0b5c6bc043bc910917ecfd33a468cfe767047 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Fri, 17 Apr 2020 13:28:29 -0400
Subject: [PATCH 14/16] merge bitcoin#19386: Assert that RPCArg names are equal
 to CRPCCommand ones (server)

---
 src/rpc/server.h | 17 ++++++++++++++++-
 src/rpc/util.cpp | 44 +++++++++++++++++++++++++-------------------
 src/rpc/util.h   | 19 +++++++++++++++++--
 3 files changed, 58 insertions(+), 22 deletions(-)

diff --git a/src/rpc/server.h b/src/rpc/server.h
index bfdead4f20..4de2724f19 100644
--- a/src/rpc/server.h
+++ b/src/rpc/server.h
@@ -8,6 +8,7 @@
 
 #include <amount.h>
 #include <rpc/request.h>
+#include <rpc/util.h>
 
 #include <map>
 #include <stdint.h>
@@ -80,6 +81,7 @@ void RPCUnsetTimerInterface(RPCTimerInterface *iface);
 void RPCRunLater(const std::string& name, std::function<void()> func, int64_t nSeconds);
 
 typedef UniValue(*rpcfn_type)(const JSONRPCRequest& jsonRequest);
+typedef RPCHelpMan (*RpcMethodFnType)();
 
 class CRPCCommand
 {
@@ -96,6 +98,19 @@ public:
     {
     }
 
+    //! Simplified constructor taking plain RpcMethodFnType function pointer.
+    CRPCCommand(std::string category, std::string name_in, RpcMethodFnType fn, std::vector<std::string> args_in)
+        : CRPCCommand(
+              category,
+              fn().m_name,
+              [fn](const JSONRPCRequest& request, UniValue& result, bool) { result = fn().HandleRequest(request); return true; },
+              fn().GetArgNames(),
+              intptr_t(fn))
+    {
+        CHECK_NONFATAL(fn().m_name == name_in);
+        CHECK_NONFATAL(fn().GetArgNames() == args_in);
+    }
+
     //! Simplified constructor taking plain rpcfn_type function pointer.
     CRPCCommand(const char* category, const char* name, rpcfn_type fn, std::initializer_list<const char*> args)
         : CRPCCommand(category, name,
@@ -112,7 +127,7 @@ public:
 };
 
 /**
- * Dash RPC command dispatcher.
+ * RPC command dispatcher.
  */
 class CRPCTable
 {
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 3a961eae74..87c5c62bbd 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -344,9 +344,7 @@ struct Sections {
             PushSection({indent + "]" + (outer_type != OuterType::NONE ? "," : ""), ""});
             break;
         }
-
-            // no default case, so the compiler can warn about missing cases
-        }
+        } // no default case, so the compiler can warn about missing cases
     }
 
     /**
@@ -357,6 +355,9 @@ struct Sections {
         std::string ret;
         const size_t pad = m_max_pad + 4;
         for (const auto& s : m_sections) {
+            // The left part of a section is assumed to be a single line, usually it is the name of the JSON struct or a
+            // brace like {, }, [, or ]
+            CHECK_NONFATAL(s.m_left.find('\n') == std::string::npos);
             if (s.m_right.empty()) {
                 ret += s.m_left;
                 ret += "\n";
@@ -391,7 +392,11 @@ struct Sections {
 };
 
 RPCHelpMan::RPCHelpMan(std::string name, std::string description, std::vector<RPCArg> args, RPCResults results, RPCExamples examples)
+    : RPCHelpMan{std::move(name), std::move(description), std::move(args), std::move(results), std::move(examples), nullptr} {}
+
+RPCHelpMan::RPCHelpMan(std::string name, std::string description, std::vector<RPCArg> args, RPCResults results, RPCExamples examples, RPCMethodImpl fun)
     : m_name{std::move(name)},
+      m_fun{std::move(fun)},
       m_description{std::move(description)},
       m_args{std::move(args)},
       m_results{std::move(results)},
@@ -444,6 +449,16 @@ bool RPCHelpMan::IsValidNumArgs(size_t num_args) const
     }
     return num_required_args <= num_args && num_args <= m_args.size();
 }
+
+std::vector<std::string> RPCHelpMan::GetArgNames() const
+{
+    std::vector<std::string> ret;
+    for (const auto& arg : m_args) {
+        ret.emplace_back(arg.m_names);
+    }
+    return ret;
+}
+
 std::string RPCHelpMan::ToString() const
 {
     std::string ret;
@@ -452,6 +467,7 @@ std::string RPCHelpMan::ToString() const
     ret += m_name;
     bool was_optional{false};
     for (const auto& arg : m_args) {
+        if (arg.m_hidden) continue;
         const bool optional = arg.IsOptional();
         ret += " ";
         if (optional) {
@@ -473,6 +489,7 @@ std::string RPCHelpMan::ToString() const
     Sections sections;
     for (size_t i{0}; i < m_args.size(); ++i) {
         const auto& arg = m_args.at(i);
+        if (arg.m_hidden) continue;
 
         if (i == 0) ret += "\nArguments:\n";
 
@@ -552,9 +569,7 @@ std::string RPCArg::ToDescriptionString() const
             ret += "json array";
             break;
         }
-
-            // no default case, so the compiler can warn about missing cases
-        }
+        } // no default case, so the compiler can warn about missing cases
     }
     if (m_fallback.which() == 1) {
         ret += ", optional, default=" + boost::get<std::string>(m_fallback);
@@ -572,9 +587,7 @@ std::string RPCArg::ToDescriptionString() const
             ret += ", required";
             break;
         }
-
-            // no default case, so the compiler can warn about missing cases
-        }
+        } // no default case, so the compiler can warn about missing cases
     }
     ret += ")";
     ret += m_description.empty() ? "" : " " + m_description;
@@ -669,10 +682,7 @@ void RPCResult::ToSections(Sections& sections, const OuterType outer_type, const
         sections.PushSection({indent + "}" + maybe_separator, ""});
         return;
     }
-
-        // no default case, so the compiler can warn about missing cases
-    }
-
+    } // no default case, so the compiler can warn about missing cases
     CHECK_NONFATAL(false);
 }
 
@@ -709,9 +719,7 @@ std::string RPCArg::ToStringObj(const bool oneline) const
     case Type::OBJ_USER_KEYS:
         // Currently unused, so avoid writing dead code
         CHECK_NONFATAL(false);
-
-        // no default case, so the compiler can warn about missing cases
-    }
+    } // no default case, so the compiler can warn about missing cases
     CHECK_NONFATAL(false);
 }
 
@@ -750,9 +758,7 @@ std::string RPCArg::ToString(const bool oneline) const
         }
         return "[" + res + "...]";
     }
-
-        // no default case, so the compiler can warn about missing cases
-    }
+    } // no default case, so the compiler can warn about missing cases
     CHECK_NONFATAL(false);
 }
 
diff --git a/src/rpc/util.h b/src/rpc/util.h
index de14f5c0ad..94dd708f38 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -135,6 +135,7 @@ struct RPCArg {
     using Fallback = boost::variant<Optional, /* default value for optional args */ std::string>;
     const std::string m_names; //!< The name of the arg (can be empty for inner args, can contain multiple aliases separated by | for named request arguments)
     const Type m_type;
+    const bool m_hidden;
     const std::vector<RPCArg> m_inner; //!< Only used for arrays or dicts
     const Fallback m_fallback;
     const std::string m_description;
@@ -147,9 +148,11 @@ struct RPCArg {
         const Fallback fallback,
         const std::string description,
         const std::string oneline_description = "",
-        const std::vector<std::string> type_str = {})
+        const std::vector<std::string> type_str = {},
+        const bool hidden = false)
         : m_names{std::move(name)},
           m_type{std::move(type)},
+          m_hidden{hidden},
           m_fallback{std::move(fallback)},
           m_description{std::move(description)},
           m_oneline_description{std::move(oneline_description)},
@@ -168,6 +171,7 @@ struct RPCArg {
         const std::vector<std::string> type_str = {})
         : m_names{std::move(name)},
           m_type{std::move(type)},
+          m_hidden{false},
           m_inner{std::move(inner)},
           m_fallback{std::move(fallback)},
           m_description{std::move(description)},
@@ -357,8 +361,15 @@ class RPCHelpMan
 {
 public:
     RPCHelpMan(std::string name, std::string description, std::vector<RPCArg> args, RPCResults results, RPCExamples examples);
+    using RPCMethodImpl = std::function<UniValue(const RPCHelpMan&, const JSONRPCRequest&)>;
+    RPCHelpMan(std::string name, std::string description, std::vector<RPCArg> args, RPCResults results, RPCExamples examples, RPCMethodImpl fun);
 
     std::string ToString() const;
+    UniValue HandleRequest(const JSONRPCRequest& request)
+    {
+        Check(request);
+        return m_fun(*this, request);
+    }
     /** If the supplied number of args is neither too small nor too high */
     bool IsValidNumArgs(size_t num_args) const;
     /**
@@ -375,8 +386,12 @@ public:
         throw std::runtime_error(ToString());
     }
 
-private:
+    std::vector<std::string> GetArgNames() const;
+
     const std::string m_name;
+
+private:
+    const RPCMethodImpl m_fun;
     const std::string m_description;
     const std::vector<RPCArg> m_args;
     const RPCResults m_results;

From 121553596ab6baaabd66f6e32ad80983c3474ff0 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sun, 27 Feb 2022 15:06:28 +0530
Subject: [PATCH 15/16] rpc: unconditionally print HelpRequiringPassphrase
 reminder

---
 src/rpc/governance.cpp   | 24 ++++++++++++------------
 src/rpc/rpcevo.cpp       | 36 ++++++++++++++++++------------------
 src/wallet/rpcwallet.cpp | 18 ++++++++----------
 src/wallet/rpcwallet.h   |  2 +-
 4 files changed, 39 insertions(+), 41 deletions(-)

diff --git a/src/rpc/governance.cpp b/src/rpc/governance.cpp
index d2f8013775..92c75e5360 100644
--- a/src/rpc/governance.cpp
+++ b/src/rpc/governance.cpp
@@ -129,11 +129,11 @@ static UniValue gobject_check(const JSONRPCRequest& request)
 }
 
 #ifdef ENABLE_WALLET
-static void gobject_prepare_help(const JSONRPCRequest& request, CWallet* const pwallet)
+static void gobject_prepare_help(const JSONRPCRequest& request)
 {
     RPCHelpMan{"gobject prepare",
         "Prepare governance object by signing and creating tx\n"
-        + HelpRequiringPassphrase(pwallet) + "\n",
+        + HelpRequiringPassphrase() + "\n",
         {
             {"parent-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "hash of the parent object, \"0\" is root"},
             {"revision", RPCArg::Type::NUM, RPCArg::Optional::NO, "object revision in the system"},
@@ -155,7 +155,7 @@ static UniValue gobject_prepare(const JSONRPCRequest& request)
     CWallet* const pwallet = wallet.get();
 
     if (request.fHelp || (request.params.size() != 5 && request.params.size() != 6 && request.params.size() != 8))
-        gobject_prepare_help(request, pwallet);
+        gobject_prepare_help(request);
 
     EnsureWalletIsUnlocked(pwallet);
 
@@ -255,11 +255,11 @@ static UniValue gobject_prepare(const JSONRPCRequest& request)
     return tx->GetHash().ToString();
 }
 
-static void gobject_list_prepared_help(const JSONRPCRequest& request, CWallet* const pwallet)
+static void gobject_list_prepared_help(const JSONRPCRequest& request)
 {
     RPCHelpMan{"gobject list-prepared",
         "Returns a list of governance objects prepared by this wallet with \"gobject prepare\" sorted by their creation time.\n"
-        + HelpRequiringPassphrase(pwallet) + "\n",
+        + HelpRequiringPassphrase() + "\n",
         {
             {"count", RPCArg::Type::NUM, /* default */ "10", "Maximum number of objects to return."},
         },
@@ -275,7 +275,7 @@ static UniValue gobject_list_prepared(const JSONRPCRequest& request)
     CWallet* const pwallet = wallet.get();
 
     if (request.fHelp || (request.params.size() > 2)) {
-        gobject_list_prepared_help(request, pwallet);
+        gobject_list_prepared_help(request);
     }
 
     EnsureWalletIsUnlocked(pwallet);
@@ -595,11 +595,11 @@ static UniValue VoteWithMasternodes(const std::map<uint256, CKey>& keys,
 }
 
 #ifdef ENABLE_WALLET
-static void gobject_vote_many_help(const JSONRPCRequest& request, CWallet* const pwallet)
+static void gobject_vote_many_help(const JSONRPCRequest& request)
 {
     RPCHelpMan{"gobject vote-many",
         "Vote on a governance object by all masternodes for which the voting key is present in the local wallet\n"
-        + HelpRequiringPassphrase(pwallet) + "\n",
+        + HelpRequiringPassphrase() + "\n",
         {
             {"governance-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "hash of the governance object"},
             {"vote", RPCArg::Type::STR, RPCArg::Optional::NO, "vote, possible values: [funding|valid|delete|endorsed]"},
@@ -617,7 +617,7 @@ static UniValue gobject_vote_many(const JSONRPCRequest& request)
     CWallet* const pwallet = wallet.get();
 
     if (request.fHelp || request.params.size() != 4)
-        gobject_vote_many_help(request, pwallet);
+        gobject_vote_many_help(request);
 
     uint256 hash = ParseHashV(request.params[1], "Object hash");
     std::string strVoteSignal = request.params[2].get_str();
@@ -650,11 +650,11 @@ static UniValue gobject_vote_many(const JSONRPCRequest& request)
     return VoteWithMasternodes(votingKeys, hash, eVoteSignal, eVoteOutcome);
 }
 
-static void gobject_vote_alias_help(const JSONRPCRequest& request, CWallet* const pwallet)
+static void gobject_vote_alias_help(const JSONRPCRequest& request)
 {
     RPCHelpMan{"gobject vote-alias",
         "Vote on a governance object by masternode's voting key (if present in local wallet)\n"
-        + HelpRequiringPassphrase(pwallet) + "\n",
+        + HelpRequiringPassphrase() + "\n",
         {
             {"governance-hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "hash of the governance object"},
             {"vote", RPCArg::Type::STR, RPCArg::Optional::NO, "vote, possible values: [funding|valid|delete|endorsed]"},
@@ -673,7 +673,7 @@ static UniValue gobject_vote_alias(const JSONRPCRequest& request)
     CWallet* const pwallet = wallet.get();
 
     if (request.fHelp || request.params.size() != 5)
-        gobject_vote_alias_help(request, pwallet);
+        gobject_vote_alias_help(request);
 
     uint256 hash = ParseHashV(request.params[1], "Object hash");
     std::string strVoteSignal = request.params[2].get_str();
diff --git a/src/rpc/rpcevo.cpp b/src/rpc/rpcevo.cpp
index 68bb1e18bb..027126a318 100644
--- a/src/rpc/rpcevo.cpp
+++ b/src/rpc/rpcevo.cpp
@@ -315,7 +315,7 @@ static std::string SignAndSendSpecialTx(const CMutableTransaction& tx, bool fSub
     return sendrawtransaction(sendRequest).get_str();
 }
 
-static void protx_register_fund_help(const JSONRPCRequest& request, CWallet* const pwallet)
+static void protx_register_fund_help(const JSONRPCRequest& request)
 {
     RPCHelpMan{"protx register_fund",
         "\nCreates, funds and sends a ProTx to the network. The resulting transaction will move 1000 Dash\n"
@@ -323,7 +323,7 @@ static void protx_register_fund_help(const JSONRPCRequest& request, CWallet* con
         "masternode.\n"
         "A few of the limitations you see in the arguments are temporary and might be lifted after DIP3\n"
         "is fully deployed.\n"
-        + HelpRequiringPassphrase(pwallet) + "\n",
+        + HelpRequiringPassphrase() + "\n",
         {
             GetRpcArg("collateralAddress"),
             GetRpcArg("ipAndPort"),
@@ -347,13 +347,13 @@ static void protx_register_fund_help(const JSONRPCRequest& request, CWallet* con
     }.Check(request);
 }
 
-static void protx_register_help(const JSONRPCRequest& request, CWallet* const pwallet)
+static void protx_register_help(const JSONRPCRequest& request)
 {
     RPCHelpMan{"protx register",
         "\nSame as \"protx register_fund\", but with an externally referenced collateral.\n"
         "The collateral is specified through \"collateralHash\" and \"collateralIndex\" and must be an unspent\n"
         "transaction output spendable by this wallet. It must also not be used by any other masternode.\n"
-        + HelpRequiringPassphrase(pwallet) + "\n",
+        + HelpRequiringPassphrase() + "\n",
         {
             GetRpcArg("collateralHash"),
             GetRpcArg("collateralIndex"),
@@ -409,13 +409,13 @@ static void protx_register_prepare_help(const JSONRPCRequest& request)
     }.Check(request);
 }
 
-static void protx_register_submit_help(const JSONRPCRequest& request, CWallet* const pwallet)
+static void protx_register_submit_help(const JSONRPCRequest& request)
 {
     RPCHelpMan{"protx register_submit",
         "\nCombines the unsigned ProTx and a signature of the signMessage, signs all inputs\n"
         "which were added to cover fees and submits the resulting transaction to the network.\n"
         "Note: See \"help protx register_prepare\" for more info about creating a ProTx and a message to sign.\n"
-        + HelpRequiringPassphrase(pwallet) + "\n",
+        + HelpRequiringPassphrase() + "\n",
         {
             {"tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized unsigned ProTx in hex format."},
             {"sig", RPCArg::Type::STR, RPCArg::Optional::NO, "The signature signed with the collateral key. Must be in base64 format."},
@@ -441,9 +441,9 @@ static UniValue protx_register(const JSONRPCRequest& request)
     bool isPrepareRegister = request.params[0].get_str() == "register_prepare";
 
     if (isFundRegister && (request.fHelp || (request.params.size() < 8 || request.params.size() > 10))) {
-        protx_register_fund_help(request, pwallet);
+        protx_register_fund_help(request);
     } else if (isExternalRegister && (request.fHelp || (request.params.size() < 9 || request.params.size() > 11))) {
-        protx_register_help(request, pwallet);
+        protx_register_help(request);
     } else if (isPrepareRegister && (request.fHelp || (request.params.size() != 9 && request.params.size() != 10))) {
         protx_register_prepare_help(request);
     }
@@ -598,7 +598,7 @@ static UniValue protx_register_submit(const JSONRPCRequest& request)
     CWallet* const pwallet = wallet.get();
 
     if (request.fHelp || request.params.size() != 3) {
-        protx_register_submit_help(request, pwallet);
+        protx_register_submit_help(request);
     }
 
     EnsureWalletIsUnlocked(pwallet);
@@ -624,13 +624,13 @@ static UniValue protx_register_submit(const JSONRPCRequest& request)
     return SignAndSendSpecialTx(tx);
 }
 
-static void protx_update_service_help(const JSONRPCRequest& request, CWallet* const pwallet)
+static void protx_update_service_help(const JSONRPCRequest& request)
 {
     RPCHelpMan{"protx update_service",
         "\nCreates and sends a ProUpServTx to the network. This will update the IP address\n"
         "of a masternode.\n"
         "If this is done for a masternode that got PoSe-banned, the ProUpServTx will also revive this masternode.\n"
-        + HelpRequiringPassphrase(pwallet) + "\n",
+        + HelpRequiringPassphrase() + "\n",
         {
             GetRpcArg("proTxHash"),
             GetRpcArg("ipAndPort"),
@@ -654,7 +654,7 @@ static UniValue protx_update_service(const JSONRPCRequest& request)
     CWallet* const pwallet = wallet.get();
 
     if (request.fHelp || (request.params.size() < 4 || request.params.size() > 6))
-        protx_update_service_help(request, pwallet);
+        protx_update_service_help(request);
 
     EnsureWalletIsUnlocked(pwallet);
 
@@ -721,13 +721,13 @@ static UniValue protx_update_service(const JSONRPCRequest& request)
     return SignAndSendSpecialTx(tx);
 }
 
-static void protx_update_registrar_help(const JSONRPCRequest& request, CWallet* const pwallet)
+static void protx_update_registrar_help(const JSONRPCRequest& request)
 {
     RPCHelpMan{"protx update_registrar",
         "\nCreates and sends a ProUpRegTx to the network. This will update the operator key, voting key and payout\n"
         "address of the masternode specified by \"proTxHash\".\n"
         "The owner key of the masternode must be known to your wallet.\n"
-        + HelpRequiringPassphrase(pwallet) + "\n",
+        + HelpRequiringPassphrase() + "\n",
         {
             GetRpcArg("proTxHash"),
             GetRpcArg("operatorPubKey_update"),
@@ -751,7 +751,7 @@ static UniValue protx_update_registrar(const JSONRPCRequest& request)
     CWallet* const pwallet = wallet.get();
 
     if (request.fHelp || (request.params.size() != 5 && request.params.size() != 6)) {
-        protx_update_registrar_help(request, pwallet);
+        protx_update_registrar_help(request);
     }
 
     EnsureWalletIsUnlocked(pwallet);
@@ -811,14 +811,14 @@ static UniValue protx_update_registrar(const JSONRPCRequest& request)
     return SignAndSendSpecialTx(tx);
 }
 
-static void protx_revoke_help(const JSONRPCRequest& request, CWallet* const pwallet)
+static void protx_revoke_help(const JSONRPCRequest& request)
 {
     RPCHelpMan{"protx revoke",
         "\nCreates and sends a ProUpRevTx to the network. This will revoke the operator key of the masternode and\n"
         "put it into the PoSe-banned state. It will also set the service field of the masternode\n"
         "to zero. Use this in case your operator key got compromised or you want to stop providing your service\n"
         "to the masternode owner.\n"
-        + HelpRequiringPassphrase(pwallet) + "\n",
+        + HelpRequiringPassphrase() + "\n",
         {
             GetRpcArg("proTxHash"),
             GetRpcArg("operatorKey"),
@@ -841,7 +841,7 @@ static UniValue protx_revoke(const JSONRPCRequest& request)
     CWallet* const pwallet = wallet.get();
 
     if (request.fHelp || (request.params.size() < 3 || request.params.size() > 5)) {
-        protx_revoke_help(request, pwallet);
+        protx_revoke_help(request);
     }
 
     EnsureWalletIsUnlocked(pwallet);
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 63afd0b76c..52e76d8c1d 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -56,11 +56,9 @@ bool GetWalletNameFromJSONRPCRequest(const JSONRPCRequest& request, std::string&
     return false;
 }
 
-std::string HelpRequiringPassphrase(CWallet * const pwallet)
+std::string HelpRequiringPassphrase()
 {
-    return pwallet && pwallet->IsCrypted()
-        ? "\nRequires wallet passphrase to be set with walletpassphrase call."
-        : "";
+    return "\nRequires wallet passphrase to be set with walletpassphrase call.";
 }
 
 std::shared_ptr<CWallet> GetWalletForJSONRPCRequest(const JSONRPCRequest& request)
@@ -329,7 +327,7 @@ static UniValue sendtoaddress(const JSONRPCRequest& request)
         throw std::runtime_error(
             RPCHelpMan{"sendtoaddress",
                 "\nSend an amount to a given address." +
-                    HelpRequiringPassphrase(pwallet) + "\n",
+                    HelpRequiringPassphrase() + "\n",
                 {
                     {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The dash address to send to."},
                     {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "The amount in " + CURRENCY_UNIT + " to send. eg 0.1"},
@@ -536,7 +534,7 @@ static UniValue signmessage(const JSONRPCRequest& request)
         throw std::runtime_error(
             RPCHelpMan{"signmessage",
                 "\nSign a message with the private key of an address" +
-                    HelpRequiringPassphrase(pwallet) + "\n",
+                    HelpRequiringPassphrase() + "\n",
                 {
                     {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The dash address to use for the private key."},
                     {"message", RPCArg::Type::STR, RPCArg::Optional::NO, "The message to create a signature of."},
@@ -827,7 +825,7 @@ static UniValue sendmany(const JSONRPCRequest& request)
 
     const RPCHelpMan help{"sendmany",
                 "\nSend multiple times. Amounts are double-precision floating point numbers." +
-                    HelpRequiringPassphrase(pwallet) + "\n",
+                    HelpRequiringPassphrase() + "\n",
                 {
                     {"dummy", RPCArg::Type::STR, RPCArg::Optional::NO, "Must be set to \"\" for backwards compatibility.", "\"\""},
                     {"amounts", RPCArg::Type::OBJ, RPCArg::Optional::NO, "A json object with addresses and amounts",
@@ -1846,7 +1844,7 @@ static UniValue keypoolrefill(const JSONRPCRequest& request)
         throw std::runtime_error(
             RPCHelpMan{"keypoolrefill",
                 "\nFills the keypool."+
-                    HelpRequiringPassphrase(pwallet) + "\n",
+                    HelpRequiringPassphrase() + "\n",
                 {
                     {"newsize", RPCArg::Type::NUM, /* default */ itostr(DEFAULT_KEYPOOL_SIZE), "The new keypool size"},
                 },
@@ -3305,7 +3303,7 @@ UniValue signrawtransactionwithwallet(const JSONRPCRequest& request)
                 "\nSign inputs for raw transaction (serialized, hex-encoded).\n"
                 "The second optional argument (may be null) is an array of previous transaction outputs that\n"
                 "this transaction depends on but may not yet be in the block chain." +
-                    HelpRequiringPassphrase(pwallet) + "\n",
+                    HelpRequiringPassphrase() + "\n",
                 {
                     {"hexstring", RPCArg::Type::STR, RPCArg::Optional::NO, "The transaction hex string"},
                     {"prevtxs", RPCArg::Type::ARR, RPCArg::Optional::OMITTED_NAMED_ARG, "A json array of previous dependent transaction outputs",
@@ -3842,7 +3840,7 @@ UniValue walletprocesspsbt(const JSONRPCRequest& request)
             RPCHelpMan{"walletprocesspsbt",
                 "\nUpdate a PSBT with input information from our wallet and then sign inputs\n"
                 "that we can sign for." +
-                    HelpRequiringPassphrase(pwallet) + "\n",
+                    HelpRequiringPassphrase() + "\n",
                 {
                     {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "The transaction base64 string"},
                     {"sign", RPCArg::Type::BOOL, /* default */ "true", "Also sign the transaction when updating"},
diff --git a/src/wallet/rpcwallet.h b/src/wallet/rpcwallet.h
index 8a4d745a1c..888593393c 100644
--- a/src/wallet/rpcwallet.h
+++ b/src/wallet/rpcwallet.h
@@ -31,7 +31,7 @@ void RegisterWalletRPCCommands(interfaces::Chain& chain, std::vector<std::unique
  */
 std::shared_ptr<CWallet> GetWalletForJSONRPCRequest(const JSONRPCRequest& request);
 
-std::string HelpRequiringPassphrase(CWallet *);
+std::string HelpRequiringPassphrase();
 void EnsureWalletIsUnlocked(CWallet *);
 
 UniValue getaddressinfo(const JSONRPCRequest& request);

From 7573b1286c62b98e11adace45479ff767ce2066d Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Sun, 13 Mar 2022 08:41:13 +0530
Subject: [PATCH 16/16] merge bitcoin#19250: Make RPC help compile-time static

---
 src/rpc/coinjoin.cpp        |   8 +-
 src/rpc/governance.cpp      |  20 +--
 src/rpc/masternode.cpp      |   7 +-
 src/rpc/rpcevo.cpp          |  60 ++++---
 src/wallet/rpcdump.cpp      | 100 ++++++-----
 src/wallet/rpcwallet.cpp    | 334 ++++++++++++++++++------------------
 test/functional/rpc_help.py |   7 +
 7 files changed, 274 insertions(+), 262 deletions(-)

diff --git a/src/rpc/coinjoin.cpp b/src/rpc/coinjoin.cpp
index ec3e53c5b1..aee9aa9f1b 100644
--- a/src/rpc/coinjoin.cpp
+++ b/src/rpc/coinjoin.cpp
@@ -18,10 +18,6 @@
 #ifdef ENABLE_WALLET
 static UniValue coinjoin(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
             RPCHelpMan{"coinjoin",
@@ -36,6 +32,10 @@ static UniValue coinjoin(const JSONRPCRequest& request)
                 RPCExamples{""},
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     if (fMasternodeMode)
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Client-side mixing is not supported on masternodes");
 
diff --git a/src/rpc/governance.cpp b/src/rpc/governance.cpp
index 92c75e5360..295d24f910 100644
--- a/src/rpc/governance.cpp
+++ b/src/rpc/governance.cpp
@@ -270,14 +270,14 @@ static void gobject_list_prepared_help(const JSONRPCRequest& request)
 
 static UniValue gobject_list_prepared(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || (request.params.size() > 2)) {
         gobject_list_prepared_help(request);
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     EnsureWalletIsUnlocked(pwallet);
 
     int64_t nCount = request.params.size() > 1 ? ParseInt64V(request.params[1], "count") : 10;
@@ -612,13 +612,13 @@ static void gobject_vote_many_help(const JSONRPCRequest& request)
 
 static UniValue gobject_vote_many(const JSONRPCRequest& request)
 {
+    if (request.fHelp || request.params.size() != 4)
+        gobject_vote_many_help(request);
+
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (request.fHelp || request.params.size() != 4)
-        gobject_vote_many_help(request);
-
     uint256 hash = ParseHashV(request.params[1], "Object hash");
     std::string strVoteSignal = request.params[2].get_str();
     std::string strVoteOutcome = request.params[3].get_str();
@@ -668,13 +668,13 @@ static void gobject_vote_alias_help(const JSONRPCRequest& request)
 
 static UniValue gobject_vote_alias(const JSONRPCRequest& request)
 {
+    if (request.fHelp || request.params.size() != 5)
+        gobject_vote_alias_help(request);
+
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (request.fHelp || request.params.size() != 5)
-        gobject_vote_alias_help(request);
-
     uint256 hash = ParseHashV(request.params[1], "Object hash");
     std::string strVoteSignal = request.params[2].get_str();
     std::string strVoteOutcome = request.params[3].get_str();
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 43bfafbeb8..f66d36fe07 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -202,13 +202,12 @@ static void masternode_outputs_help(const JSONRPCRequest& request)
 
 static UniValue masternode_outputs(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp)
         masternode_outputs_help(request);
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
 
     // Find possible candidates
     std::vector<COutput> vPossibleCoins;
diff --git a/src/rpc/rpcevo.cpp b/src/rpc/rpcevo.cpp
index 027126a318..471682d3f7 100644
--- a/src/rpc/rpcevo.cpp
+++ b/src/rpc/rpcevo.cpp
@@ -432,10 +432,6 @@ static void protx_register_submit_help(const JSONRPCRequest& request)
 // handles register, register_prepare and register_fund in one method
 static UniValue protx_register(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     bool isExternalRegister = request.params[0].get_str() == "register";
     bool isFundRegister = request.params[0].get_str() == "register_fund";
     bool isPrepareRegister = request.params[0].get_str() == "register_prepare";
@@ -448,6 +444,10 @@ static UniValue protx_register(const JSONRPCRequest& request)
         protx_register_prepare_help(request);
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     if (isExternalRegister || isFundRegister) {
         EnsureWalletIsUnlocked(pwallet);
     }
@@ -593,14 +593,14 @@ static UniValue protx_register(const JSONRPCRequest& request)
 
 static UniValue protx_register_submit(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 3) {
         protx_register_submit_help(request);
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     EnsureWalletIsUnlocked(pwallet);
 
     CMutableTransaction tx;
@@ -649,13 +649,13 @@ static void protx_update_service_help(const JSONRPCRequest& request)
 
 static UniValue protx_update_service(const JSONRPCRequest& request)
 {
+    if (request.fHelp || (request.params.size() < 4 || request.params.size() > 6))
+        protx_update_service_help(request);
+
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) return NullUniValue;
     CWallet* const pwallet = wallet.get();
 
-    if (request.fHelp || (request.params.size() < 4 || request.params.size() > 6))
-        protx_update_service_help(request);
-
     EnsureWalletIsUnlocked(pwallet);
 
     CProUpServTx ptx;
@@ -746,14 +746,14 @@ static void protx_update_registrar_help(const JSONRPCRequest& request)
 
 static UniValue protx_update_registrar(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || (request.params.size() != 5 && request.params.size() != 6)) {
         protx_update_registrar_help(request);
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     EnsureWalletIsUnlocked(pwallet);
 
     CProUpRegTx ptx;
@@ -836,14 +836,14 @@ static void protx_revoke_help(const JSONRPCRequest& request)
 
 static UniValue protx_revoke(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || (request.params.size() < 3 || request.params.size() > 5)) {
         protx_revoke_help(request);
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     EnsureWalletIsUnlocked(pwallet);
 
     CProUpRevTx ptx;
@@ -993,11 +993,16 @@ static UniValue protx_list(const JSONRPCRequest& request)
         protx_list_help(request);
     }
 
+    CWallet* pwallet;
 #ifdef ENABLE_WALLET
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    CWallet* const pwallet = wallet.get();
+    try {
+        std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+        pwallet = wallet.get();
+    } catch (...) {
+        pwallet = nullptr;
+    }
 #else
-    CWallet* const pwallet = nullptr;
+    pwallet = nullptr;
 #endif
 
     std::string type = "registered";
@@ -1096,11 +1101,16 @@ static UniValue protx_info(const JSONRPCRequest& request)
         protx_info_help(request);
     }
 
+    CWallet* pwallet;
 #ifdef ENABLE_WALLET
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    CWallet* const pwallet = wallet.get();
+    try {
+        std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+        pwallet = wallet.get();
+    } catch (...) {
+        pwallet = nullptr;
+    }
 #else
-    CWallet* const pwallet = nullptr;
+    pwallet = nullptr;
 #endif
 
     if (g_txindex) {
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index 8290ace978..c0679858ae 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -83,10 +83,6 @@ static void RescanWallet(CWallet& wallet, const WalletRescanReserver& reserver,
 
 UniValue importprivkey(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 3)
         throw std::runtime_error(
             RPCHelpMan{"importprivkey",
@@ -114,6 +110,10 @@ UniValue importprivkey(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Cannot import private keys to a wallet with private keys disabled");
     }
@@ -182,10 +182,6 @@ UniValue importprivkey(const JSONRPCRequest& request)
 
 UniValue abortrescan(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() > 0)
         throw std::runtime_error(
             RPCHelpMan{"abortrescan",
@@ -202,10 +198,14 @@ UniValue abortrescan(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     if (!pwallet->IsScanning() || pwallet->IsAbortingRescan()) return false;
-    pwallet->AbortRescan();
-    return true;
-}
+        pwallet->AbortRescan();
+        return true;
+    }
 
 static void ImportAddress(CWallet*, const CTxDestination& dest, const std::string& strLabel);
 static void ImportScript(CWallet * const pwallet, const CScript& script, const std::string& strLabel, bool isRedeemScript) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
@@ -247,10 +247,6 @@ static void ImportAddress(CWallet * const pwallet, const CTxDestination& dest, c
 
 UniValue importaddress(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 4)
         throw std::runtime_error(
             RPCHelpMan{"importaddress",
@@ -278,6 +274,9 @@ UniValue importaddress(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
 
     std::string strLabel;
     if (!request.params[1].isNull())
@@ -337,10 +336,6 @@ UniValue importaddress(const JSONRPCRequest& request)
 
 UniValue importprunedfunds(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 2)
         throw std::runtime_error(
             RPCHelpMan{"importprunedfunds",
@@ -354,6 +349,10 @@ UniValue importprunedfunds(const JSONRPCRequest& request)
             }.ToString()
         );
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     CMutableTransaction tx;
     if (!DecodeHexTx(tx, request.params[0].get_str()))
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
@@ -404,10 +403,6 @@ UniValue importprunedfunds(const JSONRPCRequest& request)
 
 UniValue removeprunedfunds(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
             RPCHelpMan{"removeprunedfunds",
@@ -423,6 +418,10 @@ UniValue removeprunedfunds(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
@@ -445,10 +444,6 @@ UniValue removeprunedfunds(const JSONRPCRequest& request)
 
 UniValue importpubkey(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 3)
         throw std::runtime_error(
             RPCHelpMan{"importpubkey",
@@ -472,6 +467,9 @@ UniValue importpubkey(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
 
     std::string strLabel;
     if (!request.params[1].isNull())
@@ -524,10 +522,6 @@ UniValue importpubkey(const JSONRPCRequest& request)
 
 UniValue importwallet(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
             RPCHelpMan{"importwallet",
@@ -547,6 +541,10 @@ UniValue importwallet(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     if (pwallet->chain().havePruned()) {
         // Exit early and print an error.
         // If a block is pruned after this check, we will import the key(s),
@@ -688,10 +686,6 @@ UniValue importwallet(const JSONRPCRequest& request)
 
 UniValue importelectrumwallet(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 2)
         throw std::runtime_error(
             RPCHelpMan{"importselectrumwallet",
@@ -711,6 +705,10 @@ UniValue importelectrumwallet(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     if (fPruneMode)
         throw JSONRPCError(RPC_WALLET_ERROR, "Importing wallets is disabled in pruned mode");
 
@@ -838,10 +836,6 @@ UniValue importelectrumwallet(const JSONRPCRequest& request)
 
 UniValue dumpprivkey(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
             RPCHelpMan{"dumpprivkey",
@@ -860,6 +854,10 @@ UniValue dumpprivkey(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
@@ -883,10 +881,6 @@ UniValue dumpprivkey(const JSONRPCRequest& request)
 
 UniValue dumphdinfo(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 0)
         throw std::runtime_error(
             RPCHelpMan{"dumphdinfo",
@@ -905,6 +899,10 @@ UniValue dumphdinfo(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     LOCK(pwallet->cs_wallet);
 
     EnsureWalletIsUnlocked(pwallet);
@@ -930,10 +928,6 @@ UniValue dumphdinfo(const JSONRPCRequest& request)
 
 UniValue dumpwallet(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
             RPCHelpMan{"dumpwallet",
@@ -957,6 +951,10 @@ UniValue dumpwallet(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     auto locked_chain = pwallet->chain().lock();
     LockAnnotation lock(::cs_main);
     LOCK(pwallet->cs_wallet);
@@ -1467,10 +1465,6 @@ static int64_t GetImportTimestamp(const UniValue& data, int64_t now)
 
 UniValue importmulti(const JSONRPCRequest& mainRequest)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(mainRequest);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (mainRequest.fHelp || mainRequest.params.size() < 1 || mainRequest.params.size() > 2)
         throw std::runtime_error(
             RPCHelpMan{"importmulti",
@@ -1540,6 +1534,10 @@ UniValue importmulti(const JSONRPCRequest& mainRequest)
 
     const UniValue& requests = mainRequest.params[0];
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(mainRequest);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     //Default options
     bool fRescan = true;
 
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 52e76d8c1d..862e8a8120 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -141,10 +141,6 @@ static std::string LabelFromValue(const UniValue& value)
 
 UniValue getnewaddress(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() > 1)
         throw std::runtime_error(
             RPCHelpMan{"getnewaddress",
@@ -163,6 +159,10 @@ UniValue getnewaddress(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     LOCK(pwallet->cs_wallet);
 
     if (!pwallet->CanGetAddresses()) {
@@ -192,10 +192,6 @@ UniValue getnewaddress(const JSONRPCRequest& request)
 
 static UniValue getrawchangeaddress(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() > 0)
         throw std::runtime_error(
             RPCHelpMan{"getrawchangeaddress",
@@ -211,6 +207,10 @@ static UniValue getrawchangeaddress(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     LOCK(pwallet->cs_wallet);
 
     if (!pwallet->CanGetAddresses(true)) {
@@ -236,10 +236,6 @@ static UniValue getrawchangeaddress(const JSONRPCRequest& request)
 
 static UniValue setlabel(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 2)
         throw std::runtime_error(
             RPCHelpMan{"setlabel",
@@ -255,6 +251,10 @@ static UniValue setlabel(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     LOCK(pwallet->cs_wallet);
 
     CTxDestination dest = DecodeDestination(request.params[0].get_str());
@@ -319,10 +319,6 @@ static CTransactionRef SendMoney(interfaces::Chain::Lock& locked_chain, CWallet
 
 static UniValue sendtoaddress(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 2 || request.params.size() > 9)
         throw std::runtime_error(
             RPCHelpMan{"sendtoaddress",
@@ -357,6 +353,10 @@ static UniValue sendtoaddress(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -420,10 +420,6 @@ static UniValue instantsendtoaddress(const JSONRPCRequest& request)
 
 static UniValue listaddressgroupings(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 0)
         throw std::runtime_error(
             RPCHelpMan{"listaddressgroupings",
@@ -450,6 +446,10 @@ static UniValue listaddressgroupings(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -480,10 +480,6 @@ static UniValue listaddressgroupings(const JSONRPCRequest& request)
 
 static UniValue listaddressbalances(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() > 1)
         throw std::runtime_error(
             RPCHelpMan{"listaddressbalances",
@@ -505,6 +501,10 @@ static UniValue listaddressbalances(const JSONRPCRequest& request)
                 }
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
@@ -526,10 +526,6 @@ static UniValue listaddressbalances(const JSONRPCRequest& request)
 
 static UniValue signmessage(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 2)
         throw std::runtime_error(
             RPCHelpMan{"signmessage",
@@ -554,6 +550,10 @@ static UniValue signmessage(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
@@ -590,10 +590,6 @@ static UniValue signmessage(const JSONRPCRequest& request)
 
 static UniValue getreceivedbyaddress(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 3)
         throw std::runtime_error(
             RPCHelpMan{"getreceivedbyaddress",
@@ -618,6 +614,10 @@ static UniValue getreceivedbyaddress(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -661,10 +661,6 @@ static UniValue getreceivedbyaddress(const JSONRPCRequest& request)
 
 static UniValue getreceivedbylabel(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 3)
         throw std::runtime_error(
             RPCHelpMan{"getreceivedbylabel",
@@ -689,6 +685,10 @@ static UniValue getreceivedbylabel(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -729,10 +729,6 @@ static UniValue getreceivedbylabel(const JSONRPCRequest& request)
 
 static UniValue getbalance(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || (request.params.size() > 4))
         throw std::runtime_error(
             RPCHelpMan{"getbalance",
@@ -758,6 +754,10 @@ static UniValue getbalance(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -793,10 +793,6 @@ static UniValue getbalance(const JSONRPCRequest& request)
 
 static UniValue getunconfirmedbalance(const JSONRPCRequest &request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() > 0)
         throw std::runtime_error(
             RPCHelpMan{"getunconfirmedbalance",
@@ -806,6 +802,10 @@ static UniValue getunconfirmedbalance(const JSONRPCRequest &request)
                 RPCExamples{""},
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -819,10 +819,6 @@ static UniValue getunconfirmedbalance(const JSONRPCRequest &request)
 
 static UniValue sendmany(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     const RPCHelpMan help{"sendmany",
                 "\nSend multiple times. Amounts are double-precision floating point numbers." +
                     HelpRequiringPassphrase() + "\n",
@@ -870,6 +866,10 @@ static UniValue sendmany(const JSONRPCRequest& request)
         throw std::runtime_error(help.ToString());
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -967,10 +967,6 @@ static UniValue sendmany(const JSONRPCRequest& request)
 
 static UniValue addmultisigaddress(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 2 || request.params.size() > 3)
     {
         std::string msg =
@@ -1005,6 +1001,10 @@ static UniValue addmultisigaddress(const JSONRPCRequest& request)
         throw std::runtime_error(msg);
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
@@ -1203,10 +1203,6 @@ static UniValue ListReceived(interfaces::Chain::Lock& locked_chain, CWallet * co
 
 static UniValue listreceivedbyaddress(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() > 5)
         throw std::runtime_error(
             RPCHelpMan{"listreceivedbyaddress",
@@ -1244,6 +1240,10 @@ static UniValue listreceivedbyaddress(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -1256,10 +1256,6 @@ static UniValue listreceivedbyaddress(const JSONRPCRequest& request)
 
 static UniValue listreceivedbylabel(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() > 4)
         throw std::runtime_error(
             RPCHelpMan{"listreceivedbylabel",
@@ -1288,6 +1284,10 @@ static UniValue listreceivedbylabel(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -1395,10 +1395,6 @@ static void ListTransactions(interfaces::Chain::Lock& locked_chain, CWallet* con
 
 static UniValue listtransactions(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() > 4)
         throw std::runtime_error(
             RPCHelpMan{"listtransactions",
@@ -1459,6 +1455,10 @@ static UniValue listtransactions(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -1518,10 +1518,6 @@ static UniValue listtransactions(const JSONRPCRequest& request)
 
 static UniValue listsinceblock(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() > 4)
         throw std::runtime_error(
             RPCHelpMan{"listsinceblock",
@@ -1574,6 +1570,10 @@ static UniValue listsinceblock(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -1658,10 +1658,6 @@ static UniValue listsinceblock(const JSONRPCRequest& request)
 
 static UniValue gettransaction(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 2)
         throw std::runtime_error(
             RPCHelpMan{"gettransaction",
@@ -1709,6 +1705,10 @@ static UniValue gettransaction(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -1754,10 +1754,6 @@ static UniValue gettransaction(const JSONRPCRequest& request)
 
 static UniValue abandontransaction(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"abandontransaction",
@@ -1777,6 +1773,10 @@ static UniValue abandontransaction(const JSONRPCRequest& request)
             }.ToString());
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -1800,10 +1800,6 @@ static UniValue abandontransaction(const JSONRPCRequest& request)
 
 static UniValue backupwallet(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
             RPCHelpMan{"backupwallet",
@@ -1818,6 +1814,10 @@ static UniValue backupwallet(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -1836,10 +1836,6 @@ static UniValue backupwallet(const JSONRPCRequest& request)
 
 static UniValue keypoolrefill(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() > 1)
         throw std::runtime_error(
             RPCHelpMan{"keypoolrefill",
@@ -1855,6 +1851,10 @@ static UniValue keypoolrefill(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Error: Private keys are disabled for this wallet");
     }
@@ -1883,10 +1883,6 @@ static UniValue keypoolrefill(const JSONRPCRequest& request)
 
 static UniValue walletpassphrase(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 2 || request.params.size() > 3) {
         throw std::runtime_error(
             RPCHelpMan{"walletpassphrase",
@@ -1914,6 +1910,10 @@ static UniValue walletpassphrase(const JSONRPCRequest& request)
             }.ToString());
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
@@ -1981,10 +1981,6 @@ static UniValue walletpassphrase(const JSONRPCRequest& request)
 
 static UniValue walletpassphrasechange(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 2) {
         throw std::runtime_error(
             RPCHelpMan{"walletpassphrasechange",
@@ -2001,6 +1997,10 @@ static UniValue walletpassphrasechange(const JSONRPCRequest& request)
             }.ToString());
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
@@ -2032,10 +2032,6 @@ static UniValue walletpassphrasechange(const JSONRPCRequest& request)
 
 static UniValue walletlock(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(
             RPCHelpMan{"walletlock",
@@ -2057,6 +2053,10 @@ static UniValue walletlock(const JSONRPCRequest& request)
             }.ToString());
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
@@ -2073,10 +2073,6 @@ static UniValue walletlock(const JSONRPCRequest& request)
 
 static UniValue encryptwallet(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"encryptwallet",
@@ -2104,6 +2100,10 @@ static UniValue encryptwallet(const JSONRPCRequest& request)
             }.ToString());
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
@@ -2134,10 +2134,6 @@ static UniValue encryptwallet(const JSONRPCRequest& request)
 
 static UniValue lockunspent(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 2)
         throw std::runtime_error(
             RPCHelpMan{"lockunspent",
@@ -2178,6 +2174,10 @@ static UniValue lockunspent(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -2264,10 +2264,6 @@ static UniValue lockunspent(const JSONRPCRequest& request)
 
 static UniValue listlockunspent(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() > 0)
         throw std::runtime_error(
             RPCHelpMan{"listlockunspent",
@@ -2298,6 +2294,10 @@ static UniValue listlockunspent(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
@@ -2319,10 +2319,6 @@ static UniValue listlockunspent(const JSONRPCRequest& request)
 
 static UniValue settxfee(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 1) {
         throw std::runtime_error(
             RPCHelpMan{"settxfee",
@@ -2340,6 +2336,10 @@ static UniValue settxfee(const JSONRPCRequest& request)
             }.ToString());
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
@@ -2359,10 +2359,6 @@ static UniValue settxfee(const JSONRPCRequest& request)
 
 static UniValue setcoinjoinrounds(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
             RPCHelpMan{"setcoinjoinrounds",
@@ -2379,6 +2375,9 @@ static UniValue setcoinjoinrounds(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+
     int nRounds = request.params[0].get_int();
 
     if (nRounds > MAX_COINJOIN_ROUNDS || nRounds < MIN_COINJOIN_ROUNDS)
@@ -2391,10 +2390,6 @@ static UniValue setcoinjoinrounds(const JSONRPCRequest& request)
 
 static UniValue setcoinjoinamount(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
             RPCHelpMan{"setcoinjoinamount",
@@ -2411,6 +2406,9 @@ static UniValue setcoinjoinamount(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+
     int nAmount = request.params[0].get_int();
 
     if (nAmount > MAX_COINJOIN_AMOUNT || nAmount < MIN_COINJOIN_AMOUNT)
@@ -2423,10 +2421,6 @@ static UniValue setcoinjoinamount(const JSONRPCRequest& request)
 
 static UniValue getwalletinfo(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 0)
         throw std::runtime_error(
             RPCHelpMan{"getwalletinfo",
@@ -2472,6 +2466,10 @@ static UniValue getwalletinfo(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
@@ -2600,10 +2598,6 @@ static UniValue listwallets(const JSONRPCRequest& request)
 
 static UniValue upgradetohd(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp)
         throw std::runtime_error(
             RPCHelpMan{"upgradetohd",
@@ -2623,6 +2617,10 @@ static UniValue upgradetohd(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
@@ -2899,10 +2897,6 @@ static UniValue unloadwallet(const JSONRPCRequest& request)
 
 static UniValue listunspent(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() > 5)
         throw std::runtime_error(
             RPCHelpMan{"listunspent",
@@ -2962,6 +2956,10 @@ static UniValue listunspent(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     int nMinDepth = 1;
     if (!request.params[0].isNull()) {
         RPCTypeCheckArgument(request.params[0], UniValue::VNUM);
@@ -3206,10 +3204,6 @@ void FundTransaction(CWallet* const pwallet, CMutableTransaction& tx, CAmount& f
 
 static UniValue fundrawtransaction(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 3)
         throw std::runtime_error(
             RPCHelpMan{"fundrawtransaction",
@@ -3273,6 +3267,10 @@ static UniValue fundrawtransaction(const JSONRPCRequest& request)
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValueType(), UniValue::VBOOL});
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // parse hex string from parameter
     CMutableTransaction tx;
     if (!DecodeHexTx(tx, request.params[0].get_str())) {
@@ -3293,10 +3291,6 @@ static UniValue fundrawtransaction(const JSONRPCRequest& request)
 
 UniValue signrawtransactionwithwallet(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 3)
         throw std::runtime_error(
             RPCHelpMan{"signrawtransactionwithwallet",
@@ -3353,6 +3347,10 @@ UniValue signrawtransactionwithwallet(const JSONRPCRequest& request)
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VARR, UniValue::VSTR}, true);
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     CMutableTransaction mtx;
     if (!DecodeHexTx(mtx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
@@ -3376,10 +3374,6 @@ UniValue signrawtransactionwithwallet(const JSONRPCRequest& request)
 #if ENABLE_MINER
 UniValue generate(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{"generate",
@@ -3398,6 +3392,10 @@ UniValue generate(const JSONRPCRequest& request)
             }.ToString());
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     int num_generate = request.params[0].get_int();
     uint64_t max_tries = 1000000;
     if (!request.params[1].isNull()) {
@@ -3428,10 +3426,6 @@ UniValue generate(const JSONRPCRequest& request)
 
 static UniValue rescanblockchain(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{"rescanblockchain",
@@ -3455,6 +3449,10 @@ static UniValue rescanblockchain(const JSONRPCRequest& request)
             }.ToString());
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     WalletRescanReserver reserver(pwallet);
     if (!reserver.reserve()) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Wallet is currently rescanning. Abort existing rescan or wait.");
@@ -3582,10 +3580,6 @@ static UniValue AddressBookDataToJSON(const CAddressBookData& data, const bool v
 
 UniValue getaddressinfo(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"getaddressinfo",
@@ -3635,6 +3629,10 @@ UniValue getaddressinfo(const JSONRPCRequest& request)
             }.ToString());
     }
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     LOCK(pwallet->cs_wallet);
 
     UniValue ret(UniValue::VOBJ);
@@ -3706,10 +3704,6 @@ UniValue getaddressinfo(const JSONRPCRequest& request)
 
 static UniValue getaddressesbylabel(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
             RPCHelpMan{"getaddressesbylabel",
@@ -3732,6 +3726,10 @@ static UniValue getaddressesbylabel(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     LOCK(pwallet->cs_wallet);
 
     std::string label = LabelFromValue(request.params[0]);
@@ -3764,10 +3762,6 @@ static UniValue getaddressesbylabel(const JSONRPCRequest& request)
 
 static UniValue listlabels(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() > 1)
         throw std::runtime_error(
             RPCHelpMan{"listlabels",
@@ -3793,6 +3787,10 @@ static UniValue listlabels(const JSONRPCRequest& request)
                 },
             }.ToString());
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     LOCK(pwallet->cs_wallet);
 
     std::string purpose;
@@ -3831,10 +3829,6 @@ UniValue importelectrumwallet(const JSONRPCRequest& request);
 
 UniValue walletprocesspsbt(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 4)
         throw std::runtime_error(
             RPCHelpMan{"walletprocesspsbt",
@@ -3867,6 +3861,10 @@ UniValue walletprocesspsbt(const JSONRPCRequest& request)
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VBOOL, UniValue::VSTR});
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     // Unserialize the transaction
     PartiallySignedTransaction psbtx;
     std::string error;
@@ -3901,10 +3899,6 @@ UniValue walletprocesspsbt(const JSONRPCRequest& request)
 
 UniValue walletcreatefundedpsbt(const JSONRPCRequest& request)
 {
-    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-    if (!wallet) return NullUniValue;
-    CWallet* const pwallet = wallet.get();
-
     if (request.fHelp || request.params.size() < 2 || request.params.size() > 5)
         throw std::runtime_error(
             RPCHelpMan{"walletcreatefundedpsbt",
@@ -3987,6 +3981,10 @@ UniValue walletcreatefundedpsbt(const JSONRPCRequest& request)
         }, true
     );
 
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
     CAmount fee;
     int change_position;
     CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2]);
diff --git a/test/functional/rpc_help.py b/test/functional/rpc_help.py
index f5f0939d1b..2e51efd479 100755
--- a/test/functional/rpc_help.py
+++ b/test/functional/rpc_help.py
@@ -17,6 +17,8 @@ class HelpRpcTest(BitcoinTestFramework):
     def run_test(self):
         self.test_categories()
         self.dump_help()
+        if self.is_wallet_compiled():
+            self.wallet_help()
 
     def test_categories(self):
         node = self.nodes[0]
@@ -52,6 +54,11 @@ class HelpRpcTest(BitcoinTestFramework):
                 # Make sure the node can generate the help at runtime without crashing
                 f.write(self.nodes[0].help(call))
 
+    def wallet_help(self):
+        assert 'getnewaddress ( "label" )' in self.nodes[0].help('getnewaddress')
+        self.restart_node(0, extra_args=['-nowallet=1'])
+        assert 'getnewaddress ( "label" )' in self.nodes[0].help('getnewaddress')
+
 
 if __name__ == '__main__':
     HelpRpcTest().main()