diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 79887261b..fbed6bce8 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -1,736 +1,740 @@
 // 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 <chainparams.h>
 #include <config.h>
 #include <httpserver.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/strencodings.h>
 #include <util/system.h>
 #include <util/validation.h>
 
 #include <univalue.h>
 
 #include <cstdint>
 #include <tuple>
 #ifdef HAVE_MALLOC_INFO
 #include <malloc.h>
 #endif
 
 static UniValue validateaddress(const Config &config,
                                 const JSONRPCRequest &request) {
     RPCHelpMan{
         "validateaddress",
         "\nReturn information about the given bitcoin address.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address to validate"},
         },
         RPCResult{
             "{\n"
             "  \"isvalid\" : true|false,       (boolean) If the address is "
             "valid or not. If not, this is the only property returned.\n"
             "  \"address\" : \"address\",        (string) The bitcoin address "
             "validated\n"
             "  \"scriptPubKey\" : \"hex\",       (string) The hex-encoded "
             "scriptPubKey generated by the address\n"
             "  \"isscript\" : true|false,      (boolean) If the key is a "
             "script\n"
             "}\n"},
         RPCExamples{HelpExampleCli("validateaddress",
                                    "\"1PSSGeFHDnKNxiEyFrD1wcEaHr9hrQDDWc\"") +
                     HelpExampleRpc("validateaddress",
                                    "\"1PSSGeFHDnKNxiEyFrD1wcEaHr9hrQDDWc\"")},
     }
         .Check(request);
 
     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.begin(), scriptPubKey.end()));
 
             UniValue detail = DescribeAddress(dest);
             ret.pushKVs(detail);
         }
     }
     return ret;
 }
 
 static UniValue createmultisig(const Config &config,
                                const JSONRPCRequest &request) {
     RPCHelpMan{
         "createmultisig",
         "\nCreates 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,
              "A json array of hex-encoded public keys.",
              {
                  {"key", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED,
                   "The hex-encoded public key"},
              }},
         },
         RPCResult{"{\n"
                   "  \"address\":\"multisigaddress\",  (string) The value of "
                   "the new multisig address.\n"
                   "  \"redeemScript\":\"script\"       (string) The string "
                   "value of the hex-encoded redemption script.\n"
                   "}\n"},
         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\\\"]\"")},
     }
         .Check(request);
 
     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_PUBLIC_KEY_SIZE ||
              keys[i].get_str().length() == 2 * CPubKey::PUBLIC_KEY_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);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("address", EncodeDestination(dest, config));
     result.pushKV("redeemScript", HexStr(inner.begin(), inner.end()));
 
     return result;
 }
 
 UniValue getdescriptorinfo(const Config &config,
                            const JSONRPCRequest &request) {
     RPCHelpMan{
         "getdescriptorinfo",
         {"\nAnalyses a descriptor.\n"},
         {
             {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The descriptor."},
         },
         RPCResult{"{\n"
                   "  \"descriptor\" : \"desc\",         (string) The "
                   "descriptor in canonical form, without private keys\n"
+                  "  \"checksum\" : \"chksum\",         (string) The checksum "
+                  "for the input descriptor\n"
                   "  \"isrange\" : true|false,        (boolean) Whether the "
                   "descriptor is ranged\n"
                   "  \"issolvable\" : true|false,     (boolean) Whether the "
                   "descriptor is solvable\n"
                   "  \"hasprivatekeys\" : true|false, (boolean) Whether the "
                   "input descriptor contained at least one private key\n"
                   "}\n"},
         RPCExamples{"Analyse a descriptor\n" +
                     HelpExampleCli("getdescriptorinfo",
                                    "\"pkh([d34db33f/84h/0h/"
                                    "0h]"
                                    "0279be667ef9dcbbac55a06295Ce870b07029Bfcdb2"
                                    "dce28d959f2815b16f81798)\"")}}
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     FlatSigningProvider provider;
     auto desc = Parse(request.params[0].get_str(), provider);
     if (!desc) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            strprintf("Invalid descriptor"));
     }
 
     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;
 }
 
 UniValue deriveaddresses(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "deriveaddresses",
         {"\nDerives 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{"[ address ] (array) the derived addresses\n"},
         RPCExamples{"First three pkh receive addresses\n" +
                     HelpExampleCli(
                         "deriveaddresses",
                         "\"pkh([d34db33f/84h/0h/0h]"
                         "xpub6DJ2dNUysrn5Vt36jH2KLBT2i1auw1tTSSomg8P"
                         "hqNiUtx8QX2SvC9nrHu81fT41fvDUnhMjEzQgXnQjKE"
                         "u3oaqMSzhSrHMxyyoEAmUHQbY/0/*)#3vhfv5h5\" \"[0,2]\"")}}
         .Check(request);
 
     // 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 provider;
     auto desc = Parse(desc_str, provider, /* require_checksum = */ true);
     if (!desc) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            strprintf("Invalid descriptor"));
     }
 
     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) {
         std::vector<CScript> scripts;
         if (!desc->Expand(i, 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 UniValue verifymessage(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "verifymessage",
         "\nVerify 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{"true|false   (boolean) If the signature is verified or "
                   "not.\n"},
         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\"")},
     }
         .Check(request);
 
     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();
 
     CTxDestination destination =
         DecodeDestination(strAddress, config.GetChainParams());
     if (!IsValidDestination(destination)) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");
     }
 
     const PKHash *pkhash = boost::get<PKHash>(&destination);
     if (!pkhash) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");
     }
 
     bool fInvalid = false;
     std::vector<uint8_t> vchSig = DecodeBase64(strSign.c_str(), &fInvalid);
 
     if (fInvalid) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Malformed base64 encoding");
     }
 
     CHashWriter ss(SER_GETHASH, 0);
     ss << strMessageMagic;
     ss << strMessage;
 
     CPubKey pubkey;
     if (!pubkey.RecoverCompact(ss.GetHash(), vchSig)) {
         return false;
     }
 
     return (pubkey.GetID() == *pkhash);
 }
 
 static UniValue signmessagewithprivkey(const Config &config,
                                        const JSONRPCRequest &request) {
     RPCHelpMan{
         "signmessagewithprivkey",
         "\nSign 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{"\"signature\"          (string) The signature of the "
                   "message encoded in base 64\n"},
         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\"")},
     }
         .Check(request);
 
     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");
     }
 
     CHashWriter ss(SER_GETHASH, 0);
     ss << strMessageMagic;
     ss << strMessage;
 
     std::vector<uint8_t> vchSig;
     if (!key.SignCompact(ss.GetHash(), vchSig)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Sign failed");
     }
 
     return EncodeBase64(vchSig.data(), vchSig.size());
 }
 
 static UniValue setmocktime(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "setmocktime",
         "\nSet the local time to given timestamp (-regtest only)\n",
         {
             {"timestamp", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "Unix seconds-since-epoch timestamp\n"
              "   Pass 0 to go back to using the system time."},
         },
         RPCResults{},
         RPCExamples{""},
     }
         .Check(request);
 
     if (!config.GetChainParams().MineBlocksOnDemand()) {
         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 mockTime = request.params[0].get_int64();
     if (mockTime < 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Timestamp must be 0 or greater");
     }
     SetMockTime(mockTime);
 
     return NullUniValue;
 }
 
 static UniValue mockscheduler(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "mockscheduler",
         "\nBump 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."},
         },
         RPCResults{},
         RPCExamples{""},
     }
         .Check(request);
 
     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)");
     }
 
     // protect against null pointer dereference
     CHECK_NONFATAL(g_rpc_node);
     CHECK_NONFATAL(g_rpc_node->scheduler);
     g_rpc_node->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 UniValue getmemoryinfo(const Config &config,
                               const JSONRPCRequest &request) {
     /* Please, avoid using the word "pool" here in the RPC interface or help,
      * as users will undoubtedly confuse it with the other "memory pool"
      */
     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\"",
                 "{\n"
                 "  \"locked\": {               (json object) Information about "
                 "locked memory manager\n"
                 "    \"used\": xxxxx,          (numeric) Number of bytes used\n"
                 "    \"free\": xxxxx,          (numeric) Number of bytes "
                 "available in current arenas\n"
                 "    \"total\": xxxxxxx,       (numeric) Total number of bytes "
                 "managed\n"
                 "    \"locked\": xxxxxx,       (numeric) Amount of bytes that "
                 "succeeded locking. If this number is smaller than total, "
                 "locking pages failed at some point and key data could be "
                 "swapped to disk.\n"
                 "    \"chunks_used\": xxxxx,   (numeric) Number allocated "
                 "chunks\n"
                 "    \"chunks_free\": xxxxx,   (numeric) Number unused chunks\n"
                 "  }\n"
                 "}\n"},
             RPCResult{"mode \"mallocinfo\"", "\"<malloc version=\"1\">...\"\n"},
         },
         RPCExamples{HelpExampleCli("getmemoryinfo", "") +
                     HelpExampleRpc("getmemoryinfo", "")},
     }
         .Check(request);
 
     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 UniValue logging(const Config &config, const JSONRPCRequest &request) {
     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: " +
             ListLogCategories() +
             "\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,
              "A json array of categories to add debug logging",
              {
                  {"include_category", RPCArg::Type::STR,
                   RPCArg::Optional::OMITTED, "the valid logging category"},
              }},
             {"exclude",
              RPCArg::Type::ARR,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "A json array of categories to remove debug logging",
              {
                  {"exclude_category", RPCArg::Type::STR,
                   RPCArg::Optional::OMITTED, "the valid logging category"},
              }},
         },
         RPCResult{"{                   (json object where keys are the logging "
                   "categories, and values indicates its status\n"
                   "  \"category\": 0|1,  (numeric) if being debug logged "
                   "or not. 0:inactive, 1:active\n"
                   "  ...\n"
                   "}\n"},
         RPCExamples{
             HelpExampleCli("logging", "\"[\\\"all\\\"]\" \"[\\\"http\\\"]\"") +
             HelpExampleRpc("logging", "[\"all\"], \"[libevent]\"")},
     }
         .Check(request);
 
     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);
     std::vector<CLogCategoryActive> vLogCatActive = ListActiveLogCategories();
     for (const auto &logCatActive : vLogCatActive) {
         result.pushKV(logCatActive.category, logCatActive.active);
     }
 
     return result;
 }
 
 static UniValue echo(const Config &config, const JSONRPCRequest &request) {
     if (request.fHelp) {
         throw std::runtime_error(RPCHelpMan{
             "echo|echojson ...",
             "\nSimply echo back the input arguments. This command is for "
             "testing.\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.",
             {},
             RPCResults{},
             RPCExamples{""},
         }
                                      .ToString());
     }
 
     CHECK_NONFATAL(request.params.size() != 100);
 
     return request.params;
 }
 
 // clang-format off
 static const CRPCCommand commands[] = {
     //  category            name                      actor (function)        argNames
     //  ------------------- ------------------------  ----------------------  ----------
     { "control",            "getmemoryinfo",          getmemoryinfo,          {"mode"} },
     { "control",            "logging",                logging,                {"include", "exclude"} },
     { "util",               "validateaddress",        validateaddress,        {"address"} },
     { "util",               "createmultisig",         createmultisig,         {"nrequired","keys"} },
     { "util",               "deriveaddresses",        deriveaddresses,        {"descriptor", "begin", "end"} },
     { "util",               "getdescriptorinfo",      getdescriptorinfo,      {"descriptor"} },
     { "util",               "verifymessage",          verifymessage,          {"address","signature","message"} },
     { "util",               "signmessagewithprivkey", signmessagewithprivkey, {"privkey","message"} },
     /* Not shown in help */
     { "hidden",             "setmocktime",            setmocktime,            {"timestamp"}},
     { "hidden",             "mockscheduler",          mockscheduler,          {"delta_time"}},
     { "hidden",             "echo",                   echo,                   {"arg0","arg1","arg2","arg3","arg4","arg5","arg6","arg7","arg8","arg9"}},
     { "hidden",             "echojson",               echo,                   {"arg0","arg1","arg2","arg3","arg4","arg5","arg6","arg7","arg8","arg9"}},
 };
 // clang-format on
 
 void RegisterMiscRPCCommands(CRPCTable &t) {
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index 1a637e05f..eaa96bef2 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -1,1125 +1,1134 @@
 // Copyright (c) 2018 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 <script/descriptor.h>
 
 #include <chainparams.h> // For Params()
 #include <config.h>
 #include <key_io.h>
 #include <pubkey.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <span.h>
 #include <util/bip32.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace {
 
 ////////////////////////////////////////////////////////////////////////////
 // Checksum                                                               //
 ////////////////////////////////////////////////////////////////////////////
 
 // This section implements a checksum algorithm for descriptors with the
 // following properties:
 // * Mistakes in a descriptor string are measured in "symbol errors". The higher
 //   the number of symbol errors, the harder it is to detect:
 //   * An error substituting a character from 0123456789()[],'/*abcdefgh@:$%{}
 //   for
 //     another in that set always counts as 1 symbol error.
 //     * Note that hex encoded keys are covered by these characters. Xprvs and
 //       xpubs use other characters too, but already have their own checksum
 //       mechanism.
 //     * Function names like "multi()" use other characters, but mistakes in
 //       these would generally result in an unparseable descriptor.
 //   * A case error always counts as 1 symbol error.
 //   * Any other 1 character substitution error counts as 1 or 2 symbol errors.
 // * Any 1 symbol error is always detected.
 // * Any 2 or 3 symbol error in a descriptor of up to 49154 characters is always
 // detected.
 // * Any 4 symbol error in a descriptor of up to 507 characters is always
 // detected.
 // * Any 5 symbol error in a descriptor of up to 77 characters is always
 // detected.
 // * Is optimized to minimize the chance a 5 symbol error in a descriptor up to
 // 387 characters is undetected
 // * Random errors have a chance of 1 in 2**40 of being undetected.
 //
 // These properties are achieved by expanding every group of 3 (non checksum)
 // characters into 4 GF(32) symbols, over which a cyclic code is defined.
 
 /*
  * Interprets c as 8 groups of 5 bits which are the coefficients of a degree 8
  * polynomial over GF(32), multiplies that polynomial by x, computes its
  * remainder modulo a generator, and adds the constant term val.
  *
  * This generator is G(x) = x^8 + {30}x^7 + {23}x^6 + {15}x^5 + {14}x^4 +
  * {10}x^3 + {6}x^2 + {12}x + {9}. It is chosen to define an cyclic error
  * detecting code which is selected by:
  * - Starting from all BCH codes over GF(32) of degree 8 and below, which by
  * construction guarantee detecting 3 errors in windows up to 19000 symbols.
  * - Taking all those generators, and for degree 7 ones, extend them to degree 8
  * by adding all degree-1 factors.
  * - Selecting just the set of generators that guarantee detecting 4 errors in a
  * window of length 512.
  * - Selecting one of those with best worst-case behavior for 5 errors in
  * windows of length up to 512.
  *
  * The generator and the constants to implement it can be verified using this
  * Sage code: B = GF(2) # Binary field BP.<b> = B[] # Polynomials over the
  * binary field F_mod = b**5 + b**3 + 1 F.<f> = GF(32, modulus=F_mod,
  * repr='int') # GF(32) definition FP.<x> = F[] # Polynomials over GF(32) E_mod
  * = x**3 + x + F.fetch_int(8) E.<e> = F.extension(E_mod) # Extension field
  * definition alpha = e**2743 # Choice of an element in extension field for p in
  * divisors(E.order() - 1): # Verify alpha has order 32767. assert((alpha**p ==
  * 1) == (p % 32767 == 0)) G = lcm([(alpha**i).minpoly() for i in
  * [1056,1057,1058]] + [x + 1]) print(G) # Print out the generator for i in
  * [1,2,4,8,16]: # Print out {1,2,4,8,16}*(G mod x^8), packed in hex integers.
  *       v = 0
  *       for coef in reversed((F.fetch_int(i)*(G %
  * x**8)).coefficients(sparse=True)): v = v*32 + coef.integer_representation()
  *       print("0x%x" % v)
  */
 uint64_t PolyMod(uint64_t c, int val) {
     uint8_t c0 = c >> 35;
     c = ((c & 0x7ffffffff) << 5) ^ val;
     if (c0 & 1) {
         c ^= 0xf5dee51989;
     }
     if (c0 & 2) {
         c ^= 0xa9fdca3312;
     }
     if (c0 & 4) {
         c ^= 0x1bab10e32d;
     }
     if (c0 & 8) {
         c ^= 0x3706b1677a;
     }
     if (c0 & 16) {
         c ^= 0x644d626ffd;
     }
     return c;
 }
 
 std::string DescriptorChecksum(const Span<const char> &span) {
     /** A character set designed such that:
      *  - The most common 'unprotected' descriptor characters (hex, keypaths)
      * are in the first group of 32.
      *  - Case errors cause an offset that's a multiple of 32.
      *  - As many alphabetic characters are in the same group (while following
      * the above restrictions).
      *
      * If p(x) gives the position of a character c in this character set, every
      * group of 3 characters (a,b,c) is encoded as the 4 symbols (p(a) & 31,
      * p(b) & 31, p(c) & 31, (p(a) / 32) + 3 * (p(b) / 32) + 9 * (p(c) / 32).
      * This means that changes that only affect the lower 5 bits of the
      * position, or only the higher 2 bits, will just affect a single symbol.
      *
      * As a result, within-group-of-32 errors count as 1 symbol, as do
      * cross-group errors that don't affect the position within the groups.
      */
     static std::string INPUT_CHARSET = "0123456789()[],'/*abcdefgh@:$%{}"
                                        "IJKLMNOPQRSTUVWXYZ&+-.;<=>?!^_|~"
                                        "ijklmnopqrstuvwxyzABCDEFGH`#\"\\ ";
 
     /** The character set for the checksum itself (same as bech32). */
     static std::string CHECKSUM_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
 
     uint64_t c = 1;
     int cls = 0;
     int clscount = 0;
     for (auto ch : span) {
         auto pos = INPUT_CHARSET.find(ch);
         if (pos == std::string::npos) {
             return "";
         }
         // Emit a symbol for the position inside the group, for every character.
         c = PolyMod(c, pos & 31);
         // Accumulate the group numbers
         cls = cls * 3 + (pos >> 5);
         if (++clscount == 3) {
             // Emit an extra symbol representing the group numbers, for every 3
             // characters.
             c = PolyMod(c, cls);
             cls = 0;
             clscount = 0;
         }
     }
     if (clscount > 0) {
         c = PolyMod(c, cls);
     }
     for (int j = 0; j < 8; ++j) {
         // Shift further to determine the checksum.
         c = PolyMod(c, 0);
     }
     // Prevent appending zeroes from not affecting the checksum.
     c ^= 1;
 
     std::string ret(8, ' ');
     for (int j = 0; j < 8; ++j) {
         ret[j] = CHECKSUM_CHARSET[(c >> (5 * (7 - j))) & 31];
     }
     return ret;
 }
 
 std::string AddChecksum(const std::string &str) {
     return str + "#" + DescriptorChecksum(MakeSpan(str));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // Internal representation                                                //
 ////////////////////////////////////////////////////////////////////////////
 
 typedef std::vector<uint32_t> KeyPath;
 
 /** Interface for public key objects in descriptors. */
 struct PubkeyProvider {
     virtual ~PubkeyProvider() = default;
 
     /** Derive a public key. If key==nullptr, only info is desired. */
     virtual bool GetPubKey(int pos, const SigningProvider &arg, CPubKey *key,
                            KeyOriginInfo &info) const = 0;
 
     /** Whether this represent multiple public keys at different positions. */
     virtual bool IsRange() const = 0;
 
     /** Get the size of the generated public key(s) in bytes (33 or 65). */
     virtual size_t GetSize() const = 0;
 
     /** Get the descriptor string form. */
     virtual std::string ToString() const = 0;
 
     /**
      * Get the descriptor string form including private data (if available in
      * arg).
      */
     virtual bool ToPrivateString(const SigningProvider &arg,
                                  std::string &out) const = 0;
 };
 
 class OriginPubkeyProvider final : public PubkeyProvider {
     KeyOriginInfo m_origin;
     std::unique_ptr<PubkeyProvider> m_provider;
 
     std::string OriginString() const {
         return HexStr(std::begin(m_origin.fingerprint),
                       std::end(m_origin.fingerprint)) +
                FormatHDKeypath(m_origin.path);
     }
 
 public:
     OriginPubkeyProvider(KeyOriginInfo info,
                          std::unique_ptr<PubkeyProvider> provider)
         : m_origin(std::move(info)), m_provider(std::move(provider)) {}
     bool GetPubKey(int pos, const SigningProvider &arg, CPubKey *key,
                    KeyOriginInfo &info) const override {
         if (!m_provider->GetPubKey(pos, arg, key, info)) {
             return false;
         }
         std::copy(std::begin(m_origin.fingerprint),
                   std::end(m_origin.fingerprint), info.fingerprint);
         info.path.insert(info.path.begin(), m_origin.path.begin(),
                          m_origin.path.end());
         return true;
     }
     bool IsRange() const override { return m_provider->IsRange(); }
     size_t GetSize() const override { return m_provider->GetSize(); }
     std::string ToString() const override {
         return "[" + OriginString() + "]" + m_provider->ToString();
     }
     bool ToPrivateString(const SigningProvider &arg,
                          std::string &ret) const override {
         std::string sub;
         if (!m_provider->ToPrivateString(arg, sub)) {
             return false;
         }
         ret = "[" + OriginString() + "]" + std::move(sub);
         return true;
     }
 };
 
 /** An object representing a parsed constant public key in a descriptor. */
 class ConstPubkeyProvider final : public PubkeyProvider {
     CPubKey m_pubkey;
 
 public:
     ConstPubkeyProvider(const CPubKey &pubkey) : m_pubkey(pubkey) {}
     bool GetPubKey(int pos, const SigningProvider &arg, CPubKey *key,
                    KeyOriginInfo &info) const override {
         if (key) {
             *key = m_pubkey;
         }
         info.path.clear();
         CKeyID keyid = m_pubkey.GetID();
         std::copy(keyid.begin(), keyid.begin() + sizeof(info.fingerprint),
                   info.fingerprint);
         return true;
     }
     bool IsRange() const override { return false; }
     size_t GetSize() const override { return m_pubkey.size(); }
     std::string ToString() const override {
         return HexStr(m_pubkey.begin(), m_pubkey.end());
     }
     bool ToPrivateString(const SigningProvider &arg,
                          std::string &ret) const override {
         CKey key;
         if (!arg.GetKey(m_pubkey.GetID(), key)) {
             return false;
         }
         ret = EncodeSecret(key);
         return true;
     }
 };
 
 enum class DeriveType {
     NO,
     UNHARDENED,
     HARDENED,
 };
 
 /** An object representing a parsed extended public key in a descriptor. */
 class BIP32PubkeyProvider final : public PubkeyProvider {
     CExtPubKey m_extkey;
     KeyPath m_path;
     DeriveType m_derive;
 
     bool GetExtKey(const SigningProvider &arg, CExtKey &ret) const {
         CKey key;
         if (!arg.GetKey(m_extkey.pubkey.GetID(), key)) {
             return false;
         }
         ret.nDepth = m_extkey.nDepth;
         std::copy(m_extkey.vchFingerprint,
                   m_extkey.vchFingerprint + sizeof(ret.vchFingerprint),
                   ret.vchFingerprint);
         ret.nChild = m_extkey.nChild;
         ret.chaincode = m_extkey.chaincode;
         ret.key = key;
         return true;
     }
 
     bool IsHardened() const {
         if (m_derive == DeriveType::HARDENED) {
             return true;
         }
         for (auto entry : m_path) {
             if (entry >> 31) {
                 return true;
             }
         }
         return false;
     }
 
 public:
     BIP32PubkeyProvider(const CExtPubKey &extkey, KeyPath path,
                         DeriveType derive)
         : m_extkey(extkey), m_path(std::move(path)), m_derive(derive) {}
     bool IsRange() const override { return m_derive != DeriveType::NO; }
     size_t GetSize() const override { return 33; }
     bool GetPubKey(int pos, const SigningProvider &arg, CPubKey *key,
                    KeyOriginInfo &info) const override {
         if (key) {
             if (IsHardened()) {
                 CExtKey extkey;
                 if (!GetExtKey(arg, extkey)) {
                     return false;
                 }
                 for (auto entry : m_path) {
                     extkey.Derive(extkey, entry);
                 }
                 if (m_derive == DeriveType::UNHARDENED) {
                     extkey.Derive(extkey, pos);
                 }
                 if (m_derive == DeriveType::HARDENED) {
                     extkey.Derive(extkey, pos | 0x80000000UL);
                 }
                 *key = extkey.Neuter().pubkey;
             } else {
                 // TODO: optimize by caching
                 CExtPubKey extkey = m_extkey;
                 for (auto entry : m_path) {
                     extkey.Derive(extkey, entry);
                 }
                 if (m_derive == DeriveType::UNHARDENED) {
                     extkey.Derive(extkey, pos);
                 }
                 assert(m_derive != DeriveType::HARDENED);
                 *key = extkey.pubkey;
             }
         }
         CKeyID keyid = m_extkey.pubkey.GetID();
         std::copy(keyid.begin(), keyid.begin() + sizeof(info.fingerprint),
                   info.fingerprint);
         info.path = m_path;
         if (m_derive == DeriveType::UNHARDENED) {
             info.path.push_back(uint32_t(pos));
         }
         if (m_derive == DeriveType::HARDENED) {
             info.path.push_back(uint32_t(pos) | 0x80000000L);
         }
         return true;
     }
     std::string ToString() const override {
         std::string ret = EncodeExtPubKey(m_extkey) + FormatHDKeypath(m_path);
         if (IsRange()) {
             ret += "/*";
             if (m_derive == DeriveType::HARDENED) {
                 ret += '\'';
             }
         }
         return ret;
     }
     bool ToPrivateString(const SigningProvider &arg,
                          std::string &out) const override {
         CExtKey key;
         if (!GetExtKey(arg, key)) {
             return false;
         }
         out = EncodeExtKey(key) + FormatHDKeypath(m_path);
         if (IsRange()) {
             out += "/*";
             if (m_derive == DeriveType::HARDENED) {
                 out += '\'';
             }
         }
         return true;
     }
 };
 
 /** Base class for all Descriptor implementations. */
 class DescriptorImpl : public Descriptor {
     //! Public key arguments for this descriptor (size 1 for PK, PKH; any size
     //! of Multisig).
     const std::vector<std::unique_ptr<PubkeyProvider>> m_pubkey_args;
     //! The sub-descriptor argument (nullptr for everything but SH).
     const std::unique_ptr<DescriptorImpl> m_script_arg;
     //! The string name of the descriptor function.
     const std::string m_name;
 
 protected:
     //! Return a serialization of anything except pubkey and script arguments,
     //! to be prepended to those.
     virtual std::string ToStringExtra() const { return ""; }
 
     /**
      * A helper function to construct the scripts for this descriptor.
      *
      *  This function is invoked once for every CScript produced by evaluating
      *  m_script_arg, or just once in case m_script_arg is nullptr.
 
      *  @param pubkeys The evaluations of the m_pubkey_args field.
      *  @param script The evaluation of m_script_arg (or nullptr when
      m_script_arg is nullptr).
      *  @param out A FlatSigningProvider to put scripts or public keys in that
      are necessary to the solver.
      *             The script arguments to this function are automatically
      added, as is the origin info of the provided pubkeys.
      *  @return A vector with scriptPubKeys for this descriptor.
      */
     virtual std::vector<CScript>
     MakeScripts(const std::vector<CPubKey> &pubkeys, const CScript *script,
                 FlatSigningProvider &out) const = 0;
 
 public:
     DescriptorImpl(std::vector<std::unique_ptr<PubkeyProvider>> pubkeys,
                    std::unique_ptr<DescriptorImpl> script,
                    const std::string &name)
         : m_pubkey_args(std::move(pubkeys)), m_script_arg(std::move(script)),
           m_name(name) {}
 
     bool IsSolvable() const override {
         if (m_script_arg) {
             if (!m_script_arg->IsSolvable()) {
                 return false;
             }
         }
         return true;
     }
 
     bool IsRange() const final {
         for (const auto &pubkey : m_pubkey_args) {
             if (pubkey->IsRange()) {
                 return true;
             }
         }
         if (m_script_arg) {
             if (m_script_arg->IsRange()) {
                 return true;
             }
         }
         return false;
     }
 
     bool ToStringHelper(const SigningProvider *arg, std::string &out,
                         bool priv) const {
         std::string extra = ToStringExtra();
         size_t pos = extra.size() > 0 ? 1 : 0;
         std::string ret = m_name + "(" + extra;
         for (const auto &pubkey : m_pubkey_args) {
             if (pos++) {
                 ret += ",";
             }
             std::string tmp;
             if (priv) {
                 if (!pubkey->ToPrivateString(*arg, tmp)) {
                     return false;
                 }
             } else {
                 tmp = pubkey->ToString();
             }
             ret += std::move(tmp);
         }
         if (m_script_arg) {
             if (pos++) {
                 ret += ",";
             }
             std::string tmp;
             if (!m_script_arg->ToStringHelper(arg, tmp, priv)) {
                 return false;
             }
             ret += std::move(tmp);
         }
         out = std::move(ret) + ")";
         return true;
     }
 
     std::string ToString() const final {
         std::string ret;
         ToStringHelper(nullptr, ret, false);
         return AddChecksum(ret);
     }
 
     bool ToPrivateString(const SigningProvider &arg,
                          std::string &out) const override final {
         bool ret = ToStringHelper(&arg, out, true);
         out = AddChecksum(out);
         return ret;
     }
 
     bool ExpandHelper(int pos, const SigningProvider &arg,
                       Span<const uint8_t> *cache_read,
                       std::vector<CScript> &output_scripts,
                       FlatSigningProvider &out,
                       std::vector<uint8_t> *cache_write) const {
         std::vector<std::pair<CPubKey, KeyOriginInfo>> entries;
         entries.reserve(m_pubkey_args.size());
 
         // Construct temporary data in `entries` and `subscripts`, to avoid
         // producing output in case of failure.
         for (const auto &p : m_pubkey_args) {
             entries.emplace_back();
             if (!p->GetPubKey(pos, arg,
                               cache_read ? nullptr : &entries.back().first,
                               entries.back().second)) {
                 return false;
             }
             if (cache_read) {
                 // Cached expanded public key exists, use it.
                 if (cache_read->size() == 0) {
                     return false;
                 }
                 bool compressed =
                     ((*cache_read)[0] == 0x02 || (*cache_read)[0] == 0x03) &&
                     cache_read->size() >= 33;
                 bool uncompressed =
                     ((*cache_read)[0] == 0x04) && cache_read->size() >= 65;
                 if (!(compressed || uncompressed)) {
                     return false;
                 }
                 CPubKey pubkey(cache_read->begin(),
                                cache_read->begin() + (compressed ? 33 : 65));
                 entries.back().first = pubkey;
                 *cache_read = cache_read->subspan(compressed ? 33 : 65);
             }
             if (cache_write) {
                 cache_write->insert(cache_write->end(),
                                     entries.back().first.begin(),
                                     entries.back().first.end());
             }
         }
         std::vector<CScript> subscripts;
         if (m_script_arg) {
             FlatSigningProvider subprovider;
             if (!m_script_arg->ExpandHelper(pos, arg, cache_read, subscripts,
                                             subprovider, cache_write)) {
                 return false;
             }
             out = Merge(out, subprovider);
         }
 
         std::vector<CPubKey> pubkeys;
         pubkeys.reserve(entries.size());
         for (auto &entry : entries) {
             pubkeys.push_back(entry.first);
             out.origins.emplace(
                 entry.first.GetID(),
                 std::make_pair<CPubKey, KeyOriginInfo>(
                     CPubKey(entry.first), std::move(entry.second)));
         }
         if (m_script_arg) {
             for (const auto &subscript : subscripts) {
                 out.scripts.emplace(CScriptID(subscript), subscript);
                 std::vector<CScript> addscripts =
                     MakeScripts(pubkeys, &subscript, out);
                 for (auto &addscript : addscripts) {
                     output_scripts.push_back(std::move(addscript));
                 }
             }
         } else {
             output_scripts = MakeScripts(pubkeys, nullptr, out);
         }
         return true;
     }
 
     bool Expand(int pos, const SigningProvider &provider,
                 std::vector<CScript> &output_scripts, FlatSigningProvider &out,
                 std::vector<uint8_t> *cache = nullptr) const final {
         return ExpandHelper(pos, provider, nullptr, output_scripts, out, cache);
     }
 
     bool ExpandFromCache(int pos, const std::vector<uint8_t> &cache,
                          std::vector<CScript> &output_scripts,
                          FlatSigningProvider &out) const final {
         Span<const uint8_t> span = MakeSpan(cache);
         return ExpandHelper(pos, DUMMY_SIGNING_PROVIDER, &span, output_scripts,
                             out, nullptr) &&
                span.size() == 0;
     }
 };
 
 /** Construct a vector with one element, which is moved into it. */
 template <typename T> std::vector<T> Singleton(T elem) {
     std::vector<T> ret;
     ret.emplace_back(std::move(elem));
     return ret;
 }
 
 /** A parsed addr(A) descriptor. */
 class AddressDescriptor final : public DescriptorImpl {
     const CTxDestination m_destination;
 
 protected:
     std::string ToStringExtra() const override {
         return EncodeDestination(m_destination, GetConfig());
     }
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &,
                                      const CScript *,
                                      FlatSigningProvider &) const override {
         return Singleton(GetScriptForDestination(m_destination));
     }
 
 public:
     AddressDescriptor(CTxDestination destination)
         : DescriptorImpl({}, {}, "addr"),
           m_destination(std::move(destination)) {}
     bool IsSolvable() const final { return false; }
 };
 
 /** A parsed raw(H) descriptor. */
 class RawDescriptor final : public DescriptorImpl {
     const CScript m_script;
 
 protected:
     std::string ToStringExtra() const override {
         return HexStr(m_script.begin(), m_script.end());
     }
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &,
                                      const CScript *,
                                      FlatSigningProvider &) const override {
         return Singleton(m_script);
     }
 
 public:
     RawDescriptor(CScript script)
         : DescriptorImpl({}, {}, "raw"), m_script(std::move(script)) {}
     bool IsSolvable() const final { return false; }
 };
 
 /** A parsed pk(P) descriptor. */
 class PKDescriptor final : public DescriptorImpl {
 protected:
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
                                      const CScript *,
                                      FlatSigningProvider &) const override {
         return Singleton(GetScriptForRawPubKey(keys[0]));
     }
 
 public:
     PKDescriptor(std::unique_ptr<PubkeyProvider> prov)
         : DescriptorImpl(Singleton(std::move(prov)), {}, "pk") {}
 };
 
 /** A parsed pkh(P) descriptor. */
 class PKHDescriptor final : public DescriptorImpl {
 protected:
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
                                      const CScript *,
                                      FlatSigningProvider &out) const override {
         CKeyID id = keys[0].GetID();
         out.pubkeys.emplace(id, keys[0]);
         return Singleton(GetScriptForDestination(PKHash(id)));
     }
 
 public:
     PKHDescriptor(std::unique_ptr<PubkeyProvider> prov)
         : DescriptorImpl(Singleton(std::move(prov)), {}, "pkh") {}
 };
 
 /** A parsed combo(P) descriptor. */
 class ComboDescriptor final : public DescriptorImpl {
 protected:
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
                                      const CScript *,
                                      FlatSigningProvider &out) const override {
         std::vector<CScript> ret;
         CKeyID id = keys[0].GetID();
         out.pubkeys.emplace(id, keys[0]);
         // P2PK
         ret.emplace_back(GetScriptForRawPubKey(keys[0]));
         // P2PKH
         ret.emplace_back(GetScriptForDestination(PKHash(id)));
         return ret;
     }
 
 public:
     ComboDescriptor(std::unique_ptr<PubkeyProvider> prov)
         : DescriptorImpl(Singleton(std::move(prov)), {}, "combo") {}
 };
 
 /** A parsed multi(...) descriptor. */
 class MultisigDescriptor final : public DescriptorImpl {
     const int m_threshold;
 
 protected:
     std::string ToStringExtra() const override {
         return strprintf("%i", m_threshold);
     }
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
                                      const CScript *,
                                      FlatSigningProvider &) const override {
         return Singleton(GetScriptForMultisig(m_threshold, keys));
     }
 
 public:
     MultisigDescriptor(int threshold,
                        std::vector<std::unique_ptr<PubkeyProvider>> providers)
         : DescriptorImpl(std::move(providers), {}, "multi"),
           m_threshold(threshold) {}
 };
 
 /** A parsed sh(...) descriptor. */
 class SHDescriptor final : public DescriptorImpl {
 protected:
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &,
                                      const CScript *script,
                                      FlatSigningProvider &) const override {
         return Singleton(GetScriptForDestination(ScriptHash(*script)));
     }
 
 public:
     SHDescriptor(std::unique_ptr<DescriptorImpl> desc)
         : DescriptorImpl({}, std::move(desc), "sh") {}
 };
 
 ////////////////////////////////////////////////////////////////////////////
 // Parser                                                                 //
 ////////////////////////////////////////////////////////////////////////////
 
 enum class ParseScriptContext {
     TOP,
     P2SH,
 };
 
 /**
  * Parse a constant. If successful, sp is updated to skip the constant and
  * return true.
  */
 bool Const(const std::string &str, Span<const char> &sp) {
     if ((size_t)sp.size() >= str.size() &&
         std::equal(str.begin(), str.end(), sp.begin())) {
         sp = sp.subspan(str.size());
         return true;
     }
     return false;
 }
 
 /**
  * Parse a function call. If successful, sp is updated to be the function's
  * argument(s).
  */
 bool Func(const std::string &str, Span<const char> &sp) {
     if ((size_t)sp.size() >= str.size() + 2 && sp[str.size()] == '(' &&
         sp[sp.size() - 1] == ')' &&
         std::equal(str.begin(), str.end(), sp.begin())) {
         sp = sp.subspan(str.size() + 1, sp.size() - str.size() - 2);
         return true;
     }
     return false;
 }
 
 /** Return the expression that sp begins with, and update sp to skip it. */
 Span<const char> Expr(Span<const char> &sp) {
     int level = 0;
     auto it = sp.begin();
     while (it != sp.end()) {
         if (*it == '(') {
             ++level;
         } else if (level && *it == ')') {
             --level;
         } else if (level == 0 && (*it == ')' || *it == ',')) {
             break;
         }
         ++it;
     }
     Span<const char> ret = sp.first(it - sp.begin());
     sp = sp.subspan(it - sp.begin());
     return ret;
 }
 
 /** Split a string on every instance of sep, returning a vector. */
 std::vector<Span<const char>> Split(const Span<const char> &sp, char sep) {
     std::vector<Span<const char>> ret;
     auto it = sp.begin();
     auto start = it;
     while (it != sp.end()) {
         if (*it == sep) {
             ret.emplace_back(start, it);
             start = it + 1;
         }
         ++it;
     }
     ret.emplace_back(start, it);
     return ret;
 }
 
 /**
  * Parse a key path, being passed a split list of elements (the first element is
  * ignored).
  */
 NODISCARD bool ParseKeyPath(const std::vector<Span<const char>> &split,
                             KeyPath &out) {
     for (size_t i = 1; i < split.size(); ++i) {
         Span<const char> elem = split[i];
         bool hardened = false;
         if (elem.size() > 0 &&
             (elem[elem.size() - 1] == '\'' || elem[elem.size() - 1] == 'h')) {
             elem = elem.first(elem.size() - 1);
             hardened = true;
         }
         uint32_t p;
         if (!ParseUInt32(std::string(elem.begin(), elem.end()), &p) ||
             p > 0x7FFFFFFFUL) {
             return false;
         }
         out.push_back(p | (uint32_t(hardened) << 31));
     }
     return true;
 }
 
 /** Parse a public key that excludes origin information. */
 std::unique_ptr<PubkeyProvider> ParsePubkeyInner(const Span<const char> &sp,
                                                  FlatSigningProvider &out) {
     auto split = Split(sp, '/');
     std::string str(split[0].begin(), split[0].end());
     if (split.size() == 1) {
         if (IsHex(str)) {
             std::vector<uint8_t> data = ParseHex(str);
             CPubKey pubkey(data);
             if (pubkey.IsFullyValid()) {
                 return std::make_unique<ConstPubkeyProvider>(pubkey);
             }
         }
         CKey key = DecodeSecret(str);
         if (key.IsValid()) {
             CPubKey pubkey = key.GetPubKey();
             out.keys.emplace(pubkey.GetID(), key);
             return std::make_unique<ConstPubkeyProvider>(pubkey);
         }
     }
     CExtKey extkey = DecodeExtKey(str);
     CExtPubKey extpubkey = DecodeExtPubKey(str);
     if (!extkey.key.IsValid() && !extpubkey.pubkey.IsValid()) {
         return nullptr;
     }
     KeyPath path;
     DeriveType type = DeriveType::NO;
     if (split.back() == MakeSpan("*").first(1)) {
         split.pop_back();
         type = DeriveType::UNHARDENED;
     } else if (split.back() == MakeSpan("*'").first(2) ||
                split.back() == MakeSpan("*h").first(2)) {
         split.pop_back();
         type = DeriveType::HARDENED;
     }
     if (!ParseKeyPath(split, path)) {
         return nullptr;
     }
     if (extkey.key.IsValid()) {
         extpubkey = extkey.Neuter();
         out.keys.emplace(extpubkey.pubkey.GetID(), extkey.key);
     }
     return std::make_unique<BIP32PubkeyProvider>(extpubkey, std::move(path),
                                                  type);
 }
 
 /** Parse a public key including origin information (if enabled). */
 std::unique_ptr<PubkeyProvider> ParsePubkey(const Span<const char> &sp,
                                             FlatSigningProvider &out) {
     auto origin_split = Split(sp, ']');
     if (origin_split.size() > 2) {
         return nullptr;
     }
     if (origin_split.size() == 1) {
         return ParsePubkeyInner(origin_split[0], out);
     }
     if (origin_split[0].size() < 1 || origin_split[0][0] != '[') {
         return nullptr;
     }
     auto slash_split = Split(origin_split[0].subspan(1), '/');
     if (slash_split[0].size() != 8) {
         return nullptr;
     }
     std::string fpr_hex =
         std::string(slash_split[0].begin(), slash_split[0].end());
     if (!IsHex(fpr_hex)) {
         return nullptr;
     }
     auto fpr_bytes = ParseHex(fpr_hex);
     KeyOriginInfo info;
     static_assert(sizeof(info.fingerprint) == 4, "Fingerprint must be 4 bytes");
     assert(fpr_bytes.size() == 4);
     std::copy(fpr_bytes.begin(), fpr_bytes.end(), info.fingerprint);
     if (!ParseKeyPath(slash_split, info.path)) {
         return nullptr;
     }
     auto provider = ParsePubkeyInner(origin_split[1], out);
     if (!provider) {
         return nullptr;
     }
     return std::make_unique<OriginPubkeyProvider>(std::move(info),
                                                   std::move(provider));
 }
 
 /** Parse a script in a particular context. */
 std::unique_ptr<DescriptorImpl> ParseScript(Span<const char> &sp,
                                             ParseScriptContext ctx,
                                             FlatSigningProvider &out) {
     auto expr = Expr(sp);
     if (Func("pk", expr)) {
         auto pubkey = ParsePubkey(expr, out);
         if (!pubkey) {
             return nullptr;
         }
         return std::make_unique<PKDescriptor>(std::move(pubkey));
     }
     if (Func("pkh", expr)) {
         auto pubkey = ParsePubkey(expr, out);
         if (!pubkey) {
             return nullptr;
         }
         return std::make_unique<PKHDescriptor>(std::move(pubkey));
     }
     if (ctx == ParseScriptContext::TOP && Func("combo", expr)) {
         auto pubkey = ParsePubkey(expr, out);
         if (!pubkey) {
             return nullptr;
         }
         return std::make_unique<ComboDescriptor>(std::move(pubkey));
     }
     if (Func("multi", expr)) {
         auto threshold = Expr(expr);
         uint32_t thres;
         std::vector<std::unique_ptr<PubkeyProvider>> providers;
         if (!ParseUInt32(std::string(threshold.begin(), threshold.end()),
                          &thres)) {
             return nullptr;
         }
         size_t script_size = 0;
         while (expr.size()) {
             if (!Const(",", expr)) {
                 return nullptr;
             }
             auto arg = Expr(expr);
             auto pk = ParsePubkey(arg, out);
             if (!pk) {
                 return nullptr;
             }
             script_size += pk->GetSize() + 1;
             providers.emplace_back(std::move(pk));
         }
         if (providers.size() < 1 || providers.size() > 16 || thres < 1 ||
             thres > providers.size()) {
             return nullptr;
         }
         if (ctx == ParseScriptContext::TOP) {
             if (providers.size() > 3) {
                 // Not more than 3 pubkeys for raw multisig
                 return nullptr;
             }
         }
         if (ctx == ParseScriptContext::P2SH) {
             if (script_size + 3 > 520) {
                 // Enforce P2SH script size limit
                 return nullptr;
             }
         }
         return std::make_unique<MultisigDescriptor>(thres,
                                                     std::move(providers));
     }
     if (ctx == ParseScriptContext::TOP && Func("sh", expr)) {
         auto desc = ParseScript(expr, ParseScriptContext::P2SH, out);
         if (!desc || expr.size()) {
             return nullptr;
         }
         return std::make_unique<SHDescriptor>(std::move(desc));
     }
     if (ctx == ParseScriptContext::TOP && Func("addr", expr)) {
         CTxDestination dest =
             DecodeDestination(std::string(expr.begin(), expr.end()), Params());
         if (!IsValidDestination(dest)) {
             return nullptr;
         }
         return std::make_unique<AddressDescriptor>(std::move(dest));
     }
     if (ctx == ParseScriptContext::TOP && Func("raw", expr)) {
         std::string str(expr.begin(), expr.end());
         if (!IsHex(str)) {
             return nullptr;
         }
         auto bytes = ParseHex(str);
         return std::make_unique<RawDescriptor>(
             CScript(bytes.begin(), bytes.end()));
     }
     return nullptr;
 }
 
 static std::unique_ptr<PubkeyProvider>
 InferPubkey(const CPubKey &pubkey, ParseScriptContext,
             const SigningProvider &provider) {
     auto key_provider = std::make_unique<ConstPubkeyProvider>(pubkey);
     KeyOriginInfo info;
     if (provider.GetKeyOrigin(pubkey.GetID(), info)) {
         return std::make_unique<OriginPubkeyProvider>(std::move(info),
                                                       std::move(key_provider));
     }
     return key_provider;
 }
 
 std::unique_ptr<DescriptorImpl> InferScript(const CScript &script,
                                             ParseScriptContext ctx,
                                             const SigningProvider &provider) {
     std::vector<std::vector<uint8_t>> data;
     txnouttype txntype = Solver(script, data);
 
     if (txntype == TX_PUBKEY) {
         CPubKey pubkey(data[0].begin(), data[0].end());
         if (pubkey.IsValid()) {
             return std::make_unique<PKDescriptor>(
                 InferPubkey(pubkey, ctx, provider));
         }
     }
     if (txntype == TX_PUBKEYHASH) {
         uint160 hash(data[0]);
         CKeyID keyid(hash);
         CPubKey pubkey;
         if (provider.GetPubKey(keyid, pubkey)) {
             return std::make_unique<PKHDescriptor>(
                 InferPubkey(pubkey, ctx, provider));
         }
     }
     if (txntype == TX_MULTISIG) {
         std::vector<std::unique_ptr<PubkeyProvider>> providers;
         for (size_t i = 1; i + 1 < data.size(); ++i) {
             CPubKey pubkey(data[i].begin(), data[i].end());
             providers.push_back(InferPubkey(pubkey, ctx, provider));
         }
         return std::make_unique<MultisigDescriptor>((int)data[0][0],
                                                     std::move(providers));
     }
     if (txntype == TX_SCRIPTHASH && ctx == ParseScriptContext::TOP) {
         uint160 hash(data[0]);
         CScriptID scriptid(hash);
         CScript subscript;
         if (provider.GetCScript(scriptid, subscript)) {
             auto sub =
                 InferScript(subscript, ParseScriptContext::P2SH, provider);
             if (sub) {
                 return std::make_unique<SHDescriptor>(std::move(sub));
             }
         }
     }
 
     CTxDestination dest;
     if (ExtractDestination(script, dest)) {
         if (GetScriptForDestination(dest) == script) {
             return std::make_unique<AddressDescriptor>(std::move(dest));
         }
     }
 
     return std::make_unique<RawDescriptor>(script);
 }
 
 } // namespace
 
 /**
  * Check a descriptor checksum, and update desc to be the checksum-less part.
  */
 bool CheckChecksum(Span<const char> &sp, bool require_checksum,
                    std::string *out_checksum = nullptr) {
     auto check_split = Split(sp, '#');
     if (check_split.size() > 2) {
         // Multiple '#' symbols
         return false;
     }
     if (check_split.size() == 1 && require_checksum) {
         // Missing checksum
         return false;
     }
     if (check_split.size() == 2) {
         if (check_split[1].size() != 8) {
             // Unexpected length for checksum
             return false;
         }
     }
     auto checksum = DescriptorChecksum(check_split[0]);
     if (checksum.empty()) {
         // Invalid characters in payload
         return false;
     }
     if (check_split.size() == 2) {
         if (!std::equal(checksum.begin(), checksum.end(),
                         check_split[1].begin())) {
             // Checksum mismatch
             return false;
         }
     }
     if (out_checksum) {
         *out_checksum = std::move(checksum);
     }
     sp = check_split[0];
     return true;
 }
 
 std::unique_ptr<Descriptor> Parse(const std::string &descriptor,
                                   FlatSigningProvider &out,
                                   bool require_checksum) {
     Span<const char> sp(descriptor.data(), descriptor.size());
     if (!CheckChecksum(sp, require_checksum)) {
         return nullptr;
     }
     auto ret = ParseScript(sp, ParseScriptContext::TOP, out);
     if (sp.size() == 0 && ret) {
         return std::unique_ptr<Descriptor>(std::move(ret));
     }
     return nullptr;
 }
 
+std::string GetDescriptorChecksum(const std::string &descriptor) {
+    std::string ret;
+    Span<const char> sp(descriptor.data(), descriptor.size());
+    if (!CheckChecksum(sp, false, &ret)) {
+        return "";
+    }
+    return ret;
+}
+
 std::unique_ptr<Descriptor> InferDescriptor(const CScript &script,
                                             const SigningProvider &provider) {
     return InferScript(script, ParseScriptContext::TOP, provider);
 }
diff --git a/src/script/descriptor.h b/src/script/descriptor.h
index e865d1fcf..e34d84186 100644
--- a/src/script/descriptor.h
+++ b/src/script/descriptor.h
@@ -1,117 +1,127 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_SCRIPT_DESCRIPTOR_H
 #define BITCOIN_SCRIPT_DESCRIPTOR_H
 
 #include <script/script.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
 
 #include <vector>
 
 // Descriptors are strings that describe a set of scriptPubKeys, together with
 // all information necessary to solve them. By combining all information into
 // one, they avoid the need to separately import keys and scripts.
 //
 // Descriptors may be ranged, which occurs when the public keys inside are
 // specified in the form of HD chains (xpubs).
 //
 // Descriptors always represent public information - public keys and scripts -
 // but in cases where private keys need to be conveyed along with a descriptor,
 // they can be included inside by changing public keys to private keys (WIF
 // format), and changing xpubs by xprvs.
 //
 // Reference documentation about the descriptor language can be found in
 // doc/descriptors.md.
 
 /** Interface for parsed descriptor objects. */
 struct Descriptor {
     virtual ~Descriptor() = default;
 
     /** Whether the expansion of this descriptor depends on the position. */
     virtual bool IsRange() const = 0;
 
     /**
      * Whether this descriptor has all information about signing ignoring lack
      * of private keys. This is true for all descriptors except ones that use
      * `raw` or `addr` constructions.
      */
     virtual bool IsSolvable() const = 0;
 
     /** Convert the descriptor back to a string, undoing parsing. */
     virtual std::string ToString() const = 0;
 
     /**
      * Convert the descriptor to a private string. This fails if the provided
      * provider does not have the relevant private keys.
      */
     virtual bool ToPrivateString(const SigningProvider &provider,
                                  std::string &out) const = 0;
 
     /**
      * Expand a descriptor at a specified position.
      *
      * pos: the position at which to expand the descriptor. If IsRange() is
      *      false, this is ignored.
      * provider: the provider to query for private keys in case of hardened
      *           derivation.
      * output_script: the expanded scriptPubKeys will be put here.
      * out: scripts and public keys necessary for solving the expanded
      * scriptPubKeys will be put here (may be equal to provider). cache: vector
      * which will be overwritten with cache data necessary to-evaluate the
      * descriptor at this point without access to private keys.
      */
     virtual bool Expand(int pos, const SigningProvider &provider,
                         std::vector<CScript> &output_scripts,
                         FlatSigningProvider &out,
                         std::vector<uint8_t> *cache = nullptr) const = 0;
 
     /**
      * Expand a descriptor at a specified position using cached expansion data.
      *
      * pos: the position at which to expand the descriptor. If IsRange() is
      * false, this is ignored. cache: vector from which cached expansion data
      * will be read. output_script: the expanded scriptPubKeys will be put here.
      * out: scripts and public keys necessary for solving the expanded
      * scriptPubKeys will be put here (may be equal to provider).
      */
     virtual bool ExpandFromCache(int pos, const std::vector<uint8_t> &cache,
                                  std::vector<CScript> &output_scripts,
                                  FlatSigningProvider &out) const = 0;
 };
 
 /** Parse a descriptor string. Included private keys are put in out.
  *
  * If the descriptor has a checksum, it must be valid. If require_checksum
  * is set, the checksum is mandatory - otherwise it is optional.
  *
  * If a parse error occurs, or the checksum is missing/invalid, or anything
  * else is wrong, nullptr is returned.
  */
 std::unique_ptr<Descriptor> Parse(const std::string &descriptor,
                                   FlatSigningProvider &out,
                                   bool require_checksum = false);
 
+/**
+ * Get the checksum for a descriptor.
+ *
+ * If it already has one, and it is correct, return the checksum in the input.
+ * If it already has one that is wrong, return "".
+ * If it does not already have one, return the checksum that would need to be
+ * added.
+ */
+std::string GetDescriptorChecksum(const std::string &descriptor);
+
 /**
  * Find a descriptor for the specified script, using information from provider
  * where possible.
  *
  * A non-ranged descriptor which only generates the specified script will be
  * returned in all circumstances.
  *
  * For public keys with key origin information, this information will be
  * preserved in the returned descriptor.
  *
  * - If all information for solving `script` is present in `provider`, a
  * descriptor will be returned which is `IsSolvable()` and encapsulates said
  * information.
  * - Failing that, if `script` corresponds to a known address type, an "addr()"
  * descriptor will be returned (which is not `IsSolvable()`).
  * - Failing that, a "raw()" descriptor is returned.
  */
 std::unique_ptr<Descriptor> InferDescriptor(const CScript &script,
                                             const SigningProvider &provider);
 
 #endif // BITCOIN_SCRIPT_DESCRIPTOR_H
diff --git a/test/functional/wallet_address_types.py b/test/functional/wallet_address_types.py
index 03f959073..fe72b358f 100755
--- a/test/functional/wallet_address_types.py
+++ b/test/functional/wallet_address_types.py
@@ -1,298 +1,306 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017 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 that the wallet can send and receive using all combinations of address types.
 
 There are 4 nodes-under-test:
     - node0 uses legacy addresses
     - node1 uses legacy addresses
     - node2 uses legacy addresses
     - node3 uses legacy addresses
 
 node4 exists to generate new blocks.
 
 ## Multisig address test
 
 Test that adding a multisig address with:
     - an uncompressed pubkey always gives a legacy address
     - only compressed pubkeys gives the an `-addresstype` address
 
 ## Sending to address types test
 
 A series of tests, iterating over node0-node3. In each iteration of the test, one node sends:
     - 10/101th of its balance to itself (using getrawchangeaddress for single key addresses)
     - 20/101th to the next node
     - 30/101th to the node after that
     - 40/101th to the remaining node
     - 1/101th remains as fee+change
 
 Iterate over each node for single key addresses, and then over each node for
 multisig addresses. Repeat test. As every node sends coins after receiving,
 this also verifies that spending coins sent to all these address types works.
 """
 
 from decimal import Decimal
 import itertools
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.descriptors import (
     descsum_create,
     descsum_check,
 )
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     connect_nodes,
 )
 
 
 class AddressTypeTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 5
         # whitelist all peers to speed up tx relay / mempool sync
         self.extra_args = [["-whitelist=127.0.0.1"]] * self.num_nodes
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def setup_network(self):
         self.setup_nodes()
 
         # Fully mesh-connect nodes for faster mempool sync
         for i, j in itertools.product(range(self.num_nodes), repeat=2):
             if i > j:
                 connect_nodes(self.nodes[i], self.nodes[j])
         self.sync_all()
 
     def get_balances(self, confirmed=True):
         """Return a list of confirmed or unconfirmed balances."""
         if confirmed:
             return [self.nodes[i].getbalance() for i in range(4)]
         else:
             return [self.nodes[i].getunconfirmedbalance() for i in range(4)]
 
     def test_address(self, node, address, multisig, typ):
         """Run sanity checks on an address."""
         self.log.info(address)
         info = self.nodes[node].getaddressinfo(address)
         assert(self.nodes[node].validateaddress(address)['isvalid'])
         assert_equal(info.get('solvable'), True)
 
         if not multisig and typ == 'legacy':
             # P2PKH
             assert(not info['isscript'])
             assert('pubkey' in info)
         elif typ == 'legacy':
             # P2SH-multisig
             assert(info['isscript'])
             assert_equal(info['script'], 'multisig')
             assert('pubkeys' in info)
         else:
             # Unknown type
             assert(False)
 
     def test_desc(self, node, address, multisig, typ, utxo):
         """Run sanity checks on a descriptor reported by getaddressinfo."""
         info = self.nodes[node].getaddressinfo(address)
         assert('desc' in info)
 
         assert_equal(info['desc'], utxo['desc'])
         assert(self.nodes[node].validateaddress(address)['isvalid'])
 
         # Use a ridiculously roundabout way to find the key origin info through
         # the PSBT logic. However, this does test consistency between the PSBT reported
         # fingerprints/paths and the descriptor logic.
         psbt = self.nodes[node].createpsbt(
             [{'txid': utxo['txid'], 'vout':utxo['vout']}], [{address: 0.00010000}])
         psbt = self.nodes[node].walletprocesspsbt(
             psbt, False, "ALL|FORKID", True)
         decode = self.nodes[node].decodepsbt(psbt['psbt'])
         key_descs = {}
         for deriv in decode['inputs'][0]['bip32_derivs']:
             assert_equal(len(deriv['master_fingerprint']), 8)
             assert_equal(deriv['path'][0], 'm')
             key_descs[deriv['pubkey']] = '[' + deriv['master_fingerprint'] + \
                 deriv['path'][1:] + ']' + deriv['pubkey']
 
         # Verify the descriptor checksum against the Python implementation
         assert(descsum_check(info['desc']))
         # Verify that stripping the checksum and recreating it using Python
         # roundtrips
         assert(info['desc'] == descsum_create(info['desc'][:-9]))
         # Verify that stripping the checksum and feeding it to
         # getdescriptorinfo roundtrips
         assert(info['desc'] == self.nodes[0].getdescriptorinfo(
             info['desc'][:-9])['descriptor'])
+        assert_equal(
+            info['desc'][-8:], self.nodes[0].getdescriptorinfo(info['desc'][:-9])['checksum'])
+        # Verify that keeping the checksum and feeding it to getdescriptorinfo
+        # roundtrips
+        assert info['desc'] == self.nodes[0].getdescriptorinfo(info['desc'])[
+            'descriptor']
+        assert_equal(info['desc'][-8:],
+                     self.nodes[0].getdescriptorinfo(info['desc'])['checksum'])
 
         if not multisig and typ == 'legacy':
             # P2PKH
             assert_equal(info['desc'],
                          descsum_create("pkh({})".format(key_descs[info['pubkey']])))
         elif typ == 'legacy':
             # P2SH-multisig
             assert_equal(info['desc'], descsum_create("sh(multi(2,{},{}))".format(
                 key_descs[info['pubkeys'][0]], key_descs[info['pubkeys'][1]])))
         else:
             # Unknown type
             assert(False)
 
     def test_change_output_type(
             self, node_sender, destinations, expected_type):
         txid = self.nodes[node_sender].sendmany(
             dummy="", amounts=dict.fromkeys(
                 destinations, 0.001))
         raw_tx = self.nodes[node_sender].getrawtransaction(txid)
         tx = self.nodes[node_sender].decoderawtransaction(raw_tx)
 
         # Make sure the transaction has change:
         assert_equal(len(tx["vout"]), len(destinations) + 1)
 
         # Make sure the destinations are included, and remove them:
         output_addresses = [vout['scriptPubKey']['addresses'][0]
                             for vout in tx["vout"]]
         change_addresses = [
             d for d in output_addresses if d not in destinations]
         assert_equal(len(change_addresses), 1)
 
         self.log.debug(
             "Check if change address " +
             change_addresses[0] +
             " is " +
             expected_type)
         self.test_address(
             node_sender,
             change_addresses[0],
             multisig=False,
             typ=expected_type)
 
     def run_test(self):
         # Mine 101 blocks on node4 to bring nodes out of IBD and make sure that
         # no coinbases are maturing for the nodes-under-test during the test
         self.nodes[4].generate(101)
         self.sync_blocks()
 
         uncompressed_1 = "0496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858ee"
         uncompressed_2 = "047211a824f55b505228e4c3d5194c1fcfaa15a456abdf37f9b9d97a4040afc073dee6c89064984f03385237d92167c13e236446b417ab79a0fcae412ae3316b77"
         compressed_1 = "0296b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52"
         compressed_2 = "037211a824f55b505228e4c3d5194c1fcfaa15a456abdf37f9b9d97a4040afc073"
 
         # addmultisigaddress with at least 1 uncompressed key should return a
         # legacy address.
         for node in range(4):
             self.test_address(node, self.nodes[node].addmultisigaddress(
                 2, [uncompressed_1, uncompressed_2])['address'], True, 'legacy')
             self.test_address(node, self.nodes[node].addmultisigaddress(
                 2, [compressed_1, uncompressed_2])['address'], True, 'legacy')
             self.test_address(node, self.nodes[node].addmultisigaddress(
                 2, [uncompressed_1, compressed_2])['address'], True, 'legacy')
         # addmultisigaddress with all compressed keys should return the
         # appropriate address type (even when the keys are not ours).
         self.test_address(0, self.nodes[0].addmultisigaddress(
             2, [compressed_1, compressed_2])['address'], True, 'legacy')
 
         for multisig, from_node in itertools.product([False, True], range(4)):
             self.log.info(
                 "Sending from node {} with{} multisig".format(from_node, "" if multisig else "out"))
             old_balances = self.get_balances()
             self.log.debug("Old balances are {}".format(old_balances))
             to_send = (
                 old_balances[from_node] /
                 101).quantize(
                 Decimal("0.00000001"))
             sends = {}
             addresses = {}
 
             self.log.debug("Prepare sends")
             for n, to_node in enumerate(range(from_node, from_node + 4)):
                 to_node %= 4
                 if not multisig:
                     if from_node == to_node:
                         # When sending non-multisig to self, use
                         # getrawchangeaddress
                         address = self.nodes[to_node].getrawchangeaddress()
                     else:
                         address = self.nodes[to_node].getnewaddress()
                 else:
                     addr1 = self.nodes[to_node].getnewaddress()
                     addr2 = self.nodes[to_node].getnewaddress()
                     address = self.nodes[to_node].addmultisigaddress(2, [addr1, addr2])[
                         'address']
 
                 # Do some sanity checking on the created address
                 typ = 'legacy'
                 self.test_address(to_node, address, multisig, typ)
 
                 # Output entry
                 sends[address] = to_send * 10 * (1 + n)
                 addresses[to_node] = (address, typ)
 
             self.log.debug("Sending: {}".format(sends))
             self.nodes[from_node].sendmany("", sends)
             self.sync_mempools()
 
             unconf_balances = self.get_balances(False)
             self.log.debug(
                 "Check unconfirmed balances: {}".format(unconf_balances))
             assert_equal(unconf_balances[from_node], 0)
             for n, to_node in enumerate(range(from_node + 1, from_node + 4)):
                 to_node %= 4
                 assert_equal(unconf_balances[to_node], to_send * 10 * (2 + n))
 
             # node4 collects fee and block subsidy to keep accounting simple
             self.nodes[4].generate(1)
             self.sync_blocks()
 
             # Verify that the receiving wallet contains a UTXO with the
             # expected address, and expected descriptor
             for n, to_node in enumerate(range(from_node, from_node + 4)):
                 to_node %= 4
                 found = False
                 for utxo in self.nodes[to_node].listunspent():
                     if utxo['address'] == addresses[to_node][0]:
                         found = True
                         self.test_desc(
                             to_node,
                             addresses[to_node][0],
                             multisig,
                             addresses[to_node][1],
                             utxo)
                         break
                 assert found
 
             new_balances = self.get_balances()
             self.log.debug("Check new balances: {}".format(new_balances))
             # We don't know what fee was set, so we can only check bounds on
             # the balance of the sending node
             assert_greater_than(new_balances[from_node], to_send * 10)
             assert_greater_than(to_send * 11, new_balances[from_node])
             for n, to_node in enumerate(range(from_node + 1, from_node + 4)):
                 to_node %= 4
                 assert_equal(
                     new_balances[to_node], old_balances[to_node] + to_send * 10 * (2 + n))
 
         # Get addresses from node2 and  node3:
         to_address_2 = self.nodes[2].getnewaddress()
         to_address_3_1 = self.nodes[3].getnewaddress()
         to_address_3_2 = self.nodes[3].getnewaddress()
 
         self.log.info("Various change output tests")
         self.test_change_output_type(0, [to_address_3_1], 'legacy')
         self.test_change_output_type(1, [to_address_2], 'legacy')
         self.test_change_output_type(1, [to_address_3_1], 'legacy')
         self.test_change_output_type(
             1, [to_address_2, to_address_3_1], 'legacy')
         self.test_change_output_type(
             1, [to_address_3_1, to_address_3_2], 'legacy')
         self.test_change_output_type(2, [to_address_3_1], 'legacy')
 
         self.log.info('Test getrawchangeaddress')
         self.test_address(
             3,
             self.nodes[3].getrawchangeaddress(),
             multisig=False,
             typ='legacy')
 
 
 if __name__ == '__main__':
     AddressTypeTest().main()