Merge bitcoin/bitcoin#32514: scripted-diff: Remove unused leading newline in RPC docs

fa1f10a49e doc: Fix minor typos in rpc help (MarcoFalke)
fae840e94b rpc: Reject beginning newline in RPC docs (MarcoFalke)
fa414eda08 scripted-diff: Remove unused leading newline in RPC docs (MarcoFalke)

Pull request description:

  It is harmless, but newlines in the beginning read a bit odd ("nReturns"). So just require them to not be present.

  The diff is large, but a trivial scripted-diff.

ACKs for top commit:
  fanquake:
    ACK fa1f10a49e
  w0xlt:
    ACK https://github.com/bitcoin/bitcoin/pull/32514/commits/fa1f10a49e7c4f6377fbc7ae2f1520b38c86e5fa

Tree-SHA512: 5d2f9632f42ec1c02814d050f223941f436e5b0df426d7d6eb93fdd0ff118d57185af07b271dd73af63735dd17231125826c0c9ce0aad36bc8829c5b050a628c

src/rpc/blockchain.cpp

@@ -219,8 +219,9 @@ UniValue blockToJSON(BlockManager& blockman, const CBlock& block, const CBlockIn
 
 static RPCHelpMan getblockcount()
 {
-    return RPCHelpMan{"getblockcount",
+    return RPCHelpMan{
-                "\nReturns the height of the most-work fully-validated chain.\n"
+        "getblockcount",
+        "Returns the height of the most-work fully-validated chain.\n"
                 "The genesis block has height 0.\n",
                 {},
                 RPCResult{
@@ -240,8 +241,9 @@ static RPCHelpMan getblockcount()
 
 static RPCHelpMan getbestblockhash()
 {
-    return RPCHelpMan{"getbestblockhash",
+    return RPCHelpMan{
-                "\nReturns the hash of the best (tip) block in the most-work fully-validated chain.\n",
+        "getbestblockhash",
+        "Returns the hash of the best (tip) block in the most-work fully-validated chain.\n",
                 {},
                 RPCResult{
                     RPCResult::Type::STR_HEX, "", "the block hash, hex-encoded"},
@@ -260,8 +262,9 @@ static RPCHelpMan getbestblockhash()
 
 static RPCHelpMan waitfornewblock()
 {
-    return RPCHelpMan{"waitfornewblock",
+    return RPCHelpMan{
-                "\nWaits for any new block and returns useful info about it.\n"
+        "waitfornewblock",
+        "Waits for any new block and returns useful info about it.\n"
                 "\nReturns the current block on timeout or exit.\n"
                 "\nMake sure to use no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",
                 {
@@ -305,8 +308,9 @@ static RPCHelpMan waitfornewblock()
 
 static RPCHelpMan waitforblock()
 {
-    return RPCHelpMan{"waitforblock",
+    return RPCHelpMan{
-                "\nWaits for a specific new block and returns useful info about it.\n"
+        "waitforblock",
+        "Waits for a specific new block and returns useful info about it.\n"
                 "\nReturns the current block on timeout or exit.\n"
                 "\nMake sure to use no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",
                 {
@@ -365,8 +369,9 @@ static RPCHelpMan waitforblock()
 
 static RPCHelpMan waitforblockheight()
 {
-    return RPCHelpMan{"waitforblockheight",
+    return RPCHelpMan{
-                "\nWaits for (at least) block height and returns the height and hash\n"
+        "waitforblockheight",
+        "Waits for (at least) block height and returns the height and hash\n"
                 "of the current tip.\n"
                 "\nReturns the current block on timeout or exit.\n"
                 "\nMake sure to use no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",
@@ -427,8 +432,9 @@ static RPCHelpMan waitforblockheight()
 
 static RPCHelpMan syncwithvalidationinterfacequeue()
 {
-    return RPCHelpMan{"syncwithvalidationinterfacequeue",
+    return RPCHelpMan{
-                "\nWaits for the validation interface queue to catch up on everything that was there when we entered this function.\n",
+        "syncwithvalidationinterfacequeue",
+        "Waits for the validation interface queue to catch up on everything that was there when we entered this function.\n",
                 {},
                 RPCResult{RPCResult::Type::NONE, "", ""},
                 RPCExamples{
@@ -446,8 +452,9 @@ static RPCHelpMan syncwithvalidationinterfacequeue()
 
 static RPCHelpMan getdifficulty()
 {
-    return RPCHelpMan{"getdifficulty",
+    return RPCHelpMan{
-                "\nReturns the proof-of-work difficulty as a multiple of the minimum difficulty.\n",
+        "getdifficulty",
+        "Returns the proof-of-work difficulty as a multiple of the minimum difficulty.\n",
                 {},
                 RPCResult{
                     RPCResult::Type::NUM, "", "the proof-of-work difficulty as a multiple of the minimum difficulty."},
@@ -521,8 +528,9 @@ static RPCHelpMan getblockfrompeer()
 
 static RPCHelpMan getblockhash()
 {
-    return RPCHelpMan{"getblockhash",
+    return RPCHelpMan{
-                "\nReturns hash of block in best-block-chain at height provided.\n",
+        "getblockhash",
+        "Returns hash of block in best-block-chain at height provided.\n",
                 {
                     {"height", RPCArg::Type::NUM, RPCArg::Optional::NO, "The height index"},
                 },
@@ -550,8 +558,9 @@ static RPCHelpMan getblockhash()
 
 static RPCHelpMan getblockheader()
 {
-    return RPCHelpMan{"getblockheader",
+    return RPCHelpMan{
-                "\nIf verbose is false, returns a string that is serialized, hex-encoded data for blockheader 'hash'.\n"
+        "getblockheader",
+        "If verbose is false, returns a string that is serialized, hex-encoded data for blockheader 'hash'.\n"
                 "If verbose is true, returns an Object with information about blockheader <hash>.\n",
                 {
                     {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The block hash"},
@@ -715,8 +724,9 @@ const RPCResult getblock_vin{
 
 static RPCHelpMan getblock()
 {
-    return RPCHelpMan{"getblock",
+    return RPCHelpMan{
-                "\nIf verbosity is 0, returns a string that is serialized, hex-encoded data for block 'hash'.\n"
+        "getblock",
+        "If verbosity is 0, returns a string that is serialized, hex-encoded data for block 'hash'.\n"
                 "If verbosity is 1, returns an Object with information about block <hash>.\n"
                 "If verbosity is 2, returns an Object with information about block <hash> and information about each transaction.\n"
                 "If verbosity is 3, returns an Object with information about block <hash> and information about each transaction, including prevout information for inputs (only for unpruned blocks in the current best chain).\n",
@@ -954,8 +964,9 @@ static std::optional<kernel::CCoinsStats> GetUTXOStats(CCoinsView* view, node::B
 
 static RPCHelpMan gettxoutsetinfo()
 {
-    return RPCHelpMan{"gettxoutsetinfo",
+    return RPCHelpMan{
-                "\nReturns statistics about the unspent transaction output set.\n"
+        "gettxoutsetinfo",
+        "Returns statistics about the unspent transaction output set.\n"
                 "Note this call may take some time if you are not using coinstatsindex.\n",
                 {
                     {"hash_type", RPCArg::Type::STR, RPCArg::Default{"hash_serialized_3"}, "Which UTXO set hash should be calculated. Options: 'hash_serialized_3' (the legacy algorithm), 'muhash', 'none'."},
@@ -1109,8 +1120,9 @@ static RPCHelpMan gettxoutsetinfo()
 
 static RPCHelpMan gettxout()
 {
-    return RPCHelpMan{"gettxout",
+    return RPCHelpMan{
-        "\nReturns details about an unspent transaction output.\n",
+        "gettxout",
+        "Returns details about an unspent transaction output.\n",
         {
             {"txid", RPCArg::Type::STR, RPCArg::Optional::NO, "The transaction id"},
             {"n", RPCArg::Type::NUM, RPCArg::Optional::NO, "vout number"},
@@ -1188,8 +1200,9 @@ static RPCHelpMan gettxout()
 
 static RPCHelpMan verifychain()
 {
-    return RPCHelpMan{"verifychain",
+    return RPCHelpMan{
-                "\nVerifies blockchain database.\n",
+        "verifychain",
+        "Verifies blockchain database.\n",
                 {
                     {"checklevel", RPCArg::Type::NUM, RPCArg::DefaultHint{strprintf("%d, range=0-4", DEFAULT_CHECKLEVEL)},
                         strprintf("How thorough the block verification is:\n%s", MakeUnorderedList(CHECKLEVEL_DOC))},
@@ -1570,8 +1583,9 @@ static RPCHelpMan getchaintips()
 
 static RPCHelpMan preciousblock()
 {
-    return RPCHelpMan{"preciousblock",
+    return RPCHelpMan{
-                "\nTreats a block as if it were received before others with the same work.\n"
+        "preciousblock",
+        "Treats a block as if it were received before others with the same work.\n"
                 "\nA later preciousblock call can override the effect of an earlier one.\n"
                 "\nThe effects of preciousblock are not retained across restarts.\n",
                 {
@@ -1631,8 +1645,9 @@ void InvalidateBlock(ChainstateManager& chainman, const uint256 block_hash) {
 
 static RPCHelpMan invalidateblock()
 {
-    return RPCHelpMan{"invalidateblock",
+    return RPCHelpMan{
-                "\nPermanently marks a block as invalid, as if it violated a consensus rule.\n",
+        "invalidateblock",
+        "Permanently marks a block as invalid, as if it violated a consensus rule.\n",
                 {
                     {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hash of the block to mark as invalid"},
                 },
@@ -1675,8 +1690,9 @@ void ReconsiderBlock(ChainstateManager& chainman, uint256 block_hash) {
 
 static RPCHelpMan reconsiderblock()
 {
-    return RPCHelpMan{"reconsiderblock",
+    return RPCHelpMan{
-                "\nRemoves invalidity status of a block, its ancestors and its descendants, reconsider them for activation.\n"
+        "reconsiderblock",
+        "Removes invalidity status of a block, its ancestors and its descendants, reconsider them for activation.\n"
                 "This can be used to undo the effects of invalidateblock.\n",
                 {
                     {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hash of the block to reconsider"},
@@ -1700,8 +1716,9 @@ static RPCHelpMan reconsiderblock()
 
 static RPCHelpMan getchaintxstats()
 {
-    return RPCHelpMan{"getchaintxstats",
+    return RPCHelpMan{
-                "\nCompute statistics about the total number and rate of transactions in the chain.\n",
+        "getchaintxstats",
+        "Compute statistics about the total number and rate of transactions in the chain.\n",
                 {
                     {"nblocks", RPCArg::Type::NUM, RPCArg::DefaultHint{"one month"}, "Size of the window in number of blocks"},
                     {"blockhash", RPCArg::Type::STR_HEX, RPCArg::DefaultHint{"chain tip"}, "The hash of the block that ends the window."},
@@ -1846,8 +1863,9 @@ static constexpr size_t PER_UTXO_OVERHEAD = sizeof(COutPoint) + sizeof(uint32_t)
 
 static RPCHelpMan getblockstats()
 {
-    return RPCHelpMan{"getblockstats",
+    return RPCHelpMan{
-                "\nCompute per block statistics for a given window. All amounts are in satoshis.\n"
+        "getblockstats",
+        "Compute per block statistics for a given window. All amounts are in satoshis.\n"
                 "It won't work for some heights with pruning.\n",
                 {
                     {"hash_or_height", RPCArg::Type::NUM, RPCArg::Optional::NO, "The block hash or height of the target block",
@@ -2204,8 +2222,9 @@ static RPCHelpMan scantxoutset()
     // raw() descriptor corresponding to mainnet address 12cbQLTFMXRnSzktFkuoG3eHoMeFtpTu3S
     const std::string EXAMPLE_DESCRIPTOR_RAW = "raw(76a91411b366edfc0a8b66feebae5c2e25a7b6a5d1cf3188ac)#fm24fxxy";
 
-    return RPCHelpMan{"scantxoutset",
+    return RPCHelpMan{
-        "\nScans the unspent transaction output set for entries that match certain output descriptors.\n"
+        "scantxoutset",
+        "Scans the unspent transaction output set for entries that match certain output descriptors.\n"
         "Examples of output descriptors are:\n"
         "    addr(<address>)                      Outputs whose output script corresponds to the specified address (does not include P2PK)\n"
         "    raw(<hex script>)                    Outputs whose output script equals the specified hex-encoded bytes\n"
@@ -2415,8 +2434,9 @@ static bool CheckBlockFilterMatches(BlockManager& blockman, const CBlockIndex& b
 
 static RPCHelpMan scanblocks()
 {
-    return RPCHelpMan{"scanblocks",
+    return RPCHelpMan{
-        "\nReturn relevant blockhashes for given descriptors (requires blockfilterindex).\n"
+        "scanblocks",
+        "Return relevant blockhashes for given descriptors (requires blockfilterindex).\n"
         "This call may take several minutes. Make sure to use no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",
         {
             scan_action_arg_desc,
@@ -2603,8 +2623,9 @@ static RPCHelpMan scanblocks()
 
 static RPCHelpMan getdescriptoractivity()
 {
-    return RPCHelpMan{"getdescriptoractivity",
+    return RPCHelpMan{
-        "\nGet spend and receive activity associated with a set of descriptors for a set of blocks. "
+        "getdescriptoractivity",
+        "Get spend and receive activity associated with a set of descriptors for a set of blocks. "
         "This command pairs well with the `relevant_blocks` output of `scanblocks()`.\n"
         "This call may take several minutes. If you encounter timeouts, try specifying no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",
         {
@@ -2832,8 +2853,9 @@ static RPCHelpMan getdescriptoractivity()
 
 static RPCHelpMan getblockfilter()
 {
-    return RPCHelpMan{"getblockfilter",
+    return RPCHelpMan{
-                "\nRetrieve a BIP 157 content filter for a particular block.\n",
+        "getblockfilter",
+        "Retrieve a BIP 157 content filter for a particular block.\n",
                 {
                     {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hash of the block"},
                     {"filtertype", RPCArg::Type::STR, RPCArg::Default{BlockFilterTypeName(BlockFilterType::BASIC)}, "The type name of the filter"},
@@ -3322,7 +3344,7 @@ static RPCHelpMan getchainstates()
 {
 return RPCHelpMan{
         "getchainstates",
-        "\nReturn information about chainstates.\n",
+        "Return information about chainstates.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ, "", "", {

src/rpc/fees.cpp

@@ -29,8 +29,9 @@ using node::NodeContext;
 
 static RPCHelpMan estimatesmartfee()
 {
-    return RPCHelpMan{"estimatesmartfee",
+    return RPCHelpMan{
-        "\nEstimates the approximate fee per kilobyte needed for a transaction to begin\n"
+        "estimatesmartfee",
+        "Estimates the approximate fee per kilobyte needed for a transaction to begin\n"
         "confirmation within conf_target blocks if possible and return the number of blocks\n"
         "for which the estimate is valid. Uses virtual transaction size as defined\n"
         "in BIP 141 (witness data is discounted).\n",
@@ -96,8 +97,9 @@ static RPCHelpMan estimatesmartfee()
 
 static RPCHelpMan estimaterawfee()
 {
-    return RPCHelpMan{"estimaterawfee",
+    return RPCHelpMan{
-        "\nWARNING: This interface is unstable and may disappear or change!\n"
+        "estimaterawfee",
+        "WARNING: This interface is unstable and may disappear or change!\n"
         "\nWARNING: This is an advanced API call that is tightly coupled to the specific\n"
         "implementation of fee estimation. The parameters it can be called with\n"
         "and the results it returns will change if the internal implementation changes.\n"

src/rpc/mempool.cpp

@@ -41,8 +41,9 @@ using util::ToString;
 
 static RPCHelpMan sendrawtransaction()
 {
-    return RPCHelpMan{"sendrawtransaction",
+    return RPCHelpMan{
-        "\nSubmit a raw transaction (serialized, hex-encoded) to local node and network.\n"
+        "sendrawtransaction",
+        "Submit a raw transaction (serialized, hex-encoded) to local node and network.\n"
         "\nThe transaction will be sent unconditionally to all peers, so using sendrawtransaction\n"
         "for manual rebroadcast may degrade privacy by leaking the transaction's origin, as\n"
         "nodes will normally not rebroadcast non-wallet transactions already in their mempool.\n"
@@ -108,8 +109,9 @@ static RPCHelpMan sendrawtransaction()
 
 static RPCHelpMan testmempoolaccept()
 {
-    return RPCHelpMan{"testmempoolaccept",
+    return RPCHelpMan{
-        "\nReturns result of mempool acceptance tests indicating if raw transaction(s) (serialized, hex-encoded) would be accepted by mempool.\n"
+        "testmempoolaccept",
+        "Returns result of mempool acceptance tests indicating if raw transaction(s) (serialized, hex-encoded) would be accepted by mempool.\n"
         "\nIf multiple transactions are passed in, parents must come before children and package policies apply: the transactions cannot conflict with any mempool transactions or each other.\n"
         "\nIf one transaction fails, other transactions may not be fully validated (the 'allowed' key will be blank).\n"
         "\nThe maximum number of transactions allowed is " + ToString(MAX_PACKAGE_COUNT) + ".\n"
@@ -381,8 +383,9 @@ UniValue MempoolToJSON(const CTxMemPool& pool, bool verbose, bool include_mempoo
 
 static RPCHelpMan getrawmempool()
 {
-    return RPCHelpMan{"getrawmempool",
+    return RPCHelpMan{
-        "\nReturns all transaction ids in memory pool as a json array of string transaction ids.\n"
+        "getrawmempool",
+        "Returns all transaction ids in memory pool as a json array of string transaction ids.\n"
         "\nHint: use getmempoolentry to fetch a specific transaction from the mempool.\n",
         {
             {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},
@@ -431,8 +434,9 @@ static RPCHelpMan getrawmempool()
 
 static RPCHelpMan getmempoolancestors()
 {
-    return RPCHelpMan{"getmempoolancestors",
+    return RPCHelpMan{
-        "\nIf txid is in the mempool, returns all in-mempool ancestors.\n",
+        "getmempoolancestors",
+        "If txid is in the mempool, returns all in-mempool ancestors.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},
             {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},
@@ -492,8 +496,9 @@ static RPCHelpMan getmempoolancestors()
 
 static RPCHelpMan getmempooldescendants()
 {
-    return RPCHelpMan{"getmempooldescendants",
+    return RPCHelpMan{
-        "\nIf txid is in the mempool, returns all in-mempool descendants.\n",
+        "getmempooldescendants",
+        "If txid is in the mempool, returns all in-mempool descendants.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},
             {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},
@@ -557,8 +562,9 @@ static RPCHelpMan getmempooldescendants()
 
 static RPCHelpMan getmempoolentry()
 {
-    return RPCHelpMan{"getmempoolentry",
+    return RPCHelpMan{
-        "\nReturns mempool data for given transaction\n",
+        "getmempoolentry",
+        "Returns mempool data for given transaction\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},
         },
@@ -782,8 +788,9 @@ static RPCHelpMan importmempool()
 
 static RPCHelpMan savemempool()
 {
-    return RPCHelpMan{"savemempool",
+    return RPCHelpMan{
-        "\nDumps the mempool to disk. It will fail until the previous dump is fully loaded.\n",
+        "savemempool",
+        "Dumps the mempool to disk. It will fail until the previous dump is fully loaded.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ, "", "",
@@ -854,8 +861,9 @@ static UniValue OrphanToJSON(const TxOrphanage::OrphanTxBase& orphan)
 
 static RPCHelpMan getorphantxs()
 {
-    return RPCHelpMan{"getorphantxs",
+    return RPCHelpMan{
-        "\nShows transactions in the tx orphanage.\n"
+        "getorphantxs",
+        "Shows transactions in the tx orphanage.\n"
         "\nEXPERIMENTAL warning: this call may be changed in future releases.\n",
         {
             {"verbosity", RPCArg::Type::NUM, RPCArg::Default{0}, "0 for an array of txids (may contain duplicates), 1 for an array of objects with tx details, and 2 for details from (1) and tx hex",

src/rpc/mining.cpp

@@ -110,8 +110,9 @@ static UniValue GetNetworkHashPS(int lookup, int height, const CChain& active_ch
 
 static RPCHelpMan getnetworkhashps()
 {
-    return RPCHelpMan{"getnetworkhashps",
+    return RPCHelpMan{
-                "\nReturns the estimated network hashes per second based on the last n blocks.\n"
+        "getnetworkhashps",
+        "Returns the estimated network hashes per second based on the last n blocks.\n"
                 "Pass in [blocks] to override # of blocks, -1 specifies since last difficulty change.\n"
                 "Pass in [height] to estimate the network speed at the time when a certain block was found.\n",
                 {
@@ -414,8 +415,9 @@ static RPCHelpMan generateblock()
 
 static RPCHelpMan getmininginfo()
 {
-    return RPCHelpMan{"getmininginfo",
+    return RPCHelpMan{
-                "\nReturns a json object containing mining-related information.",
+        "getmininginfo",
+        "Returns a json object containing mining-related information.",
                 {},
                 RPCResult{
                     RPCResult::Type::OBJ, "", "",
@@ -608,8 +610,9 @@ static std::string gbt_rule_value(const std::string& name, bool gbt_optional_rul
 
 static RPCHelpMan getblocktemplate()
 {
-    return RPCHelpMan{"getblocktemplate",
+    return RPCHelpMan{
-        "\nIf the request parameters include a 'mode' key, that is used to explicitly select between the default 'template' request or a 'proposal'.\n"
+        "getblocktemplate",
+        "If the request parameters include a 'mode' key, that is used to explicitly select between the default 'template' request or a 'proposal'.\n"
         "It returns data needed to construct a block to work on.\n"
         "For full specification, see BIPs 22, 23, 9, and 145:\n"
         "    https://github.com/bitcoin/bips/blob/master/bip-0022.mediawiki\n"
@@ -1045,8 +1048,9 @@ protected:
 static RPCHelpMan submitblock()
 {
     // We allow 2 arguments for compliance with BIP22. Argument 2 is ignored.
-    return RPCHelpMan{"submitblock",
+    return RPCHelpMan{
-        "\nAttempts to submit new block to network.\n"
+        "submitblock",
+        "Attempts to submit new block to network.\n"
         "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n",
         {
             {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block data to submit"},
@@ -1095,8 +1099,9 @@ static RPCHelpMan submitblock()
 
 static RPCHelpMan submitheader()
 {
-    return RPCHelpMan{"submitheader",
+    return RPCHelpMan{
-                "\nDecode the given hexdata as a header and submit it as a candidate chain tip if valid."
+        "submitheader",
+        "Decode the given hexdata as a header and submit it as a candidate chain tip if valid."
                 "\nThrows when the header is invalid.\n",
                 {
                     {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block header data"},

src/rpc/net.cpp

@@ -56,8 +56,9 @@ const std::vector<std::string> TRANSPORT_TYPE_DOC{
 
 static RPCHelpMan getconnectioncount()
 {
-    return RPCHelpMan{"getconnectioncount",
+    return RPCHelpMan{
-                "\nReturns the number of connections to other nodes.\n",
+        "getconnectioncount",
+        "Returns the number of connections to other nodes.\n",
                 {},
                 RPCResult{
                     RPCResult::Type::NUM, "", "The connection count"
@@ -78,8 +79,9 @@ static RPCHelpMan getconnectioncount()
 
 static RPCHelpMan ping()
 {
-    return RPCHelpMan{"ping",
+    return RPCHelpMan{
-                "\nRequests that a ping be sent to all other nodes, to measure ping time.\n"
+        "ping",
+        "Requests that a ping be sent to all other nodes, to measure ping time.\n"
                 "Results provided in getpeerinfo, pingtime and pingwait fields are decimal seconds.\n"
                 "Ping command is handled in queue with all other commands, so it measures processing backlog, not just network ping.\n",
                 {},
@@ -304,8 +306,9 @@ static RPCHelpMan getpeerinfo()
 
 static RPCHelpMan addnode()
 {
-    return RPCHelpMan{"addnode",
+    return RPCHelpMan{
-                "\nAttempts to add or remove a node from the addnode list.\n"
+        "addnode",
+        "Attempts to add or remove a node from the addnode list.\n"
                 "Or try a connection to a node once.\n"
                 "Nodes added using addnode (or -connect) are protected from DoS disconnection and are not required to be\n"
                 "full nodes/support SegWit as other outbound peers are (though such peers will not be synced from).\n" +
@@ -367,8 +370,9 @@ static RPCHelpMan addnode()
 
 static RPCHelpMan addconnection()
 {
-    return RPCHelpMan{"addconnection",
+    return RPCHelpMan{
-        "\nOpen an outbound connection to a specified node. This RPC is for testing only.\n",
+        "addconnection",
+        "Open an outbound connection to a specified node. This RPC is for testing only.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP address and port to attempt connecting to."},
             {"connection_type", RPCArg::Type::STR, RPCArg::Optional::NO, "Type of connection to open (\"outbound-full-relay\", \"block-relay-only\", \"addr-fetch\" or \"feeler\")."},
@@ -429,8 +433,9 @@ static RPCHelpMan addconnection()
 
 static RPCHelpMan disconnectnode()
 {
-    return RPCHelpMan{"disconnectnode",
+    return RPCHelpMan{
-                "\nImmediately disconnects from the specified peer node.\n"
+        "disconnectnode",
+        "Immediately disconnects from the specified peer node.\n"
                 "\nStrictly one out of 'address' and 'nodeid' can be provided to identify the node.\n"
                 "\nTo disconnect by nodeid, either set 'address' to the empty string, or call using the named 'nodeid' argument only.\n",
                 {
@@ -475,8 +480,9 @@ static RPCHelpMan disconnectnode()
 
 static RPCHelpMan getaddednodeinfo()
 {
-    return RPCHelpMan{"getaddednodeinfo",
+    return RPCHelpMan{
-                "\nReturns information about the given added node, or all added nodes\n"
+        "getaddednodeinfo",
+        "Returns information about the given added node, or all added nodes\n"
                 "(note that onetry addnodes are not listed here)\n",
                 {
                     {"node", RPCArg::Type::STR, RPCArg::DefaultHint{"all nodes"}, "If provided, return information about this specific node, otherwise all nodes are returned."},
@@ -724,8 +730,9 @@ static RPCHelpMan getnetworkinfo()
 
 static RPCHelpMan setban()
 {
-    return RPCHelpMan{"setban",
+    return RPCHelpMan{
-                "\nAttempts to add or remove an IP/Subnet from the banned list.\n",
+        "setban",
+        "Attempts to add or remove an IP/Subnet from the banned list.\n",
                 {
                     {"subnet", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP/Subnet (see getpeerinfo for nodes IP) with an optional netmask (default is /32 = single IP)"},
                     {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "'add' to add an IP/Subnet to the list, 'remove' to remove an IP/Subnet from the list"},
@@ -809,8 +816,9 @@ static RPCHelpMan setban()
 
 static RPCHelpMan listbanned()
 {
-    return RPCHelpMan{"listbanned",
+    return RPCHelpMan{
-                "\nList all manually banned IPs/Subnets.\n",
+        "listbanned",
+        "List all manually banned IPs/Subnets.\n",
                 {},
         RPCResult{RPCResult::Type::ARR, "", "",
             {
@@ -856,8 +864,9 @@ static RPCHelpMan listbanned()
 
 static RPCHelpMan clearbanned()
 {
-    return RPCHelpMan{"clearbanned",
+    return RPCHelpMan{
-                "\nClear all banned IPs.\n",
+        "clearbanned",
+        "Clear all banned IPs.\n",
                 {},
                 RPCResult{RPCResult::Type::NONE, "", ""},
                 RPCExamples{
@@ -877,8 +886,9 @@ static RPCHelpMan clearbanned()
 
 static RPCHelpMan setnetworkactive()
 {
-    return RPCHelpMan{"setnetworkactive",
+    return RPCHelpMan{
-                "\nDisable/enable all p2p network activity.\n",
+        "setnetworkactive",
+        "Disable/enable all p2p network activity.\n",
                 {
                     {"state", RPCArg::Type::BOOL, RPCArg::Optional::NO, "true to enable networking, false to disable"},
                 },
@@ -1067,7 +1077,7 @@ static RPCHelpMan getaddrmaninfo()
 {
     return RPCHelpMan{
         "getaddrmaninfo",
-        "\nProvides information about the node's address manager by returning the number of "
+        "Provides information about the node's address manager by returning the number of "
         "addresses in the `new` and `tried` tables and their sum for all networks.\n",
         {},
         RPCResult{

src/rpc/node.cpp

@@ -35,8 +35,9 @@ using node::NodeContext;
 
 static RPCHelpMan setmocktime()
 {
-    return RPCHelpMan{"setmocktime",
+    return RPCHelpMan{
-        "\nSet the local time to given timestamp (-regtest only)\n",
+        "setmocktime",
+        "Set the local time to given timestamp (-regtest only)\n",
         {
             {"timestamp", RPCArg::Type::NUM, RPCArg::Optional::NO, UNIX_EPOCH_TIME + "\n"
              "Pass 0 to go back to using the system time."},
@@ -75,8 +76,9 @@ static RPCHelpMan setmocktime()
 
 static RPCHelpMan mockscheduler()
 {
-    return RPCHelpMan{"mockscheduler",
+    return RPCHelpMan{
-        "\nBump the scheduler into the future (-regtest only)\n",
+        "mockscheduler",
+        "Bump the scheduler into the future (-regtest only)\n",
         {
             {"delta_time", RPCArg::Type::NUM, RPCArg::Optional::NO, "Number of seconds to forward the scheduler into the future." },
         },
@@ -271,8 +273,9 @@ static RPCHelpMan logging()
 
 static RPCHelpMan echo(const std::string& name)
 {
-    return RPCHelpMan{name,
+    return RPCHelpMan{
-                "\nSimply echo back the input arguments. This command is for testing.\n"
+        name,
+        "Simply echo back the input arguments. This command is for testing.\n"
                 "\nIt will return an internal bug report when arg9='trigger_internal_bug' is passed.\n"
                 "\nThe difference between echo and echojson is that echojson has argument conversion enabled in the client-side table in "
                 "bitcoin-cli and the GUI. There is no server-side difference.",
@@ -308,7 +311,7 @@ static RPCHelpMan echoipc()
 {
     return RPCHelpMan{
         "echoipc",
-        "\nEcho back the input argument, passing it through a spawned process in a multiprocess build.\n"
+        "Echo back the input argument, passing it through a spawned process in a multiprocess build.\n"
         "This command is for testing.\n",
         {{"arg", RPCArg::Type::STR, RPCArg::Optional::NO, "The string to echo",}},
         RPCResult{RPCResult::Type::STR, "echo", "The echoed string."},
@@ -356,8 +359,9 @@ static UniValue SummaryToJSON(const IndexSummary&& summary, std::string index_na
 
 static RPCHelpMan getindexinfo()
 {
-    return RPCHelpMan{"getindexinfo",
+    return RPCHelpMan{
-                "\nReturns the status of one or all available indices currently running in the node.\n",
+        "getindexinfo",
+        "Returns the status of one or all available indices currently running in the node.\n",
                 {
                     {"index_name", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Filter results for an index with a specific name."},
                 },

src/rpc/output_script.cpp

@@ -29,7 +29,7 @@ static RPCHelpMan validateaddress()
 {
     return RPCHelpMan{
         "validateaddress",
-        "\nReturn information about the given bitcoin address.\n",
+        "Return information about the given bitcoin address.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address to validate"},
         },
@@ -87,11 +87,12 @@ static RPCHelpMan validateaddress()
 
 static RPCHelpMan createmultisig()
 {
-    return RPCHelpMan{"createmultisig",
+    return RPCHelpMan{
-        "\nCreates a multi-signature address with n signature of m keys required.\n"
+        "createmultisig",
+        "Creates a multi-signature address with n signatures of m keys required.\n"
         "It returns a json object with the address and redeemScript.\n",
         {
-            {"nrequired", RPCArg::Type::NUM, RPCArg::Optional::NO, "The number of required signatures out of the n keys."},
+            {"nrequired", RPCArg::Type::NUM, RPCArg::Optional::NO, "The number of required signatures out of the m keys."},
             {"keys", RPCArg::Type::ARR, RPCArg::Optional::NO, "The hex-encoded public keys.",
                 {
                     {"key", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "The hex-encoded public key"},
@@ -168,8 +169,9 @@ static RPCHelpMan getdescriptorinfo()
 {
     const std::string EXAMPLE_DESCRIPTOR = "wpkh([d34db33f/84h/0h/0h]0279be667ef9dcbbac55a06295Ce870b07029Bfcdb2dce28d959f2815b16f81798)";
 
-    return RPCHelpMan{"getdescriptorinfo",
+    return RPCHelpMan{
-        {"\nAnalyses a descriptor.\n"},
+        "getdescriptorinfo",
+        "Analyses a descriptor.\n",
         {
             {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor."},
         },
@@ -259,8 +261,9 @@ static RPCHelpMan deriveaddresses()
 {
     const std::string EXAMPLE_DESCRIPTOR = "wpkh([d34db33f/84h/0h/0h]xpub6DJ2dNUysrn5Vt36jH2KLBT2i1auw1tTSSomg8PhqNiUtx8QX2SvC9nrHu81fT41fvDUnhMjEzQgXnQjKEu3oaqMSzhSrHMxyyoEAmUHQbY/0/*)#cjjspncu";
 
-    return RPCHelpMan{"deriveaddresses",
+    return RPCHelpMan{
-        {"\nDerives one or more addresses corresponding to an output descriptor.\n"
+        "deriveaddresses",
+        "Derives one or more addresses corresponding to an output descriptor.\n"
          "Examples of output descriptors are:\n"
          "    pkh(<pubkey>)                                     P2PKH outputs for the given pubkey\n"
          "    wpkh(<pubkey>)                                    Native segwit P2PKH outputs for the given pubkey\n"
@@ -269,7 +272,7 @@ static RPCHelpMan deriveaddresses()
          "    tr(<pubkey>,multi_a(<n>,<pubkey>,<pubkey>,...))   P2TR-multisig outputs for the given threshold and pubkeys\n"
          "\nIn the above, <pubkey> either refers to a fixed public key in hexadecimal notation, or to an xpub/xprv optionally followed by one\n"
          "or more path elements separated by \"/\", where \"h\" represents a hardened child key.\n"
-         "For more information on output descriptors, see the documentation in the doc/descriptors.md file.\n"},
+        "For more information on output descriptors, see the documentation in the doc/descriptors.md file.\n",
         {
             {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor."},
             {"range", RPCArg::Type::RANGE, RPCArg::Optional::OMITTED, "If a ranged descriptor is used, this specifies the end or the range (in [begin,end] notation) to derive."},

src/rpc/rawtransaction.cpp

@@ -411,8 +411,9 @@ static RPCHelpMan getrawtransaction()
 
 static RPCHelpMan createrawtransaction()
 {
-    return RPCHelpMan{"createrawtransaction",
+    return RPCHelpMan{
-                "\nCreate a transaction spending the given inputs and creating new outputs.\n"
+        "createrawtransaction",
+        "Create a transaction spending the given inputs and creating new outputs.\n"
                 "Outputs can be addresses or data.\n"
                 "Returns hex-encoded raw transaction.\n"
                 "Note that the transaction's inputs are not signed, and\n"
@@ -485,7 +486,7 @@ static RPCHelpMan decodescript()
 {
     return RPCHelpMan{
         "decodescript",
-        "\nDecode a hex-encoded script.\n",
+        "Decode a hex-encoded script.\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded script"},
         },
@@ -618,8 +619,9 @@ static RPCHelpMan decodescript()
 
 static RPCHelpMan combinerawtransaction()
 {
-    return RPCHelpMan{"combinerawtransaction",
+    return RPCHelpMan{
-                "\nCombine multiple partially signed transactions into one transaction.\n"
+        "combinerawtransaction",
+        "Combine multiple partially signed transactions into one transaction.\n"
                 "The combined transaction may be another partially signed transaction or a \n"
                 "fully signed transaction.",
                 {
@@ -704,8 +706,9 @@ static RPCHelpMan combinerawtransaction()
 
 static RPCHelpMan signrawtransactionwithkey()
 {
-    return RPCHelpMan{"signrawtransactionwithkey",
+    return RPCHelpMan{
-                "\nSign inputs for raw transaction (serialized, hex-encoded).\n"
+        "signrawtransactionwithkey",
+        "Sign inputs for raw transaction (serialized, hex-encoded).\n"
                 "The second argument is an array of base58-encoded private\n"
                 "keys that will be the only keys used to sign the transaction.\n"
                 "The third optional argument (may be null) is an array of previous transaction outputs that\n"
@@ -1548,8 +1551,9 @@ static RPCHelpMan decodepsbt()
 
 static RPCHelpMan combinepsbt()
 {
-    return RPCHelpMan{"combinepsbt",
+    return RPCHelpMan{
-                "\nCombine multiple partially signed Bitcoin transactions into one transaction.\n"
+        "combinepsbt",
+        "Combine multiple partially signed Bitcoin transactions into one transaction.\n"
                 "Implements the Combiner role.\n",
                 {
                     {"txs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The base64 strings of partially signed transactions",
@@ -1652,8 +1656,9 @@ static RPCHelpMan finalizepsbt()
 
 static RPCHelpMan createpsbt()
 {
-    return RPCHelpMan{"createpsbt",
+    return RPCHelpMan{
-                "\nCreates a transaction in the Partially Signed Transaction format.\n"
+        "createpsbt",
+        "Creates a transaction in the Partially Signed Transaction format.\n"
                 "Implements the Creator role.\n"
                 "Note that the transaction's inputs are not signed, and\n"
                 "it is not stored in the wallet or transmitted to the network.\n",
@@ -1694,8 +1699,9 @@ static RPCHelpMan createpsbt()
 
 static RPCHelpMan converttopsbt()
 {
-    return RPCHelpMan{"converttopsbt",
+    return RPCHelpMan{
-                "\nConverts a network serialized transaction to a PSBT. This should be used only with createrawtransaction and fundrawtransaction\n"
+        "converttopsbt",
+        "Converts a network serialized transaction to a PSBT. This should be used only with createrawtransaction and fundrawtransaction\n"
                 "createpsbt and walletcreatefundedpsbt should be used for new applications.\n",
                 {
                     {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex string of a raw transaction"},
@@ -1761,8 +1767,9 @@ static RPCHelpMan converttopsbt()
 
 static RPCHelpMan utxoupdatepsbt()
 {
-    return RPCHelpMan{"utxoupdatepsbt",
+    return RPCHelpMan{
-            "\nUpdates all segwit inputs and outputs in a PSBT with data from output descriptors, the UTXO set, txindex, or the mempool.\n",
+        "utxoupdatepsbt",
+        "Updates all segwit inputs and outputs in a PSBT with data from output descriptors, the UTXO set, txindex, or the mempool.\n",
             {
                 {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "A base64 string of a PSBT"},
                 {"descriptors", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "An array of either strings or objects", {
@@ -1807,8 +1814,9 @@ static RPCHelpMan utxoupdatepsbt()
 
 static RPCHelpMan joinpsbts()
 {
-    return RPCHelpMan{"joinpsbts",
+    return RPCHelpMan{
-            "\nJoins multiple distinct PSBTs with different inputs and outputs into one PSBT with inputs and outputs from all of the PSBTs\n"
+        "joinpsbts",
+        "Joins multiple distinct PSBTs with different inputs and outputs into one PSBT with inputs and outputs from all of the PSBTs\n"
             "No input in any of the PSBTs can be in more than one of the PSBTs.\n",
             {
                 {"txs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The base64 strings of partially signed transactions",
@@ -1908,8 +1916,9 @@ static RPCHelpMan joinpsbts()
 
 static RPCHelpMan analyzepsbt()
 {
-    return RPCHelpMan{"analyzepsbt",
+    return RPCHelpMan{
-            "\nAnalyzes and provides information about the current status of a PSBT and its inputs\n",
+        "analyzepsbt",
+        "Analyzes and provides information about the current status of a PSBT and its inputs\n",
             {
                 {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "A base64 string of a PSBT"}
             },
@@ -2017,8 +2026,9 @@ static RPCHelpMan analyzepsbt()
 
 RPCHelpMan descriptorprocesspsbt()
 {
-    return RPCHelpMan{"descriptorprocesspsbt",
+    return RPCHelpMan{
-                "\nUpdate all segwit inputs in a PSBT with information from output descriptors, the UTXO set or the mempool. \n"
+        "descriptorprocesspsbt",
+        "Update all segwit inputs in a PSBT with information from output descriptors, the UTXO set or the mempool. \n"
                 "Then, sign the inputs we are able to with information from the output descriptors. ",
                 {
                     {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "The transaction base64 string"},

src/rpc/server.cpp

@@ -126,8 +126,9 @@ std::string CRPCTable::help(const std::string& strCommand, const JSONRPCRequest&
 
 static RPCHelpMan help()
 {
-    return RPCHelpMan{"help",
+    return RPCHelpMan{
-                "\nList all commands, or get help for a specified command.\n",
+        "help",
+        "List all commands, or get help for a specified command.\n",
                 {
                     {"command", RPCArg::Type::STR, RPCArg::DefaultHint{"all commands"}, "The command to get help on"},
                 },
@@ -155,11 +156,12 @@ static RPCHelpMan help()
 static RPCHelpMan stop()
 {
     static const std::string RESULT{CLIENT_NAME " stopping"};
-    return RPCHelpMan{"stop",
+    return RPCHelpMan{
+        "stop",
     // Also accept the hidden 'wait' integer argument (milliseconds)
     // For instance, 'stop 1000' makes the call wait 1 second before returning
     // to the client (intended for testing)
-                "\nRequest a graceful shutdown of " CLIENT_NAME ".",
+        "Request a graceful shutdown of " CLIENT_NAME ".",
                 {
                     {"wait", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "how long to wait in ms", RPCArgOptions{.hidden=true}},
                 },
@@ -180,8 +182,9 @@ static RPCHelpMan stop()
 
 static RPCHelpMan uptime()
 {
-    return RPCHelpMan{"uptime",
+    return RPCHelpMan{
-                "\nReturns the total uptime of the server.\n",
+        "uptime",
+        "Returns the total uptime of the server.\n",
                             {},
                             RPCResult{
                                 RPCResult::Type::NUM, "", "The number of seconds that the server has been running"
@@ -199,8 +202,9 @@ static RPCHelpMan uptime()
 
 static RPCHelpMan getrpcinfo()
 {
-    return RPCHelpMan{"getrpcinfo",
+    return RPCHelpMan{
-                "\nReturns details of the RPC server.\n",
+        "getrpcinfo",
+        "Returns details of the RPC server.\n",
                 {},
                 RPCResult{
                     RPCResult::Type::OBJ, "", "",

src/rpc/signmessage.cpp

@@ -63,8 +63,9 @@ static RPCHelpMan verifymessage()
 
 static RPCHelpMan signmessagewithprivkey()
 {
-    return RPCHelpMan{"signmessagewithprivkey",
+    return RPCHelpMan{
-        "\nSign a message with the private key of an address\n",
+        "signmessagewithprivkey",
+        "Sign a message with the private key of an address\n",
         {
             {"privkey", RPCArg::Type::STR, RPCArg::Optional::NO, "The private key to sign the message with."},
             {"message", RPCArg::Type::STR, RPCArg::Optional::NO, "The message to create a signature of."},

src/rpc/txoutproof.cpp

@@ -22,8 +22,9 @@ using node::GetTransaction;
 
 static RPCHelpMan gettxoutproof()
 {
-    return RPCHelpMan{"gettxoutproof",
+    return RPCHelpMan{
-        "\nReturns a hex-encoded proof that \"txid\" was included in a block.\n"
+        "gettxoutproof",
+        "Returns a hex-encoded proof that \"txid\" was included in a block.\n"
         "\nNOTE: By default this function only works sometimes. This is when there is an\n"
         "unspent output in the utxo for this transaction. To make it always work,\n"
         "you need to maintain a transaction index, using the -txindex command line option or\n"
@@ -127,8 +128,9 @@ static RPCHelpMan gettxoutproof()
 
 static RPCHelpMan verifytxoutproof()
 {
-    return RPCHelpMan{"verifytxoutproof",
+    return RPCHelpMan{
-        "\nVerifies that a proof points to a transaction in a block, returning the transaction it commits to\n"
+        "verifytxoutproof",
+        "Verifies that a proof points to a transaction in a block, returning the transaction it commits to\n"
         "and throwing an RPC error if the block is not in our best chain\n",
         {
             {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex-encoded proof generated by gettxoutproof"},

src/rpc/util.cpp

@@ -793,6 +793,7 @@ std::string RPCHelpMan::ToString() const
     if (was_optional) ret += " )";
 
     // Description
+    CHECK_NONFATAL(!m_description.starts_with('\n'));  // Historically \n was required, but reject it for new code.
     ret += "\n\n" + TrimString(m_description) + "\n";
 
     // Arguments

src/wallet/rpc/addresses.cpp

@@ -20,8 +20,9 @@
 namespace wallet {
 RPCHelpMan getnewaddress()
 {
-    return RPCHelpMan{"getnewaddress",
+    return RPCHelpMan{
-                "\nReturns a new Bitcoin address for receiving payments.\n"
+        "getnewaddress",
+        "Returns a new Bitcoin address for receiving payments.\n"
                 "If 'label' is specified, it is added to the address book \n"
                 "so payments received with the address will be associated with 'label'.\n",
                 {
@@ -70,8 +71,9 @@ RPCHelpMan getnewaddress()
 
 RPCHelpMan getrawchangeaddress()
 {
-    return RPCHelpMan{"getrawchangeaddress",
+    return RPCHelpMan{
-                "\nReturns a new Bitcoin address, for receiving change.\n"
+        "getrawchangeaddress",
+        "Returns a new Bitcoin address, for receiving change.\n"
                 "This is for use with raw transactions, NOT normal use.\n",
                 {
                     {"address_type", RPCArg::Type::STR, RPCArg::DefaultHint{"set by -changetype"}, "The address type to use. Options are \"legacy\", \"p2sh-segwit\", \"bech32\", and \"bech32m\"."},
@@ -115,8 +117,9 @@ RPCHelpMan getrawchangeaddress()
 
 RPCHelpMan setlabel()
 {
-    return RPCHelpMan{"setlabel",
+    return RPCHelpMan{
-                "\nSets the label associated with the given address.\n",
+        "setlabel",
+        "Sets the label associated with the given address.\n",
                 {
                     {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address to be associated with a label."},
                     {"label", RPCArg::Type::STR, RPCArg::Optional::NO, "The label to assign to the address."},
@@ -153,8 +156,9 @@ RPCHelpMan setlabel()
 
 RPCHelpMan listaddressgroupings()
 {
-    return RPCHelpMan{"listaddressgroupings",
+    return RPCHelpMan{
-                "\nLists groups of addresses which have had their common ownership\n"
+        "listaddressgroupings",
+        "Lists groups of addresses which have had their common ownership\n"
                 "made public by common use as inputs or as the resulting change\n"
                 "in past transactions\n",
                 {},
@@ -362,8 +366,9 @@ static UniValue DescribeWalletAddress(const CWallet& wallet, const CTxDestinatio
 
 RPCHelpMan getaddressinfo()
 {
-    return RPCHelpMan{"getaddressinfo",
+    return RPCHelpMan{
-                "\nReturn information about the given bitcoin address.\n"
+        "getaddressinfo",
+        "Return information about the given bitcoin address.\n"
                 "Some of the information will only be present if the address is in the active wallet.\n",
                 {
                     {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address for which to get information."},
@@ -508,8 +513,9 @@ RPCHelpMan getaddressinfo()
 
 RPCHelpMan getaddressesbylabel()
 {
-    return RPCHelpMan{"getaddressesbylabel",
+    return RPCHelpMan{
-                "\nReturns the list of addresses assigned the specified label.\n",
+        "getaddressesbylabel",
+        "Returns the list of addresses assigned the specified label.\n",
                 {
                     {"label", RPCArg::Type::STR, RPCArg::Optional::NO, "The label."},
                 },
@@ -568,8 +574,9 @@ RPCHelpMan getaddressesbylabel()
 
 RPCHelpMan listlabels()
 {
-    return RPCHelpMan{"listlabels",
+    return RPCHelpMan{
-                "\nReturns the list of all labels, or labels that are assigned to addresses with a specific purpose.\n",
+        "listlabels",
+        "Returns the list of all labels, or labels that are assigned to addresses with a specific purpose.\n",
                 {
                     {"purpose", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Address purpose to list labels for ('send','receive'). An empty string is the same as not providing this argument."},
                 },

src/wallet/rpc/backup.cpp

@@ -36,8 +36,9 @@ using interfaces::FoundBlock;
 namespace wallet {
 RPCHelpMan importprunedfunds()
 {
-    return RPCHelpMan{"importprunedfunds",
+    return RPCHelpMan{
-                "\nImports funds without rescan. Corresponding address or script must previously be included in wallet. Aimed towards pruned wallets. The end-user is responsible to import additional transactions that subsequently spend the imported outputs or rescan after the point in the blockchain the transaction is included.\n",
+        "importprunedfunds",
+        "Imports funds without rescan. Corresponding address or script must previously be included in wallet. Aimed towards pruned wallets. The end-user is responsible to import additional transactions that subsequently spend the imported outputs or rescan after the point in the blockchain the transaction is included.\n",
                 {
                     {"rawtransaction", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "A raw transaction in hex funding an already-existing address in wallet"},
                     {"txoutproof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex output from gettxoutproof that contains the transaction"},
@@ -91,8 +92,9 @@ RPCHelpMan importprunedfunds()
 
 RPCHelpMan removeprunedfunds()
 {
-    return RPCHelpMan{"removeprunedfunds",
+    return RPCHelpMan{
-                "\nDeletes the specified transaction from the wallet. Meant for use with pruned wallets and as a companion to importprunedfunds. This will affect wallet balances.\n",
+        "removeprunedfunds",
+        "Deletes the specified transaction from the wallet. Meant for use with pruned wallets and as a companion to importprunedfunds. This will affect wallet balances.\n",
                 {
                     {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex-encoded id of the transaction you are deleting"},
                 },
@@ -296,9 +298,10 @@ static UniValue ProcessDescriptorImport(CWallet& wallet, const UniValue& data, c
 
 RPCHelpMan importdescriptors()
 {
-    return RPCHelpMan{"importdescriptors",
+    return RPCHelpMan{
-                "\nImport descriptors. This will trigger a rescan of the blockchain based on the earliest timestamp of all descriptors being imported. Requires a new wallet backup.\n"
+        "importdescriptors",
-            "When importing descriptors with multipath key expressions, if the multipath specifier contains exactly two elements, the descriptor produced from the second elements will be imported as an internal descriptor.\n"
+        "Import descriptors. This will trigger a rescan of the blockchain based on the earliest timestamp of all descriptors being imported. Requires a new wallet backup.\n"
+        "When importing descriptors with multipath key expressions, if the multipath specifier contains exactly two elements, the descriptor produced from the second element will be imported as an internal descriptor.\n"
             "\nNote: This call can take over an hour to complete if using an early timestamp; during that time, other rpc calls\n"
             "may report that the imported keys, addresses or scripts exist but related transactions are still missing.\n"
             "The rescan is significantly faster if block filters are available (using startup option \"-blockfilterindex=1\").\n",
@@ -463,7 +466,7 @@ RPCHelpMan listdescriptors()
 {
     return RPCHelpMan{
         "listdescriptors",
-        "\nList descriptors imported into a descriptor-enabled wallet.\n",
+        "List descriptors imported into a descriptor-enabled wallet.\n",
         {
             {"private", RPCArg::Type::BOOL, RPCArg::Default{false}, "Show private descriptors."}
         },
@@ -574,8 +577,9 @@ RPCHelpMan listdescriptors()
 
 RPCHelpMan backupwallet()
 {
-    return RPCHelpMan{"backupwallet",
+    return RPCHelpMan{
-                "\nSafely copies the current wallet file to the specified destination, which can either be a directory or a path with a filename.\n",
+        "backupwallet",
+        "Safely copies the current wallet file to the specified destination, which can either be a directory or a path with a filename.\n",
                 {
                     {"destination", RPCArg::Type::STR, RPCArg::Optional::NO, "The destination directory or file"},
                 },
@@ -610,7 +614,7 @@ RPCHelpMan restorewallet()
 {
     return RPCHelpMan{
         "restorewallet",
-        "\nRestores and loads a wallet from backup.\n"
+        "Restores and loads a wallet from backup.\n"
         "\nThe rescan is significantly faster if a descriptor wallet is restored"
         "\nand block filters are available (using startup option \"-blockfilterindex=1\").\n",
         {

src/wallet/rpc/coins.cpp

@@ -79,8 +79,9 @@ static CAmount GetReceived(const CWallet& wallet, const UniValue& params, bool b
 
 RPCHelpMan getreceivedbyaddress()
 {
-    return RPCHelpMan{"getreceivedbyaddress",
+    return RPCHelpMan{
-                "\nReturns the total amount received by the given address in transactions with at least minconf confirmations.\n",
+        "getreceivedbyaddress",
+        "Returns the total amount received by the given address in transactions with at least minconf confirmations.\n",
                 {
                     {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address for transactions."},
                     {"minconf", RPCArg::Type::NUM, RPCArg::Default{1}, "Only include transactions confirmed at least this many times."},
@@ -120,8 +121,9 @@ RPCHelpMan getreceivedbyaddress()
 
 RPCHelpMan getreceivedbylabel()
 {
-    return RPCHelpMan{"getreceivedbylabel",
+    return RPCHelpMan{
-                "\nReturns the total amount received by addresses with <label> in transactions with at least [minconf] confirmations.\n",
+        "getreceivedbylabel",
+        "Returns the total amount received by addresses with <label> in transactions with at least [minconf] confirmations.\n",
                 {
                     {"label", RPCArg::Type::STR, RPCArg::Optional::NO, "The selected label, may be the default label using \"\"."},
                     {"minconf", RPCArg::Type::NUM, RPCArg::Default{1}, "Only include transactions confirmed at least this many times."},
@@ -161,8 +163,9 @@ RPCHelpMan getreceivedbylabel()
 
 RPCHelpMan getbalance()
 {
-    return RPCHelpMan{"getbalance",
+    return RPCHelpMan{
-                "\nReturns the total available balance.\n"
+        "getbalance",
+        "Returns the total available balance.\n"
                 "The available balance is what the wallet considers currently spendable, and is\n"
                 "thus affected by options which limit spendability such as -spendzeroconfchange.\n",
                 {
@@ -236,8 +239,9 @@ RPCHelpMan getunconfirmedbalance()
 
 RPCHelpMan lockunspent()
 {
-    return RPCHelpMan{"lockunspent",
+    return RPCHelpMan{
-                "\nUpdates list of temporarily unspendable outputs.\n"
+        "lockunspent",
+        "Updates list of temporarily unspendable outputs.\n"
                 "Temporarily lock (unlock=false) or unlock (unlock=true) specified transaction outputs.\n"
                 "If no transaction outputs are specified when unlocking then all current locked transaction outputs are unlocked.\n"
                 "A locked transaction output will not be chosen by automatic coin selection, when spending bitcoins.\n"
@@ -372,8 +376,9 @@ RPCHelpMan lockunspent()
 
 RPCHelpMan listlockunspent()
 {
-    return RPCHelpMan{"listlockunspent",
+    return RPCHelpMan{
-                "\nReturns list of temporarily unspendable outputs.\n"
+        "listlockunspent",
+        "Returns list of temporarily unspendable outputs.\n"
                 "See the lockunspent call to lock and unlock transactions for spending.\n",
                 {},
                 RPCResult{
@@ -481,8 +486,8 @@ RPCHelpMan getbalances()
 RPCHelpMan listunspent()
 {
     return RPCHelpMan{
-                "listunspent",
+        "listunspent",
-                "\nReturns array of unspent transaction outputs\n"
+        "Returns array of unspent transaction outputs\n"
                 "with between minconf and maxconf (inclusive) confirmations.\n"
                 "Optionally filter to only include txouts paid to specified addresses.\n",
                 {

src/wallet/rpc/encrypt.cpp

@@ -10,8 +10,9 @@
 namespace wallet {
 RPCHelpMan walletpassphrase()
 {
-    return RPCHelpMan{"walletpassphrase",
+    return RPCHelpMan{
-                "\nStores the wallet decryption key in memory for 'timeout' seconds.\n"
+        "walletpassphrase",
+        "Stores the wallet decryption key in memory for 'timeout' seconds.\n"
                 "This is needed prior to performing transactions related to private keys such as sending bitcoins\n"
             "\nNote:\n"
             "Issuing the walletpassphrase command while the wallet is already unlocked will set a new unlock\n"
@@ -114,8 +115,9 @@ RPCHelpMan walletpassphrase()
 
 RPCHelpMan walletpassphrasechange()
 {
-    return RPCHelpMan{"walletpassphrasechange",
+    return RPCHelpMan{
-                "\nChanges the wallet passphrase from 'oldpassphrase' to 'newpassphrase'.\n",
+        "walletpassphrasechange",
+        "Changes the wallet passphrase from 'oldpassphrase' to 'newpassphrase'.\n",
                 {
                     {"oldpassphrase", RPCArg::Type::STR, RPCArg::Optional::NO, "The current passphrase"},
                     {"newpassphrase", RPCArg::Type::STR, RPCArg::Optional::NO, "The new passphrase"},
@@ -173,8 +175,9 @@ RPCHelpMan walletpassphrasechange()
 
 RPCHelpMan walletlock()
 {
-    return RPCHelpMan{"walletlock",
+    return RPCHelpMan{
-                "\nRemoves the wallet encryption key from memory, locking the wallet.\n"
+        "walletlock",
+        "Removes the wallet encryption key from memory, locking the wallet.\n"
                 "After calling this method, you will need to call walletpassphrase again\n"
                 "before being able to call any methods which require the wallet to be unlocked.\n",
                 {},
@@ -215,10 +218,11 @@ RPCHelpMan walletlock()
 
 RPCHelpMan encryptwallet()
 {
-    return RPCHelpMan{"encryptwallet",
+    return RPCHelpMan{
-                "\nEncrypts the wallet with 'passphrase'. This is for first time encryption.\n"
+        "encryptwallet",
-                "After this, any calls that interact with private keys such as sending or signing \n"
+        "Encrypts the wallet with 'passphrase'. This is for first time encryption.\n"
-                "will require the passphrase to be set prior the making these calls.\n"
+        "After this, any calls that interact with private keys such as sending or signing \n"
+        "will require the passphrase to be set prior to making these calls.\n"
                 "Use the walletpassphrase call for this, and then walletlock call.\n"
                 "If the wallet is already encrypted, use the walletpassphrasechange call.\n"
                 "** IMPORTANT **\n"

src/wallet/rpc/signmessage.cpp

@@ -13,8 +13,9 @@
 namespace wallet {
 RPCHelpMan signmessage()
 {
-    return RPCHelpMan{"signmessage",
+    return RPCHelpMan{
-        "\nSign a message with the private key of an address" +
+        "signmessage",
+        "Sign a message with the private key of an address" +
           HELP_REQUIRING_PASSPHRASE,
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address to use for the private key."},

src/wallet/rpc/spend.cpp

@@ -226,8 +226,9 @@ static void SetFeeEstimateMode(const CWallet& wallet, CCoinControl& cc, const Un
 
 RPCHelpMan sendtoaddress()
 {
-    return RPCHelpMan{"sendtoaddress",
+    return RPCHelpMan{
-                "\nSend an amount to a given address." +
+        "sendtoaddress",
+        "Send an amount to a given address." +
         HELP_REQUIRING_PASSPHRASE,
                 {
                     {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address to send to."},
@@ -417,8 +418,9 @@ RPCHelpMan sendmany()
 
 RPCHelpMan settxfee()
 {
-    return RPCHelpMan{"settxfee",
+    return RPCHelpMan{
-                "\n(DEPRECATED) Set the transaction fee rate in " + CURRENCY_UNIT + "/kvB for this wallet. Overrides the global -paytxfee command line parameter.\n"
+        "settxfee",
+        "(DEPRECATED) Set the transaction fee rate in " + CURRENCY_UNIT + "/kvB for this wallet. Overrides the global -paytxfee command line parameter.\n"
                 "Can be deactivated by passing 0 as the fee. In that case automatic fee selection will be used by default.\n",
                 {
                     {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "The transaction fee rate in " + CURRENCY_UNIT + "/kvB"},
@@ -742,8 +744,9 @@ static void SetOptionsInputWeights(const UniValue& inputs, UniValue& options)
 
 RPCHelpMan fundrawtransaction()
 {
-    return RPCHelpMan{"fundrawtransaction",
+    return RPCHelpMan{
-                "\nIf the transaction has no inputs, they will be automatically selected to meet its out value.\n"
+        "fundrawtransaction",
+        "If the transaction has no inputs, they will be automatically selected to meet its out value.\n"
                 "It will add at most one change output to the outputs.\n"
                 "No existing outputs will be modified unless \"subtractFeeFromOutputs\" is specified.\n"
                 "Note that inputs which were signed may need to be resigned after completion since in/outputs have been added.\n"
@@ -876,8 +879,9 @@ RPCHelpMan fundrawtransaction()
 
 RPCHelpMan signrawtransactionwithwallet()
 {
-    return RPCHelpMan{"signrawtransactionwithwallet",
+    return RPCHelpMan{
-                "\nSign inputs for raw transaction (serialized, hex-encoded).\n"
+        "signrawtransactionwithwallet",
+        "Sign 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." +
         HELP_REQUIRING_PASSPHRASE,
@@ -1201,8 +1205,9 @@ RPCHelpMan psbtbumpfee() { return bumpfee_helper("psbtbumpfee"); }
 
 RPCHelpMan send()
 {
-    return RPCHelpMan{"send",
+    return RPCHelpMan{
-        "\nEXPERIMENTAL warning: this call may be changed in future releases.\n"
+        "send",
+        "EXPERIMENTAL warning: this call may be changed in future releases.\n"
         "\nSend a transaction.\n",
         {
             {"outputs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The outputs specified as key-value pairs.\n"
@@ -1582,8 +1587,9 @@ RPCHelpMan sendall()
 
 RPCHelpMan walletprocesspsbt()
 {
-    return RPCHelpMan{"walletprocesspsbt",
+    return RPCHelpMan{
-                "\nUpdate a PSBT with input information from our wallet and then sign inputs\n"
+        "walletprocesspsbt",
+        "Update a PSBT with input information from our wallet and then sign inputs\n"
                 "that we can sign for." +
         HELP_REQUIRING_PASSPHRASE,
                 {
@@ -1665,8 +1671,9 @@ RPCHelpMan walletprocesspsbt()
 
 RPCHelpMan walletcreatefundedpsbt()
 {
-    return RPCHelpMan{"walletcreatefundedpsbt",
+    return RPCHelpMan{
-                "\nCreates and funds a transaction in the Partially Signed Transaction format.\n"
+        "walletcreatefundedpsbt",
+        "Creates and funds a transaction in the Partially Signed Transaction format.\n"
                 "Implements the Creator and Updater roles.\n"
                 "All existing inputs must either have their previous output transaction be in the wallet\n"
                 "or be in the UTXO set. Solving data must be provided for non-wallet inputs.\n",

src/wallet/rpc/transactions.cpp

@@ -204,8 +204,9 @@ static UniValue ListReceived(const CWallet& wallet, const UniValue& params, cons
 
 RPCHelpMan listreceivedbyaddress()
 {
-    return RPCHelpMan{"listreceivedbyaddress",
+    return RPCHelpMan{
-                "\nList balances by receiving address.\n",
+        "listreceivedbyaddress",
+        "List balances by receiving address.\n",
                 {
                     {"minconf", RPCArg::Type::NUM, RPCArg::Default{1}, "The minimum number of confirmations before payments are included."},
                     {"include_empty", RPCArg::Type::BOOL, RPCArg::Default{false}, "Whether to include addresses that haven't received any payments."},
@@ -257,8 +258,9 @@ RPCHelpMan listreceivedbyaddress()
 
 RPCHelpMan listreceivedbylabel()
 {
-    return RPCHelpMan{"listreceivedbylabel",
+    return RPCHelpMan{
-                "\nList received transactions by label.\n",
+        "listreceivedbylabel",
+        "List received transactions by label.\n",
                 {
                     {"minconf", RPCArg::Type::NUM, RPCArg::Default{1}, "The minimum number of confirmations before payments are included."},
                     {"include_empty", RPCArg::Type::BOOL, RPCArg::Default{false}, "Whether to include labels that haven't received any payments."},
@@ -439,8 +441,9 @@ static std::vector<RPCResult> TransactionDescriptionString()
 
 RPCHelpMan listtransactions()
 {
-    return RPCHelpMan{"listtransactions",
+    return RPCHelpMan{
-                "\nIf a label name is provided, this will return only incoming transactions paying to addresses with the specified label.\n"
+        "listtransactions",
+        "If 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, "If set, should be a valid label name to return only incoming transactions\n"
@@ -548,8 +551,9 @@ RPCHelpMan listtransactions()
 
 RPCHelpMan listsinceblock()
 {
-    return RPCHelpMan{"listsinceblock",
+    return RPCHelpMan{
-                "\nGet all transactions in blocks since block [blockhash], or all transactions if omitted.\n"
+        "listsinceblock",
+        "Get all transactions in blocks since block [blockhash], or all transactions if omitted.\n"
                 "If \"blockhash\" is no longer a part of the main chain, transactions from the fork point onward are included.\n"
                 "Additionally, if include_removed is set, transactions affecting the wallet which were removed are returned in the \"removed\" array.\n",
                 {
@@ -692,8 +696,9 @@ RPCHelpMan listsinceblock()
 
 RPCHelpMan gettransaction()
 {
-    return RPCHelpMan{"gettransaction",
+    return RPCHelpMan{
-                "\nGet detailed information about in-wallet transaction <txid>\n",
+        "gettransaction",
+        "Get detailed information about in-wallet transaction <txid>\n",
                 {
                     {"txid", RPCArg::Type::STR, RPCArg::Optional::NO, "The transaction id"},
                     {"include_watchonly", RPCArg::Type::BOOL, RPCArg::DefaultHint{"true for watch-only wallets, otherwise false"},
@@ -806,8 +811,9 @@ RPCHelpMan gettransaction()
 
 RPCHelpMan abandontransaction()
 {
-    return RPCHelpMan{"abandontransaction",
+    return RPCHelpMan{
-                "\nMark in-wallet transaction <txid> as abandoned\n"
+        "abandontransaction",
+        "Mark in-wallet transaction <txid> as abandoned\n"
                 "This will mark this transaction and all its in-wallet descendants as abandoned which will allow\n"
                 "for their inputs to be respent.  It can be used to replace \"stuck\" or evicted transactions.\n"
                 "It only works on transactions which are not included in a block and are not currently in the mempool.\n"
@@ -847,8 +853,9 @@ RPCHelpMan abandontransaction()
 
 RPCHelpMan rescanblockchain()
 {
-    return RPCHelpMan{"rescanblockchain",
+    return RPCHelpMan{
-                "\nRescan the local blockchain for wallet related transactions.\n"
+        "rescanblockchain",
+        "Rescan the local blockchain for wallet related transactions.\n"
                 "Note: Use \"getwalletinfo\" to query the scanning progress.\n"
                 "The rescan is significantly faster when used on a descriptor wallet\n"
                 "and block filters are available (using startup option \"-blockfilterindex=1\").\n",

src/wallet/rpc/wallet.cpp

@@ -197,8 +197,9 @@ static RPCHelpMan listwallets()
 
 static RPCHelpMan loadwallet()
 {
-    return RPCHelpMan{"loadwallet",
+    return RPCHelpMan{
-                "\nLoads a wallet from a wallet file or directory."
+        "loadwallet",
+        "Loads a wallet from a wallet file or directory."
                 "\nNote that all wallet command-line options used when starting bitcoind will be"
                 "\napplied to the new wallet.\n",
                 {
@@ -266,8 +267,9 @@ static RPCHelpMan setwalletflag()
                 if (it.second & MUTABLE_WALLET_FLAGS)
                     flags += (flags == "" ? "" : ", ") + it.first;
 
-    return RPCHelpMan{"setwalletflag",
+    return RPCHelpMan{
-                "\nChange the state of the given wallet flag for a wallet.\n",
+        "setwalletflag",
+        "Change the state of the given wallet flag for a wallet.\n",
                 {
                     {"flag", RPCArg::Type::STR, RPCArg::Optional::NO, "The name of the flag to change. Current available flags: " + flags},
                     {"value", RPCArg::Type::BOOL, RPCArg::Default{true}, "The new state."},
@@ -330,7 +332,7 @@ static RPCHelpMan createwallet()
 {
     return RPCHelpMan{
         "createwallet",
-        "\nCreates and loads a new wallet.\n",
+        "Creates and loads a new wallet.\n",
         {
             {"wallet_name", RPCArg::Type::STR, RPCArg::Optional::NO, "The name for the new wallet. If this is a path, the wallet will be created at the path location."},
             {"disable_private_keys", RPCArg::Type::BOOL, RPCArg::Default{false}, "Disable the possibility of private keys (only watchonlys are possible in this mode)."},
@@ -481,8 +483,9 @@ static RPCHelpMan unloadwallet()
 
 static RPCHelpMan upgradewallet()
 {
-    return RPCHelpMan{"upgradewallet",
+    return RPCHelpMan{
-        "\nUpgrade the wallet. Upgrades to the latest version if no version number is specified.\n"
+        "upgradewallet",
+        "Upgrade the wallet. Upgrades to the latest version if no version number is specified.\n"
         "New keys may be generated and a new wallet backup will need to be made.",
         {
             {"version", RPCArg::Type::NUM, RPCArg::Default{int{FEATURE_LATEST}}, "The version number to upgrade to. Default is the latest wallet version."}
@@ -543,8 +546,9 @@ static RPCHelpMan upgradewallet()
 
 RPCHelpMan simulaterawtransaction()
 {
-    return RPCHelpMan{"simulaterawtransaction",
+    return RPCHelpMan{
-        "\nCalculate the balance change resulting in the signing and broadcasting of the given transaction(s).\n",
+        "simulaterawtransaction",
+        "Calculate the balance change resulting in the signing and broadcasting of the given transaction(s).\n",
         {
             {"rawtxs", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "An array of hex strings of raw transactions.\n",
                 {
@@ -652,8 +656,9 @@ RPCHelpMan simulaterawtransaction()
 
 static RPCHelpMan migratewallet()
 {
-    return RPCHelpMan{"migratewallet",
+    return RPCHelpMan{
-        "\nMigrate the wallet to a descriptor wallet.\n"
+        "migratewallet",
+        "Migrate the wallet to a descriptor wallet.\n"
         "A new wallet backup will need to be made.\n"
         "\nThe migration process will create a backup of the wallet before migrating. This backup\n"
         "file will be named <wallet name>-<timestamp>.legacy.bak and can be found in the directory\n"
@@ -722,7 +727,7 @@ RPCHelpMan gethdkeys()
 {
     return RPCHelpMan{
         "gethdkeys",
-        "\nList all BIP 32 HD keys in the wallet and which descriptors use them.\n",
+        "List all BIP 32 HD keys in the wallet and which descriptors use them.\n",
         {
             {"options", RPCArg::Type::OBJ_NAMED_PARAMS, RPCArg::Optional::OMITTED, "", {
                 {"active_only", RPCArg::Type::BOOL, RPCArg::Default{false}, "Show the keys for only active descriptors"},

src/zmq/zmqrpc.cpp

@@ -20,8 +20,9 @@ namespace {
 
 static RPCHelpMan getzmqnotifications()
 {
-    return RPCHelpMan{"getzmqnotifications",
+    return RPCHelpMan{
-                "\nReturns information about the active ZeroMQ notifications.\n",
+        "getzmqnotifications",
+        "Returns information about the active ZeroMQ notifications.\n",
                 {},
                 RPCResult{
                     RPCResult::Type::ARR, "", "",