diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 7a1a24ec7..3526c3d3b 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -1,914 +1,920 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <amount.h>
 #include <chainparams.h>
 #include <config.h>
 #include <httpserver.h>
 #include <index/blockfilterindex.h>
+#include <index/coinstatsindex.h>
 #include <index/txindex.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
 #include <logging.h>
 #include <node/context.h>
 #include <outputtype.h>
 #include <rpc/blockchain.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <scheduler.h>
 #include <script/descriptor.h>
 #include <util/check.h>
 #include <util/message.h> // For MessageSign(), MessageVerify()
 #include <util/strencodings.h>
 #include <util/system.h>
 
 #include <univalue.h>
 
 #include <cstdint>
 #include <tuple>
 #ifdef HAVE_MALLOC_INFO
 #include <malloc.h>
 #endif
 
 static RPCHelpMan validateaddress() {
     return RPCHelpMan{
         "validateaddress",
         "Return information about the given bitcoin address.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address to validate"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::BOOL, "isvalid",
                  "If the address is valid or not. If not, this is the only "
                  "property returned."},
                 {RPCResult::Type::STR, "address",
                  "The bitcoin address validated"},
                 {RPCResult::Type::STR_HEX, "scriptPubKey",
                  "The hex-encoded scriptPubKey generated by the address"},
                 {RPCResult::Type::BOOL, "isscript", "If the key is a script"},
             }},
         RPCExamples{HelpExampleCli("validateaddress", EXAMPLE_ADDRESS) +
                     HelpExampleRpc("validateaddress", EXAMPLE_ADDRESS)},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             CTxDestination dest = DecodeDestination(request.params[0].get_str(),
                                                     config.GetChainParams());
             bool isValid = IsValidDestination(dest);
 
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("isvalid", isValid);
 
             if (isValid) {
                 if (ret["address"].isNull()) {
                     std::string currentAddress =
                         EncodeDestination(dest, config);
                     ret.pushKV("address", currentAddress);
 
                     CScript scriptPubKey = GetScriptForDestination(dest);
                     ret.pushKV("scriptPubKey", HexStr(scriptPubKey));
 
                     UniValue detail = DescribeAddress(dest);
                     ret.pushKVs(detail);
                 }
             }
             return ret;
         },
     };
 }
 
 static RPCHelpMan createmultisig() {
     return RPCHelpMan{
         "createmultisig",
         "Creates a multi-signature address with n signature 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."},
             {"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"},
              }},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR, "address",
                  "The value of the new multisig address."},
                 {RPCResult::Type::STR_HEX, "redeemScript",
                  "The string value of the hex-encoded redemption script."},
                 {RPCResult::Type::STR, "descriptor",
                  "The descriptor for this multisig"},
             }},
         RPCExamples{
             "\nCreate a multisig address from 2 public keys\n" +
             HelpExampleCli("createmultisig",
                            "2 "
                            "\"["
                            "\\\"03789ed0bb717d88f7d321a368d905e7430207ebbd82bd3"
                            "42cf11ae157a7ace5fd\\\","
                            "\\\"03dbc6764b8884a92e871274b87583e6d5c2a58819473e1"
                            "7e107ef3f6aa5a61626\\\"]\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("createmultisig",
                            "2, "
                            "\"["
                            "\\\"03789ed0bb717d88f7d321a368d905e7430207ebbd82bd3"
                            "42cf11ae157a7ace5fd\\\","
                            "\\\"03dbc6764b8884a92e871274b87583e6d5c2a58819473e1"
                            "7e107ef3f6aa5a61626\\\"]\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             int required = request.params[0].get_int();
 
             // Get the public keys
             const UniValue &keys = request.params[1].get_array();
             std::vector<CPubKey> pubkeys;
             for (size_t i = 0; i < keys.size(); ++i) {
                 if ((keys[i].get_str().length() ==
                          2 * CPubKey::COMPRESSED_SIZE ||
                      keys[i].get_str().length() == 2 * CPubKey::SIZE) &&
                     IsHex(keys[i].get_str())) {
                     pubkeys.push_back(HexToPubKey(keys[i].get_str()));
                 } else {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        strprintf("Invalid public key: %s\n",
                                                  keys[i].get_str()));
                 }
             }
 
             // Get the output type
             OutputType output_type = OutputType::LEGACY;
 
             // Construct using pay-to-script-hash:
             FillableSigningProvider keystore;
             CScript inner;
             const CTxDestination dest = AddAndGetMultisigDestination(
                 required, pubkeys, output_type, keystore, inner);
 
             // Make the descriptor
             std::unique_ptr<Descriptor> descriptor =
                 InferDescriptor(GetScriptForDestination(dest), keystore);
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("address", EncodeDestination(dest, config));
             result.pushKV("redeemScript", HexStr(inner));
             result.pushKV("descriptor", descriptor->ToString());
 
             return result;
         },
     };
 }
 
 static RPCHelpMan getdescriptorinfo() {
     return RPCHelpMan{
         "getdescriptorinfo",
         {"Analyses a descriptor.\n"},
         {
             {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The descriptor."},
         },
         RPCResult{
             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{"Analyse a descriptor\n" +
                     HelpExampleCli("getdescriptorinfo",
                                    "\"pkh([d34db33f/84h/0h/"
                                    "0h]"
                                    "0279be667ef9dcbbac55a06295Ce870b07029Bfcdb2"
                                    "dce28d959f2815b16f81798)\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             RPCTypeCheck(request.params, {UniValue::VSTR});
 
             FlatSigningProvider provider;
             std::string error;
             auto desc = Parse(request.params[0].get_str(), provider, error);
             if (!desc) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
             }
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("descriptor", desc->ToString());
             result.pushKV("checksum",
                           GetDescriptorChecksum(request.params[0].get_str()));
             result.pushKV("isrange", desc->IsRange());
             result.pushKV("issolvable", desc->IsSolvable());
             result.pushKV("hasprivatekeys", provider.keys.size() > 0);
             return result;
         },
     };
 }
 
 static RPCHelpMan deriveaddresses() {
     return RPCHelpMan{
         "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"
          "    sh(multi(<n>,<pubkey>,<pubkey>,...)) P2SH-multisig outputs for "
          "the given threshold and pubkeys\n"
          "    raw(<hex script>)                    Outputs whose scriptPubKey "
          "equals the specified hex scripts\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"},
         {
             {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The descriptor."},
             {"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{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::STR, "address", "the derived addresses"},
             }},
         RPCExamples{"First three pkh receive addresses\n" +
                     HelpExampleCli(
                         "deriveaddresses",
                         "\"pkh([d34db33f/84h/0h/0h]"
                         "xpub6DJ2dNUysrn5Vt36jH2KLBT2i1auw1tTSSomg8P"
                         "hqNiUtx8QX2SvC9nrHu81fT41fvDUnhMjEzQgXnQjKE"
                         "u3oaqMSzhSrHMxyyoEAmUHQbY/0/*)#3vhfv5h5\" \"[0,2]\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             // Range argument is checked later
             RPCTypeCheck(request.params, {UniValue::VSTR, UniValueType()});
             const std::string desc_str = request.params[0].get_str();
 
             int64_t range_begin = 0;
             int64_t range_end = 0;
 
             if (request.params.size() >= 2 && !request.params[1].isNull()) {
                 std::tie(range_begin, range_end) =
                     ParseDescriptorRange(request.params[1]);
             }
 
             FlatSigningProvider key_provider;
             std::string error;
             auto desc = Parse(desc_str, key_provider, error,
                               /* require_checksum = */ true);
             if (!desc) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
             }
 
             if (!desc->IsRange() && request.params.size() > 1) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Range should not be specified for an "
                                    "un-ranged descriptor");
             }
 
             if (desc->IsRange() && request.params.size() == 1) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     "Range must be specified for a ranged descriptor");
             }
 
             UniValue addresses(UniValue::VARR);
 
             for (int i = range_begin; i <= range_end; ++i) {
                 FlatSigningProvider provider;
                 std::vector<CScript> scripts;
                 if (!desc->Expand(i, key_provider, scripts, provider)) {
                     throw JSONRPCError(
                         RPC_INVALID_ADDRESS_OR_KEY,
                         strprintf("Cannot derive script without private keys"));
                 }
 
                 for (const CScript &script : scripts) {
                     CTxDestination dest;
                     if (!ExtractDestination(script, dest)) {
                         throw JSONRPCError(
                             RPC_INVALID_ADDRESS_OR_KEY,
                             strprintf("Descriptor does not have a "
                                       "corresponding address"));
                     }
 
                     addresses.push_back(EncodeDestination(dest, config));
                 }
             }
 
             // This should not be possible, but an assert seems overkill:
             if (addresses.empty()) {
                 throw JSONRPCError(RPC_MISC_ERROR, "Unexpected empty result");
             }
 
             return addresses;
         },
     };
 }
 
 static RPCHelpMan verifymessage() {
     return RPCHelpMan{
         "verifymessage",
         "Verify a signed message\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address to use for the signature."},
             {"signature", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The signature provided by the signer in base 64 encoding (see "
              "signmessage)."},
             {"message", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The message that was signed."},
         },
         RPCResult{RPCResult::Type::BOOL, "",
                   "If the signature is verified or not."},
         RPCExamples{
             "\nUnlock the wallet for 30 seconds\n" +
             HelpExampleCli("walletpassphrase", "\"mypassphrase\" 30") +
             "\nCreate the signature\n" +
             HelpExampleCli(
                 "signmessage",
                 "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"my message\"") +
             "\nVerify the signature\n" +
             HelpExampleCli("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4"
                                             "XX\" \"signature\" \"my "
                                             "message\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4"
                                             "XX\", \"signature\", \"my "
                                             "message\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             LOCK(cs_main);
 
             std::string strAddress = request.params[0].get_str();
             std::string strSign = request.params[1].get_str();
             std::string strMessage = request.params[2].get_str();
 
             switch (MessageVerify(config.GetChainParams(), strAddress, strSign,
                                   strMessage)) {
                 case MessageVerificationResult::ERR_INVALID_ADDRESS:
                     throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");
                 case MessageVerificationResult::ERR_ADDRESS_NO_KEY:
                     throw JSONRPCError(RPC_TYPE_ERROR,
                                        "Address does not refer to key");
                 case MessageVerificationResult::ERR_MALFORMED_SIGNATURE:
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Malformed base64 encoding");
                 case MessageVerificationResult::ERR_PUBKEY_NOT_RECOVERED:
                 case MessageVerificationResult::ERR_NOT_SIGNED:
                     return false;
                 case MessageVerificationResult::OK:
                     return true;
             }
 
             return false;
         },
     };
 }
 
 static RPCHelpMan signmessagewithprivkey() {
     return RPCHelpMan{
         "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."},
         },
         RPCResult{RPCResult::Type::STR, "signature",
                   "The signature of the message encoded in base 64"},
         RPCExamples{"\nCreate the signature\n" +
                     HelpExampleCli("signmessagewithprivkey",
                                    "\"privkey\" \"my message\"") +
                     "\nVerify the signature\n" +
                     HelpExampleCli("verifymessage",
                                    "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" "
                                    "\"signature\" \"my message\"") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc("signmessagewithprivkey",
                                    "\"privkey\", \"my message\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::string strPrivkey = request.params[0].get_str();
             std::string strMessage = request.params[1].get_str();
 
             CKey key = DecodeSecret(strPrivkey);
             if (!key.IsValid()) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Invalid private key");
             }
 
             std::string signature;
 
             if (!MessageSign(key, strMessage, signature)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Sign failed");
             }
 
             return signature;
         },
     };
 }
 
 static RPCHelpMan setmocktime() {
     return RPCHelpMan{
         "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."},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{""},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             if (!config.GetChainParams().IsMockableChain()) {
                 throw std::runtime_error(
                     "setmocktime for regression testing (-regtest mode) only");
             }
 
             // For now, don't change mocktime if we're in the middle of
             // validation, as this could have an effect on mempool time-based
             // eviction, as well as IsInitialBlockDownload().
             // TODO: figure out the right way to synchronize around mocktime,
             // and ensure all call sites of GetTime() are accessing this safely.
             LOCK(cs_main);
 
             RPCTypeCheck(request.params, {UniValue::VNUM});
             int64_t time = request.params[0].get_int64();
             if (time < 0) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Timestamp must be 0 or greater");
             }
             SetMockTime(time);
             auto node_context = util::AnyPtr<NodeContext>(request.context);
             if (node_context) {
                 for (const auto &chain_client : node_context->chain_clients) {
                     chain_client->setMockTime(time);
                 }
             }
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan mockscheduler() {
     return RPCHelpMan{
         "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."},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{""},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             if (!Params().IsMockableChain()) {
                 throw std::runtime_error("mockscheduler is for regression "
                                          "testing (-regtest mode) only");
             }
 
             // check params are valid values
             RPCTypeCheck(request.params, {UniValue::VNUM});
             int64_t delta_seconds = request.params[0].get_int64();
             if ((delta_seconds <= 0) || (delta_seconds > 3600)) {
                 throw std::runtime_error(
                     "delta_time must be between 1 and 3600 seconds (1 hr)");
             }
 
             auto node_context = util::AnyPtr<NodeContext>(request.context);
             // protect against null pointer dereference
             CHECK_NONFATAL(node_context);
             CHECK_NONFATAL(node_context->scheduler);
             node_context->scheduler->MockForward(
                 std::chrono::seconds(delta_seconds));
 
             return NullUniValue;
         },
     };
 }
 
 static UniValue RPCLockedMemoryInfo() {
     LockedPool::Stats stats = LockedPoolManager::Instance().stats();
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("used", uint64_t(stats.used));
     obj.pushKV("free", uint64_t(stats.free));
     obj.pushKV("total", uint64_t(stats.total));
     obj.pushKV("locked", uint64_t(stats.locked));
     obj.pushKV("chunks_used", uint64_t(stats.chunks_used));
     obj.pushKV("chunks_free", uint64_t(stats.chunks_free));
     return obj;
 }
 
 #ifdef HAVE_MALLOC_INFO
 static std::string RPCMallocInfo() {
     char *ptr = nullptr;
     size_t size = 0;
     FILE *f = open_memstream(&ptr, &size);
     if (f) {
         malloc_info(0, f);
         fclose(f);
         if (ptr) {
             std::string rv(ptr, size);
             free(ptr);
             return rv;
         }
     }
     return "";
 }
 #endif
 
 static RPCHelpMan getmemoryinfo() {
     /* Please, avoid using the word "pool" here in the RPC interface or help,
      * as users will undoubtedly confuse it with the other "memory pool"
      */
     return RPCHelpMan{
         "getmemoryinfo",
         "Returns an object containing information about memory usage.\n",
         {
             {"mode", RPCArg::Type::STR, /* default */ "\"stats\"",
              "determines what kind of information is returned.\n"
              "  - \"stats\" returns general statistics about memory usage in "
              "the daemon.\n"
              "  - \"mallocinfo\" returns an XML string describing low-level "
              "heap state (only available if compiled with glibc 2.10+)."},
         },
         {
             RPCResult{
                 "mode \"stats\"",
                 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\"", RPCResult::Type::STR, "",
                       "\"<malloc version=\"1\">...\""},
         },
         RPCExamples{HelpExampleCli("getmemoryinfo", "") +
                     HelpExampleRpc("getmemoryinfo", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::string mode = request.params[0].isNull()
                                    ? "stats"
                                    : request.params[0].get_str();
             if (mode == "stats") {
                 UniValue obj(UniValue::VOBJ);
                 obj.pushKV("locked", RPCLockedMemoryInfo());
                 return obj;
             } else if (mode == "mallocinfo") {
 #ifdef HAVE_MALLOC_INFO
                 return RPCMallocInfo();
 #else
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "mallocinfo is only available when compiled "
                                    "with glibc 2.10+");
 #endif
             } else {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "unknown mode " + mode);
             }
         },
     };
 }
 
 static void EnableOrDisableLogCategories(UniValue cats, bool enable) {
     cats = cats.get_array();
     for (size_t i = 0; i < cats.size(); ++i) {
         std::string cat = cats[i].get_str();
 
         bool success;
         if (enable) {
             success = LogInstance().EnableCategory(cat);
         } else {
             success = LogInstance().DisableCategory(cat);
         }
 
         if (!success) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "unknown logging category " + cat);
         }
     }
 }
 
 static RPCHelpMan logging() {
     return RPCHelpMan{
         "logging",
         "Gets and sets the logging configuration.\n"
         "When called without an argument, returns the list of categories with "
         "status that are currently being debug logged or not.\n"
         "When called with arguments, adds or removes categories from debug "
         "logging and return the lists above.\n"
         "The arguments are evaluated in order \"include\", \"exclude\".\n"
         "If an item is both included and excluded, it will thus end up being "
         "excluded.\n"
         "The valid logging categories are: " +
             LogInstance().LogCategoriesString() +
             "\n"
             "In addition, the following are available as category names with "
             "special meanings:\n"
             "  - \"all\",  \"1\" : represent all logging categories.\n"
             "  - \"none\", \"0\" : even if other logging categories are "
             "specified, ignore all of them.\n",
         {
             {"include",
              RPCArg::Type::ARR,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "The categories to add to debug logging",
              {
                  {"include_category", RPCArg::Type::STR,
                   RPCArg::Optional::OMITTED, "the valid logging category"},
              }},
             {"exclude",
              RPCArg::Type::ARR,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "The categories to remove from debug logging",
              {
                  {"exclude_category", RPCArg::Type::STR,
                   RPCArg::Optional::OMITTED, "the valid logging category"},
              }},
         },
         RPCResult{
             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\\\"]\"") +
             HelpExampleRpc("logging", "[\"all\"], [\"libevent\"]")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             uint32_t original_log_categories = LogInstance().GetCategoryMask();
             if (request.params[0].isArray()) {
                 EnableOrDisableLogCategories(request.params[0], true);
             }
 
             if (request.params[1].isArray()) {
                 EnableOrDisableLogCategories(request.params[1], false);
             }
 
             uint32_t updated_log_categories = LogInstance().GetCategoryMask();
             uint32_t changed_log_categories =
                 original_log_categories ^ updated_log_categories;
 
             /**
              * Update libevent logging if BCLog::LIBEVENT has changed.
              * If the library version doesn't allow it,
              * UpdateHTTPServerLogging() returns false, in which case we should
              * clear the BCLog::LIBEVENT flag. Throw an error if the user has
              * explicitly asked to change only the libevent flag and it failed.
              */
             if (changed_log_categories & BCLog::LIBEVENT) {
                 if (!UpdateHTTPServerLogging(
                         LogInstance().WillLogCategory(BCLog::LIBEVENT))) {
                     LogInstance().DisableCategory(BCLog::LIBEVENT);
                     if (changed_log_categories == BCLog::LIBEVENT) {
                         throw JSONRPCError(
                             RPC_INVALID_PARAMETER,
                             "libevent logging cannot be updated when "
                             "using libevent before v2.1.1.");
                     }
                 }
             }
 
             UniValue result(UniValue::VOBJ);
             for (const auto &logCatActive : LogInstance().LogCategoriesList()) {
                 result.pushKV(logCatActive.category, logCatActive.active);
             }
 
             return result;
         },
     };
 }
 
 static RPCHelpMan echo(const std::string &name) {
     return RPCHelpMan{
         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.",
         {
             {"arg0", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              ""},
             {"arg1", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              ""},
             {"arg2", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              ""},
             {"arg3", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              ""},
             {"arg4", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              ""},
             {"arg5", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              ""},
             {"arg6", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              ""},
             {"arg7", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              ""},
             {"arg8", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              ""},
             {"arg9", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              ""},
         },
         RPCResult{RPCResult::Type::NONE, "", "Returns whatever was passed in"},
         RPCExamples{""},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             if (request.params[9].isStr()) {
                 CHECK_NONFATAL(request.params[9].get_str() !=
                                "trigger_internal_bug");
             }
 
             return request.params;
         },
     };
 }
 
 static RPCHelpMan echo() {
     return echo("echo");
 }
 static RPCHelpMan echojson() {
     return echo("echojson");
 }
 
 static RPCHelpMan getcurrencyinfo() {
     return RPCHelpMan{
         "getcurrencyinfo",
         "Returns an object containing information about the currency.\n",
         {},
         {
             RPCResult{
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::STR, "ticker", "Ticker symbol"},
                     {RPCResult::Type::NUM, "satoshisperunit",
                      "Number of satoshis per base unit"},
                     {RPCResult::Type::NUM, "decimals",
                      "Number of digits to the right of the decimal point."},
                 }},
         },
         RPCExamples{HelpExampleCli("getcurrencyinfo", "") +
                     HelpExampleRpc("getcurrencyinfo", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const Currency &currency = Currency::get();
 
             UniValue res(UniValue::VOBJ);
             res.pushKV("ticker", currency.ticker);
             res.pushKV("satoshisperunit", currency.baseunit / SATOSHI);
             res.pushKV("decimals", currency.decimals);
             return res;
         },
     };
 }
 
 static UniValue SummaryToJSON(const IndexSummary &&summary,
                               std::string index_name) {
     UniValue ret_summary(UniValue::VOBJ);
     if (!index_name.empty() && index_name != summary.name) {
         return ret_summary;
     }
 
     UniValue entry(UniValue::VOBJ);
     entry.pushKV("synced", summary.synced);
     entry.pushKV("best_block_height", summary.best_block_height);
     ret_summary.pushKV(summary.name, entry);
     return ret_summary;
 }
 
 static RPCHelpMan getindexinfo() {
     return RPCHelpMan{
         "getindexinfo",
         "Returns the status of one or all available indices currently "
         "running in the node.\n",
         {
             {"index_name", RPCArg::Type::STR,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "Filter results for an index with a specific name."},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "name",
                  "The name of the index",
                  {
                      {RPCResult::Type::BOOL, "synced",
                       "Whether the index is synced or not"},
                      {RPCResult::Type::NUM, "best_block_height",
                       "The block height to which the index is synced"},
                  }},
             },
         },
         RPCExamples{HelpExampleCli("getindexinfo", "") +
                     HelpExampleRpc("getindexinfo", "") +
                     HelpExampleCli("getindexinfo", "txindex") +
                     HelpExampleRpc("getindexinfo", "txindex")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             UniValue result(UniValue::VOBJ);
             const std::string index_name =
                 request.params[0].isNull() ? "" : request.params[0].get_str();
 
             if (g_txindex) {
                 result.pushKVs(
                     SummaryToJSON(g_txindex->GetSummary(), index_name));
             }
 
+            if (g_coin_stats_index) {
+                result.pushKVs(SummaryToJSON(g_coin_stats_index->GetSummary(),
+                                             index_name));
+            }
+
             ForEachBlockFilterIndex([&result, &index_name](
                                         const BlockFilterIndex &index) {
                 result.pushKVs(SummaryToJSON(index.GetSummary(), index_name));
             });
 
             return result;
         },
     };
 }
 
 void RegisterMiscRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            actor (function)
         //  ------------------  ----------------------
         { "control",            getmemoryinfo,           },
         { "control",            logging,                 },
         { "util",               validateaddress,         },
         { "util",               createmultisig,          },
         { "util",               deriveaddresses,         },
         { "util",               getdescriptorinfo,       },
         { "util",               verifymessage,           },
         { "util",               signmessagewithprivkey,  },
         { "util",               getcurrencyinfo,         },
         { "util",               getindexinfo,            },
 
         /* Not shown in help */
         { "hidden",             setmocktime,             },
         { "hidden",             mockscheduler,           },
         { "hidden",             echo,                    },
         { "hidden",             echojson,                },
     };
     // clang-format on
     for (const auto &c : commands) {
         t.appendCommand(c.name, &c);
     }
 }
diff --git a/test/functional/rpc_misc.py b/test/functional/rpc_misc.py
index 75c58fe57..90e52c3fd 100755
--- a/test/functional/rpc_misc.py
+++ b/test/functional/rpc_misc.py
@@ -1,97 +1,95 @@
 #!/usr/bin/env python3
 # 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.
 """Test RPC misc output."""
 import xml.etree.ElementTree as ET
 
 from test_framework.authproxy import JSONRPCException
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_greater_than_or_equal,
     assert_raises_rpc_error,
 )
 
 
 class RpcMiscTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.supports_cli = False
 
     def run_test(self):
         node = self.nodes[0]
 
         self.log.info("test CHECK_NONFATAL")
         assert_raises_rpc_error(
             -1,
             'Internal bug detected: \'request.params[9].get_str() != "trigger_internal_bug"\'',
             lambda: node.echo(arg9='trigger_internal_bug'),
         )
 
         self.log.info("test getmemoryinfo")
         memory = node.getmemoryinfo()['locked']
         assert_greater_than(memory['used'], 0)
         assert_greater_than(memory['free'], 0)
         assert_greater_than(memory['total'], 0)
         # assert_greater_than_or_equal() for locked in case locking pages
         # failed at some point
         assert_greater_than_or_equal(memory['locked'], 0)
         assert_greater_than(memory['chunks_used'], 0)
         assert_greater_than(memory['chunks_free'], 0)
         assert_equal(memory['used'] + memory['free'], memory['total'])
 
         self.log.info("test mallocinfo")
         try:
             mallocinfo = node.getmemoryinfo(mode="mallocinfo")
             self.log.info('getmemoryinfo(mode="mallocinfo") call succeeded')
             tree = ET.fromstring(mallocinfo)
             assert_equal(tree.tag, 'malloc')
         except JSONRPCException:
             self.log.info('getmemoryinfo(mode="mallocinfo") not available')
             assert_raises_rpc_error(-8, 'mallocinfo is only available when compiled with glibc 2.10+',
                                     node.getmemoryinfo, mode="mallocinfo")
 
         assert_raises_rpc_error(-8, "unknown mode foobar",
                                 node.getmemoryinfo, mode="foobar")
 
         self.log.info("test logging")
         assert_equal(node.logging()['qt'], True)
         node.logging(exclude=['qt'])
         assert_equal(node.logging()['qt'], False)
         node.logging(include=['qt'])
         assert_equal(node.logging()['qt'], True)
 
         self.log.info("test getindexinfo")
         # Without any indices running the RPC returns an empty object
         assert_equal(node.getindexinfo(), {})
 
         # Restart the node with indices and wait for them to sync
-        self.restart_node(0, ["-txindex", "-blockfilterindex"])
+        self.restart_node(
+            0, ["-txindex", "-blockfilterindex", "-coinstatsindex"])
         self.wait_until(
             lambda: all(i["synced"] for i in node.getindexinfo().values()))
 
         # Returns a list of all running indices by default
+        values = {"synced": True, "best_block_height": 200}
         assert_equal(
             node.getindexinfo(),
             {
-                "txindex": {"synced": True, "best_block_height": 200},
-                "basic block filter index": {"synced": True, "best_block_height": 200}
+                "txindex": values,
+                "basic block filter index": values,
+                "coinstatsindex": values,
             }
         )
-
         # Specifying an index by name returns only the status of that index
-        assert_equal(
-            node.getindexinfo("txindex"),
-            {
-                "txindex": {"synced": True, "best_block_height": 200},
-            }
-        )
+        for i in {"txindex", "basic block filter index", "coinstatsindex"}:
+            assert_equal(node.getindexinfo(i), {i: values})
 
         # Specifying an unknown index name returns an empty result
         assert_equal(node.getindexinfo("foo"), {})
 
 
 if __name__ == '__main__':
     RpcMiscTest().main()