diff --git a/arcanist/linter/LocaleDependenceLinter.php b/arcanist/linter/LocaleDependenceLinter.php
index cea509f5c..853e6ea90 100644
--- a/arcanist/linter/LocaleDependenceLinter.php
+++ b/arcanist/linter/LocaleDependenceLinter.php
@@ -1,295 +1,296 @@
 <?php
 
 /**
  * Check for locale dependent functions.
  * Unnecessary locale dependence can cause bugs that are very tricky to isolate
  * and fix.
  */
 final class LocaleDependenceLinter extends ArcanistLinter {
 
   const KNOWN_VIOLATIONS = array(
     "src/bitcoin-tx.cpp" => [
       "stoul",
       "trim_right",
     ],
     "src/dbwrapper.cpp" => [
         "stoul",
         "vsnprintf"
     ],
     "src/httprpc.cpp" => ["trim"],
     "src/init.cpp" => ["atoi"],
     "src/netbase.cpp" => ["to_lower"],
     "src/qt/rpcconsole.cpp" => [
       "atoi",
     ],
     "src/rest.cpp" => ["strtol"],
     "src/rpc/server.cpp" => ["to_upper"],
     "src/test/dbwrapper_tests.cpp" => ["snprintf"],
     "src/test/getarg_tests.cpp" => [
       "split",
       "is_space",
     ],
     "src/seeder/main.cpp" => [
         "strtoull",
         "strcasecmp",
         "strftime",
     ],
     "src/seeder/dns.cpp" => ["strcasecmp"],
     "src/torcontrol.cpp" => [
       "atoi",
       "strtol",
     ],
     "src/test/fuzz/locale.cpp" => [
       "atoi",
       "setlocale",
     ],
     "src/test/fuzz/parse_numbers.cpp" => ["atoi"],
     "src/util/system.cpp" => ["atoi"],
     "src/util/strencodings.cpp" => [
       "atoi",
       "strtol",
       "strtoll",
       "strtoul",
       "strtoull",
     ],
     "src/util/strencodings.h" => ["atoi"],
   );
 
   const LOCALE_DEPENDENT_FUNCTIONS = array(
     "alphasort",   // LC_COLLATE (via strcoll)
     "asctime",     // LC_TIME (directly)
     "asprintf",    // (via vasprintf)
     "atof",        // LC_NUMERIC (via strtod)
     "atoi",        // LC_NUMERIC (via strtol)
     "atol",        // LC_NUMERIC (via strtol)
     "atoll",       // (via strtoll)
     "atoq",
     "btowc",       // LC_CTYPE (directly)
     "ctime",       // (via asctime or localtime)
     "dprintf",     // (via vdprintf)
     "fgetwc",
     "fgetws",
     "fold_case",   // boost::locale::fold_case
     "fprintf",     // (via vfprintf)
     "fputwc",
     "fputws",
     "fscanf",      // (via __vfscanf)
     "fwprintf",    // (via __vfwprintf)
     "getdate",     // via __getdate_r => isspace // __localtime_r
     "getwc",
     "getwchar",
     "is_digit",    // boost::algorithm::is_digit
     "is_space",    // boost::algorithm::is_space
     "isalnum",     // LC_CTYPE
     "isalpha",     // LC_CTYPE
     "isblank",     // LC_CTYPE
     "iscntrl",     // LC_CTYPE
     "isctype",     // LC_CTYPE
     "isdigit",     // LC_CTYPE
     "isgraph",     // LC_CTYPE
     "islower",     // LC_CTYPE
     "isprint",     // LC_CTYPE
     "ispunct",     // LC_CTYPE
     "isspace",     // LC_CTYPE
     "isupper",     // LC_CTYPE
     "iswalnum",    // LC_CTYPE
     "iswalpha",    // LC_CTYPE
     "iswblank",    // LC_CTYPE
     "iswcntrl",    // LC_CTYPE
     "iswctype",    // LC_CTYPE
     "iswdigit",    // LC_CTYPE
     "iswgraph",    // LC_CTYPE
     "iswlower",    // LC_CTYPE
     "iswprint",    // LC_CTYPE
     "iswpunct",    // LC_CTYPE
     "iswspace",    // LC_CTYPE
     "iswupper",    // LC_CTYPE
     "iswxdigit",   // LC_CTYPE
     "isxdigit",    // LC_CTYPE
     "localeconv",  // LC_NUMERIC + LC_MONETARY
     "mblen",       // LC_CTYPE
     "mbrlen",
     "mbrtowc",
     "mbsinit",
     "mbsnrtowcs",
     "mbsrtowcs",
     "mbstowcs",    // LC_CTYPE
     "mbtowc",      // LC_CTYPE
     "mktime",
     "normalize",   // boost::locale::normalize
     "printf",      // LC_NUMERIC
     "putwc",
     "putwchar",
     "scanf",       // LC_NUMERIC
     "setlocale",
     "snprintf",
     "sprintf",
     "sscanf",
+    "std::to_string",
     "stod",
     "stof",
     "stoi",
     "stol",
     "stold",
     "stoll",
     "stoul",
     "stoull",
     "strcasecmp",
     "strcasestr",
     "strcoll",     // LC_COLLATE
     //"strerror"
     "strfmon",
     "strftime",    // LC_TIME
     "strncasecmp",
     "strptime",
     "strtod",      // LC_NUMERIC
     "strtof",
     "strtoimax",
     "strtol",      // LC_NUMERIC
     "strtold",
     "strtoll",
     "strtoq",
     "strtoul",     // LC_NUMERIC
     "strtoull",
     "strtoumax",
     "strtouq",
     "strxfrm",     // LC_COLLATE
     "swprintf",
     "to_lower",    // boost::locale::to_lower
     "to_title",    // boost::locale::to_title
     "to_upper",    // boost::locale::to_upper
     "tolower",     // LC_CTYPE
     "toupper",     // LC_CTYPE
     "towctrans",
     "towlower",    // LC_CTYPE
     "towupper",    // LC_CTYPE
     "trim",        // boost::algorithm::trim
     "trim_left",   // boost::algorithm::trim_left
     "trim_right",  // boost::algorithm::trim_right
     "ungetwc",
     "vasprintf",
     "vdprintf",
     "versionsort",
     "vfprintf",
     "vfscanf",
     "vfwprintf",
     "vprintf",
     "vscanf",
     "vsnprintf",
     "vsprintf",
     "vsscanf",
     "vswprintf",
     "vwprintf",
     "wcrtomb",
     "wcscasecmp",
     "wcscoll",     // LC_COLLATE
     "wcsftime",    // LC_TIME
     "wcsncasecmp",
     "wcsnrtombs",
     "wcsrtombs",
     "wcstod",      // LC_NUMERIC
     "wcstof",
     "wcstoimax",
     "wcstol",      // LC_NUMERIC
     "wcstold",
     "wcstoll",
     "wcstombs",    // LC_CTYPE
     "wcstoul",     // LC_NUMERIC
     "wcstoull",
     "wcstoumax",
     "wcswidth",
     "wcsxfrm",     // LC_COLLATE
     "wctob",
     "wctomb",      // LC_CTYPE
     "wctrans",
     "wctype",
     "wcwidth",
     "wprintf",
   );
 
   const LOCALE_DEPENDENCE_ERROR = 1;
 
   const ADVICE_MESSAGE = <<<ADVICE
 Unnecessary locale dependence can cause bugs and should be avoided.
 Otherwise an exception can be added to the LocaleDependenceLinter.php linter.
 ADVICE;
 
   public function getInfoName() {
     return 'lint-locale-dependence';
   }
 
   public function getInfoURI() {
     return '';
   }
 
   public function getInfoDescription() {
     return pht('Throw an error when functions relying on the system locale '.
       'are used.');
   }
 
   public function getLinterName() {
     return 'lint-locale-dependence';
   }
 
   public function getLinterConfigurationName() {
     return 'lint-locale-dependence';
   }
 
   public function getLinterConfigurationOptions() {
     $options = array();
     return $options + parent::getLinterConfigurationOptions();
   }
 
   public function getLintSeverityMap() {
     return array(
       self::LOCALE_DEPENDENCE_ERROR => ArcanistLintSeverity::SEVERITY_ERROR,
     );
   }
 
   public function getLintNameMap() {
     return array(
       self::LOCALE_DEPENDENCE_ERROR => pht('Locale dependent function'),
     );
   }
 
   public function lintPath($path) {
     $absolutePath = Filesystem::resolvePath($path, $this->getProjectRoot());
     $fileContent = file($absolutePath, FILE_SKIP_EMPTY_LINES);
 
     // Flag if the path is part of the known exceptions
     $exceptions = array();
     if (array_key_exists($path, self::KNOWN_VIOLATIONS)) {
       $exceptions = self::KNOWN_VIOLATIONS[$path];
     }
 
     $anyFunction = implode("|", self::LOCALE_DEPENDENT_FUNCTIONS);
     $pattern = "/[^\w`'\"<>](?P<function>".$anyFunction."(_r|_s)?)[^\w`'\"<>]/";
 
     foreach ($fileContent as $lineNumber => $lineContent) {
       // Filter comments and string constants
       if (preg_match("#^\s*(//|\*|/\*|\")#", $lineContent)) {
         continue;
       }
 
       /*
        * Find the locale dependent functions occurrences.
        * There can be multiple occurrences for a single line.
        */
       if (preg_match_all($pattern, $lineContent, $matches,
         PREG_OFFSET_CAPTURE)) {
         foreach($matches["function"] as $function) {
           list($functionName, $offset) = $function;
 
           // Filter known exceptions
           if (!in_array($functionName, $exceptions)) {
             $this->raiseLintAtLine(
               $lineNumber + 1,
               $offset + 1,
               self::LOCALE_DEPENDENCE_ERROR,
               self::ADVICE_MESSAGE,
               $functionName);
           }
         }
       }
     }
   }
 }
diff --git a/src/bitcoin-tx.cpp b/src/bitcoin-tx.cpp
index 4d78d30a4..39bc42e28 100644
--- a/src/bitcoin-tx.cpp
+++ b/src/bitcoin-tx.cpp
@@ -1,905 +1,906 @@
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <chainparams.h>
 #include <clientversion.h>
 #include <coins.h>
 #include <consensus/consensus.h>
 #include <core_io.h>
 #include <key_io.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
 #include <util/moneystr.h>
 #include <util/strencodings.h>
+#include <util/string.h>
 #include <util/system.h>
 #include <util/translation.h>
 
 #include <univalue.h>
 
 #include <boost/algorithm/string.hpp>
 
 #include <cstdio>
 #include <functional>
 #include <memory>
 
 static bool fCreateBlank;
 static std::map<std::string, UniValue> registers;
 static const int CONTINUE_EXECUTION = -1;
 
 const std::function<std::string(const char *)> G_TRANSLATION_FUN = nullptr;
 
 static void SetupBitcoinTxArgs(ArgsManager &argsman) {
     SetupHelpOptions(argsman);
 
     argsman.AddArg("-create", "Create new, empty TX.", ArgsManager::ALLOW_ANY,
                    OptionsCategory::OPTIONS);
     argsman.AddArg("-json", "Select JSON output", ArgsManager::ALLOW_ANY,
                    OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-txid",
         "Output only the hex-encoded transaction id of the resultant "
         "transaction.",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     SetupChainParamsBaseOptions(argsman);
 
     argsman.AddArg("delin=N", "Delete input N from TX", ArgsManager::ALLOW_ANY,
                    OptionsCategory::COMMANDS);
     argsman.AddArg("delout=N", "Delete output N from TX",
                    ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
     argsman.AddArg("in=TXID:VOUT(:SEQUENCE_NUMBER)", "Add input to TX",
                    ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
     argsman.AddArg("locktime=N", "Set TX lock time to N",
                    ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
     argsman.AddArg("nversion=N", "Set TX version to N", ArgsManager::ALLOW_ANY,
                    OptionsCategory::COMMANDS);
     argsman.AddArg("outaddr=VALUE:ADDRESS", "Add address-based output to TX",
                    ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
     argsman.AddArg("outpubkey=VALUE:PUBKEY[:FLAGS]",
                    "Add pay-to-pubkey output to TX. "
                    "Optionally add the \"S\" flag to wrap the output in a "
                    "pay-to-script-hash.",
                    ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
     argsman.AddArg("outdata=[VALUE:]DATA", "Add data-based output to TX",
                    ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
     argsman.AddArg("outscript=VALUE:SCRIPT[:FLAGS]",
                    "Add raw script output to TX. "
                    "Optionally add the \"S\" flag to wrap the output in a "
                    "pay-to-script-hash.",
                    ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
     argsman.AddArg(
         "outmultisig=VALUE:REQUIRED:PUBKEYS:PUBKEY1:PUBKEY2:....[:FLAGS]",
         "Add Pay To n-of-m Multi-sig output to TX. n = REQUIRED, m = PUBKEYS. "
         "Optionally add the \"S\" flag to wrap the output in a "
         "pay-to-script-hash.",
         ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
     argsman.AddArg("sign=SIGHASH-FLAGS",
                    "Add zero or more signatures to transaction. "
                    "This command requires JSON registers:"
                    "prevtxs=JSON object, "
                    "privatekeys=JSON object. "
                    "See signrawtransactionwithkey docs for format of sighash "
                    "flags, JSON objects.",
                    ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
 
     argsman.AddArg("load=NAME:FILENAME",
                    "Load JSON file FILENAME into register NAME",
                    ArgsManager::ALLOW_ANY, OptionsCategory::REGISTER_COMMANDS);
     argsman.AddArg("set=NAME:JSON-STRING",
                    "Set register NAME to given JSON-STRING",
                    ArgsManager::ALLOW_ANY, OptionsCategory::REGISTER_COMMANDS);
 }
 
 //
 // This function returns either one of EXIT_ codes when it's expected to stop
 // the process or CONTINUE_EXECUTION when it's expected to continue further.
 //
 static int AppInitRawTx(int argc, char *argv[]) {
     //
     // Parameters
     //
     SetupBitcoinTxArgs(gArgs);
     std::string error;
     if (!gArgs.ParseParameters(argc, argv, error)) {
         tfm::format(std::cerr, "Error parsing command line arguments: %s\n",
                     error);
         return EXIT_FAILURE;
     }
 
     // Check for -chain, -testnet or -regtest parameter (Params() calls are only
     // valid after this clause)
     try {
         SelectParams(gArgs.GetChainName());
     } catch (const std::exception &e) {
         tfm::format(std::cerr, "Error: %s\n", e.what());
         return EXIT_FAILURE;
     }
 
     fCreateBlank = gArgs.GetBoolArg("-create", false);
 
     if (argc < 2 || HelpRequested(gArgs)) {
         // First part of help message is specific to this utility
         std::string strUsage =
             PACKAGE_NAME " bitcoin-tx utility version " + FormatFullVersion() +
             "\n\n" +
             "Usage:  bitcoin-tx [options] <hex-tx> [commands]  Update "
             "hex-encoded bitcoin transaction\n" +
             "or:     bitcoin-tx [options] -create [commands]   Create "
             "hex-encoded bitcoin transaction\n" +
             "\n";
         strUsage += gArgs.GetHelpMessage();
 
         tfm::format(std::cout, "%s", strUsage);
 
         if (argc < 2) {
             tfm::format(std::cerr, "Error: too few parameters\n");
             return EXIT_FAILURE;
         }
 
         return EXIT_SUCCESS;
     }
 
     return CONTINUE_EXECUTION;
 }
 
 static void RegisterSetJson(const std::string &key,
                             const std::string &rawJson) {
     UniValue val;
     if (!val.read(rawJson)) {
         std::string strErr = "Cannot parse JSON for key " + key;
         throw std::runtime_error(strErr);
     }
 
     registers[key] = val;
 }
 
 static void RegisterSet(const std::string &strInput) {
     // separate NAME:VALUE in string
     size_t pos = strInput.find(':');
     if ((pos == std::string::npos) || (pos == 0) ||
         (pos == (strInput.size() - 1))) {
         throw std::runtime_error("Register input requires NAME:VALUE");
     }
 
     std::string key = strInput.substr(0, pos);
     std::string valStr = strInput.substr(pos + 1, std::string::npos);
 
     RegisterSetJson(key, valStr);
 }
 
 static void RegisterLoad(const std::string &strInput) {
     // separate NAME:FILENAME in string
     size_t pos = strInput.find(':');
     if ((pos == std::string::npos) || (pos == 0) ||
         (pos == (strInput.size() - 1))) {
         throw std::runtime_error("Register load requires NAME:FILENAME");
     }
 
     std::string key = strInput.substr(0, pos);
     std::string filename = strInput.substr(pos + 1, std::string::npos);
 
     FILE *f = fopen(filename.c_str(), "r");
     if (!f) {
         std::string strErr = "Cannot open file " + filename;
         throw std::runtime_error(strErr);
     }
 
     // load file chunks into one big buffer
     std::string valStr;
     while ((!feof(f)) && (!ferror(f))) {
         char buf[4096];
         int bread = fread(buf, 1, sizeof(buf), f);
         if (bread <= 0) {
             break;
         }
 
         valStr.insert(valStr.size(), buf, bread);
     }
 
     int error = ferror(f);
     fclose(f);
 
     if (error) {
         std::string strErr = "Error reading file " + filename;
         throw std::runtime_error(strErr);
     }
 
     // evaluate as JSON buffer register
     RegisterSetJson(key, valStr);
 }
 
 static Amount ExtractAndValidateValue(const std::string &strValue) {
     Amount value;
     if (!ParseMoney(strValue, value)) {
         throw std::runtime_error("invalid TX output value");
     }
 
     return value;
 }
 
 static void MutateTxVersion(CMutableTransaction &tx,
                             const std::string &cmdVal) {
     int64_t newVersion;
     if (!ParseInt64(cmdVal, &newVersion) || newVersion < 1 ||
         newVersion > CTransaction::MAX_STANDARD_VERSION) {
         throw std::runtime_error("Invalid TX version requested: '" + cmdVal +
                                  "'");
     }
 
     tx.nVersion = int(newVersion);
 }
 
 static void MutateTxLocktime(CMutableTransaction &tx,
                              const std::string &cmdVal) {
     int64_t newLocktime;
     if (!ParseInt64(cmdVal, &newLocktime) || newLocktime < 0LL ||
         newLocktime > 0xffffffffLL) {
         throw std::runtime_error("Invalid TX locktime requested: '" + cmdVal +
                                  "'");
     }
 
     tx.nLockTime = (unsigned int)newLocktime;
 }
 
 static void MutateTxAddInput(CMutableTransaction &tx,
                              const std::string &strInput) {
     std::vector<std::string> vStrInputParts;
     boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
 
     // separate TXID:VOUT in string
     if (vStrInputParts.size() < 2) {
         throw std::runtime_error("TX input missing separator");
     }
 
     // extract and validate TXID
     uint256 hash;
     if (!ParseHashStr(vStrInputParts[0], hash)) {
         throw std::runtime_error("invalid TX input txid");
     }
 
     TxId txid(hash);
 
     static const unsigned int minTxOutSz = 9;
     static const unsigned int maxVout = MAX_TX_SIZE / minTxOutSz;
 
     // extract and validate vout
     const std::string &strVout = vStrInputParts[1];
     int64_t vout;
     if (!ParseInt64(strVout, &vout) || vout < 0 ||
         vout > static_cast<int64_t>(maxVout)) {
         throw std::runtime_error("invalid TX input vout '" + strVout + "'");
     }
 
     // extract the optional sequence number
     uint32_t nSequenceIn = std::numeric_limits<unsigned int>::max();
     if (vStrInputParts.size() > 2) {
         nSequenceIn = std::stoul(vStrInputParts[2]);
     }
 
     // append to transaction input list
     CTxIn txin(txid, vout, CScript(), nSequenceIn);
     tx.vin.push_back(txin);
 }
 
 static void MutateTxAddOutAddr(CMutableTransaction &tx,
                                const std::string &strInput,
                                const CChainParams &chainParams) {
     // Separate into VALUE:ADDRESS
     std::vector<std::string> vStrInputParts;
     boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
 
     if (vStrInputParts.size() != 2) {
         throw std::runtime_error("TX output missing or too many separators");
     }
 
     // Extract and validate VALUE
     Amount value = ExtractAndValidateValue(vStrInputParts[0]);
 
     // extract and validate ADDRESS
     std::string strAddr = vStrInputParts[1];
     CTxDestination destination = DecodeDestination(strAddr, chainParams);
     if (!IsValidDestination(destination)) {
         throw std::runtime_error("invalid TX output address");
     }
     CScript scriptPubKey = GetScriptForDestination(destination);
 
     // construct TxOut, append to transaction output list
     CTxOut txout(value, scriptPubKey);
     tx.vout.push_back(txout);
 }
 
 static void MutateTxAddOutPubKey(CMutableTransaction &tx,
                                  const std::string &strInput) {
     // Separate into VALUE:PUBKEY[:FLAGS]
     std::vector<std::string> vStrInputParts;
     boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
 
     if (vStrInputParts.size() < 2 || vStrInputParts.size() > 3) {
         throw std::runtime_error("TX output missing or too many separators");
     }
 
     // Extract and validate VALUE
     Amount value = ExtractAndValidateValue(vStrInputParts[0]);
 
     // Extract and validate PUBKEY
     CPubKey pubkey(ParseHex(vStrInputParts[1]));
     if (!pubkey.IsFullyValid()) {
         throw std::runtime_error("invalid TX output pubkey");
     }
 
     CScript scriptPubKey = GetScriptForRawPubKey(pubkey);
 
     // Extract and validate FLAGS
     bool bScriptHash = false;
     if (vStrInputParts.size() == 3) {
         std::string flags = vStrInputParts[2];
         bScriptHash = (flags.find('S') != std::string::npos);
     }
 
     if (bScriptHash) {
         // Get the ID for the script, and then construct a P2SH destination for
         // it.
         scriptPubKey = GetScriptForDestination(ScriptHash(scriptPubKey));
     }
 
     // construct TxOut, append to transaction output list
     CTxOut txout(value, scriptPubKey);
     tx.vout.push_back(txout);
 }
 
 static void MutateTxAddOutMultiSig(CMutableTransaction &tx,
                                    const std::string &strInput) {
     // Separate into VALUE:REQUIRED:NUMKEYS:PUBKEY1:PUBKEY2:....[:FLAGS]
     std::vector<std::string> vStrInputParts;
     boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
 
     // Check that there are enough parameters
     if (vStrInputParts.size() < 3) {
         throw std::runtime_error("Not enough multisig parameters");
     }
 
     // Extract and validate VALUE
     Amount value = ExtractAndValidateValue(vStrInputParts[0]);
 
     // Extract REQUIRED
     uint32_t required = stoul(vStrInputParts[1]);
 
     // Extract NUMKEYS
     uint32_t numkeys = stoul(vStrInputParts[2]);
 
     // Validate there are the correct number of pubkeys
     if (vStrInputParts.size() < numkeys + 3) {
         throw std::runtime_error("incorrect number of multisig pubkeys");
     }
 
     if (required < 1 || required > MAX_PUBKEYS_PER_MULTISIG || numkeys < 1 ||
         numkeys > MAX_PUBKEYS_PER_MULTISIG || numkeys < required) {
         throw std::runtime_error("multisig parameter mismatch. Required " +
-                                 std::to_string(required) + " of " +
-                                 std::to_string(numkeys) + "signatures.");
+                                 ToString(required) + " of " +
+                                 ToString(numkeys) + "signatures.");
     }
 
     // extract and validate PUBKEYs
     std::vector<CPubKey> pubkeys;
     for (int pos = 1; pos <= int(numkeys); pos++) {
         CPubKey pubkey(ParseHex(vStrInputParts[pos + 2]));
         if (!pubkey.IsFullyValid()) {
             throw std::runtime_error("invalid TX output pubkey");
         }
 
         pubkeys.push_back(pubkey);
     }
 
     // Extract FLAGS
     bool bScriptHash = false;
     if (vStrInputParts.size() == numkeys + 4) {
         std::string flags = vStrInputParts.back();
         bScriptHash = (flags.find('S') != std::string::npos);
     } else if (vStrInputParts.size() > numkeys + 4) {
         // Validate that there were no more parameters passed
         throw std::runtime_error("Too many parameters");
     }
 
     CScript scriptPubKey = GetScriptForMultisig(required, pubkeys);
 
     if (bScriptHash) {
         if (scriptPubKey.size() > MAX_SCRIPT_ELEMENT_SIZE) {
             throw std::runtime_error(
                 strprintf("redeemScript exceeds size limit: %d > %d",
                           scriptPubKey.size(), MAX_SCRIPT_ELEMENT_SIZE));
         }
         // Get the ID for the script, and then construct a P2SH destination for
         // it.
         scriptPubKey = GetScriptForDestination(ScriptHash(scriptPubKey));
     }
 
     // construct TxOut, append to transaction output list
     CTxOut txout(value, scriptPubKey);
     tx.vout.push_back(txout);
 }
 
 static void MutateTxAddOutData(CMutableTransaction &tx,
                                const std::string &strInput) {
     Amount value = Amount::zero();
 
     // separate [VALUE:]DATA in string
     size_t pos = strInput.find(':');
 
     if (pos == 0) {
         throw std::runtime_error("TX output value not specified");
     }
 
     if (pos != std::string::npos) {
         // Extract and validate VALUE
         value = ExtractAndValidateValue(strInput.substr(0, pos));
     }
 
     // extract and validate DATA
     std::string strData = strInput.substr(pos + 1, std::string::npos);
 
     if (!IsHex(strData)) {
         throw std::runtime_error("invalid TX output data");
     }
 
     std::vector<uint8_t> data = ParseHex(strData);
 
     CTxOut txout(value, CScript() << OP_RETURN << data);
     tx.vout.push_back(txout);
 }
 
 static void MutateTxAddOutScript(CMutableTransaction &tx,
                                  const std::string &strInput) {
     // separate VALUE:SCRIPT[:FLAGS]
     std::vector<std::string> vStrInputParts;
     boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
     if (vStrInputParts.size() < 2) {
         throw std::runtime_error("TX output missing separator");
     }
 
     // Extract and validate VALUE
     Amount value = ExtractAndValidateValue(vStrInputParts[0]);
 
     // extract and validate script
     std::string strScript = vStrInputParts[1];
     CScript scriptPubKey = ParseScript(strScript);
 
     // Extract FLAGS
     bool bScriptHash = false;
     if (vStrInputParts.size() == 3) {
         std::string flags = vStrInputParts.back();
         bScriptHash = (flags.find('S') != std::string::npos);
     }
 
     if (scriptPubKey.size() > MAX_SCRIPT_SIZE) {
         throw std::runtime_error(strprintf("script exceeds size limit: %d > %d",
                                            scriptPubKey.size(),
                                            MAX_SCRIPT_SIZE));
     }
 
     if (bScriptHash) {
         if (scriptPubKey.size() > MAX_SCRIPT_ELEMENT_SIZE) {
             throw std::runtime_error(
                 strprintf("redeemScript exceeds size limit: %d > %d",
                           scriptPubKey.size(), MAX_SCRIPT_ELEMENT_SIZE));
         }
         scriptPubKey = GetScriptForDestination(ScriptHash(scriptPubKey));
     }
 
     // construct TxOut, append to transaction output list
     CTxOut txout(value, scriptPubKey);
     tx.vout.push_back(txout);
 }
 
 static void MutateTxDelInput(CMutableTransaction &tx,
                              const std::string &strInIdx) {
     // parse requested deletion index
     int64_t inIdx;
     if (!ParseInt64(strInIdx, &inIdx) || inIdx < 0 ||
         inIdx >= static_cast<int64_t>(tx.vin.size())) {
         throw std::runtime_error("Invalid TX input index '" + strInIdx + "'");
     }
 
     // delete input from transaction
     tx.vin.erase(tx.vin.begin() + inIdx);
 }
 
 static void MutateTxDelOutput(CMutableTransaction &tx,
                               const std::string &strOutIdx) {
     // parse requested deletion index
     int64_t outIdx;
     if (!ParseInt64(strOutIdx, &outIdx) || outIdx < 0 ||
         outIdx >= static_cast<int64_t>(tx.vout.size())) {
         throw std::runtime_error("Invalid TX output index '" + strOutIdx + "'");
     }
 
     // delete output from transaction
     tx.vout.erase(tx.vout.begin() + outIdx);
 }
 
 static const unsigned int N_SIGHASH_OPTS = 12;
 static const struct {
     const char *flagStr;
     int flags;
 } sigHashOptions[N_SIGHASH_OPTS] = {
     {"ALL", SIGHASH_ALL},
     {"NONE", SIGHASH_NONE},
     {"SINGLE", SIGHASH_SINGLE},
     {"ALL|ANYONECANPAY", SIGHASH_ALL | SIGHASH_ANYONECANPAY},
     {"NONE|ANYONECANPAY", SIGHASH_NONE | SIGHASH_ANYONECANPAY},
     {"SINGLE|ANYONECANPAY", SIGHASH_SINGLE | SIGHASH_ANYONECANPAY},
     {"ALL|FORKID", SIGHASH_ALL | SIGHASH_FORKID},
     {"NONE|FORKID", SIGHASH_NONE | SIGHASH_FORKID},
     {"SINGLE|FORKID", SIGHASH_SINGLE | SIGHASH_FORKID},
     {"ALL|FORKID|ANYONECANPAY",
      SIGHASH_ALL | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
     {"NONE|FORKID|ANYONECANPAY",
      SIGHASH_NONE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
     {"SINGLE|FORKID|ANYONECANPAY",
      SIGHASH_SINGLE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
 };
 
 static bool findSigHashFlags(SigHashType &sigHashType,
                              const std::string &flagStr) {
     sigHashType = SigHashType();
 
     for (unsigned int i = 0; i < N_SIGHASH_OPTS; i++) {
         if (flagStr == sigHashOptions[i].flagStr) {
             sigHashType = SigHashType(sigHashOptions[i].flags);
             return true;
         }
     }
 
     return false;
 }
 
 static Amount AmountFromValue(const UniValue &value) {
     if (!value.isNum() && !value.isStr()) {
         throw std::runtime_error("Amount is not a number or string");
     }
 
     int64_t n;
     if (!ParseFixedPoint(value.getValStr(), 8, &n)) {
         throw std::runtime_error("Invalid amount");
     }
     Amount amount = n * SATOSHI;
 
     if (!MoneyRange(amount)) {
         throw std::runtime_error("Amount out of range");
     }
 
     return amount;
 }
 
 static void MutateTxSign(CMutableTransaction &tx, const std::string &flagStr) {
     SigHashType sigHashType = SigHashType().withForkId();
 
     if ((flagStr.size() > 0) && !findSigHashFlags(sigHashType, flagStr)) {
         throw std::runtime_error("unknown sighash flag/sign option");
     }
 
     // mergedTx will end up with all the signatures; it
     // starts as a clone of the raw tx:
     CMutableTransaction mergedTx{tx};
     const CMutableTransaction txv{tx};
 
     CCoinsView viewDummy;
     CCoinsViewCache view(&viewDummy);
 
     if (!registers.count("privatekeys")) {
         throw std::runtime_error("privatekeys register variable must be set.");
     }
 
     FillableSigningProvider tempKeystore;
     UniValue keysObj = registers["privatekeys"];
 
     for (unsigned int kidx = 0; kidx < keysObj.size(); kidx++) {
         if (!keysObj[kidx].isStr()) {
             throw std::runtime_error("privatekey not a std::string");
         }
 
         CKey key = DecodeSecret(keysObj[kidx].getValStr());
         if (!key.IsValid()) {
             throw std::runtime_error("privatekey not valid");
         }
         tempKeystore.AddKey(key);
     }
 
     // Add previous txouts given in the RPC call:
     if (!registers.count("prevtxs")) {
         throw std::runtime_error("prevtxs register variable must be set.");
     }
 
     UniValue prevtxsObj = registers["prevtxs"];
 
     for (unsigned int previdx = 0; previdx < prevtxsObj.size(); previdx++) {
         UniValue prevOut = prevtxsObj[previdx];
         if (!prevOut.isObject()) {
             throw std::runtime_error("expected prevtxs internal object");
         }
 
         std::map<std::string, UniValue::VType> types = {
             {"txid", UniValue::VSTR},
             {"vout", UniValue::VNUM},
             {"scriptPubKey", UniValue::VSTR}};
         if (!prevOut.checkObject(types)) {
             throw std::runtime_error("prevtxs internal object typecheck fail");
         }
 
         uint256 hash;
         if (!ParseHashStr(prevOut["txid"].get_str(), hash)) {
             throw std::runtime_error("txid must be hexadecimal string (not '" +
                                      prevOut["txid"].get_str() + "')");
         }
 
         TxId txid(hash);
 
         const int nOut = prevOut["vout"].get_int();
         if (nOut < 0) {
             throw std::runtime_error("vout must be positive");
         }
 
         COutPoint out(txid, nOut);
         std::vector<uint8_t> pkData(
             ParseHexUV(prevOut["scriptPubKey"], "scriptPubKey"));
         CScript scriptPubKey(pkData.begin(), pkData.end());
 
         {
             const Coin &coin = view.AccessCoin(out);
             if (!coin.IsSpent() &&
                 coin.GetTxOut().scriptPubKey != scriptPubKey) {
                 std::string err("Previous output scriptPubKey mismatch:\n");
                 err = err + ScriptToAsmStr(coin.GetTxOut().scriptPubKey) +
                       "\nvs:\n" + ScriptToAsmStr(scriptPubKey);
                 throw std::runtime_error(err);
             }
 
             CTxOut txout;
             txout.scriptPubKey = scriptPubKey;
             txout.nValue = Amount::zero();
             if (prevOut.exists("amount")) {
                 txout.nValue = AmountFromValue(prevOut["amount"]);
             }
 
             view.AddCoin(out, Coin(txout, 1, false), true);
         }
 
         // If redeemScript given and private keys given, add redeemScript to the
         // tempKeystore so it can be signed:
         if (scriptPubKey.IsPayToScriptHash() &&
             prevOut.exists("redeemScript")) {
             UniValue v = prevOut["redeemScript"];
             std::vector<uint8_t> rsData(ParseHexUV(v, "redeemScript"));
             CScript redeemScript(rsData.begin(), rsData.end());
             tempKeystore.AddCScript(redeemScript);
         }
     }
 
     const FillableSigningProvider &keystore = tempKeystore;
 
     // Sign what we can:
     for (size_t i = 0; i < mergedTx.vin.size(); i++) {
         CTxIn &txin = mergedTx.vin[i];
         const Coin &coin = view.AccessCoin(txin.prevout);
         if (coin.IsSpent()) {
             continue;
         }
 
         const CScript &prevPubKey = coin.GetTxOut().scriptPubKey;
         const Amount amount = coin.GetTxOut().nValue;
 
         SignatureData sigdata =
             DataFromTransaction(mergedTx, i, coin.GetTxOut());
         // Only sign SIGHASH_SINGLE if there's a corresponding output:
         if ((sigHashType.getBaseType() != BaseSigHashType::SINGLE) ||
             (i < mergedTx.vout.size())) {
             ProduceSignature(keystore,
                              MutableTransactionSignatureCreator(
                                  &mergedTx, i, amount, sigHashType),
                              prevPubKey, sigdata);
         }
 
         UpdateInput(txin, sigdata);
     }
 
     tx = mergedTx;
 }
 
 class Secp256k1Init {
     ECCVerifyHandle globalVerifyHandle;
 
 public:
     Secp256k1Init() { ECC_Start(); }
     ~Secp256k1Init() { ECC_Stop(); }
 };
 
 static void MutateTx(CMutableTransaction &tx, const std::string &command,
                      const std::string &commandVal,
                      const CChainParams &chainParams) {
     std::unique_ptr<Secp256k1Init> ecc;
 
     if (command == "nversion") {
         MutateTxVersion(tx, commandVal);
     } else if (command == "locktime") {
         MutateTxLocktime(tx, commandVal);
     } else if (command == "delin") {
         MutateTxDelInput(tx, commandVal);
     } else if (command == "in") {
         MutateTxAddInput(tx, commandVal);
     } else if (command == "delout") {
         MutateTxDelOutput(tx, commandVal);
     } else if (command == "outaddr") {
         MutateTxAddOutAddr(tx, commandVal, chainParams);
     } else if (command == "outpubkey") {
         ecc.reset(new Secp256k1Init());
         MutateTxAddOutPubKey(tx, commandVal);
     } else if (command == "outmultisig") {
         ecc.reset(new Secp256k1Init());
         MutateTxAddOutMultiSig(tx, commandVal);
     } else if (command == "outscript") {
         MutateTxAddOutScript(tx, commandVal);
     } else if (command == "outdata") {
         MutateTxAddOutData(tx, commandVal);
     } else if (command == "sign") {
         ecc.reset(new Secp256k1Init());
         MutateTxSign(tx, commandVal);
     } else if (command == "load") {
         RegisterLoad(commandVal);
     } else if (command == "set") {
         RegisterSet(commandVal);
     } else {
         throw std::runtime_error("unknown command");
     }
 }
 
 static void OutputTxJSON(const CTransaction &tx) {
     UniValue entry(UniValue::VOBJ);
     TxToUniv(tx, uint256(), entry);
 
     std::string jsonOutput = entry.write(4);
     tfm::format(std::cout, "%s\n", jsonOutput);
 }
 
 static void OutputTxHash(const CTransaction &tx) {
     // the hex-encoded transaction id.
     std::string strHexHash = tx.GetId().GetHex();
 
     tfm::format(std::cout, "%s\n", strHexHash);
 }
 
 static void OutputTxHex(const CTransaction &tx) {
     std::string strHex = EncodeHexTx(tx);
 
     tfm::format(std::cout, "%s\n", strHex);
 }
 
 static void OutputTx(const CTransaction &tx) {
     if (gArgs.GetBoolArg("-json", false)) {
         OutputTxJSON(tx);
     } else if (gArgs.GetBoolArg("-txid", false)) {
         OutputTxHash(tx);
     } else {
         OutputTxHex(tx);
     }
 }
 
 static std::string readStdin() {
     char buf[4096];
     std::string ret;
 
     while (!feof(stdin)) {
         size_t bread = fread(buf, 1, sizeof(buf), stdin);
         ret.append(buf, bread);
         if (bread < sizeof(buf)) {
             break;
         }
     }
 
     if (ferror(stdin)) {
         throw std::runtime_error("error reading stdin");
     }
 
     boost::algorithm::trim_right(ret);
 
     return ret;
 }
 
 static int CommandLineRawTx(int argc, char *argv[],
                             const CChainParams &chainParams) {
     std::string strPrint;
     int nRet = 0;
     try {
         // Skip switches; Permit common stdin convention "-"
         while (argc > 1 && IsSwitchChar(argv[1][0]) && (argv[1][1] != 0)) {
             argc--;
             argv++;
         }
 
         CMutableTransaction tx;
         int startArg;
 
         if (!fCreateBlank) {
             // require at least one param
             if (argc < 2) {
                 throw std::runtime_error("too few parameters");
             }
 
             // param: hex-encoded bitcoin transaction
             std::string strHexTx(argv[1]);
 
             // "-" implies standard input
             if (strHexTx == "-") {
                 strHexTx = readStdin();
             }
 
             if (!DecodeHexTx(tx, strHexTx)) {
                 throw std::runtime_error("invalid transaction encoding");
             }
 
             startArg = 2;
         } else {
             startArg = 1;
         }
 
         for (int i = startArg; i < argc; i++) {
             std::string arg = argv[i];
             std::string key, value;
             size_t eqpos = arg.find('=');
             if (eqpos == std::string::npos) {
                 key = arg;
             } else {
                 key = arg.substr(0, eqpos);
                 value = arg.substr(eqpos + 1);
             }
 
             MutateTx(tx, key, value, chainParams);
         }
 
         OutputTx(CTransaction(tx));
     } catch (const std::exception &e) {
         strPrint = std::string("error: ") + e.what();
         nRet = EXIT_FAILURE;
     } catch (...) {
         PrintExceptionContinue(nullptr, "CommandLineRawTx()");
         throw;
     }
 
     if (strPrint != "") {
         tfm::format(nRet == 0 ? std::cout : std::cerr, "%s\n", strPrint);
     }
 
     return nRet;
 }
 
 int main(int argc, char *argv[]) {
     SetupEnvironment();
 
     try {
         int ret = AppInitRawTx(argc, argv);
         if (ret != CONTINUE_EXECUTION) {
             return ret;
         }
     } catch (const std::exception &e) {
         PrintExceptionContinue(&e, "AppInitRawTx()");
         return EXIT_FAILURE;
     } catch (...) {
         PrintExceptionContinue(nullptr, "AppInitRawTx()");
         return EXIT_FAILURE;
     }
 
     int ret = EXIT_FAILURE;
     try {
         ret = CommandLineRawTx(argc, argv, Params());
     } catch (const std::exception &e) {
         PrintExceptionContinue(&e, "CommandLineRawTx()");
     } catch (...) {
         PrintExceptionContinue(nullptr, "CommandLineRawTx()");
     }
 
     return ret;
 }
diff --git a/src/core_read.cpp b/src/core_read.cpp
index 4b68c68d1..8bb0b5b2b 100644
--- a/src/core_read.cpp
+++ b/src/core_read.cpp
@@ -1,285 +1,285 @@
 // 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 <core_io.h>
 
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <psbt.h>
 #include <script/script.h>
 #include <script/sign.h>
 #include <serialize.h>
 #include <streams.h>
 #include <util/strencodings.h>
+#include <util/string.h>
 #include <version.h>
 
 #include <univalue.h>
 
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/split.hpp>
 
 #include <algorithm>
 
 CScript ParseScript(const std::string &s) {
     CScript result;
 
     static std::map<std::string, opcodetype> mapOpNames;
 
     if (mapOpNames.empty()) {
         for (int op = 0; op < FIRST_UNDEFINED_OP_VALUE; op++) {
             if (op < OP_PUSHDATA1) {
                 continue;
             }
 
             const char *name = GetOpName(static_cast<opcodetype>(op));
             if (strcmp(name, "OP_UNKNOWN") == 0) {
                 continue;
             }
 
             std::string strName(name);
             mapOpNames[strName] = static_cast<opcodetype>(op);
             // Convenience: OP_ADD and just ADD are both recognized:
             boost::algorithm::replace_first(strName, "OP_", "");
             mapOpNames[strName] = static_cast<opcodetype>(op);
         }
     }
 
     std::vector<std::string> words;
     boost::algorithm::split(words, s, boost::algorithm::is_any_of(" \t\n"),
                             boost::algorithm::token_compress_on);
 
     size_t push_size = 0, next_push_size = 0;
     size_t script_size = 0;
     // Deal with PUSHDATA1 operation with some more hacks.
     size_t push_data_size = 0;
 
     for (const auto &w : words) {
         if (w.empty()) {
             // Empty string, ignore. (boost::split given '' will return one
             // word)
             continue;
         }
 
         // Update script size.
         script_size = result.size();
 
         // Make sure we keep track of the size of push operations.
         push_size = next_push_size;
         next_push_size = 0;
 
         // Decimal numbers
         if (std::all_of(w.begin(), w.end(), ::IsDigit) ||
             (w.front() == '-' && w.size() > 1 &&
              std::all_of(w.begin() + 1, w.end(), ::IsDigit))) {
             // Number
             int64_t n = atoi64(w);
             result << n;
             goto next;
         }
 
         // Hex Data
         if (w.substr(0, 2) == "0x" && w.size() > 2) {
             if (!IsHex(std::string(w.begin() + 2, w.end()))) {
                 // Should only arrive here for improperly formatted hex values
                 throw std::runtime_error("Hex numbers expected to be formatted "
                                          "in full-byte chunks (ex: 0x00 "
                                          "instead of 0x0)");
             }
 
             // Raw hex data, inserted NOT pushed onto stack:
             std::vector<uint8_t> raw =
                 ParseHex(std::string(w.begin() + 2, w.end()));
 
             result.insert(result.end(), raw.begin(), raw.end());
             goto next;
         }
 
         if (w.size() >= 2 && w.front() == '\'' && w.back() == '\'') {
             // Single-quoted string, pushed as data. NOTE: this is poor-man's
             // parsing, spaces/tabs/newlines in single-quoted strings won't
             // work.
             std::vector<uint8_t> value(w.begin() + 1, w.end() - 1);
             result << value;
             goto next;
         }
 
         if (mapOpNames.count(w)) {
             // opcode, e.g. OP_ADD or ADD:
             opcodetype op = mapOpNames[w];
 
             result << op;
             goto next;
         }
 
         throw std::runtime_error("Error parsing script: " + s);
 
     next:
         size_t size_change = result.size() - script_size;
 
         // If push_size is set, ensure have added the right amount of stuff.
         if (push_size != 0 && size_change != push_size) {
             throw std::runtime_error(
                 "Wrong number of bytes being pushed. Expected:" +
-                std::to_string(push_size) +
-                " Pushed:" + std::to_string(size_change));
+                ToString(push_size) + " Pushed:" + ToString(size_change));
         }
 
         // If push_size is set, and we have push_data_size set, then we have a
         // PUSHDATAX opcode.  We need to read it's push size as a LE value for
         // the next iteration of this loop.
         if (push_size != 0 && push_data_size != 0) {
             auto offset = &result[script_size];
 
             // Push data size is not a CScriptNum (Because it is
             // 2's-complement instead of 1's complement).  We need to use
             // ReadLE(N) instead of converting to a CScriptNum.
             if (push_data_size == 1) {
                 next_push_size = *offset;
             } else if (push_data_size == 2) {
                 next_push_size = ReadLE16(offset);
             } else if (push_data_size == 4) {
                 next_push_size = ReadLE32(offset);
             }
 
             push_data_size = 0;
         }
 
         // If push_size is unset, but size_change is 1, that means we have an
         // opcode in the form of `0x00` or <opcodename>.  We will check to see
         // if it is a push operation and set state accordingly
         if (push_size == 0 && size_change == 1) {
             opcodetype op = opcodetype(*result.rbegin());
 
             // If we have what looks like an immediate push, figure out its
             // size.
             if (op < OP_PUSHDATA1) {
                 next_push_size = op;
                 continue;
             }
 
             switch (op) {
                 case OP_PUSHDATA1:
                     push_data_size = next_push_size = 1;
                     break;
                 case OP_PUSHDATA2:
                     push_data_size = next_push_size = 2;
                     break;
                 case OP_PUSHDATA4:
                     push_data_size = next_push_size = 4;
                     break;
                 default:
                     break;
             }
         }
     }
 
     return result;
 }
 
 bool DecodeHexTx(CMutableTransaction &tx, const std::string &strHexTx) {
     if (!IsHex(strHexTx)) {
         return false;
     }
 
     std::vector<uint8_t> txData(ParseHex(strHexTx));
 
     CDataStream ssData(txData, SER_NETWORK, PROTOCOL_VERSION);
     try {
         ssData >> tx;
         if (ssData.eof()) {
             return true;
         }
     } catch (const std::exception &e) {
         // Fall through.
     }
 
     return false;
 }
 
 bool DecodeHexBlockHeader(CBlockHeader &header, const std::string &hex_header) {
     if (!IsHex(hex_header)) {
         return false;
     }
 
     const std::vector<uint8_t> header_data{ParseHex(hex_header)};
     CDataStream ser_header(header_data, SER_NETWORK, PROTOCOL_VERSION);
     try {
         ser_header >> header;
     } catch (const std::exception &) {
         return false;
     }
     return true;
 }
 
 bool DecodeHexBlk(CBlock &block, const std::string &strHexBlk) {
     if (!IsHex(strHexBlk)) {
         return false;
     }
 
     std::vector<uint8_t> blockData(ParseHex(strHexBlk));
     CDataStream ssBlock(blockData, SER_NETWORK, PROTOCOL_VERSION);
     try {
         ssBlock >> block;
     } catch (const std::exception &) {
         return false;
     }
 
     return true;
 }
 
 bool ParseHashStr(const std::string &strHex, uint256 &result) {
     if ((strHex.size() != 64) || !IsHex(strHex)) {
         return false;
     }
 
     result.SetHex(strHex);
     return true;
 }
 
 std::vector<uint8_t> ParseHexUV(const UniValue &v, const std::string &strName) {
     std::string strHex;
     if (v.isStr()) {
         strHex = v.getValStr();
     }
 
     if (!IsHex(strHex)) {
         throw std::runtime_error(
             strName + " must be hexadecimal string (not '" + strHex + "')");
     }
 
     return ParseHex(strHex);
 }
 
 SigHashType ParseSighashString(const UniValue &sighash) {
     SigHashType sigHashType = SigHashType().withForkId();
     if (!sighash.isNull()) {
         static std::map<std::string, int> map_sighash_values = {
             {"ALL", SIGHASH_ALL},
             {"ALL|ANYONECANPAY", SIGHASH_ALL | SIGHASH_ANYONECANPAY},
             {"ALL|FORKID", SIGHASH_ALL | SIGHASH_FORKID},
             {"ALL|FORKID|ANYONECANPAY",
              SIGHASH_ALL | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
             {"NONE", SIGHASH_NONE},
             {"NONE|ANYONECANPAY", SIGHASH_NONE | SIGHASH_ANYONECANPAY},
             {"NONE|FORKID", SIGHASH_NONE | SIGHASH_FORKID},
             {"NONE|FORKID|ANYONECANPAY",
              SIGHASH_NONE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
             {"SINGLE", SIGHASH_SINGLE},
             {"SINGLE|ANYONECANPAY", SIGHASH_SINGLE | SIGHASH_ANYONECANPAY},
             {"SINGLE|FORKID", SIGHASH_SINGLE | SIGHASH_FORKID},
             {"SINGLE|FORKID|ANYONECANPAY",
              SIGHASH_SINGLE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
         };
         std::string strHashType = sighash.get_str();
         const auto &it = map_sighash_values.find(strHashType);
         if (it != map_sighash_values.end()) {
             sigHashType = SigHashType(it->second);
         } else {
             throw std::runtime_error(strHashType +
                                      " is not a valid sighash parameter.");
         }
     }
     return sigHashType;
 }
diff --git a/src/qt/optionsmodel.cpp b/src/qt/optionsmodel.cpp
index faff48bf0..0f8a403a5 100644
--- a/src/qt/optionsmodel.cpp
+++ b/src/qt/optionsmodel.cpp
@@ -1,586 +1,587 @@
 // Copyright (c) 2011-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.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/optionsmodel.h>
 
 #include <interfaces/node.h>
 #include <net.h>
 #include <netbase.h>
 #include <qt/bitcoinunits.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #include <qt/intro.h>
-#include <txdb.h>       // for -dbcache defaults
+#include <txdb.h> // for -dbcache defaults
+#include <util/string.h>
 #include <validation.h> // For DEFAULT_SCRIPTCHECK_THREADS
 
 #include <QNetworkProxy>
 #include <QSettings>
 #include <QStringList>
 
 const char *DEFAULT_GUI_PROXY_HOST = "127.0.0.1";
 
 static const QString GetDefaultProxyAddress();
 
 OptionsModel::OptionsModel(QObject *parent, bool resetSettings)
     : QAbstractListModel(parent) {
     Init(resetSettings);
 }
 
 void OptionsModel::addOverriddenOption(const std::string &option) {
     strOverriddenByCommandLine +=
         QString::fromStdString(option) + "=" +
         QString::fromStdString(gArgs.GetArg(option, "")) + " ";
 }
 
 // Writes all missing QSettings with their default values
 void OptionsModel::Init(bool resetSettings) {
     if (resetSettings) {
         Reset();
     }
 
     checkAndMigrate();
 
     QSettings settings;
 
     // Ensure restart flag is unset on client startup
     setRestartRequired(false);
 
     // These are Qt-only settings:
 
     // Window
     if (!settings.contains("fHideTrayIcon")) {
         settings.setValue("fHideTrayIcon", false);
     }
     fHideTrayIcon = settings.value("fHideTrayIcon").toBool();
     Q_EMIT hideTrayIconChanged(fHideTrayIcon);
 
     if (!settings.contains("fMinimizeToTray")) {
         settings.setValue("fMinimizeToTray", false);
     }
     fMinimizeToTray =
         settings.value("fMinimizeToTray").toBool() && !fHideTrayIcon;
 
     if (!settings.contains("fMinimizeOnClose")) {
         settings.setValue("fMinimizeOnClose", false);
     }
     fMinimizeOnClose = settings.value("fMinimizeOnClose").toBool();
 
     // Display
     if (!settings.contains("nDisplayUnit")) {
         settings.setValue("nDisplayUnit", BitcoinUnits::BCH);
     }
     nDisplayUnit = settings.value("nDisplayUnit").toInt();
 
     if (!settings.contains("strThirdPartyTxUrls")) {
         settings.setValue("strThirdPartyTxUrls", "");
     }
     strThirdPartyTxUrls = settings.value("strThirdPartyTxUrls", "").toString();
 
     if (!settings.contains("fCoinControlFeatures")) {
         settings.setValue("fCoinControlFeatures", false);
     }
     fCoinControlFeatures =
         settings.value("fCoinControlFeatures", false).toBool();
 
     // These are shared with the core or have a command-line parameter
     // and we want command-line parameters to overwrite the GUI settings.
     //
     // If setting doesn't exist create it with defaults.
     //
     // If gArgs.SoftSetArg() or gArgs.SoftSetBoolArg() return false we were
     // overridden
     // by command-line and show this in the UI.
 
     // Main
     if (!settings.contains("bPrune")) {
         settings.setValue("bPrune", false);
     }
     if (!settings.contains("nPruneSize")) {
         settings.setValue("nPruneSize", 2);
     }
     SetPrune(settings.value("bPrune").toBool());
 
     if (!settings.contains("nDatabaseCache")) {
         settings.setValue("nDatabaseCache", (qint64)DEFAULT_DB_CACHE_MB);
     }
     if (!gArgs.SoftSetArg(
             "-dbcache",
             settings.value("nDatabaseCache").toString().toStdString())) {
         addOverriddenOption("-dbcache");
     }
 
     if (!settings.contains("nThreadsScriptVerif")) {
         settings.setValue("nThreadsScriptVerif", DEFAULT_SCRIPTCHECK_THREADS);
     }
     if (!gArgs.SoftSetArg(
             "-par",
             settings.value("nThreadsScriptVerif").toString().toStdString())) {
         addOverriddenOption("-par");
     }
 
     if (!settings.contains("strDataDir")) {
         settings.setValue("strDataDir", Intro::getDefaultDataDirectory());
     }
 
 // Wallet
 #ifdef ENABLE_WALLET
     if (!settings.contains("bSpendZeroConfChange")) {
         settings.setValue("bSpendZeroConfChange", true);
     }
     if (!gArgs.SoftSetBoolArg(
             "-spendzeroconfchange",
             settings.value("bSpendZeroConfChange").toBool())) {
         addOverriddenOption("-spendzeroconfchange");
     }
 #endif
 
     // Network
     if (!settings.contains("fUseUPnP")) {
         settings.setValue("fUseUPnP", DEFAULT_UPNP);
     }
     if (!gArgs.SoftSetBoolArg("-upnp", settings.value("fUseUPnP").toBool())) {
         addOverriddenOption("-upnp");
     }
 
     if (!settings.contains("fListen")) {
         settings.setValue("fListen", DEFAULT_LISTEN);
     }
     if (!gArgs.SoftSetBoolArg("-listen", settings.value("fListen").toBool())) {
         addOverriddenOption("-listen");
     }
 
     if (!settings.contains("fUseProxy")) {
         settings.setValue("fUseProxy", false);
     }
     if (!settings.contains("addrProxy")) {
         settings.setValue("addrProxy", GetDefaultProxyAddress());
     }
     // Only try to set -proxy, if user has enabled fUseProxy
     if (settings.value("fUseProxy").toBool() &&
         !gArgs.SoftSetArg(
             "-proxy", settings.value("addrProxy").toString().toStdString())) {
         addOverriddenOption("-proxy");
     } else if (!settings.value("fUseProxy").toBool() &&
                !gArgs.GetArg("-proxy", "").empty()) {
         addOverriddenOption("-proxy");
     }
 
     if (!settings.contains("fUseSeparateProxyTor")) {
         settings.setValue("fUseSeparateProxyTor", false);
     }
     if (!settings.contains("addrSeparateProxyTor")) {
         settings.setValue("addrSeparateProxyTor", GetDefaultProxyAddress());
     }
     // Only try to set -onion, if user has enabled fUseSeparateProxyTor
     if (settings.value("fUseSeparateProxyTor").toBool() &&
         !gArgs.SoftSetArg(
             "-onion",
             settings.value("addrSeparateProxyTor").toString().toStdString())) {
         addOverriddenOption("-onion");
     } else if (!settings.value("fUseSeparateProxyTor").toBool() &&
                !gArgs.GetArg("-onion", "").empty()) {
         addOverriddenOption("-onion");
     }
 
     // Display
     if (!settings.contains("language")) {
         settings.setValue("language", "");
     }
     if (!gArgs.SoftSetArg(
             "-lang", settings.value("language").toString().toStdString())) {
         addOverriddenOption("-lang");
     }
 
     language = settings.value("language").toString();
 }
 
 /**
  * Helper function to copy contents from one QSettings to another.
  * By using allKeys this also covers nested settings in a hierarchy.
  */
 static void CopySettings(QSettings &dst, const QSettings &src) {
     for (const QString &key : src.allKeys()) {
         dst.setValue(key, src.value(key));
     }
 }
 
 /** Back up a QSettings to an ini-formatted file. */
 static void BackupSettings(const fs::path &filename, const QSettings &src) {
     qInfo() << "Backing up GUI settings to"
             << GUIUtil::boostPathToQString(filename);
     QSettings dst(GUIUtil::boostPathToQString(filename), QSettings::IniFormat);
     dst.clear();
     CopySettings(dst, src);
 }
 
 void OptionsModel::Reset() {
     QSettings settings;
 
     // Backup old settings to chain-specific datadir for troubleshooting
     BackupSettings(GetDataDir(true) / "guisettings.ini.bak", settings);
 
     // Save the strDataDir setting
     QString dataDir = Intro::getDefaultDataDirectory();
     dataDir = settings.value("strDataDir", dataDir).toString();
 
     // Remove all entries from our QSettings object
     settings.clear();
 
     // Set strDataDir
     settings.setValue("strDataDir", dataDir);
 
     // Set that this was reset
     settings.setValue("fReset", true);
 
     // default setting for OptionsModel::StartAtStartup - disabled
     if (GUIUtil::GetStartOnSystemStartup()) {
         GUIUtil::SetStartOnSystemStartup(false);
     }
 }
 
 int OptionsModel::rowCount(const QModelIndex &parent) const {
     return OptionIDRowCount;
 }
 
 struct ProxySetting {
     bool is_set;
     QString ip;
     QString port;
 };
 
 static ProxySetting GetProxySetting(QSettings &settings, const QString &name) {
     static const ProxySetting default_val = {
         false, DEFAULT_GUI_PROXY_HOST,
         QString("%1").arg(DEFAULT_GUI_PROXY_PORT)};
     // Handle the case that the setting is not set at all
     if (!settings.contains(name)) {
         return default_val;
     }
     // contains IP at index 0 and port at index 1
     QStringList ip_port =
         GUIUtil::splitSkipEmptyParts(settings.value(name).toString(), ":");
     if (ip_port.size() == 2) {
         return {true, ip_port.at(0), ip_port.at(1)};
     } else { // Invalid: return default
         return default_val;
     }
 }
 
 static void SetProxySetting(QSettings &settings, const QString &name,
                             const ProxySetting &ip_port) {
     settings.setValue(name, ip_port.ip + ":" + ip_port.port);
 }
 
 static const QString GetDefaultProxyAddress() {
     return QString("%1:%2")
         .arg(DEFAULT_GUI_PROXY_HOST)
         .arg(DEFAULT_GUI_PROXY_PORT);
 }
 
 void OptionsModel::SetPrune(bool prune, bool force) {
     QSettings settings;
     settings.setValue("bPrune", prune);
     // Convert prune size from GB to MiB:
     const uint64_t nPruneSizeMiB =
         (settings.value("nPruneSize").toInt() * GB_BYTES) >> 20;
-    std::string prune_val = prune ? std::to_string(nPruneSizeMiB) : "0";
+    std::string prune_val = prune ? ToString(nPruneSizeMiB) : "0";
     if (force) {
         gArgs.ForceSetArg("-prune", prune_val);
         return;
     }
     if (!gArgs.SoftSetArg("-prune", prune_val)) {
         addOverriddenOption("-prune");
     }
 }
 
 // read QSettings values and return them
 QVariant OptionsModel::data(const QModelIndex &index, int role) const {
     if (role == Qt::EditRole) {
         QSettings settings;
         switch (index.row()) {
             case StartAtStartup:
                 return GUIUtil::GetStartOnSystemStartup();
             case HideTrayIcon:
                 return fHideTrayIcon;
             case MinimizeToTray:
                 return fMinimizeToTray;
             case MapPortUPnP:
 #ifdef USE_UPNP
                 return settings.value("fUseUPnP");
 #else
                 return false;
 #endif
             case MinimizeOnClose:
                 return fMinimizeOnClose;
 
             // default proxy
             case ProxyUse:
                 return settings.value("fUseProxy", false);
             case ProxyIP:
                 return GetProxySetting(settings, "addrProxy").ip;
             case ProxyPort:
                 return GetProxySetting(settings, "addrProxy").port;
 
             // separate Tor proxy
             case ProxyUseTor:
                 return settings.value("fUseSeparateProxyTor", false);
             case ProxyIPTor:
                 return GetProxySetting(settings, "addrSeparateProxyTor").ip;
             case ProxyPortTor:
                 return GetProxySetting(settings, "addrSeparateProxyTor").port;
 
 #ifdef ENABLE_WALLET
             case SpendZeroConfChange:
                 return settings.value("bSpendZeroConfChange");
 #endif
             case DisplayUnit:
                 return nDisplayUnit;
             case ThirdPartyTxUrls:
                 return strThirdPartyTxUrls;
             case Language:
                 return settings.value("language");
             case CoinControlFeatures:
                 return fCoinControlFeatures;
             case Prune:
                 return settings.value("bPrune");
             case PruneSize:
                 return settings.value("nPruneSize");
             case DatabaseCache:
                 return settings.value("nDatabaseCache");
             case ThreadsScriptVerif:
                 return settings.value("nThreadsScriptVerif");
             case Listen:
                 return settings.value("fListen");
             default:
                 return QVariant();
         }
     }
     return QVariant();
 }
 
 // write QSettings values
 bool OptionsModel::setData(const QModelIndex &index, const QVariant &value,
                            int role) {
     bool successful = true; /* set to false on parse error */
     if (role == Qt::EditRole) {
         QSettings settings;
         switch (index.row()) {
             case StartAtStartup:
                 successful = GUIUtil::SetStartOnSystemStartup(value.toBool());
                 break;
             case HideTrayIcon:
                 fHideTrayIcon = value.toBool();
                 settings.setValue("fHideTrayIcon", fHideTrayIcon);
                 Q_EMIT hideTrayIconChanged(fHideTrayIcon);
                 break;
             case MinimizeToTray:
                 fMinimizeToTray = value.toBool();
                 settings.setValue("fMinimizeToTray", fMinimizeToTray);
                 break;
             case MapPortUPnP: // core option - can be changed on-the-fly
                 settings.setValue("fUseUPnP", value.toBool());
                 node().mapPort(value.toBool());
                 break;
             case MinimizeOnClose:
                 fMinimizeOnClose = value.toBool();
                 settings.setValue("fMinimizeOnClose", fMinimizeOnClose);
                 break;
 
             // default proxy
             case ProxyUse:
                 if (settings.value("fUseProxy") != value) {
                     settings.setValue("fUseProxy", value.toBool());
                     setRestartRequired(true);
                 }
                 break;
             case ProxyIP: {
                 auto ip_port = GetProxySetting(settings, "addrProxy");
                 if (!ip_port.is_set || ip_port.ip != value.toString()) {
                     ip_port.ip = value.toString();
                     SetProxySetting(settings, "addrProxy", ip_port);
                     setRestartRequired(true);
                 }
             } break;
             case ProxyPort: {
                 auto ip_port = GetProxySetting(settings, "addrProxy");
                 if (!ip_port.is_set || ip_port.port != value.toString()) {
                     ip_port.port = value.toString();
                     SetProxySetting(settings, "addrProxy", ip_port);
                     setRestartRequired(true);
                 }
             } break;
 
             // separate Tor proxy
             case ProxyUseTor:
                 if (settings.value("fUseSeparateProxyTor") != value) {
                     settings.setValue("fUseSeparateProxyTor", value.toBool());
                     setRestartRequired(true);
                 }
                 break;
             case ProxyIPTor: {
                 auto ip_port =
                     GetProxySetting(settings, "addrSeparateProxyTor");
                 if (!ip_port.is_set || ip_port.ip != value.toString()) {
                     ip_port.ip = value.toString();
                     SetProxySetting(settings, "addrSeparateProxyTor", ip_port);
                     setRestartRequired(true);
                 }
             } break;
             case ProxyPortTor: {
                 auto ip_port =
                     GetProxySetting(settings, "addrSeparateProxyTor");
                 if (!ip_port.is_set || ip_port.port != value.toString()) {
                     ip_port.port = value.toString();
                     SetProxySetting(settings, "addrSeparateProxyTor", ip_port);
                     setRestartRequired(true);
                 }
             } break;
 
 #ifdef ENABLE_WALLET
             case SpendZeroConfChange:
                 if (settings.value("bSpendZeroConfChange") != value) {
                     settings.setValue("bSpendZeroConfChange", value);
                     setRestartRequired(true);
                 }
                 break;
 #endif
             case DisplayUnit:
                 setDisplayUnit(value);
                 break;
             case ThirdPartyTxUrls:
                 if (strThirdPartyTxUrls != value.toString()) {
                     strThirdPartyTxUrls = value.toString();
                     settings.setValue("strThirdPartyTxUrls",
                                       strThirdPartyTxUrls);
                     setRestartRequired(true);
                 }
                 break;
             case Language:
                 if (settings.value("language") != value) {
                     settings.setValue("language", value);
                     setRestartRequired(true);
                 }
                 break;
             case CoinControlFeatures:
                 fCoinControlFeatures = value.toBool();
                 settings.setValue("fCoinControlFeatures", fCoinControlFeatures);
                 Q_EMIT coinControlFeaturesChanged(fCoinControlFeatures);
                 break;
             case Prune:
                 if (settings.value("bPrune") != value) {
                     settings.setValue("bPrune", value);
                     setRestartRequired(true);
                 }
                 break;
             case PruneSize:
                 if (settings.value("nPruneSize") != value) {
                     settings.setValue("nPruneSize", value);
                     setRestartRequired(true);
                 }
                 break;
             case DatabaseCache:
                 if (settings.value("nDatabaseCache") != value) {
                     settings.setValue("nDatabaseCache", value);
                     setRestartRequired(true);
                 }
                 break;
             case ThreadsScriptVerif:
                 if (settings.value("nThreadsScriptVerif") != value) {
                     settings.setValue("nThreadsScriptVerif", value);
                     setRestartRequired(true);
                 }
                 break;
             case Listen:
                 if (settings.value("fListen") != value) {
                     settings.setValue("fListen", value);
                     setRestartRequired(true);
                 }
                 break;
             default:
                 break;
         }
     }
 
     Q_EMIT dataChanged(index, index);
 
     return successful;
 }
 
 /** Updates current unit in memory, settings and emits
  * displayUnitChanged(newUnit) signal */
 void OptionsModel::setDisplayUnit(const QVariant &value) {
     if (!value.isNull()) {
         QSettings settings;
         nDisplayUnit = value.toInt();
         settings.setValue("nDisplayUnit", nDisplayUnit);
         Q_EMIT displayUnitChanged(nDisplayUnit);
     }
 }
 
 bool OptionsModel::getProxySettings(QNetworkProxy &proxy) const {
     // Directly query current base proxy, because
     // GUI settings can be overridden with -proxy.
     proxyType curProxy;
     if (node().getProxy(NET_IPV4, curProxy)) {
         proxy.setType(QNetworkProxy::Socks5Proxy);
         proxy.setHostName(QString::fromStdString(curProxy.proxy.ToStringIP()));
         proxy.setPort(curProxy.proxy.GetPort());
 
         return true;
     } else {
         proxy.setType(QNetworkProxy::NoProxy);
     }
 
     return false;
 }
 
 void OptionsModel::setRestartRequired(bool fRequired) {
     QSettings settings;
     return settings.setValue("fRestartRequired", fRequired);
 }
 
 bool OptionsModel::isRestartRequired() const {
     QSettings settings;
     return settings.value("fRestartRequired", false).toBool();
 }
 
 void OptionsModel::checkAndMigrate() {
     // Migration of default values
     // Check if the QSettings container was already loaded with this client
     // version
     QSettings settings;
     static const char strSettingsVersionKey[] = "nSettingsVersion";
     int settingsVersion = settings.contains(strSettingsVersionKey)
                               ? settings.value(strSettingsVersionKey).toInt()
                               : 0;
     if (settingsVersion < CLIENT_VERSION) {
         // -dbcache was bumped from 100 to 300 in 0.13
         // see https://github.com/bitcoin/bitcoin/pull/8273
         // force people to upgrade to the new value if they are using 100MB
         if (settingsVersion < 130000 && settings.contains("nDatabaseCache") &&
             settings.value("nDatabaseCache").toLongLong() == 100) {
             settings.setValue("nDatabaseCache", (qint64)DEFAULT_DB_CACHE_MB);
         }
 
         settings.setValue(strSettingsVersionKey, CLIENT_VERSION);
     }
 
     // Overwrite the 'addrProxy' setting in case it has been set to an illegal
     // default value (see issue #12623; PR #12650).
     if (settings.contains("addrProxy") &&
         settings.value("addrProxy").toString().endsWith("%2")) {
         settings.setValue("addrProxy", GetDefaultProxyAddress());
     }
 
     // Overwrite the 'addrSeparateProxyTor' setting in case it has been set to
     // an illegal default value (see issue #12623; PR #12650).
     if (settings.contains("addrSeparateProxyTor") &&
         settings.value("addrSeparateProxyTor").toString().endsWith("%2")) {
         settings.setValue("addrSeparateProxyTor", GetDefaultProxyAddress());
     }
 }
diff --git a/src/rpc/abc.cpp b/src/rpc/abc.cpp
index 28ba8d55e..8d52d2ddf 100644
--- a/src/rpc/abc.cpp
+++ b/src/rpc/abc.cpp
@@ -1,95 +1,96 @@
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <config.h>
 #include <consensus/consensus.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <sync.h>
 #include <util/strencodings.h>
+#include <util/string.h>
 #include <validation.h>
 
 #include <univalue.h>
 
 static UniValue getexcessiveblock(const Config &config,
                                   const JSONRPCRequest &request) {
     RPCHelpMan{
         "getexcessiveblock",
         "Return the excessive block size.",
         {},
         RPCResult{RPCResult::Type::NUM, "", "excessive block size in bytes"},
         RPCExamples{HelpExampleCli("getexcessiveblock", "") +
                     HelpExampleRpc("getexcessiveblock", "")},
     }
         .Check(request);
 
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("excessiveBlockSize", config.GetMaxBlockSize());
     return ret;
 }
 
 static UniValue setexcessiveblock(Config &config,
                                   const JSONRPCRequest &request) {
     RPCHelpMan{
         "setexcessiveblock",
         "Set the excessive block size. Excessive blocks will not be used in "
         "the active chain or relayed. This discourages the propagation of "
         "blocks that you consider excessively large.",
         {
             {"blockSize", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "Excessive block size in bytes.  Must be greater than " +
-                 std::to_string(LEGACY_MAX_BLOCK_SIZE) + "."},
+                 ToString(LEGACY_MAX_BLOCK_SIZE) + "."},
         },
         RPCResult{RPCResult::Type::NUM, "", "excessive block size in bytes"},
         RPCExamples{HelpExampleCli("setexcessiveblock", "25000000") +
                     HelpExampleRpc("setexcessiveblock", "25000000")},
     }
         .Check(request);
 
     if (!request.params[0].isNum()) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             std::string(
                 "Invalid parameter, excessiveblock must be an integer"));
     }
 
     int64_t ebs = request.params[0].get_int64();
 
     // Do not allow maxBlockSize to be set below historic 1MB limit
     if (ebs <= int64_t(LEGACY_MAX_BLOCK_SIZE)) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             std::string(
                 "Invalid parameter, excessiveblock must be larger than ") +
-                std::to_string(LEGACY_MAX_BLOCK_SIZE));
+                ToString(LEGACY_MAX_BLOCK_SIZE));
     }
 
     // Set the new max block size.
     {
         LOCK(cs_main);
         if (!config.SetMaxBlockSize(ebs)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Unexpected error");
         }
     }
 
     // settingsToUserAgentString();
     std::ostringstream ret;
     ret << "Excessive Block set to " << ebs << " bytes.";
     return UniValue(ret.str());
 }
 
 void RegisterABCRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            name                      actor (function)        argNames
         //  ------------------- ------------------------  ----------------------  ----------
         { "network",            "getexcessiveblock",      getexcessiveblock,      {}},
         { "network",            "setexcessiveblock",      setexcessiveblock,      {"maxBlockSize"}},
     };
     // clang-format on
 
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index e4990a807..60f1ef54e 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -1,997 +1,998 @@
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <rpc/server.h>
 
 #include <banman.h>
 #include <clientversion.h>
 #include <config.h>
 #include <core_io.h>
 #include <net.h>
 #include <net_permissions.h>
 #include <net_processing.h>
 #include <net_types.h> // For banmap_t
 #include <netbase.h>
 #include <network.h>
 #include <node/context.h>
 #include <policy/settings.h>
 #include <rpc/blockchain.h>
 #include <rpc/protocol.h>
 #include <rpc/util.h>
 #include <sync.h>
 #include <timedata.h>
 #include <util/strencodings.h>
+#include <util/string.h>
 #include <util/system.h>
 #include <validation.h>
 #include <version.h>
 #include <warnings.h>
 
 #include <univalue.h>
 
 static UniValue getconnectioncount(const Config &config,
                                    const JSONRPCRequest &request) {
     RPCHelpMan{
         "getconnectioncount",
         "Returns the number of connections to other nodes.\n",
         {},
         RPCResult{RPCResult::Type::NUM, "", "The connection count"},
         RPCExamples{HelpExampleCli("getconnectioncount", "") +
                     HelpExampleRpc("getconnectioncount", "")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     return int(node.connman->GetNodeCount(CConnman::CONNECTIONS_ALL));
 }
 
 static UniValue ping(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "ping",
         "Requests that a ping be sent to all other nodes, to measure ping "
         "time.\n"
         "Results provided in getpeerinfo, pingtime and pingwait fields are "
         "decimal seconds.\n"
         "Ping command is handled in queue with all other commands, so it "
         "measures processing backlog, not just network ping.\n",
         {},
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("ping", "") + HelpExampleRpc("ping", "")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     // Request that each node send a ping during next message processing pass
     node.connman->ForEachNode([](CNode *pnode) { pnode->fPingQueued = true; });
     return NullUniValue;
 }
 
 static UniValue getpeerinfo(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "getpeerinfo",
         "Returns data about each connected network node as a json array of "
         "objects.\n",
         {},
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {{
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {{
                     {RPCResult::Type::NUM, "id", "Peer index"},
                     {RPCResult::Type::STR, "addr",
                      "(host:port) The IP address and port of the peer"},
                     {RPCResult::Type::STR, "addrbind",
                      "(ip:port) Bind address of the connection to the peer"},
                     {RPCResult::Type::STR, "addrlocal",
                      "(ip:port) Local address as reported by the peer"},
                     {RPCResult::Type::NUM, "mapped_as",
                      "The AS in the BGP route to the peer used for "
                      "diversifying\n"
                      "peer selection (only available if the asmap config flag "
                      "is set)\n"},
                     {RPCResult::Type::STR_HEX, "services",
                      "The services offered"},
                     {RPCResult::Type::ARR,
                      "servicesnames",
                      "the services offered, in human-readable form",
                      {{RPCResult::Type::STR, "SERVICE_NAME",
                        "the service name if it is recognised"}}},
                     {RPCResult::Type::BOOL, "relaytxes",
                      "Whether peer has asked us to relay transactions to it"},
                     {RPCResult::Type::NUM_TIME, "lastsend",
                      "The " + UNIX_EPOCH_TIME + " of the last send"},
                     {RPCResult::Type::NUM_TIME, "lastrecv",
                      "The " + UNIX_EPOCH_TIME + " of the last receive"},
                     {RPCResult::Type::NUM, "bytessent", "The total bytes sent"},
                     {RPCResult::Type::NUM, "bytesrecv",
                      "The total bytes received"},
                     {RPCResult::Type::NUM_TIME, "conntime",
                      "The " + UNIX_EPOCH_TIME + " of the connection"},
                     {RPCResult::Type::NUM, "timeoffset",
                      "The time offset in seconds"},
                     {RPCResult::Type::NUM, "pingtime",
                      "ping time (if available)"},
                     {RPCResult::Type::NUM, "minping",
                      "minimum observed ping time (if any at all)"},
                     {RPCResult::Type::NUM, "pingwait",
                      "ping wait (if non-zero)"},
                     {RPCResult::Type::NUM, "version",
                      "The peer version, such as 70001"},
                     {RPCResult::Type::STR, "subver", "The string version"},
                     {RPCResult::Type::BOOL, "inbound",
                      "Inbound (true) or Outbound (false)"},
                     {RPCResult::Type::BOOL, "addnode",
                      "Whether connection was due to addnode/-connect or if it "
                      "was an automatic/inbound connection"},
                     {RPCResult::Type::NUM, "startingheight",
                      "The starting height (block) of the peer"},
                     {RPCResult::Type::NUM, "banscore",
                      "The ban score (DEPRECATED, returned only if config "
                      "option -deprecatedrpc=banscore is passed)"},
                     {RPCResult::Type::NUM, "synced_headers",
                      "The last header we have in common with this peer"},
                     {RPCResult::Type::NUM, "synced_blocks",
                      "The last block we have in common with this peer"},
                     {RPCResult::Type::ARR,
                      "inflight",
                      "",
                      {
                          {RPCResult::Type::NUM, "n",
                           "The heights of blocks we're currently asking from "
                           "this peer"},
                      }},
                     {RPCResult::Type::BOOL, "whitelisted",
                      "Whether the peer is whitelisted"},
                     {RPCResult::Type::NUM, "minfeefilter",
                      "The minimum fee rate for transactions this peer accepts"},
                     {RPCResult::Type::OBJ_DYN,
                      "bytessent_per_msg",
                      "",
                      {{RPCResult::Type::NUM, "msg",
                        "The total bytes sent aggregated by message type\n"
                        "When a message type is not listed in this json object, "
                        "the bytes sent are 0.\n"
                        "Only known message types can appear as keys in the "
                        "object."}}},
                     {RPCResult::Type::OBJ,
                      "bytesrecv_per_msg",
                      "",
                      {{RPCResult::Type::NUM, "msg",
                        "The total bytes received aggregated by message type\n"
                        "When a message type is not listed in this json object, "
                        "the bytes received are 0.\n"
                        "Only known message types can appear as keys in the "
                        "object and all bytes received of unknown message types "
                        "are listed under '" +
                            NET_MESSAGE_COMMAND_OTHER + "'."}}},
                 }},
             }},
         },
         RPCExamples{HelpExampleCli("getpeerinfo", "") +
                     HelpExampleRpc("getpeerinfo", "")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     std::vector<CNodeStats> vstats;
     node.connman->GetNodeStats(vstats);
 
     UniValue ret(UniValue::VARR);
 
     for (const CNodeStats &stats : vstats) {
         UniValue obj(UniValue::VOBJ);
         CNodeStateStats statestats;
         bool fStateStats = GetNodeStateStats(stats.nodeid, statestats);
         obj.pushKV("id", stats.nodeid);
         obj.pushKV("addr", stats.addrName);
         if (!(stats.addrLocal.empty())) {
             obj.pushKV("addrlocal", stats.addrLocal);
         }
         if (stats.addrBind.IsValid()) {
             obj.pushKV("addrbind", stats.addrBind.ToString());
         }
         if (stats.m_mapped_as != 0) {
             obj.pushKV("mapped_as", uint64_t(stats.m_mapped_as));
         }
         obj.pushKV("services", strprintf("%016x", stats.nServices));
         obj.pushKV("servicesnames", GetServicesNames(stats.nServices));
         obj.pushKV("relaytxes", stats.fRelayTxes);
         obj.pushKV("lastsend", stats.nLastSend);
         obj.pushKV("lastrecv", stats.nLastRecv);
         obj.pushKV("bytessent", stats.nSendBytes);
         obj.pushKV("bytesrecv", stats.nRecvBytes);
         obj.pushKV("conntime", stats.nTimeConnected);
         obj.pushKV("timeoffset", stats.nTimeOffset);
         if (stats.m_ping_usec > 0) {
             obj.pushKV("pingtime", double(stats.m_ping_usec) / 1e6);
         }
         if (stats.m_min_ping_usec < std::numeric_limits<int64_t>::max()) {
             obj.pushKV("minping", double(stats.m_min_ping_usec) / 1e6);
         }
         if (stats.m_ping_wait_usec > 0) {
             obj.pushKV("pingwait", double(stats.m_ping_wait_usec) / 1e6);
         }
         obj.pushKV("version", stats.nVersion);
         // Use the sanitized form of subver here, to avoid tricksy remote peers
         // from corrupting or modifying the JSON output by putting special
         // characters in their ver message.
         obj.pushKV("subver", stats.cleanSubVer);
         obj.pushKV("inbound", stats.fInbound);
         obj.pushKV("addnode", stats.m_manual_connection);
         obj.pushKV("startingheight", stats.nStartingHeight);
         if (fStateStats) {
             if (IsDeprecatedRPCEnabled(gArgs, "banscore")) {
                 // banscore is deprecated in v0.22.11 for removal in v0.23
                 obj.pushKV("banscore", statestats.m_misbehavior_score);
             }
             obj.pushKV("synced_headers", statestats.nSyncHeight);
             obj.pushKV("synced_blocks", statestats.nCommonHeight);
             UniValue heights(UniValue::VARR);
             for (const int height : statestats.vHeightInFlight) {
                 heights.push_back(height);
             }
             obj.pushKV("inflight", heights);
         }
         obj.pushKV("whitelisted", stats.m_legacyWhitelisted);
         UniValue permissions(UniValue::VARR);
         for (const auto &permission :
              NetPermissions::ToStrings(stats.m_permissionFlags)) {
             permissions.push_back(permission);
         }
         obj.pushKV("permissions", permissions);
         obj.pushKV("minfeefilter", ValueFromAmount(stats.minFeeFilter));
 
         UniValue sendPerMsgCmd(UniValue::VOBJ);
         for (const auto &i : stats.mapSendBytesPerMsgCmd) {
             if (i.second > 0) {
                 sendPerMsgCmd.pushKV(i.first, i.second);
             }
         }
         obj.pushKV("bytessent_per_msg", sendPerMsgCmd);
 
         UniValue recvPerMsgCmd(UniValue::VOBJ);
         for (const auto &i : stats.mapRecvBytesPerMsgCmd) {
             if (i.second > 0) {
                 recvPerMsgCmd.pushKV(i.first, i.second);
             }
         }
         obj.pushKV("bytesrecv_per_msg", recvPerMsgCmd);
 
         ret.push_back(obj);
     }
 
     return ret;
 }
 
 static UniValue addnode(const Config &config, const JSONRPCRequest &request) {
     std::string strCommand;
     if (!request.params[1].isNull()) {
         strCommand = request.params[1].get_str();
     }
 
     if (request.fHelp || request.params.size() != 2 ||
         (strCommand != "onetry" && strCommand != "add" &&
          strCommand != "remove")) {
         throw std::runtime_error(RPCHelpMan{
             "addnode",
             "Attempts to add or remove a node from the addnode list.\n"
             "Or try a connection to a node once.\n"
             "Nodes added using addnode (or -connect) are protected from "
             "DoS disconnection and are not required to be\n"
             "full nodes as other outbound peers are (though such peers "
             "will not be synced from).\n",
             {
                 {"node", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The node (see getpeerinfo for nodes)"},
                 {"command", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "'add' to add a node to the list, 'remove' to remove a "
                  "node from the list, 'onetry' to try a connection to the "
                  "node once"},
             },
             RPCResult{RPCResult::Type::NONE, "", ""},
             RPCExamples{
                 HelpExampleCli("addnode", "\"192.168.0.6:8333\" \"onetry\"") +
                 HelpExampleRpc("addnode", "\"192.168.0.6:8333\", \"onetry\"")},
         }
                                      .ToString());
     }
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     std::string strNode = request.params[0].get_str();
 
     if (strCommand == "onetry") {
         CAddress addr;
         node.connman->OpenNetworkConnection(
             addr, false, nullptr, strNode.c_str(), ConnectionType::MANUAL);
         return NullUniValue;
     }
 
     if ((strCommand == "add") && (!node.connman->AddNode(strNode))) {
         throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED,
                            "Error: Node already added");
     } else if ((strCommand == "remove") &&
                (!node.connman->RemoveAddedNode(strNode))) {
         throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED,
                            "Error: Node has not been added.");
     }
 
     return NullUniValue;
 }
 
 static UniValue disconnectnode(const Config &config,
                                const JSONRPCRequest &request) {
     RPCHelpMan{
         "disconnectnode",
         "Immediately disconnects from the specified peer node.\n"
         "\nStrictly one out of 'address' and 'nodeid' can be provided to "
         "identify the node.\n"
         "\nTo disconnect by nodeid, either set 'address' to the empty string, "
         "or call using the named 'nodeid' argument only.\n",
         {
             {"address", RPCArg::Type::STR,
              /* default */ "fallback to nodeid",
              "The IP address/port of the node"},
             {"nodeid", RPCArg::Type::NUM,
              /* default */ "fallback to address",
              "The node ID (see getpeerinfo for node IDs)"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("disconnectnode", "\"192.168.0.6:8333\"") +
                     HelpExampleCli("disconnectnode", "\"\" 1") +
                     HelpExampleRpc("disconnectnode", "\"192.168.0.6:8333\"") +
                     HelpExampleRpc("disconnectnode", "\"\", 1")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     bool success;
     const UniValue &address_arg = request.params[0];
     const UniValue &id_arg = request.params[1];
 
     if (!address_arg.isNull() && id_arg.isNull()) {
         /* handle disconnect-by-address */
         success = node.connman->DisconnectNode(address_arg.get_str());
     } else if (!id_arg.isNull() &&
                (address_arg.isNull() ||
                 (address_arg.isStr() && address_arg.get_str().empty()))) {
         /* handle disconnect-by-id */
         NodeId nodeid = (NodeId)id_arg.get_int64();
         success = node.connman->DisconnectNode(nodeid);
     } else {
         throw JSONRPCError(
             RPC_INVALID_PARAMS,
             "Only one of address and nodeid should be provided.");
     }
 
     if (!success) {
         throw JSONRPCError(RPC_CLIENT_NODE_NOT_CONNECTED,
                            "Node not found in connected nodes");
     }
 
     return NullUniValue;
 }
 
 static UniValue getaddednodeinfo(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "getaddednodeinfo",
         "Returns information about the given added node, or all added nodes\n"
         "(note that onetry addnodes are not listed here)\n",
         {
             {"node", RPCArg::Type::STR, /* default */ "all nodes",
              "If provided, return information about this specific node, "
              "otherwise all nodes are returned."},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "",
                  "",
                  {
                      {RPCResult::Type::STR, "addednode",
                       "The node IP address or name (as provided to addnode)"},
                      {RPCResult::Type::BOOL, "connected", "If connected"},
                      {RPCResult::Type::ARR,
                       "addresses",
                       "Only when connected = true",
                       {
                           {RPCResult::Type::OBJ,
                            "",
                            "",
                            {
                                {RPCResult::Type::STR, "address",
                                 "The bitcoin server IP and port we're "
                                 "connected to"},
                                {RPCResult::Type::STR, "connected",
                                 "connection, inbound or outbound"},
                            }},
                       }},
                  }},
             }},
         RPCExamples{HelpExampleCli("getaddednodeinfo", "\"192.168.0.201\"") +
                     HelpExampleRpc("getaddednodeinfo", "\"192.168.0.201\"")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     std::vector<AddedNodeInfo> vInfo = node.connman->GetAddedNodeInfo();
 
     if (!request.params[0].isNull()) {
         bool found = false;
         for (const AddedNodeInfo &info : vInfo) {
             if (info.strAddedNode == request.params[0].get_str()) {
                 vInfo.assign(1, info);
                 found = true;
                 break;
             }
         }
         if (!found) {
             throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED,
                                "Error: Node has not been added.");
         }
     }
 
     UniValue ret(UniValue::VARR);
 
     for (const AddedNodeInfo &info : vInfo) {
         UniValue obj(UniValue::VOBJ);
         obj.pushKV("addednode", info.strAddedNode);
         obj.pushKV("connected", info.fConnected);
         UniValue addresses(UniValue::VARR);
         if (info.fConnected) {
             UniValue address(UniValue::VOBJ);
             address.pushKV("address", info.resolvedAddress.ToString());
             address.pushKV("connected", info.fInbound ? "inbound" : "outbound");
             addresses.push_back(address);
         }
         obj.pushKV("addresses", addresses);
         ret.push_back(obj);
     }
 
     return ret;
 }
 
 static UniValue getnettotals(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "getnettotals",
         "Returns information about network traffic, including bytes in, "
         "bytes out,\n"
         "and current time.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "totalbytesrecv",
                  "Total bytes received"},
                 {RPCResult::Type::NUM, "totalbytessent", "Total bytes sent"},
                 {RPCResult::Type::NUM_TIME, "timemillis",
                  "Current UNIX time in milliseconds"},
                 {RPCResult::Type::OBJ,
                  "uploadtarget",
                  "",
                  {
                      {RPCResult::Type::NUM, "timeframe",
                       "Length of the measuring timeframe in seconds"},
                      {RPCResult::Type::NUM, "target", "Target in bytes"},
                      {RPCResult::Type::BOOL, "target_reached",
                       "True if target is reached"},
                      {RPCResult::Type::BOOL, "serve_historical_blocks",
                       "True if serving historical blocks"},
                      {RPCResult::Type::NUM, "bytes_left_in_cycle",
                       "Bytes left in current time cycle"},
                      {RPCResult::Type::NUM, "time_left_in_cycle",
                       "Seconds left in current time cycle"},
                  }},
             }},
         RPCExamples{HelpExampleCli("getnettotals", "") +
                     HelpExampleRpc("getnettotals", "")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("totalbytesrecv", node.connman->GetTotalBytesRecv());
     obj.pushKV("totalbytessent", node.connman->GetTotalBytesSent());
     obj.pushKV("timemillis", GetTimeMillis());
 
     UniValue outboundLimit(UniValue::VOBJ);
     outboundLimit.pushKV("timeframe", node.connman->GetMaxOutboundTimeframe());
     outboundLimit.pushKV("target", node.connman->GetMaxOutboundTarget());
     outboundLimit.pushKV("target_reached",
                          node.connman->OutboundTargetReached(false));
     outboundLimit.pushKV("serve_historical_blocks",
                          !node.connman->OutboundTargetReached(true));
     outboundLimit.pushKV("bytes_left_in_cycle",
                          node.connman->GetOutboundTargetBytesLeft());
     outboundLimit.pushKV("time_left_in_cycle",
                          node.connman->GetMaxOutboundTimeLeftInCycle());
     obj.pushKV("uploadtarget", outboundLimit);
     return obj;
 }
 
 static UniValue GetNetworksInfo() {
     UniValue networks(UniValue::VARR);
     for (int n = 0; n < NET_MAX; ++n) {
         enum Network network = static_cast<enum Network>(n);
         if (network == NET_UNROUTABLE || network == NET_INTERNAL) {
             continue;
         }
         proxyType proxy;
         UniValue obj(UniValue::VOBJ);
         GetProxy(network, proxy);
         obj.pushKV("name", GetNetworkName(network));
         obj.pushKV("limited", !IsReachable(network));
         obj.pushKV("reachable", IsReachable(network));
         obj.pushKV("proxy", proxy.IsValid() ? proxy.proxy.ToStringIPPort()
                                             : std::string());
         obj.pushKV("proxy_randomize_credentials", proxy.randomize_credentials);
         networks.push_back(obj);
     }
     return networks;
 }
 
 static UniValue getnetworkinfo(const Config &config,
                                const JSONRPCRequest &request) {
     RPCHelpMan{
         "getnetworkinfo",
         "Returns an object containing various state info regarding P2P "
         "networking.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "version", "the server version"},
                 {RPCResult::Type::STR, "subversion",
                  "the server subversion string"},
                 {RPCResult::Type::NUM, "protocolversion",
                  "the protocol version"},
                 {RPCResult::Type::STR_HEX, "localservices",
                  "the services we offer to the network"},
                 {RPCResult::Type::ARR,
                  "localservicesnames",
                  "the services we offer to the network, in human-readable form",
                  {
                      {RPCResult::Type::STR, "SERVICE_NAME", "the service name"},
                  }},
                 {RPCResult::Type::BOOL, "localrelay",
                  "true if transaction relay is requested from peers"},
                 {RPCResult::Type::NUM, "timeoffset", "the time offset"},
                 {RPCResult::Type::NUM, "connections",
                  "the number of connections"},
                 {RPCResult::Type::BOOL, "networkactive",
                  "whether p2p networking is enabled"},
                 {RPCResult::Type::ARR,
                  "networks",
                  "information per network",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR, "name",
                            "network (ipv4, ipv6 or onion)"},
                           {RPCResult::Type::BOOL, "limited",
                            "is the network limited using -onlynet?"},
                           {RPCResult::Type::BOOL, "reachable",
                            "is the network reachable?"},
                           {RPCResult::Type::STR, "proxy",
                            "(\"host:port\") the proxy that is used for this "
                            "network, or empty if none"},
                           {RPCResult::Type::BOOL, "proxy_randomize_credentials",
                            "Whether randomized credentials are used"},
                       }},
                  }},
                 {RPCResult::Type::NUM, "relayfee",
                  "minimum relay fee for transactions in " + CURRENCY_UNIT +
                      "/kB"},
                 {RPCResult::Type::NUM, "excessutxocharge",
                  "minimum charge for excess utxos in " + CURRENCY_UNIT},
                 {RPCResult::Type::ARR,
                  "localaddresses",
                  "list of local addresses",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR, "address", "network address"},
                           {RPCResult::Type::NUM, "port", "network port"},
                           {RPCResult::Type::NUM, "score", "relative score"},
                       }},
                  }},
                 {RPCResult::Type::STR, "warnings",
                  "any network and blockchain warnings"},
             }},
         RPCExamples{HelpExampleCli("getnetworkinfo", "") +
                     HelpExampleRpc("getnetworkinfo", "")},
     }
         .Check(request);
 
     LOCK(cs_main);
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("version", CLIENT_VERSION);
     obj.pushKV("subversion", userAgent(config));
     obj.pushKV("protocolversion", PROTOCOL_VERSION);
     NodeContext &node = EnsureNodeContext(request.context);
     if (node.connman) {
         ServiceFlags services = node.connman->GetLocalServices();
         obj.pushKV("localservices", strprintf("%016x", services));
         obj.pushKV("localservicesnames", GetServicesNames(services));
     }
     obj.pushKV("localrelay", g_relay_txes);
     obj.pushKV("timeoffset", GetTimeOffset());
     if (node.connman) {
         obj.pushKV("networkactive", node.connman->GetNetworkActive());
         obj.pushKV("connections",
                    int(node.connman->GetNodeCount(CConnman::CONNECTIONS_ALL)));
     }
     obj.pushKV("networks", GetNetworksInfo());
     obj.pushKV("relayfee", ValueFromAmount(::minRelayTxFee.GetFeePerK()));
     obj.pushKV("excessutxocharge",
                ValueFromAmount(config.GetExcessUTXOCharge()));
     UniValue localAddresses(UniValue::VARR);
     {
         LOCK(cs_mapLocalHost);
         for (const std::pair<const CNetAddr, LocalServiceInfo> &item :
              mapLocalHost) {
             UniValue rec(UniValue::VOBJ);
             rec.pushKV("address", item.first.ToString());
             rec.pushKV("port", item.second.nPort);
             rec.pushKV("score", item.second.nScore);
             localAddresses.push_back(rec);
         }
     }
     obj.pushKV("localaddresses", localAddresses);
     obj.pushKV("warnings", GetWarnings(false));
     return obj;
 }
 
 static UniValue setban(const Config &config, const JSONRPCRequest &request) {
     const RPCHelpMan help{
         "setban",
         "Attempts to add or remove an IP/Subnet from the banned list.\n",
         {
             {"subnet", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The IP/Subnet (see getpeerinfo for nodes IP) with an optional "
              "netmask (default is /32 = single IP)"},
             {"command", RPCArg::Type::STR, RPCArg::Optional::NO,
              "'add' to add an IP/Subnet to the list, 'remove' to remove an "
              "IP/Subnet from the list"},
             {"bantime", RPCArg::Type::NUM, /* default */ "0",
              "time in seconds how long (or until when if [absolute] is set) "
              "the IP is banned (0 or empty means using the default time of 24h "
              "which can also be overwritten by the -bantime startup argument)"},
             {"absolute", RPCArg::Type::BOOL, /* default */ "false",
              "If set, the bantime must be an absolute timestamp expressed in " +
                  UNIX_EPOCH_TIME},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{
             HelpExampleCli("setban", "\"192.168.0.6\" \"add\" 86400") +
             HelpExampleCli("setban", "\"192.168.0.0/24\" \"add\"") +
             HelpExampleRpc("setban", "\"192.168.0.6\", \"add\", 86400")},
     };
 
     std::string strCommand;
     if (!request.params[1].isNull()) {
         strCommand = request.params[1].get_str();
     }
 
     if (request.fHelp || !help.IsValidNumArgs(request.params.size()) ||
         (strCommand != "add" && strCommand != "remove")) {
         throw std::runtime_error(help.ToString());
     }
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.banman) {
         throw JSONRPCError(RPC_DATABASE_ERROR,
                            "Error: Ban database not loaded");
     }
 
     CSubNet subNet;
     CNetAddr netAddr;
     bool isSubnet = false;
 
     if (request.params[0].get_str().find('/') != std::string::npos) {
         isSubnet = true;
     }
 
     if (!isSubnet) {
         CNetAddr resolved;
         LookupHost(request.params[0].get_str(), resolved, false);
         netAddr = resolved;
     } else {
         LookupSubNet(request.params[0].get_str(), subNet);
     }
 
     if (!(isSubnet ? subNet.IsValid() : netAddr.IsValid())) {
         throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET,
                            "Error: Invalid IP/Subnet");
     }
 
     if (strCommand == "add") {
         if (isSubnet ? node.banman->IsBanned(subNet)
                      : node.banman->IsBanned(netAddr)) {
             throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED,
                                "Error: IP/Subnet already banned");
         }
 
         // Use standard bantime if not specified.
         int64_t banTime = 0;
         if (!request.params[2].isNull()) {
             banTime = request.params[2].get_int64();
         }
 
         bool absolute = false;
         if (request.params[3].isTrue()) {
             absolute = true;
         }
 
         if (isSubnet) {
             node.banman->Ban(subNet, banTime, absolute);
             if (node.connman) {
                 node.connman->DisconnectNode(subNet);
             }
         } else {
             node.banman->Ban(netAddr, banTime, absolute);
             if (node.connman) {
                 node.connman->DisconnectNode(netAddr);
             }
         }
     } else if (strCommand == "remove") {
         if (!(isSubnet ? node.banman->Unban(subNet)
                        : node.banman->Unban(netAddr))) {
             throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET,
                                "Error: Unban failed. Requested address/subnet "
                                "was not previously manually banned.");
         }
     }
     return NullUniValue;
 }
 
 static UniValue listbanned(const Config &config,
                            const JSONRPCRequest &request) {
     RPCHelpMan{
         "listbanned",
         "List all manually banned IPs/Subnets.\n",
         {},
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::OBJ,
                        "",
                        "",
                        {
                            {RPCResult::Type::STR, "address", ""},
                            {RPCResult::Type::NUM_TIME, "banned_until", ""},
                            {RPCResult::Type::NUM_TIME, "ban_created", ""},
                            {RPCResult::Type::STR, "ban_reason", ""},
                        }},
                   }},
         RPCExamples{HelpExampleCli("listbanned", "") +
                     HelpExampleRpc("listbanned", "")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.banman) {
         throw JSONRPCError(RPC_DATABASE_ERROR,
                            "Error: Ban database not loaded");
     }
 
     banmap_t banMap;
     node.banman->GetBanned(banMap);
 
     UniValue bannedAddresses(UniValue::VARR);
     for (const auto &entry : banMap) {
         const CBanEntry &banEntry = entry.second;
         UniValue rec(UniValue::VOBJ);
         rec.pushKV("address", entry.first.ToString());
         rec.pushKV("banned_until", banEntry.nBanUntil);
         rec.pushKV("ban_created", banEntry.nCreateTime);
 
         bannedAddresses.push_back(rec);
     }
 
     return bannedAddresses;
 }
 
 static UniValue clearbanned(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "clearbanned",
         "Clear all banned IPs.\n",
         {},
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("clearbanned", "") +
                     HelpExampleRpc("clearbanned", "")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.banman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     node.banman->ClearBanned();
 
     return NullUniValue;
 }
 
 static UniValue setnetworkactive(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "setnetworkactive",
         "Disable/enable all p2p network activity.\n",
         {
             {"state", RPCArg::Type::BOOL, RPCArg::Optional::NO,
              "true to enable networking, false to disable"},
         },
         RPCResult{RPCResult::Type::BOOL, "", "The value that was passed in"},
         RPCExamples{""},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.banman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     node.connman->SetNetworkActive(request.params[0].get_bool());
 
     return node.connman->GetNetworkActive();
 }
 
 static UniValue getnodeaddresses(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "getnodeaddresses",
         "Return known addresses which can potentially be used to find new "
         "nodes in the network\n",
         {
             {"count", RPCArg::Type::NUM, /* default */ "1",
              "How many addresses to return. Limited to the smaller of " +
-                 std::to_string(ADDRMAN_GETADDR_MAX) + " or " +
-                 std::to_string(ADDRMAN_GETADDR_MAX_PCT) +
+                 ToString(ADDRMAN_GETADDR_MAX) + " or " +
+                 ToString(ADDRMAN_GETADDR_MAX_PCT) +
                  "% of all known addresses."},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "",
                  "",
                  {
                      {RPCResult::Type::NUM_TIME, "time",
                       "The " + UNIX_EPOCH_TIME +
                           " of when the node was last seen"},
                      {RPCResult::Type::NUM, "services", "The services offered"},
                      {RPCResult::Type::STR, "address",
                       "The address of the node"},
                      {RPCResult::Type::NUM, "port", "The port of the node"},
                  }},
             }},
         RPCExamples{HelpExampleCli("getnodeaddresses", "8") +
                     HelpExampleRpc("getnodeaddresses", "8")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.banman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     int count = 1;
     if (!request.params[0].isNull()) {
         count = request.params[0].get_int();
         if (count <= 0) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Address count out of range");
         }
     }
     // returns a shuffled list of CAddress
     std::vector<CAddress> vAddr = node.connman->GetAddresses();
     UniValue ret(UniValue::VARR);
 
     int address_return_count = std::min<int>(count, vAddr.size());
     for (int i = 0; i < address_return_count; ++i) {
         UniValue obj(UniValue::VOBJ);
         const CAddress &addr = vAddr[i];
         obj.pushKV("time", int(addr.nTime));
         obj.pushKV("services", uint64_t(addr.nServices));
         obj.pushKV("address", addr.ToStringIP());
         obj.pushKV("port", addr.GetPort());
         ret.push_back(obj);
     }
     return ret;
 }
 
 void RegisterNetRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            name                      actor (function)        argNames
         //  ------------------- ------------------------  ----------------------  ----------
         { "network",            "getconnectioncount",     getconnectioncount,     {} },
         { "network",            "ping",                   ping,                   {} },
         { "network",            "getpeerinfo",            getpeerinfo,            {} },
         { "network",            "addnode",                addnode,                {"node","command"} },
         { "network",            "disconnectnode",         disconnectnode,         {"address", "nodeid"} },
         { "network",            "getaddednodeinfo",       getaddednodeinfo,       {"node"} },
         { "network",            "getnettotals",           getnettotals,           {} },
         { "network",            "getnetworkinfo",         getnetworkinfo,         {} },
         { "network",            "setban",                 setban,                 {"subnet", "command", "bantime", "absolute"} },
         { "network",            "listbanned",             listbanned,             {} },
         { "network",            "clearbanned",            clearbanned,            {} },
         { "network",            "setnetworkactive",       setnetworkactive,       {"state"} },
         { "network",            "getnodeaddresses",       getnodeaddresses,       {"count"} },
     };
     // clang-format on
 
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 97a8a46a1..31121d144 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -1,2189 +1,2190 @@
 // 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 <blockdb.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <coins.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <index/txindex.h>
 #include <key_io.h>
 #include <merkleblock.h>
 #include <network.h>
 #include <node/coin.h>
 #include <node/context.h>
 #include <node/psbt.h>
 #include <node/transaction.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <psbt.h>
 #include <random.h>
 #include <rpc/blockchain.h>
 #include <rpc/rawtransaction_util.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/script.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
 #include <script/standard.h>
 #include <txmempool.h>
 #include <uint256.h>
 #include <util/error.h>
 #include <util/moneystr.h>
 #include <util/strencodings.h>
+#include <util/string.h>
 #include <validation.h>
 #include <validationinterface.h>
 
 #include <cstdint>
 #include <numeric>
 
 #include <univalue.h>
 
 static void TxToJSON(const CTransaction &tx, const BlockHash &hashBlock,
                      UniValue &entry) {
     // Call into TxToUniv() in bitcoin-common to decode the transaction hex.
     //
     // Blockchain contextual information (confirmations and blocktime) is not
     // available to code in bitcoin-common, so we query them here and push the
     // data into the returned UniValue.
     TxToUniv(tx, uint256(), entry, true, RPCSerializationFlags());
 
     if (!hashBlock.IsNull()) {
         LOCK(cs_main);
 
         entry.pushKV("blockhash", hashBlock.GetHex());
         CBlockIndex *pindex = LookupBlockIndex(hashBlock);
         if (pindex) {
             if (::ChainActive().Contains(pindex)) {
                 entry.pushKV("confirmations",
                              1 + ::ChainActive().Height() - pindex->nHeight);
                 entry.pushKV("time", pindex->GetBlockTime());
                 entry.pushKV("blocktime", pindex->GetBlockTime());
             } else {
                 entry.pushKV("confirmations", 0);
             }
         }
     }
 }
 
 static UniValue getrawtransaction(const Config &config,
                                   const JSONRPCRequest &request) {
     RPCHelpMan{
         "getrawtransaction",
         "By default this function only works for mempool transactions. When "
         "called with a blockhash\n"
         "argument, getrawtransaction will return the transaction if the "
         "specified block is available and\n"
         "the transaction is found in that block. When called without a "
         "blockhash argument, getrawtransaction\n"
         "will return the transaction if it is in the mempool, or if -txindex "
         "is enabled and the transaction\n"
         "is in a block in the blockchain.\n"
 
         "\nReturn the raw transaction data.\n"
         "\nIf verbose is 'true', returns an Object with information about "
         "'txid'.\n"
         "If verbose is 'false' or omitted, returns a string that is "
         "serialized, hex-encoded data for 'txid'.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id"},
             {"verbose", RPCArg::Type::BOOL, /* default */ "false",
              "If false, return a string, otherwise return a json object"},
             {"blockhash", RPCArg::Type::STR_HEX,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "The block in which to look for the transaction"},
         },
         {
             RPCResult{"if verbose is not set or set to false",
                       RPCResult::Type::STR, "data",
                       "The serialized, hex-encoded data for 'txid'"},
             RPCResult{
                 "if verbose is set to true",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::BOOL, "in_active_chain",
                      "Whether specified block is in the active chain or not "
                      "(only present with explicit \"blockhash\" argument)"},
                     {RPCResult::Type::STR_HEX, "hex",
                      "The serialized, hex-encoded data for 'txid'"},
                     {RPCResult::Type::STR_HEX, "txid",
                      "The transaction id (same as provided)"},
                     {RPCResult::Type::STR_HEX, "hash", "The transaction hash"},
                     {RPCResult::Type::NUM, "size",
                      "The serialized transaction size"},
                     {RPCResult::Type::NUM, "version", "The version"},
                     {RPCResult::Type::NUM_TIME, "locktime", "The lock time"},
                     {RPCResult::Type::ARR,
                      "vin",
                      "",
                      {
                          {RPCResult::Type::OBJ,
                           "",
                           "",
                           {
                               {RPCResult::Type::STR_HEX, "txid",
                                "The transaction id"},
                               {RPCResult::Type::STR, "vout", ""},
                               {RPCResult::Type::OBJ,
                                "scriptSig",
                                "The script",
                                {
                                    {RPCResult::Type::STR, "asm", "asm"},
                                    {RPCResult::Type::STR_HEX, "hex", "hex"},
                                }},
                               {RPCResult::Type::NUM, "sequence",
                                "The script sequence number"},
                           }},
                      }},
                     {RPCResult::Type::ARR,
                      "vout",
                      "",
                      {
                          {RPCResult::Type::OBJ,
                           "",
                           "",
                           {
                               {RPCResult::Type::NUM, "value",
                                "The value in " + CURRENCY_UNIT},
                               {RPCResult::Type::NUM, "n", "index"},
                               {RPCResult::Type::OBJ,
                                "scriptPubKey",
                                "",
                                {
                                    {RPCResult::Type::STR, "asm", "the asm"},
                                    {RPCResult::Type::STR, "hex", "the hex"},
                                    {RPCResult::Type::NUM, "reqSigs",
                                     "The required sigs"},
                                    {RPCResult::Type::STR, "type",
                                     "The type, eg 'pubkeyhash'"},
                                    {RPCResult::Type::ARR,
                                     "addresses",
                                     "",
                                     {
                                         {RPCResult::Type::STR, "address",
                                          "bitcoin address"},
                                     }},
                                }},
                           }},
                      }},
                     {RPCResult::Type::STR_HEX, "blockhash", "the block hash"},
                     {RPCResult::Type::NUM, "confirmations",
                      "The confirmations"},
                     {RPCResult::Type::NUM_TIME, "blocktime",
                      "The block time expressed in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::NUM, "time", "Same as \"blocktime\""},
                 }},
         },
         RPCExamples{HelpExampleCli("getrawtransaction", "\"mytxid\"") +
                     HelpExampleCli("getrawtransaction", "\"mytxid\" true") +
                     HelpExampleRpc("getrawtransaction", "\"mytxid\", true") +
                     HelpExampleCli("getrawtransaction",
                                    "\"mytxid\" false \"myblockhash\"") +
                     HelpExampleCli("getrawtransaction",
                                    "\"mytxid\" true \"myblockhash\"")},
     }
         .Check(request);
 
     bool in_active_chain = true;
     TxId txid = TxId(ParseHashV(request.params[0], "parameter 1"));
     CBlockIndex *blockindex = nullptr;
 
     const CChainParams &params = config.GetChainParams();
     if (txid == params.GenesisBlock().hashMerkleRoot) {
         // Special exception for the genesis block coinbase transaction
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "The genesis block coinbase is not considered an "
                            "ordinary transaction and cannot be retrieved");
     }
 
     // Accept either a bool (true) or a num (>=1) to indicate verbose output.
     bool fVerbose = false;
     if (!request.params[1].isNull()) {
         fVerbose = request.params[1].isNum()
                        ? (request.params[1].get_int() != 0)
                        : request.params[1].get_bool();
     }
 
     if (!request.params[2].isNull()) {
         LOCK(cs_main);
 
         BlockHash blockhash(ParseHashV(request.params[2], "parameter 3"));
         blockindex = LookupBlockIndex(blockhash);
         if (!blockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Block hash not found");
         }
         in_active_chain = ::ChainActive().Contains(blockindex);
     }
 
     bool f_txindex_ready = false;
     if (g_txindex && !blockindex) {
         f_txindex_ready = g_txindex->BlockUntilSyncedToCurrentChain();
     }
 
     CTransactionRef tx;
     BlockHash hash_block;
     if (!GetTransaction(txid, tx, params.GetConsensus(), hash_block,
                         blockindex)) {
         std::string errmsg;
         if (blockindex) {
             if (!blockindex->nStatus.hasData()) {
                 throw JSONRPCError(RPC_MISC_ERROR, "Block not available");
             }
             errmsg = "No such transaction found in the provided block";
         } else if (!g_txindex) {
             errmsg = "No such mempool transaction. Use -txindex or provide a "
                      "block hash to enable blockchain transaction queries";
         } else if (!f_txindex_ready) {
             errmsg = "No such mempool transaction. Blockchain transactions are "
                      "still in the process of being indexed";
         } else {
             errmsg = "No such mempool or blockchain transaction";
         }
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            errmsg +
                                ". Use gettransaction for wallet transactions.");
     }
 
     if (!fVerbose) {
         return EncodeHexTx(*tx, RPCSerializationFlags());
     }
 
     UniValue result(UniValue::VOBJ);
     if (blockindex) {
         result.pushKV("in_active_chain", in_active_chain);
     }
     TxToJSON(*tx, hash_block, result);
     return result;
 }
 
 static UniValue gettxoutproof(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "gettxoutproof",
         "Returns a hex-encoded proof that \"txid\" was included in a block.\n"
         "\nNOTE: By default this function only works sometimes. "
         "This is when there is an\n"
         "unspent output in the utxo for this transaction. To make it always "
         "work,\n"
         "you need to maintain a transaction index, using the -txindex command "
         "line option or\n"
         "specify the block in which the transaction is included manually (by "
         "blockhash).\n",
         {
             {
                 "txids",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The txids to filter",
                 {
                     {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED,
                      "A transaction hash"},
                 },
             },
             {"blockhash", RPCArg::Type::STR_HEX,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "If specified, looks for txid in the block with this hash"},
         },
         RPCResult{
             RPCResult::Type::STR, "data",
             "A string that is a serialized, hex-encoded data for the proof."},
         RPCExamples{""},
     }
         .Check(request);
 
     std::set<TxId> setTxIds;
     TxId oneTxId;
     UniValue txids = request.params[0].get_array();
     for (unsigned int idx = 0; idx < txids.size(); idx++) {
         const UniValue &utxid = txids[idx];
         TxId txid(ParseHashV(utxid, "txid"));
         if (setTxIds.count(txid)) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 std::string("Invalid parameter, duplicated txid: ") +
                     utxid.get_str());
         }
 
         setTxIds.insert(txid);
         oneTxId = txid;
     }
 
     CBlockIndex *pblockindex = nullptr;
 
     BlockHash hashBlock;
     if (!request.params[1].isNull()) {
         LOCK(cs_main);
         hashBlock = BlockHash(ParseHashV(request.params[1], "blockhash"));
         pblockindex = LookupBlockIndex(hashBlock);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
     } else {
         LOCK(cs_main);
         // Loop through txids and try to find which block they're in. Exit loop
         // once a block is found.
         for (const auto &txid : setTxIds) {
             const Coin &coin =
                 AccessByTxid(::ChainstateActive().CoinsTip(), txid);
             if (!coin.IsSpent()) {
                 pblockindex = ::ChainActive()[coin.GetHeight()];
                 break;
             }
         }
     }
 
     // Allow txindex to catch up if we need to query it and before we acquire
     // cs_main.
     if (g_txindex && !pblockindex) {
         g_txindex->BlockUntilSyncedToCurrentChain();
     }
 
     const Consensus::Params &params = config.GetChainParams().GetConsensus();
 
     LOCK(cs_main);
 
     if (pblockindex == nullptr) {
         CTransactionRef tx;
         if (!GetTransaction(oneTxId, tx, params, hashBlock) ||
             hashBlock.IsNull()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Transaction not yet in block");
         }
 
         pblockindex = LookupBlockIndex(hashBlock);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Transaction index corrupt");
         }
     }
 
     CBlock block;
     if (!ReadBlockFromDisk(block, pblockindex, params)) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Can't read block from disk");
     }
 
     unsigned int ntxFound = 0;
     for (const auto &tx : block.vtx) {
         if (setTxIds.count(tx->GetId())) {
             ntxFound++;
         }
     }
 
     if (ntxFound != setTxIds.size()) {
         throw JSONRPCError(
             RPC_INVALID_ADDRESS_OR_KEY,
             "Not all transactions found in specified or retrieved block");
     }
 
     CDataStream ssMB(SER_NETWORK, PROTOCOL_VERSION);
     CMerkleBlock mb(block, setTxIds);
     ssMB << mb;
     std::string strHex = HexStr(ssMB.begin(), ssMB.end());
     return strHex;
 }
 
 static UniValue verifytxoutproof(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "verifytxoutproof",
         "Verifies that a proof points to a transaction in a block, returning "
         "the transaction it commits to\n"
         "and throwing an RPC error if the block is not in our best chain\n",
         {
             {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hex-encoded proof generated by gettxoutproof"},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "txid",
                        "The txid(s) which the proof commits to, or empty array "
                        "if the proof can not be validated."},
                   }},
         RPCExamples{""},
     }
         .Check(request);
 
     CDataStream ssMB(ParseHexV(request.params[0], "proof"), SER_NETWORK,
                      PROTOCOL_VERSION);
     CMerkleBlock merkleBlock;
     ssMB >> merkleBlock;
 
     UniValue res(UniValue::VARR);
 
     std::vector<uint256> vMatch;
     std::vector<size_t> vIndex;
     if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) !=
         merkleBlock.header.hashMerkleRoot) {
         return res;
     }
 
     LOCK(cs_main);
 
     const CBlockIndex *pindex = LookupBlockIndex(merkleBlock.header.GetHash());
     if (!pindex || !::ChainActive().Contains(pindex) || pindex->nTx == 0) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Block not found in chain");
     }
 
     // Check if proof is valid, only add results if so
     if (pindex->nTx == merkleBlock.txn.GetNumTransactions()) {
         for (const uint256 &hash : vMatch) {
             res.push_back(hash.GetHex());
         }
     }
 
     return res;
 }
 
 static UniValue createrawtransaction(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "createrawtransaction",
         "Create a transaction spending the given inputs and creating new "
         "outputs.\n"
         "Outputs can be addresses or data.\n"
         "Returns hex-encoded raw transaction.\n"
         "Note that the transaction's inputs are not signed, and\n"
         "it is not stored in the wallet or transmitted to the network.\n",
         {
             {
                 "inputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The inputs",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                             {"sequence", RPCArg::Type::NUM, /* default */
                              "depends on the value of the 'locktime' argument",
                              "The sequence number"},
                         },
                     },
                 },
             },
             {
                 "outputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The outputs (key-value pairs), where none of "
                 "the keys are duplicated.\n"
                 "That is, each address can only appear once and there can only "
                 "be one 'data' object.\n"
                 "For compatibility reasons, a dictionary, which holds the "
                 "key-value pairs directly, is also\n"
                 "                             accepted as second parameter.",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"address", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key (string) is the "
                              "bitcoin address, the value (float or string) is "
                              "the amount in " +
                                  CURRENCY_UNIT},
                         },
                     },
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"data", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key must be \"data\", the "
                              "value is hex-encoded data"},
                         },
                     },
                 },
             },
             {"locktime", RPCArg::Type::NUM, /* default */ "0",
              "Raw locktime. Non-0 value also locktime-activates inputs"},
         },
         RPCResult{RPCResult::Type::STR_HEX, "transaction",
                   "hex string of the transaction"},
         RPCExamples{
             HelpExampleCli("createrawtransaction",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                            "\" \"[{\\\"address\\\":0.01}]\"") +
             HelpExampleCli("createrawtransaction",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                            "\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"") +
             HelpExampleRpc("createrawtransaction",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                            "\", \"[{\\\"address\\\":0.01}]\"") +
             HelpExampleRpc("createrawtransaction",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                            "\", \"[{\\\"data\\\":\\\"00010203\\\"}]\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params,
                  {UniValue::VARR,
                   UniValueType(), // ARR or OBJ, checked later
                   UniValue::VNUM},
                  true);
 
     CMutableTransaction rawTx =
         ConstructTransaction(config.GetChainParams(), request.params[0],
                              request.params[1], request.params[2]);
 
     return EncodeHexTx(CTransaction(rawTx));
 }
 
 static UniValue decoderawtransaction(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "decoderawtransaction",
         "Return a JSON object representing the serialized, hex-encoded "
         "transaction.\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction hex string"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR_HEX, "txid", "The transaction id"},
                 {RPCResult::Type::STR_HEX, "hash", "The transaction hash"},
                 {RPCResult::Type::NUM, "size", "The transaction size"},
                 {RPCResult::Type::NUM, "version", "The version"},
                 {RPCResult::Type::NUM_TIME, "locktime", "The lock time"},
                 {RPCResult::Type::ARR,
                  "vin",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "txid",
                            "The transaction id"},
                           {RPCResult::Type::NUM, "vout", "The output number"},
                           {RPCResult::Type::OBJ,
                            "scriptSig",
                            "The script",
                            {
                                {RPCResult::Type::STR, "asm", "asm"},
                                {RPCResult::Type::STR_HEX, "hex", "hex"},
                            }},
                           {RPCResult::Type::NUM, "sequence",
                            "The script sequence number"},
                       }},
                  }},
                 {RPCResult::Type::ARR,
                  "vout",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::NUM, "value",
                            "The value in " + CURRENCY_UNIT},
                           {RPCResult::Type::NUM, "n", "index"},
                           {RPCResult::Type::OBJ,
                            "scriptPubKey",
                            "",
                            {
                                {RPCResult::Type::STR, "asm", "the asm"},
                                {RPCResult::Type::STR_HEX, "hex", "the hex"},
                                {RPCResult::Type::NUM, "reqSigs",
                                 "The required sigs"},
                                {RPCResult::Type::STR, "type",
                                 "The type, eg 'pubkeyhash'"},
                                {RPCResult::Type::ARR,
                                 "addresses",
                                 "",
                                 {
                                     {RPCResult::Type::STR, "address",
                                      "bitcoin address"},
                                 }},
                            }},
                       }},
                  }},
             }},
         RPCExamples{HelpExampleCli("decoderawtransaction", "\"hexstring\"") +
                     HelpExampleRpc("decoderawtransaction", "\"hexstring\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     CMutableTransaction mtx;
 
     if (!DecodeHexTx(mtx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     UniValue result(UniValue::VOBJ);
     TxToUniv(CTransaction(std::move(mtx)), uint256(), result, false);
 
     return result;
 }
 
 static std::string GetAllOutputTypes() {
     std::string ret;
     for (int i = TX_NONSTANDARD; i <= TX_NULL_DATA; ++i) {
         if (i != TX_NONSTANDARD) {
             ret += ", ";
         }
         ret += GetTxnOutputType(static_cast<txnouttype>(i));
     }
     return ret;
 }
 
 static UniValue decodescript(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "decodescript",
         "Decode a hex-encoded script.\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hex-encoded script"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR, "asm", "Script public key"},
                 {RPCResult::Type::STR, "type",
                  "The output type (e.g. " + GetAllOutputTypes() + ")"},
                 {RPCResult::Type::NUM, "reqSigs", "The required signatures"},
                 {RPCResult::Type::ARR,
                  "addresses",
                  "",
                  {
                      {RPCResult::Type::STR, "address", "bitcoin address"},
                  }},
                 {RPCResult::Type::STR, "p2sh",
                  "address of P2SH script wrapping this redeem script (not "
                  "returned if the script is already a P2SH)"},
             }},
         RPCExamples{HelpExampleCli("decodescript", "\"hexstring\"") +
                     HelpExampleRpc("decodescript", "\"hexstring\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     UniValue r(UniValue::VOBJ);
     CScript script;
     if (request.params[0].get_str().size() > 0) {
         std::vector<uint8_t> scriptData(
             ParseHexV(request.params[0], "argument"));
         script = CScript(scriptData.begin(), scriptData.end());
     } else {
         // Empty scripts are valid.
     }
 
     ScriptPubKeyToUniv(script, r, /* fIncludeHex */ false);
 
     UniValue type;
     type = find_value(r, "type");
 
     if (type.isStr() && type.get_str() != "scripthash") {
         // P2SH cannot be wrapped in a P2SH. If this script is already a P2SH,
         // don't return the address for a P2SH of the P2SH.
         r.pushKV("p2sh", EncodeDestination(ScriptHash(script), config));
     }
 
     return r;
 }
 
 static UniValue combinerawtransaction(const Config &config,
                                       const JSONRPCRequest &request) {
     RPCHelpMan{
         "combinerawtransaction",
         "Combine multiple partially signed transactions into one "
         "transaction.\n"
         "The combined transaction may be another partially signed transaction "
         "or a \n"
         "fully signed transaction.",
         {
             {
                 "txs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The hex strings of partially signed "
                 "transactions",
                 {
                     {"hexstring", RPCArg::Type::STR_HEX,
                      RPCArg::Optional::OMITTED, "A transaction hash"},
                 },
             },
         },
         RPCResult{RPCResult::Type::STR, "",
                   "The hex-encoded raw transaction with signature(s)"},
         RPCExamples{HelpExampleCli("combinerawtransaction",
                                    "[\"myhex1\", \"myhex2\", \"myhex3\"]")},
     }
         .Check(request);
 
     UniValue txs = request.params[0].get_array();
     std::vector<CMutableTransaction> txVariants(txs.size());
 
     for (unsigned int idx = 0; idx < txs.size(); idx++) {
         if (!DecodeHexTx(txVariants[idx], txs[idx].get_str())) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                strprintf("TX decode failed for tx %d", idx));
         }
     }
 
     if (txVariants.empty()) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Missing transactions");
     }
 
     // mergedTx will end up with all the signatures; it
     // starts as a clone of the rawtx:
     CMutableTransaction mergedTx(txVariants[0]);
 
     // Fetch previous transactions (inputs):
     CCoinsView viewDummy;
     CCoinsViewCache view(&viewDummy);
     {
         const CTxMemPool &mempool = EnsureMemPool(request.context);
         LOCK(cs_main);
         LOCK(mempool.cs);
         CCoinsViewCache &viewChain = ::ChainstateActive().CoinsTip();
         CCoinsViewMemPool viewMempool(&viewChain, mempool);
         // temporarily switch cache backend to db+mempool view
         view.SetBackend(viewMempool);
 
         for (const CTxIn &txin : mergedTx.vin) {
             // Load entries from viewChain into view; can fail.
             view.AccessCoin(txin.prevout);
         }
 
         // switch back to avoid locking mempool for too long
         view.SetBackend(viewDummy);
     }
 
     // Use CTransaction for the constant parts of the
     // transaction to avoid rehashing.
     const CTransaction txConst(mergedTx);
     // Sign what we can:
     for (size_t i = 0; i < mergedTx.vin.size(); i++) {
         CTxIn &txin = mergedTx.vin[i];
         const Coin &coin = view.AccessCoin(txin.prevout);
         if (coin.IsSpent()) {
             throw JSONRPCError(RPC_VERIFY_ERROR,
                                "Input not found or already spent");
         }
         SignatureData sigdata;
 
         const CTxOut &txout = coin.GetTxOut();
 
         // ... and merge in other signatures:
         for (const CMutableTransaction &txv : txVariants) {
             if (txv.vin.size() > i) {
                 sigdata.MergeSignatureData(DataFromTransaction(txv, i, txout));
             }
         }
         ProduceSignature(
             DUMMY_SIGNING_PROVIDER,
             MutableTransactionSignatureCreator(&mergedTx, i, txout.nValue),
             txout.scriptPubKey, sigdata);
 
         UpdateInput(txin, sigdata);
     }
 
     return EncodeHexTx(CTransaction(mergedTx));
 }
 
 static UniValue signrawtransactionwithkey(const Config &config,
                                           const JSONRPCRequest &request) {
     RPCHelpMan{
         "signrawtransactionwithkey",
         "Sign inputs for raw transaction (serialized, hex-encoded).\n"
         "The second argument is an array of base58-encoded private\n"
         "keys that will be the only keys used to sign the transaction.\n"
         "The third optional argument (may be null) is an array of previous "
         "transaction outputs that\n"
         "this transaction depends on but may not yet be in the block chain.\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction hex string"},
             {
                 "privkeys",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The base58-encoded private keys for signing",
                 {
                     {"privatekey", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                      "private key in base58-encoding"},
                 },
             },
             {
                 "prevtxs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::OMITTED_NAMED_ARG,
                 "The previous dependent transaction outputs",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                             {"scriptPubKey", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "script key"},
                             {"redeemScript", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::OMITTED,
                              "(required for P2SH) redeem script"},
                             {"amount", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO, "The amount spent"},
                         },
                     },
                 },
             },
             {"sighashtype", RPCArg::Type::STR, /* default */ "ALL|FORKID",
              "The signature hash type. Must be one of:\n"
              "       \"ALL|FORKID\"\n"
              "       \"NONE|FORKID\"\n"
              "       \"SINGLE|FORKID\"\n"
              "       \"ALL|FORKID|ANYONECANPAY\"\n"
              "       \"NONE|FORKID|ANYONECANPAY\"\n"
              "       \"SINGLE|FORKID|ANYONECANPAY\""},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR_HEX, "hex",
                  "The hex-encoded raw transaction with signature(s)"},
                 {RPCResult::Type::BOOL, "complete",
                  "If the transaction has a complete set of signatures"},
                 {RPCResult::Type::ARR,
                  "errors",
                  "Script verification errors (if there are any)",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "txid",
                            "The hash of the referenced, previous transaction"},
                           {RPCResult::Type::NUM, "vout",
                            "The index of the output to spent and used as "
                            "input"},
                           {RPCResult::Type::STR_HEX, "scriptSig",
                            "The hex-encoded signature script"},
                           {RPCResult::Type::NUM, "sequence",
                            "Script sequence number"},
                           {RPCResult::Type::STR, "error",
                            "Verification or signing error related to the "
                            "input"},
                       }},
                  }},
             }},
         RPCExamples{
             HelpExampleCli("signrawtransactionwithkey",
                            "\"myhex\" \"[\\\"key1\\\",\\\"key2\\\"]\"") +
             HelpExampleRpc("signrawtransactionwithkey",
                            "\"myhex\", \"[\\\"key1\\\",\\\"key2\\\"]\"")},
     }
         .Check(request);
 
     RPCTypeCheck(
         request.params,
         {UniValue::VSTR, UniValue::VARR, UniValue::VARR, UniValue::VSTR}, true);
 
     CMutableTransaction mtx;
     if (!DecodeHexTx(mtx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     FillableSigningProvider keystore;
     const UniValue &keys = request.params[1].get_array();
     for (size_t idx = 0; idx < keys.size(); ++idx) {
         UniValue k = keys[idx];
         CKey key = DecodeSecret(k.get_str());
         if (!key.IsValid()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid private key");
         }
         keystore.AddKey(key);
     }
 
     // Fetch previous transactions (inputs):
     std::map<COutPoint, Coin> coins;
     for (const CTxIn &txin : mtx.vin) {
         // Create empty map entry keyed by prevout.
         coins[txin.prevout];
     }
     NodeContext &node = EnsureNodeContext(request.context);
     FindCoins(node, coins);
 
     // Parse the prevtxs array
     ParsePrevouts(request.params[2], &keystore, coins);
 
     UniValue result(UniValue::VOBJ);
     SignTransaction(mtx, &keystore, coins, request.params[3], result);
     return result;
 }
 
 static UniValue sendrawtransaction(const Config &config,
                                    const JSONRPCRequest &request) {
     RPCHelpMan{
         "sendrawtransaction",
         "Submits raw transaction (serialized, hex-encoded) to local node and "
         "network.\n"
         "\nAlso see createrawtransaction and "
         "signrawtransactionwithkey calls.\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hex string of the raw transaction"},
             {"maxfeerate", RPCArg::Type::AMOUNT,
              /* default */
              FormatMoney(DEFAULT_MAX_RAW_TX_FEE_RATE.GetFeePerK()),
              "Reject transactions whose fee rate is higher than the specified "
              "value, expressed in " +
                  CURRENCY_UNIT + "/kB\nSet to 0 to accept any fee rate.\n"},
         },
         RPCResult{RPCResult::Type::STR_HEX, "", "The transaction hash in hex"},
         RPCExamples{
             "\nCreate a transaction\n" +
             HelpExampleCli(
                 "createrawtransaction",
                 "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" "
                 "\"{\\\"myaddress\\\":0.01}\"") +
             "Sign the transaction, and get back the hex\n" +
             HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
             "\nSend the transaction (signed hex)\n" +
             HelpExampleCli("sendrawtransaction", "\"signedhex\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("sendrawtransaction", "\"signedhex\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {
                                      UniValue::VSTR,
                                      // NUM or BOOL, checked later
                                      UniValueType(),
                                  });
 
     // parse hex string from parameter
     CMutableTransaction mtx;
     if (!DecodeHexTx(mtx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     CTransactionRef tx(MakeTransactionRef(std::move(mtx)));
 
     CFeeRate max_raw_tx_fee_rate = DEFAULT_MAX_RAW_TX_FEE_RATE;
     // TODO: temporary migration code for old clients. Remove in v0.22
     if (request.params[1].isBool()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Second argument must be numeric (maxfeerate) and "
                            "no longer supports a boolean. To allow a "
                            "transaction with high fees, set maxfeerate to 0.");
     } else if (!request.params[1].isNull()) {
         max_raw_tx_fee_rate = CFeeRate(AmountFromValue(request.params[1]));
     }
 
     int64_t virtual_size = GetVirtualTransactionSize(*tx);
     Amount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
 
     std::string err_string;
     AssertLockNotHeld(cs_main);
     NodeContext &node = EnsureNodeContext(request.context);
     const TransactionError err = BroadcastTransaction(
         node, config, tx, err_string, max_raw_tx_fee, /*relay*/ true,
         /*wait_callback*/ true);
     if (err != TransactionError::OK) {
         throw JSONRPCTransactionError(err, err_string);
     }
 
     return tx->GetHash().GetHex();
 }
 
 static UniValue testmempoolaccept(const Config &config,
                                   const JSONRPCRequest &request) {
     RPCHelpMan{
         "testmempoolaccept",
         "Returns result of mempool acceptance tests indicating if raw"
         " transaction (serialized, hex-encoded) would be accepted"
         " by mempool.\n"
         "\nThis checks if the transaction violates the consensus or policy "
         "rules.\n"
         "\nSee sendrawtransaction call.\n",
         {
             {
                 "rawtxs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "An array of hex strings of raw transactions.\n"
                 "                             Length must be one for now.",
                 {
                     {"rawtx", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED,
                      ""},
                 },
             },
             {"maxfeerate", RPCArg::Type::AMOUNT,
              /* default */
              FormatMoney(DEFAULT_MAX_RAW_TX_FEE_RATE.GetFeePerK()),
              "Reject transactions whose fee rate is higher than the specified "
              "value, expressed in " +
                  CURRENCY_UNIT + "/kB\n"},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "The result of the mempool acceptance test for each raw "
                   "transaction in the input array.\n"
                   "Length is exactly one for now.",
                   {
                       {RPCResult::Type::OBJ,
                        "",
                        "",
                        {
                            {RPCResult::Type::STR_HEX, "txid",
                             "The transaction hash in hex"},
                            {RPCResult::Type::BOOL, "allowed",
                             "If the mempool allows this tx to be inserted"},
                            {RPCResult::Type::STR, "reject-reason",
                             "Rejection string (only present when 'allowed' is "
                             "false)"},
                        }},
                   }},
         RPCExamples{
             "\nCreate a transaction\n" +
             HelpExampleCli(
                 "createrawtransaction",
                 "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" "
                 "\"{\\\"myaddress\\\":0.01}\"") +
             "Sign the transaction, and get back the hex\n" +
             HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
             "\nTest acceptance of the transaction (signed hex)\n" +
             HelpExampleCli("testmempoolaccept", "[\"signedhex\"]") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("testmempoolaccept", "[\"signedhex\"]")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {
                                      UniValue::VARR,
                                      // NUM or BOOL, checked later
                                      UniValueType(),
                                  });
 
     if (request.params[0].get_array().size() != 1) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "Array must contain exactly one raw transaction for now");
     }
 
     CMutableTransaction mtx;
     if (!DecodeHexTx(mtx, request.params[0].get_array()[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
     CTransactionRef tx(MakeTransactionRef(std::move(mtx)));
     const TxId &txid = tx->GetId();
 
     CFeeRate max_raw_tx_fee_rate = DEFAULT_MAX_RAW_TX_FEE_RATE;
     // TODO: temporary migration code for old clients. Remove in v0.22
     if (request.params[1].isBool()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Second argument must be numeric (maxfeerate) and "
                            "no longer supports a boolean. To allow a "
                            "transaction with high fees, set maxfeerate to 0.");
     } else if (!request.params[1].isNull()) {
         max_raw_tx_fee_rate = CFeeRate(AmountFromValue(request.params[1]));
     }
 
     CTxMemPool &mempool = EnsureMemPool(request.context);
     int64_t virtual_size = GetVirtualTransactionSize(*tx);
     Amount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
 
     UniValue result(UniValue::VARR);
     UniValue result_0(UniValue::VOBJ);
     result_0.pushKV("txid", txid.GetHex());
 
     TxValidationState state;
     bool test_accept_res;
     {
         LOCK(cs_main);
         test_accept_res = AcceptToMemoryPool(
             config, mempool, state, std::move(tx), false /* bypass_limits */,
             max_raw_tx_fee, true /* test_accept */);
     }
     result_0.pushKV("allowed", test_accept_res);
     if (!test_accept_res) {
         if (state.IsInvalid()) {
             if (state.GetResult() == TxValidationResult::TX_MISSING_INPUTS) {
                 result_0.pushKV("reject-reason", "missing-inputs");
             } else {
                 result_0.pushKV("reject-reason",
                                 strprintf("%s", state.GetRejectReason()));
             }
         } else {
             result_0.pushKV("reject-reason", state.GetRejectReason());
         }
     }
 
     result.push_back(std::move(result_0));
     return result;
 }
 
 static std::string WriteHDKeypath(std::vector<uint32_t> &keypath) {
     std::string keypath_str = "m";
     for (uint32_t num : keypath) {
         keypath_str += "/";
         bool hardened = false;
         if (num & 0x80000000) {
             hardened = true;
             num &= ~0x80000000;
         }
 
-        keypath_str += std::to_string(num);
+        keypath_str += ToString(num);
         if (hardened) {
             keypath_str += "'";
         }
     }
     return keypath_str;
 }
 
 static UniValue decodepsbt(const Config &config,
                            const JSONRPCRequest &request) {
     RPCHelpMan{
         "decodepsbt",
         "Return a JSON object representing the serialized, base64-encoded "
         "partially signed Bitcoin transaction.\n",
         {
             {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The PSBT base64 string"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "tx",
                  "The decoded network-serialized unsigned transaction.",
                  {
                      {RPCResult::Type::ELISION, "",
                       "The layout is the same as the output of "
                       "decoderawtransaction."},
                  }},
                 {RPCResult::Type::OBJ_DYN,
                  "unknown",
                  "The unknown global fields",
                  {
                      {RPCResult::Type::STR_HEX, "key",
                       "(key-value pair) An unknown key-value pair"},
                  }},
                 {RPCResult::Type::ARR,
                  "inputs",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::OBJ,
                            "utxo",
                            /* optional */ true,
                            "Transaction output for UTXOs",
                            {
                                {RPCResult::Type::NUM, "amount",
                                 "The value in " + CURRENCY_UNIT},
                                {RPCResult::Type::OBJ,
                                 "scriptPubKey",
                                 "",
                                 {
                                     {RPCResult::Type::STR, "asm", "The asm"},
                                     {RPCResult::Type::STR_HEX, "hex",
                                      "The hex"},
                                     {RPCResult::Type::STR, "type",
                                      "The type, eg 'pubkeyhash'"},
                                     {RPCResult::Type::STR, "address",
                                      " Bitcoin address if there is one"},
                                 }},
                            }},
                           {RPCResult::Type::OBJ_DYN,
                            "partial_signatures",
                            /* optional */ true,
                            "",
                            {
                                {RPCResult::Type::STR, "pubkey",
                                 "The public key and signature that corresponds "
                                 "to it."},
                            }},
                           {RPCResult::Type::STR, "sighash", /* optional */ true,
                            "The sighash type to be used"},
                           {RPCResult::Type::OBJ,
                            "redeem_script",
                            /* optional */ true,
                            "",
                            {
                                {RPCResult::Type::STR, "asm", "The asm"},
                                {RPCResult::Type::STR_HEX, "hex", "The hex"},
                                {RPCResult::Type::STR, "type",
                                 "The type, eg 'pubkeyhash'"},
                            }},
                           {RPCResult::Type::ARR,
                            "bip32_derivs",
                            /* optional */ true,
                            "",
                            {
                                {RPCResult::Type::OBJ,
                                 "pubkey",
                                 /* optional */ true,
                                 "The public key with the derivation path as "
                                 "the value.",
                                 {
                                     {RPCResult::Type::STR, "master_fingerprint",
                                      "The fingerprint of the master key"},
                                     {RPCResult::Type::STR, "path", "The path"},
                                 }},
                            }},
                           {RPCResult::Type::OBJ,
                            "final_scriptsig",
                            /* optional */ true,
                            "",
                            {
                                {RPCResult::Type::STR, "asm", "The asm"},
                                {RPCResult::Type::STR, "hex", "The hex"},
                            }},
                           {RPCResult::Type::OBJ_DYN,
                            "unknown",
                            "The unknown global fields",
                            {
                                {RPCResult::Type::STR_HEX, "key",
                                 "(key-value pair) An unknown key-value pair"},
                            }},
                       }},
                  }},
                 {RPCResult::Type::ARR,
                  "outputs",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::OBJ,
                            "redeem_script",
                            /* optional */ true,
                            "",
                            {
                                {RPCResult::Type::STR, "asm", "The asm"},
                                {RPCResult::Type::STR_HEX, "hex", "The hex"},
                                {RPCResult::Type::STR, "type",
                                 "The type, eg 'pubkeyhash'"},
                            }},
                           {RPCResult::Type::ARR,
                            "bip32_derivs",
                            /* optional */ true,
                            "",
                            {
                                {RPCResult::Type::OBJ,
                                 "",
                                 "",
                                 {
                                     {RPCResult::Type::STR, "pubkey",
                                      "The public key this path corresponds to"},
                                     {RPCResult::Type::STR, "master_fingerprint",
                                      "The fingerprint of the master key"},
                                     {RPCResult::Type::STR, "path", "The path"},
                                 }},
                            }},
                           {RPCResult::Type::OBJ_DYN,
                            "unknown",
                            "The unknown global fields",
                            {
                                {RPCResult::Type::STR_HEX, "key",
                                 "(key-value pair) An unknown key-value pair"},
                            }},
                       }},
                  }},
                 {RPCResult::Type::STR_AMOUNT, "fee", /* optional */ true,
                  "The transaction fee paid if all UTXOs slots in the PSBT have "
                  "been filled."},
             }},
         RPCExamples{HelpExampleCli("decodepsbt", "\"psbt\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     // Unserialize the transactions
     PartiallySignedTransaction psbtx;
     std::string error;
     if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            strprintf("TX decode failed %s", error));
     }
 
     UniValue result(UniValue::VOBJ);
 
     // Add the decoded tx
     UniValue tx_univ(UniValue::VOBJ);
     TxToUniv(CTransaction(*psbtx.tx), uint256(), tx_univ, false);
     result.pushKV("tx", tx_univ);
 
     // Unknown data
     if (psbtx.unknown.size() > 0) {
         UniValue unknowns(UniValue::VOBJ);
         for (auto entry : psbtx.unknown) {
             unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
         }
         result.pushKV("unknown", unknowns);
     }
 
     // inputs
     Amount total_in = Amount::zero();
     bool have_all_utxos = true;
     UniValue inputs(UniValue::VARR);
     for (size_t i = 0; i < psbtx.inputs.size(); ++i) {
         const PSBTInput &input = psbtx.inputs[i];
         UniValue in(UniValue::VOBJ);
         // UTXOs
         if (!input.utxo.IsNull()) {
             const CTxOut &txout = input.utxo;
 
             UniValue out(UniValue::VOBJ);
 
             out.pushKV("amount", ValueFromAmount(txout.nValue));
             if (MoneyRange(txout.nValue) &&
                 MoneyRange(total_in + txout.nValue)) {
                 total_in += txout.nValue;
             } else {
                 // Hack to just not show fee later
                 have_all_utxos = false;
             }
 
             UniValue o(UniValue::VOBJ);
             ScriptToUniv(txout.scriptPubKey, o, true);
             out.pushKV("scriptPubKey", o);
             in.pushKV("utxo", out);
         } else {
             have_all_utxos = false;
         }
 
         // Partial sigs
         if (!input.partial_sigs.empty()) {
             UniValue partial_sigs(UniValue::VOBJ);
             for (const auto &sig : input.partial_sigs) {
                 partial_sigs.pushKV(HexStr(sig.second.first),
                                     HexStr(sig.second.second));
             }
             in.pushKV("partial_signatures", partial_sigs);
         }
 
         // Sighash
         uint8_t sighashbyte = input.sighash_type.getRawSigHashType() & 0xff;
         if (sighashbyte > 0) {
             in.pushKV("sighash", SighashToStr(sighashbyte));
         }
 
         // Redeem script
         if (!input.redeem_script.empty()) {
             UniValue r(UniValue::VOBJ);
             ScriptToUniv(input.redeem_script, r, false);
             in.pushKV("redeem_script", r);
         }
 
         // keypaths
         if (!input.hd_keypaths.empty()) {
             UniValue keypaths(UniValue::VARR);
             for (auto entry : input.hd_keypaths) {
                 UniValue keypath(UniValue::VOBJ);
                 keypath.pushKV("pubkey", HexStr(entry.first));
 
                 keypath.pushKV(
                     "master_fingerprint",
                     strprintf("%08x", ReadBE32(entry.second.fingerprint)));
                 keypath.pushKV("path", WriteHDKeypath(entry.second.path));
                 keypaths.push_back(keypath);
             }
             in.pushKV("bip32_derivs", keypaths);
         }
 
         // Final scriptSig
         if (!input.final_script_sig.empty()) {
             UniValue scriptsig(UniValue::VOBJ);
             scriptsig.pushKV("asm",
                              ScriptToAsmStr(input.final_script_sig, true));
             scriptsig.pushKV("hex", HexStr(input.final_script_sig));
             in.pushKV("final_scriptSig", scriptsig);
         }
 
         // Unknown data
         if (input.unknown.size() > 0) {
             UniValue unknowns(UniValue::VOBJ);
             for (auto entry : input.unknown) {
                 unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
             }
             in.pushKV("unknown", unknowns);
         }
 
         inputs.push_back(in);
     }
     result.pushKV("inputs", inputs);
 
     // outputs
     Amount output_value = Amount::zero();
     UniValue outputs(UniValue::VARR);
     for (size_t i = 0; i < psbtx.outputs.size(); ++i) {
         const PSBTOutput &output = psbtx.outputs[i];
         UniValue out(UniValue::VOBJ);
         // Redeem script
         if (!output.redeem_script.empty()) {
             UniValue r(UniValue::VOBJ);
             ScriptToUniv(output.redeem_script, r, false);
             out.pushKV("redeem_script", r);
         }
 
         // keypaths
         if (!output.hd_keypaths.empty()) {
             UniValue keypaths(UniValue::VARR);
             for (auto entry : output.hd_keypaths) {
                 UniValue keypath(UniValue::VOBJ);
                 keypath.pushKV("pubkey", HexStr(entry.first));
                 keypath.pushKV(
                     "master_fingerprint",
                     strprintf("%08x", ReadBE32(entry.second.fingerprint)));
                 keypath.pushKV("path", WriteHDKeypath(entry.second.path));
                 keypaths.push_back(keypath);
             }
             out.pushKV("bip32_derivs", keypaths);
         }
 
         // Unknown data
         if (output.unknown.size() > 0) {
             UniValue unknowns(UniValue::VOBJ);
             for (auto entry : output.unknown) {
                 unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
             }
             out.pushKV("unknown", unknowns);
         }
 
         outputs.push_back(out);
 
         // Fee calculation
         if (MoneyRange(psbtx.tx->vout[i].nValue) &&
             MoneyRange(output_value + psbtx.tx->vout[i].nValue)) {
             output_value += psbtx.tx->vout[i].nValue;
         } else {
             // Hack to just not show fee later
             have_all_utxos = false;
         }
     }
     result.pushKV("outputs", outputs);
     if (have_all_utxos) {
         result.pushKV("fee", ValueFromAmount(total_in - output_value));
     }
 
     return result;
 }
 
 static UniValue combinepsbt(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "combinepsbt",
         "Combine multiple partially signed Bitcoin transactions into one "
         "transaction.\n"
         "Implements the Combiner role.\n",
         {
             {
                 "txs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The base64 strings of partially signed transactions",
                 {
                     {"psbt", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                      "A base64 string of a PSBT"},
                 },
             },
         },
         RPCResult{RPCResult::Type::STR, "",
                   "The base64-encoded partially signed transaction"},
         RPCExamples{HelpExampleCli(
             "combinepsbt", "[\"mybase64_1\", \"mybase64_2\", \"mybase64_3\"]")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VARR}, true);
 
     // Unserialize the transactions
     std::vector<PartiallySignedTransaction> psbtxs;
     UniValue txs = request.params[0].get_array();
     if (txs.empty()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Parameter 'txs' cannot be empty");
     }
     for (size_t i = 0; i < txs.size(); ++i) {
         PartiallySignedTransaction psbtx;
         std::string error;
         if (!DecodeBase64PSBT(psbtx, txs[i].get_str(), error)) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                strprintf("TX decode failed %s", error));
         }
         psbtxs.push_back(psbtx);
     }
 
     PartiallySignedTransaction merged_psbt;
     const TransactionError error = CombinePSBTs(merged_psbt, psbtxs);
     if (error != TransactionError::OK) {
         throw JSONRPCTransactionError(error);
     }
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << merged_psbt;
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 static UniValue finalizepsbt(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "finalizepsbt",
         "Finalize the inputs of a PSBT. If the transaction is fully signed, it "
         "will produce a\n"
         "network serialized transaction which can be broadcast with "
         "sendrawtransaction. Otherwise a PSBT will be\n"
         "created which has the final_scriptSigfields filled for inputs that "
         "are complete.\n"
         "Implements the Finalizer and Extractor roles.\n",
         {
             {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
              "A base64 string of a PSBT"},
             {"extract", RPCArg::Type::BOOL, /* default */ "true",
              "If true and the transaction is complete,\n"
              "                             extract and return the complete "
              "transaction in normal network serialization instead of the "
              "PSBT."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "psbt",
                        "The base64-encoded partially signed transaction if not "
                        "extracted"},
                       {RPCResult::Type::STR_HEX, "hex",
                        "The hex-encoded network transaction if extracted"},
                       {RPCResult::Type::BOOL, "complete",
                        "If the transaction has a complete set of signatures"},
                   }},
         RPCExamples{HelpExampleCli("finalizepsbt", "\"psbt\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VBOOL}, true);
 
     // Unserialize the transactions
     PartiallySignedTransaction psbtx;
     std::string error;
     if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            strprintf("TX decode failed %s", error));
     }
 
     bool extract = request.params[1].isNull() || (!request.params[1].isNull() &&
                                                   request.params[1].get_bool());
 
     CMutableTransaction mtx;
     bool complete = FinalizeAndExtractPSBT(psbtx, mtx);
 
     UniValue result(UniValue::VOBJ);
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     std::string result_str;
 
     if (complete && extract) {
         ssTx << mtx;
         result_str = HexStr(ssTx.str());
         result.pushKV("hex", result_str);
     } else {
         ssTx << psbtx;
         result_str = EncodeBase64(ssTx.str());
         result.pushKV("psbt", result_str);
     }
     result.pushKV("complete", complete);
 
     return result;
 }
 
 static UniValue createpsbt(const Config &config,
                            const JSONRPCRequest &request) {
     RPCHelpMan{
         "createpsbt",
         "Creates a transaction in the Partially Signed Transaction format.\n"
         "Implements the Creator role.\n",
         {
             {
                 "inputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The json objects",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                             {"sequence", RPCArg::Type::NUM, /* default */
                              "depends on the value of the 'locktime' argument",
                              "The sequence number"},
                         },
                     },
                 },
             },
             {
                 "outputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The outputs (key-value pairs), where none of "
                 "the keys are duplicated.\n"
                 "That is, each address can only appear once and there can only "
                 "be one 'data' object.\n"
                 "For compatibility reasons, a dictionary, which holds the "
                 "key-value pairs directly, is also\n"
                 "                             accepted as second parameter.",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"address", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key (string) is the "
                              "bitcoin address, the value (float or string) is "
                              "the amount in " +
                                  CURRENCY_UNIT},
                         },
                     },
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"data", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key must be \"data\", the "
                              "value is hex-encoded data"},
                         },
                     },
                 },
             },
             {"locktime", RPCArg::Type::NUM, /* default */ "0",
              "Raw locktime. Non-0 value also locktime-activates inputs"},
         },
         RPCResult{RPCResult::Type::STR, "",
                   "The resulting raw transaction (base64-encoded string)"},
         RPCExamples{HelpExampleCli(
             "createpsbt", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                           "\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params,
                  {
                      UniValue::VARR,
                      UniValueType(), // ARR or OBJ, checked later
                      UniValue::VNUM,
                  },
                  true);
 
     CMutableTransaction rawTx =
         ConstructTransaction(config.GetChainParams(), request.params[0],
                              request.params[1], request.params[2]);
 
     // Make a blank psbt
     PartiallySignedTransaction psbtx;
     psbtx.tx = rawTx;
     for (size_t i = 0; i < rawTx.vin.size(); ++i) {
         psbtx.inputs.push_back(PSBTInput());
     }
     for (size_t i = 0; i < rawTx.vout.size(); ++i) {
         psbtx.outputs.push_back(PSBTOutput());
     }
 
     // Serialize the PSBT
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
 
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 static UniValue converttopsbt(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "converttopsbt",
         "Converts a network serialized transaction to a PSBT. "
         "This should be used only with createrawtransaction and "
         "fundrawtransaction\n"
         "createpsbt and walletcreatefundedpsbt should be used for new "
         "applications.\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hex string of a raw transaction"},
             {"permitsigdata", RPCArg::Type::BOOL, /* default */ "false",
              "If true, any signatures in the input will be discarded and "
              "conversion.\n"
              "                              will continue. If false, RPC will "
              "fail if any signatures are present."},
         },
         RPCResult{RPCResult::Type::STR, "",
                   "The resulting raw transaction (base64-encoded string)"},
         RPCExamples{
             "\nCreate a transaction\n" +
             HelpExampleCli("createrawtransaction",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                            "\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"") +
             "\nConvert the transaction to a PSBT\n" +
             HelpExampleCli("converttopsbt", "\"rawtransaction\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VBOOL}, true);
 
     // parse hex string from parameter
     CMutableTransaction tx;
     bool permitsigdata =
         request.params[1].isNull() ? false : request.params[1].get_bool();
     if (!DecodeHexTx(tx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     // Remove all scriptSigs from inputs
     for (CTxIn &input : tx.vin) {
         if (!input.scriptSig.empty() && !permitsigdata) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                "Inputs must not have scriptSigs");
         }
         input.scriptSig.clear();
     }
 
     // Make a blank psbt
     PartiallySignedTransaction psbtx;
     psbtx.tx = tx;
     for (size_t i = 0; i < tx.vin.size(); ++i) {
         psbtx.inputs.push_back(PSBTInput());
     }
     for (size_t i = 0; i < tx.vout.size(); ++i) {
         psbtx.outputs.push_back(PSBTOutput());
     }
 
     // Serialize the PSBT
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
 
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 UniValue utxoupdatepsbt(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "utxoupdatepsbt",
         "Updates all inputs and outputs in a PSBT with data from output "
         "descriptors, the UTXO set or the mempool.\n",
         {
             {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
              "A base64 string of a PSBT"},
             {"descriptors",
              RPCArg::Type::ARR,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "An array of either strings or objects",
              {
                  {"", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                   "An output descriptor"},
                  {"",
                   RPCArg::Type::OBJ,
                   RPCArg::Optional::OMITTED,
                   "An object with an output descriptor and extra information",
                   {
                       {"desc", RPCArg::Type::STR, RPCArg::Optional::NO,
                        "An output descriptor"},
                       {"range", RPCArg::Type::RANGE, "1000",
                        "Up to what index HD chains should be explored (either "
                        "end or [begin,end])"},
                   }},
              }},
         },
         RPCResult{RPCResult::Type::STR, "",
                   "The base64-encoded partially signed transaction with inputs "
                   "updated"},
         RPCExamples{HelpExampleCli("utxoupdatepsbt", "\"psbt\"")}}
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VARR}, true);
 
     // Unserialize the transactions
     PartiallySignedTransaction psbtx;
     std::string error;
     if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            strprintf("TX decode failed %s", error));
     }
 
     // Parse descriptors, if any.
     FlatSigningProvider provider;
     if (!request.params[1].isNull()) {
         auto descs = request.params[1].get_array();
         for (size_t i = 0; i < descs.size(); ++i) {
             EvalDescriptorStringOrObject(descs[i], provider);
         }
     }
     // We don't actually need private keys further on; hide them as a
     // precaution.
     HidingSigningProvider public_provider(&provider, /* nosign */ true,
                                           /* nobip32derivs */ false);
 
     // Fetch previous transactions (inputs):
     CCoinsView viewDummy;
     CCoinsViewCache view(&viewDummy);
     {
         const CTxMemPool &mempool = EnsureMemPool(request.context);
         LOCK2(cs_main, mempool.cs);
         CCoinsViewCache &viewChain = ::ChainstateActive().CoinsTip();
         CCoinsViewMemPool viewMempool(&viewChain, mempool);
         // temporarily switch cache backend to db+mempool view
         view.SetBackend(viewMempool);
 
         for (const CTxIn &txin : psbtx.tx->vin) {
             // Load entries from viewChain into view; can fail.
             view.AccessCoin(txin.prevout);
         }
 
         // switch back to avoid locking mempool for too long
         view.SetBackend(viewDummy);
     }
 
     // Fill the inputs
     for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
         PSBTInput &input = psbtx.inputs.at(i);
 
         if (!input.utxo.IsNull()) {
             continue;
         }
 
         // Update script/keypath information using descriptor data.
         // Note that SignPSBTInput does a lot more than just constructing ECDSA
         // signatures we don't actually care about those here, in fact.
         SignPSBTInput(public_provider, psbtx, i,
                       /* sighash_type */ SigHashType().withForkId());
     }
 
     // Update script/keypath information using descriptor data.
     for (unsigned int i = 0; i < psbtx.tx->vout.size(); ++i) {
         UpdatePSBTOutput(public_provider, psbtx, i);
     }
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 UniValue joinpsbts(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "joinpsbts",
         "Joins multiple distinct PSBTs with different inputs and outputs "
         "into one PSBT with inputs and outputs from all of the PSBTs\n"
         "No input in any of the PSBTs can be in more than one of the PSBTs.\n",
         {{"txs",
           RPCArg::Type::ARR,
           RPCArg::Optional::NO,
           "The base64 strings of partially signed transactions",
           {{"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
             "A base64 string of a PSBT"}}}},
         RPCResult{RPCResult::Type::STR, "",
                   "The base64-encoded partially signed transaction"},
         RPCExamples{HelpExampleCli("joinpsbts", "\"psbt\"")}}
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VARR}, true);
 
     // Unserialize the transactions
     std::vector<PartiallySignedTransaction> psbtxs;
     UniValue txs = request.params[0].get_array();
 
     if (txs.size() <= 1) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "At least two PSBTs are required to join PSBTs.");
     }
 
     int32_t best_version = 1;
     uint32_t best_locktime = 0xffffffff;
     for (size_t i = 0; i < txs.size(); ++i) {
         PartiallySignedTransaction psbtx;
         std::string error;
         if (!DecodeBase64PSBT(psbtx, txs[i].get_str(), error)) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                strprintf("TX decode failed %s", error));
         }
         psbtxs.push_back(psbtx);
         // Choose the highest version number
         if (psbtx.tx->nVersion > best_version) {
             best_version = psbtx.tx->nVersion;
         }
         // Choose the lowest lock time
         if (psbtx.tx->nLockTime < best_locktime) {
             best_locktime = psbtx.tx->nLockTime;
         }
     }
 
     // Create a blank psbt where everything will be added
     PartiallySignedTransaction merged_psbt;
     merged_psbt.tx = CMutableTransaction();
     merged_psbt.tx->nVersion = best_version;
     merged_psbt.tx->nLockTime = best_locktime;
 
     // Merge
     for (auto &psbt : psbtxs) {
         for (size_t i = 0; i < psbt.tx->vin.size(); ++i) {
             if (!merged_psbt.AddInput(psbt.tx->vin[i], psbt.inputs[i])) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf(
                         "Input %s:%d exists in multiple PSBTs",
                         psbt.tx->vin[i].prevout.GetTxId().ToString().c_str(),
                         psbt.tx->vin[i].prevout.GetN()));
             }
         }
         for (size_t i = 0; i < psbt.tx->vout.size(); ++i) {
             merged_psbt.AddOutput(psbt.tx->vout[i], psbt.outputs[i]);
         }
         merged_psbt.unknown.insert(psbt.unknown.begin(), psbt.unknown.end());
     }
 
     // Generate list of shuffled indices for shuffling inputs and outputs of the
     // merged PSBT
     std::vector<int> input_indices(merged_psbt.inputs.size());
     std::iota(input_indices.begin(), input_indices.end(), 0);
     std::vector<int> output_indices(merged_psbt.outputs.size());
     std::iota(output_indices.begin(), output_indices.end(), 0);
 
     // Shuffle input and output indices lists
     Shuffle(input_indices.begin(), input_indices.end(), FastRandomContext());
     Shuffle(output_indices.begin(), output_indices.end(), FastRandomContext());
 
     PartiallySignedTransaction shuffled_psbt;
     shuffled_psbt.tx = CMutableTransaction();
     shuffled_psbt.tx->nVersion = merged_psbt.tx->nVersion;
     shuffled_psbt.tx->nLockTime = merged_psbt.tx->nLockTime;
     for (int i : input_indices) {
         shuffled_psbt.AddInput(merged_psbt.tx->vin[i], merged_psbt.inputs[i]);
     }
     for (int i : output_indices) {
         shuffled_psbt.AddOutput(merged_psbt.tx->vout[i],
                                 merged_psbt.outputs[i]);
     }
     shuffled_psbt.unknown.insert(merged_psbt.unknown.begin(),
                                  merged_psbt.unknown.end());
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << shuffled_psbt;
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 UniValue analyzepsbt(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "analyzepsbt",
         "Analyzes and provides information about the current status of a "
         "PSBT and its inputs\n",
         {{"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
           "A base64 string of a PSBT"}},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::ARR,
                  "inputs",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::BOOL, "has_utxo",
                            "Whether a UTXO is provided"},
                           {RPCResult::Type::BOOL, "is_final",
                            "Whether the input is finalized"},
                           {RPCResult::Type::OBJ,
                            "missing",
                            /* optional */ true,
                            "Things that are missing that are required to "
                            "complete this input",
                            {
                                {RPCResult::Type::ARR,
                                 "pubkeys",
                                 /* optional */ true,
                                 "",
                                 {
                                     {RPCResult::Type::STR_HEX, "keyid",
                                      "Public key ID, hash160 of the public "
                                      "key, of a public key whose BIP 32 "
                                      "derivation path is missing"},
                                 }},
                                {RPCResult::Type::ARR,
                                 "signatures",
                                 /* optional */ true,
                                 "",
                                 {
                                     {RPCResult::Type::STR_HEX, "keyid",
                                      "Public key ID, hash160 of the public "
                                      "key, of a public key whose signature is "
                                      "missing"},
                                 }},
                                {RPCResult::Type::STR_HEX, "redeemscript",
                                 /* optional */ true,
                                 "Hash160 of the redeemScript that is missing"},
                            }},
                           {RPCResult::Type::STR, "next", /* optional */ true,
                            "Role of the next person that this input needs to "
                            "go to"},
                       }},
                  }},
                 {RPCResult::Type::NUM, "estimated_vsize", /* optional */ true,
                  "Estimated vsize of the final signed transaction"},
                 {RPCResult::Type::STR_AMOUNT, "estimated_feerate",
                  /* optional */ true,
                  "Estimated feerate of the final signed transaction in " +
                      CURRENCY_UNIT +
                      "/kB. Shown only if all UTXO slots in the PSBT have been "
                      "filled"},
                 {RPCResult::Type::STR_AMOUNT, "fee", /* optional */ true,
                  "The transaction fee paid. Shown only if all UTXO slots in "
                  "the PSBT have been filled"},
                 {RPCResult::Type::STR, "next",
                  "Role of the next person that this psbt needs to go to"},
                 {RPCResult::Type::STR, "error",
                  "Error message if there is one"},
             }},
         RPCExamples{HelpExampleCli("analyzepsbt", "\"psbt\"")}}
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     // Unserialize the transaction
     PartiallySignedTransaction psbtx;
     std::string error;
     if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            strprintf("TX decode failed %s", error));
     }
 
     PSBTAnalysis psbta = AnalyzePSBT(psbtx);
 
     UniValue result(UniValue::VOBJ);
     UniValue inputs_result(UniValue::VARR);
     for (const auto &input : psbta.inputs) {
         UniValue input_univ(UniValue::VOBJ);
         UniValue missing(UniValue::VOBJ);
 
         input_univ.pushKV("has_utxo", input.has_utxo);
         input_univ.pushKV("is_final", input.is_final);
         input_univ.pushKV("next", PSBTRoleName(input.next));
 
         if (!input.missing_pubkeys.empty()) {
             UniValue missing_pubkeys_univ(UniValue::VARR);
             for (const CKeyID &pubkey : input.missing_pubkeys) {
                 missing_pubkeys_univ.push_back(HexStr(pubkey));
             }
             missing.pushKV("pubkeys", missing_pubkeys_univ);
         }
         if (!input.missing_redeem_script.IsNull()) {
             missing.pushKV("redeemscript", HexStr(input.missing_redeem_script));
         }
         if (!input.missing_sigs.empty()) {
             UniValue missing_sigs_univ(UniValue::VARR);
             for (const CKeyID &pubkey : input.missing_sigs) {
                 missing_sigs_univ.push_back(HexStr(pubkey));
             }
             missing.pushKV("signatures", missing_sigs_univ);
         }
         if (!missing.getKeys().empty()) {
             input_univ.pushKV("missing", missing);
         }
         inputs_result.push_back(input_univ);
     }
     if (!inputs_result.empty()) {
         result.pushKV("inputs", inputs_result);
     }
     if (psbta.estimated_vsize != std::nullopt) {
         result.pushKV("estimated_vsize", (int)*psbta.estimated_vsize);
     }
     if (psbta.estimated_feerate != std::nullopt) {
         result.pushKV("estimated_feerate",
                       ValueFromAmount(psbta.estimated_feerate->GetFeePerK()));
     }
     if (psbta.fee != std::nullopt) {
         result.pushKV("fee", ValueFromAmount(*psbta.fee));
     }
     result.pushKV("next", PSBTRoleName(psbta.next));
     if (!psbta.error.empty()) {
         result.pushKV("error", psbta.error);
     }
 
     return result;
 }
 
 void RegisterRawTransactionRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            name                         actor (function)           argNames
         //  ------------------- ------------------------     ----------------------     ----------
         { "rawtransactions",    "getrawtransaction",         getrawtransaction,         {"txid","verbose","blockhash"} },
         { "rawtransactions",    "createrawtransaction",      createrawtransaction,      {"inputs","outputs","locktime"} },
         { "rawtransactions",    "decoderawtransaction",      decoderawtransaction,      {"hexstring"} },
         { "rawtransactions",    "decodescript",              decodescript,              {"hexstring"} },
         { "rawtransactions",    "sendrawtransaction",        sendrawtransaction,        {"hexstring","allowhighfees|maxfeerate"} },
         { "rawtransactions",    "combinerawtransaction",     combinerawtransaction,     {"txs"} },
         { "rawtransactions",    "signrawtransactionwithkey", signrawtransactionwithkey, {"hexstring","privkeys","prevtxs","sighashtype"} },
         { "rawtransactions",    "testmempoolaccept",         testmempoolaccept,         {"rawtxs","allowhighfees|maxfeerate"} },
         { "rawtransactions",    "decodepsbt",                decodepsbt,                {"psbt"} },
         { "rawtransactions",    "combinepsbt",               combinepsbt,               {"txs"} },
         { "rawtransactions",    "finalizepsbt",               finalizepsbt,               {"psbt", "extract"} },
         { "rawtransactions",    "createpsbt",                createpsbt,                {"inputs","outputs","locktime"} },
         { "rawtransactions",    "converttopsbt",             converttopsbt,             {"hexstring","permitsigdata"} },
         { "rawtransactions",    "utxoupdatepsbt",            utxoupdatepsbt,            {"psbt", "descriptors"} },
         { "rawtransactions",    "joinpsbts",                 joinpsbts,                 {"txs"} },
         { "rawtransactions",    "analyzepsbt",               analyzepsbt,               {"psbt"} },
         { "blockchain",         "gettxoutproof",             gettxoutproof,             {"txids", "blockhash"} },
         { "blockchain",         "verifytxoutproof",          verifytxoutproof,          {"proof"} },
     };
     // clang-format on
 
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 058ac4fdd..dfcff6ce5 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -1,893 +1,893 @@
 // Copyright (c) 2017-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.
 
 #include <rpc/util.h>
 
 #include <key_io.h>
 #include <script/descriptor.h>
 #include <script/signingprovider.h>
 #include <tinyformat.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/translation.h>
 
 #include <tuple>
 
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/split.hpp>
 #include <boost/variant/static_visitor.hpp>
 
 const std::string UNIX_EPOCH_TIME = "UNIX epoch time";
 const std::string EXAMPLE_ADDRESS =
     "\"qrmzys48glkpevp2l4t24jtcltc9hyzx9cep2qffm4\"";
 
 void RPCTypeCheck(const UniValue &params,
                   const std::list<UniValueType> &typesExpected,
                   bool fAllowNull) {
     unsigned int i = 0;
     for (const UniValueType &t : typesExpected) {
         if (params.size() <= i) {
             break;
         }
 
         const UniValue &v = params[i];
         if (!(fAllowNull && v.isNull())) {
             RPCTypeCheckArgument(v, t);
         }
         i++;
     }
 }
 
 void RPCTypeCheckArgument(const UniValue &value,
                           const UniValueType &typeExpected) {
     if (!typeExpected.typeAny && value.type() != typeExpected.type) {
         throw JSONRPCError(RPC_TYPE_ERROR,
                            strprintf("Expected type %s, got %s",
                                      uvTypeName(typeExpected.type),
                                      uvTypeName(value.type())));
     }
 }
 
 void RPCTypeCheckObj(const UniValue &o,
                      const std::map<std::string, UniValueType> &typesExpected,
                      bool fAllowNull, bool fStrict) {
     for (const auto &t : typesExpected) {
         const UniValue &v = find_value(o, t.first);
         if (!fAllowNull && v.isNull()) {
             throw JSONRPCError(RPC_TYPE_ERROR,
                                strprintf("Missing %s", t.first));
         }
 
         if (!(t.second.typeAny || v.type() == t.second.type ||
               (fAllowNull && v.isNull()))) {
             std::string err = strprintf("Expected type %s for %s, got %s",
                                         uvTypeName(t.second.type), t.first,
                                         uvTypeName(v.type()));
             throw JSONRPCError(RPC_TYPE_ERROR, err);
         }
     }
 
     if (fStrict) {
         for (const std::string &k : o.getKeys()) {
             if (typesExpected.count(k) == 0) {
                 std::string err = strprintf("Unexpected key %s", k);
                 throw JSONRPCError(RPC_TYPE_ERROR, err);
             }
         }
     }
 }
 
 Amount AmountFromValue(const UniValue &value) {
     if (!value.isNum() && !value.isStr()) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Amount is not a number or string");
     }
 
     int64_t n;
     if (!ParseFixedPoint(value.getValStr(), 8, &n)) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
     }
 
     Amount amt = n * SATOSHI;
     if (!MoneyRange(amt)) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Amount out of range");
     }
 
     return amt;
 }
 
 uint256 ParseHashV(const UniValue &v, std::string strName) {
     std::string strHex(v.get_str());
     if (64 != strHex.length()) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             strprintf("%s must be of length %d (not %d, for '%s')", strName, 64,
                       strHex.length(), strHex));
     }
     // Note: IsHex("") is false
     if (!IsHex(strHex)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            strName + " must be hexadecimal string (not '" +
                                strHex + "')");
     }
     return uint256S(strHex);
 }
 
 uint256 ParseHashO(const UniValue &o, std::string strKey) {
     return ParseHashV(find_value(o, strKey), strKey);
 }
 
 std::vector<uint8_t> ParseHexV(const UniValue &v, std::string strName) {
     std::string strHex;
     if (v.isStr()) {
         strHex = v.get_str();
     }
     if (!IsHex(strHex)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            strName + " must be hexadecimal string (not '" +
                                strHex + "')");
     }
 
     return ParseHex(strHex);
 }
 
 std::vector<uint8_t> ParseHexO(const UniValue &o, std::string strKey) {
     return ParseHexV(find_value(o, strKey), strKey);
 }
 
 std::string HelpExampleCli(const std::string &methodname,
                            const std::string &args) {
     return "> bitcoin-cli " + methodname + " " + args + "\n";
 }
 
 std::string HelpExampleRpc(const std::string &methodname,
                            const std::string &args) {
     return "> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", "
            "\"id\": \"curltest\", "
            "\"method\": \"" +
            methodname + "\", \"params\": [" + args +
            "]}' -H 'content-type: text/plain;' http://127.0.0.1:8332/\n";
 }
 
 // Converts a hex string to a public key if possible
 CPubKey HexToPubKey(const std::string &hex_in) {
     if (!IsHex(hex_in)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid public key: " + hex_in);
     }
     CPubKey vchPubKey(ParseHex(hex_in));
     if (!vchPubKey.IsFullyValid()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid public key: " + hex_in);
     }
     return vchPubKey;
 }
 
 // Retrieves a public key for an address from the given FillableSigningProvider
 CPubKey AddrToPubKey(const CChainParams &chainparams,
                      const FillableSigningProvider &keystore,
                      const std::string &addr_in) {
     CTxDestination dest = DecodeDestination(addr_in, chainparams);
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid address: " + addr_in);
     }
     CKeyID key = GetKeyForDestination(keystore, dest);
     if (key.IsNull()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            strprintf("%s does not refer to a key", addr_in));
     }
     CPubKey vchPubKey;
     if (!keystore.GetPubKey(key, vchPubKey)) {
         throw JSONRPCError(
             RPC_INVALID_ADDRESS_OR_KEY,
             strprintf("no full public key for address %s", addr_in));
     }
     if (!vchPubKey.IsFullyValid()) {
         throw JSONRPCError(RPC_INTERNAL_ERROR,
                            "Wallet contains an invalid public key");
     }
     return vchPubKey;
 }
 
 // Creates a multisig address from a given list of public keys, number of
 // signatures required, and the address type
 CTxDestination AddAndGetMultisigDestination(const int required,
                                             const std::vector<CPubKey> &pubkeys,
                                             OutputType type,
                                             FillableSigningProvider &keystore,
                                             CScript &script_out) {
     // Gather public keys
     if (required < 1) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "a multisignature address must require at least one key to redeem");
     }
     if ((int)pubkeys.size() < required) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            strprintf("not enough keys supplied (got %u keys, "
                                      "but need at least %d to redeem)",
                                      pubkeys.size(), required));
     }
     if (pubkeys.size() > 16) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Number of keys involved in the multisignature "
                            "address creation > 16\nReduce the number");
     }
 
     script_out = GetScriptForMultisig(required, pubkeys);
 
     if (script_out.size() > MAX_SCRIPT_ELEMENT_SIZE) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             (strprintf("redeemScript exceeds size limit: %d > %d",
                        script_out.size(), MAX_SCRIPT_ELEMENT_SIZE)));
     }
 
     // Check if any keys are uncompressed. If so, the type is legacy
     for (const CPubKey &pk : pubkeys) {
         if (!pk.IsCompressed()) {
             type = OutputType::LEGACY;
             break;
         }
     }
 
     // Make the address
     CTxDestination dest =
         AddAndGetDestinationForScript(keystore, script_out, type);
 
     return dest;
 }
 
 class DescribeAddressVisitor : public boost::static_visitor<UniValue> {
 public:
     explicit DescribeAddressVisitor() {}
 
     UniValue operator()(const CNoDestination &dest) const {
         return UniValue(UniValue::VOBJ);
     }
 
     UniValue operator()(const PKHash &keyID) const {
         UniValue obj(UniValue::VOBJ);
         obj.pushKV("isscript", false);
         return obj;
     }
 
     UniValue operator()(const ScriptHash &scriptID) const {
         UniValue obj(UniValue::VOBJ);
         obj.pushKV("isscript", true);
         return obj;
     }
 };
 
 UniValue DescribeAddress(const CTxDestination &dest) {
     return boost::apply_visitor(DescribeAddressVisitor(), dest);
 }
 
 RPCErrorCode RPCErrorFromTransactionError(TransactionError terr) {
     switch (terr) {
         case TransactionError::MEMPOOL_REJECTED:
             return RPC_TRANSACTION_REJECTED;
         case TransactionError::ALREADY_IN_CHAIN:
             return RPC_TRANSACTION_ALREADY_IN_CHAIN;
         case TransactionError::P2P_DISABLED:
             return RPC_CLIENT_P2P_DISABLED;
         case TransactionError::INVALID_PSBT:
         case TransactionError::PSBT_MISMATCH:
             return RPC_INVALID_PARAMETER;
         case TransactionError::SIGHASH_MISMATCH:
             return RPC_DESERIALIZATION_ERROR;
         default:
             break;
     }
     return RPC_TRANSACTION_ERROR;
 }
 
 UniValue JSONRPCTransactionError(TransactionError terr,
                                  const std::string &err_string) {
     if (err_string.length() > 0) {
         return JSONRPCError(RPCErrorFromTransactionError(terr), err_string);
     } else {
         return JSONRPCError(RPCErrorFromTransactionError(terr),
                             TransactionErrorString(terr).original);
     }
 }
 
 /**
  * A pair of strings that can be aligned (through padding) with other Sections
  * later on
  */
 struct Section {
     Section(const std::string &left, const std::string &right)
         : m_left{left}, m_right{right} {}
     const std::string m_left;
     const std::string m_right;
 };
 
 /**
  * Keeps track of RPCArgs by transforming them into sections for the purpose
  * of serializing everything to a single string
  */
 struct Sections {
     std::vector<Section> m_sections;
     size_t m_max_pad{0};
 
     void PushSection(const Section &s) {
         m_max_pad = std::max(m_max_pad, s.m_left.size());
         m_sections.push_back(s);
     }
 
     /**
      * Recursive helper to translate an RPCArg into sections
      */
     void Push(const RPCArg &arg, const size_t current_indent = 5,
               const OuterType outer_type = OuterType::NONE) {
         const auto indent = std::string(current_indent, ' ');
         const auto indent_next = std::string(current_indent + 2, ' ');
         // Dictionary keys must have a name
         const bool push_name{outer_type == OuterType::OBJ};
 
         switch (arg.m_type) {
             case RPCArg::Type::STR_HEX:
             case RPCArg::Type::STR:
             case RPCArg::Type::NUM:
             case RPCArg::Type::AMOUNT:
             case RPCArg::Type::RANGE:
             case RPCArg::Type::BOOL: {
                 // Nothing more to do for non-recursive types on first recursion
                 if (outer_type == OuterType::NONE) {
                     return;
                 }
                 auto left = indent;
                 if (arg.m_type_str.size() != 0 && push_name) {
                     left +=
                         "\"" + arg.GetName() + "\": " + arg.m_type_str.at(0);
                 } else {
                     left += push_name ? arg.ToStringObj(/* oneline */ false)
                                       : arg.ToString(/* oneline */ false);
                 }
                 left += ",";
                 PushSection({left, arg.ToDescriptionString()});
                 break;
             }
             case RPCArg::Type::OBJ:
             case RPCArg::Type::OBJ_USER_KEYS: {
                 const auto right = outer_type == OuterType::NONE
                                        ? ""
                                        : arg.ToDescriptionString();
                 PushSection(
                     {indent + (push_name ? "\"" + arg.GetName() + "\": " : "") +
                          "{",
                      right});
                 for (const auto &arg_inner : arg.m_inner) {
                     Push(arg_inner, current_indent + 2, OuterType::OBJ);
                 }
                 if (arg.m_type != RPCArg::Type::OBJ) {
                     PushSection({indent_next + "...", ""});
                 }
                 PushSection(
                     {indent + "}" + (outer_type != OuterType::NONE ? "," : ""),
                      ""});
                 break;
             }
             case RPCArg::Type::ARR: {
                 auto left = indent;
                 left += push_name ? "\"" + arg.GetName() + "\": " : "";
                 left += "[";
                 const auto right = outer_type == OuterType::NONE
                                        ? ""
                                        : arg.ToDescriptionString();
                 PushSection({left, right});
                 for (const auto &arg_inner : arg.m_inner) {
                     Push(arg_inner, current_indent + 2, OuterType::ARR);
                 }
                 PushSection({indent_next + "...", ""});
                 PushSection(
                     {indent + "]" + (outer_type != OuterType::NONE ? "," : ""),
                      ""});
                 break;
             }
 
                 // no default case, so the compiler can warn about missing cases
         }
     }
 
     /**
      * Concatenate all sections with proper padding
      */
     std::string ToString() const {
         std::string ret;
         const size_t pad = m_max_pad + 4;
         for (const auto &s : m_sections) {
             if (s.m_right.empty()) {
                 ret += s.m_left;
                 ret += "\n";
                 continue;
             }
 
             std::string left = s.m_left;
             left.resize(pad, ' ');
             ret += left;
 
             // Properly pad after newlines
             std::string right;
             size_t begin = 0;
             size_t new_line_pos = s.m_right.find_first_of('\n');
             while (true) {
                 right += s.m_right.substr(begin, new_line_pos - begin);
                 if (new_line_pos == std::string::npos) {
                     // No new line
                     break;
                 }
                 right += "\n" + std::string(pad, ' ');
                 begin = s.m_right.find_first_not_of(' ', new_line_pos + 1);
                 if (begin == std::string::npos) {
                     break; // Empty line
                 }
                 new_line_pos = s.m_right.find_first_of('\n', begin + 1);
             }
             ret += right;
             ret += "\n";
         }
         return ret;
     }
 };
 
 RPCHelpMan::RPCHelpMan(std::string name_, std::string description,
                        std::vector<RPCArg> args, RPCResults results,
                        RPCExamples examples)
     : m_name{std::move(name_)}, m_description{std::move(description)},
       m_args{std::move(args)}, m_results{std::move(results)},
       m_examples{std::move(examples)} {
     std::set<std::string> named_args;
     for (const auto &arg : m_args) {
         std::vector<std::string> names;
         boost::split(names, arg.m_names, boost::is_any_of("|"));
         // Should have unique named arguments
         for (const std::string &name : names) {
             CHECK_NONFATAL(named_args.insert(name).second);
         }
     }
 }
 
 std::string RPCResults::ToDescriptionString() const {
     std::string result;
     for (const auto &r : m_results) {
         if (r.m_cond.empty()) {
             result += "\nResult:\n";
         } else {
             result += "\nResult (" + r.m_cond + "):\n";
         }
         Sections sections;
         r.ToSections(sections);
         result += sections.ToString();
     }
     return result;
 }
 
 std::string RPCExamples::ToDescriptionString() const {
     return m_examples.empty() ? m_examples : "\nExamples:\n" + m_examples;
 }
 
 bool RPCHelpMan::IsValidNumArgs(size_t num_args) const {
     size_t num_required_args = 0;
     for (size_t n = m_args.size(); n > 0; --n) {
         if (!m_args.at(n - 1).IsOptional()) {
             num_required_args = n;
             break;
         }
     }
     return num_required_args <= num_args && num_args <= m_args.size();
 }
 std::string RPCHelpMan::ToString() const {
     std::string ret;
 
     // Oneline summary
     ret += m_name;
     bool was_optional{false};
     for (const auto &arg : m_args) {
         const bool optional = arg.IsOptional();
         ret += " ";
         if (optional) {
             if (!was_optional) {
                 ret += "( ";
             }
             was_optional = true;
         } else {
             if (was_optional) {
                 ret += ") ";
             }
             was_optional = false;
         }
         ret += arg.ToString(/* oneline */ true);
     }
     if (was_optional) {
         ret += " )";
     }
     ret += "\n\n";
 
     // Description
     ret += m_description;
 
     // Arguments
     Sections sections;
     for (size_t i{0}; i < m_args.size(); ++i) {
         const auto &arg = m_args.at(i);
 
         if (i == 0) {
             ret += "\nArguments:\n";
         }
 
         // Push named argument name and description
-        sections.m_sections.emplace_back(std::to_string(i + 1) + ". " +
+        sections.m_sections.emplace_back(::ToString(i + 1) + ". " +
                                              arg.GetFirstName(),
                                          arg.ToDescriptionString());
         sections.m_max_pad = std::max(sections.m_max_pad,
                                       sections.m_sections.back().m_left.size());
 
         // Recursively push nested args
         sections.Push(arg);
     }
     ret += sections.ToString();
 
     // Result
     ret += m_results.ToDescriptionString();
 
     // Examples
     ret += m_examples.ToDescriptionString();
 
     return ret;
 }
 
 std::string RPCArg::GetFirstName() const {
     return m_names.substr(0, m_names.find("|"));
 }
 
 std::string RPCArg::GetName() const {
     CHECK_NONFATAL(std::string::npos == m_names.find("|"));
     return m_names;
 }
 
 bool RPCArg::IsOptional() const {
     if (m_fallback.which() == 1) {
         return true;
     } else {
         return RPCArg::Optional::NO != boost::get<RPCArg::Optional>(m_fallback);
     }
 }
 
 std::string RPCArg::ToDescriptionString() const {
     std::string ret;
     ret += "(";
     if (m_type_str.size() != 0) {
         ret += m_type_str.at(1);
     } else {
         switch (m_type) {
             case Type::STR_HEX:
             case Type::STR: {
                 ret += "string";
                 break;
             }
             case Type::NUM: {
                 ret += "numeric";
                 break;
             }
             case Type::AMOUNT: {
                 ret += "numeric or string";
                 break;
             }
             case Type::RANGE: {
                 ret += "numeric or array";
                 break;
             }
             case Type::BOOL: {
                 ret += "boolean";
                 break;
             }
             case Type::OBJ:
             case Type::OBJ_USER_KEYS: {
                 ret += "json object";
                 break;
             }
             case Type::ARR: {
                 ret += "json array";
                 break;
             }
 
                 // no default case, so the compiler can warn about missing cases
         }
     }
     if (m_fallback.which() == 1) {
         ret += ", optional, default=" + boost::get<std::string>(m_fallback);
     } else {
         switch (boost::get<RPCArg::Optional>(m_fallback)) {
             case RPCArg::Optional::OMITTED: {
                 // nothing to do. Element is treated as if not present and has
                 // no default value
                 break;
             }
             case RPCArg::Optional::OMITTED_NAMED_ARG: {
                 ret += ", optional"; // Default value is "null"
                 break;
             }
             case RPCArg::Optional::NO: {
                 ret += ", required";
                 break;
             }
 
                 // no default case, so the compiler can warn about missing cases
         }
     }
     ret += ")";
     ret += m_description.empty() ? "" : " " + m_description;
     return ret;
 }
 
 void RPCResult::ToSections(Sections &sections, const OuterType outer_type,
                            const int current_indent) const {
     // Indentation
     const std::string indent(current_indent, ' ');
     const std::string indent_next(current_indent + 2, ' ');
 
     // Elements in a JSON structure (dictionary or array) are separated by a
     // comma
     const std::string maybe_separator{outer_type != OuterType::NONE ? "," : ""};
 
     // The key name if recursed into an dictionary
     const std::string maybe_key{
         outer_type == OuterType::OBJ ? "\"" + this->m_key_name + "\" : " : ""};
 
     // Format description with type
     const auto Description = [&](const std::string &type) {
         return "(" + type + (this->m_optional ? ", optional" : "") + ")" +
                (this->m_description.empty() ? "" : " " + this->m_description);
     };
 
     switch (m_type) {
         case Type::ELISION: {
             // If the inner result is empty, use three dots for elision
             sections.PushSection({indent_next + "...", m_description});
             return;
         }
         case Type::NONE: {
             sections.PushSection({indent + "None", Description("json null")});
             return;
         }
         case Type::STR: {
             sections.PushSection(
                 {indent + maybe_key + "\"str\"" + maybe_separator,
                  Description("string")});
             return;
         }
         case Type::STR_AMOUNT: {
             sections.PushSection({indent + maybe_key + "n" + maybe_separator,
                                   Description("numeric")});
             return;
         }
         case Type::STR_HEX: {
             sections.PushSection(
                 {indent + maybe_key + "\"hex\"" + maybe_separator,
                  Description("string")});
             return;
         }
         case Type::NUM: {
             sections.PushSection({indent + maybe_key + "n" + maybe_separator,
                                   Description("numeric")});
             return;
         }
         case Type::NUM_TIME: {
             sections.PushSection({indent + maybe_key + "xxx" + maybe_separator,
                                   Description("numeric")});
             return;
         }
         case Type::BOOL: {
             sections.PushSection(
                 {indent + maybe_key + "true|false" + maybe_separator,
                  Description("boolean")});
             return;
         }
         case Type::ARR_FIXED:
         case Type::ARR: {
             sections.PushSection(
                 {indent + maybe_key + "[", Description("json array")});
             for (const auto &i : m_inner) {
                 i.ToSections(sections, OuterType::ARR, current_indent + 2);
             }
             if (m_type == Type::ARR) {
                 sections.PushSection({indent_next + "...", ""});
             }
             sections.PushSection({indent + "]" + maybe_separator, ""});
             return;
         }
         case Type::OBJ_DYN:
         case Type::OBJ: {
             sections.PushSection(
                 {indent + maybe_key + "{", Description("json object")});
             for (const auto &i : m_inner) {
                 i.ToSections(sections, OuterType::OBJ, current_indent + 2);
             }
             if (m_type == Type::OBJ_DYN) {
                 // If the dictionary keys are dynamic, use three dots for
                 // continuation
                 sections.PushSection({indent_next + "...", ""});
             }
             sections.PushSection({indent + "}" + maybe_separator, ""});
             return;
         }
 
             // no default case, so the compiler can warn about missing cases
     }
 
     CHECK_NONFATAL(false);
 }
 
 std::string RPCArg::ToStringObj(const bool oneline) const {
     std::string res;
     res += "\"";
     res += GetFirstName();
     if (oneline) {
         res += "\":";
     } else {
         res += "\": ";
     }
     switch (m_type) {
         case Type::STR:
             return res + "\"str\"";
         case Type::STR_HEX:
             return res + "\"hex\"";
         case Type::NUM:
             return res + "n";
         case Type::RANGE:
             return res + "n or [n,n]";
         case Type::AMOUNT:
             return res + "amount";
         case Type::BOOL:
             return res + "bool";
         case Type::ARR:
             res += "[";
             for (const auto &i : m_inner) {
                 res += i.ToString(oneline) + ",";
             }
             return res + "...]";
         case Type::OBJ:
         case Type::OBJ_USER_KEYS:
             // Currently unused, so avoid writing dead code
             CHECK_NONFATAL(false);
 
             // no default case, so the compiler can warn about missing cases
     }
     CHECK_NONFATAL(false);
 }
 
 std::string RPCArg::ToString(const bool oneline) const {
     if (oneline && !m_oneline_description.empty()) {
         return m_oneline_description;
     }
 
     switch (m_type) {
         case Type::STR_HEX:
         case Type::STR: {
             return "\"" + GetFirstName() + "\"";
         }
         case Type::NUM:
         case Type::RANGE:
         case Type::AMOUNT:
         case Type::BOOL: {
             return GetFirstName();
         }
         case Type::OBJ:
         case Type::OBJ_USER_KEYS: {
             const std::string res = Join(m_inner, ",", [&](const RPCArg &i) {
                 return i.ToStringObj(oneline);
             });
             if (m_type == Type::OBJ) {
                 return "{" + res + "}";
             } else {
                 return "{" + res + ",...}";
             }
         }
         case Type::ARR: {
             std::string res;
             for (const auto &i : m_inner) {
                 res += i.ToString(oneline) + ",";
             }
             return "[" + res + "...]";
         }
 
             // no default case, so the compiler can warn about missing cases
     }
     CHECK_NONFATAL(false);
 }
 
 static std::pair<int64_t, int64_t> ParseRange(const UniValue &value) {
     if (value.isNum()) {
         return {0, value.get_int64()};
     }
     if (value.isArray() && value.size() == 2 && value[0].isNum() &&
         value[1].isNum()) {
         int64_t low = value[0].get_int64();
         int64_t high = value[1].get_int64();
         if (low > high) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Range specified as [begin,end] must not have begin after end");
         }
         return {low, high};
     }
     throw JSONRPCError(RPC_INVALID_PARAMETER,
                        "Range must be specified as end or as [begin,end]");
 }
 
 std::pair<int64_t, int64_t> ParseDescriptorRange(const UniValue &value) {
     int64_t low, high;
     std::tie(low, high) = ParseRange(value);
     if (low < 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Range should be greater or equal than 0");
     }
     if ((high >> 31) != 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "End of range is too high");
     }
     if (high >= low + 1000000) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Range is too large");
     }
     return {low, high};
 }
 
 std::vector<CScript>
 EvalDescriptorStringOrObject(const UniValue &scanobject,
                              FlatSigningProvider &provider) {
     std::string desc_str;
     std::pair<int64_t, int64_t> range = {0, 1000};
     if (scanobject.isStr()) {
         desc_str = scanobject.get_str();
     } else if (scanobject.isObject()) {
         UniValue desc_uni = find_value(scanobject, "desc");
         if (desc_uni.isNull()) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Descriptor needs to be provided in scan object");
         }
         desc_str = desc_uni.get_str();
         UniValue range_uni = find_value(scanobject, "range");
         if (!range_uni.isNull()) {
             range = ParseDescriptorRange(range_uni);
         }
     } else {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "Scan object needs to be either a string or an object");
     }
 
     std::string error;
     auto desc = Parse(desc_str, provider, error);
     if (!desc) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
     }
     if (!desc->IsRange()) {
         range.first = 0;
         range.second = 0;
     }
     std::vector<CScript> ret;
     for (int i = range.first; i <= range.second; ++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: '%s'",
                           desc_str));
         }
         std::move(scripts.begin(), scripts.end(), std::back_inserter(ret));
     }
     return ret;
 }
 
 UniValue GetServicesNames(ServiceFlags services) {
     UniValue servicesNames(UniValue::VARR);
 
     for (const auto &flag : serviceFlagsToStr(services)) {
         servicesNames.push_back(flag);
     }
 
     return servicesNames;
 }
diff --git a/src/test/addrman_tests.cpp b/src/test/addrman_tests.cpp
index fc9412994..561c8b77d 100644
--- a/src/test/addrman_tests.cpp
+++ b/src/test/addrman_tests.cpp
@@ -1,929 +1,927 @@
 // Copyright (c) 2012-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.
 #include <addrman.h>
 
 #include <hash.h>
 #include <netbase.h>
 #include <random.h>
 #include <util/asmap.h>
+#include <util/string.h>
 
 #include <test/data/asmap.raw.h>
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <string>
 
 class CAddrManTest : public CAddrMan {
 private:
     bool deterministic;
 
 public:
     explicit CAddrManTest(bool makeDeterministic = true,
                           std::vector<bool> asmap = std::vector<bool>()) {
         if (makeDeterministic) {
             // Set addrman addr placement to be deterministic.
             MakeDeterministic();
         }
         deterministic = makeDeterministic;
         m_asmap = asmap;
     }
 
     //! Ensure that bucket placement is always the same for testing purposes.
     void MakeDeterministic() {
         nKey.SetNull();
         insecure_rand = FastRandomContext(true);
     }
 
     CAddrInfo *Find(const CNetAddr &addr, int *pnId = nullptr) {
         LOCK(cs);
         return CAddrMan::Find(addr, pnId);
     }
 
     CAddrInfo *Create(const CAddress &addr, const CNetAddr &addrSource,
                       int *pnId = nullptr) {
         LOCK(cs);
         return CAddrMan::Create(addr, addrSource, pnId);
     }
 
     void Delete(int nId) {
         LOCK(cs);
         CAddrMan::Delete(nId);
     }
 
     // Used to test deserialization
     std::pair<int, int> GetBucketAndEntry(const CAddress &addr) {
         LOCK(cs);
         int nId = mapAddr[addr];
         for (int bucket = 0; bucket < ADDRMAN_NEW_BUCKET_COUNT; ++bucket) {
             for (int entry = 0; entry < ADDRMAN_BUCKET_SIZE; ++entry) {
                 if (nId == vvNew[bucket][entry]) {
                     return std::pair<int, int>(bucket, entry);
                 }
             }
         }
         return std::pair<int, int>(-1, -1);
     }
 
     // Simulates connection failure so that we can test eviction of offline
     // nodes
     void SimConnFail(CService &addr) {
         LOCK(cs);
         int64_t nLastSuccess = 1;
         // Set last good connection in the deep past.
         Good_(addr, true, nLastSuccess);
 
         bool count_failure = false;
         int64_t nLastTry = GetAdjustedTime() - 61;
         Attempt(addr, count_failure, nLastTry);
     }
 
     void Clear() {
         CAddrMan::Clear();
         if (deterministic) {
             nKey.SetNull();
             insecure_rand = FastRandomContext(true);
         }
     }
 };
 
 static CNetAddr ResolveIP(const std::string &ip) {
     CNetAddr addr;
     BOOST_CHECK_MESSAGE(LookupHost(ip, addr, false),
                         strprintf("failed to resolve: %s", ip));
     return addr;
 }
 
 static CService ResolveService(const std::string &ip, const int port = 0) {
     CService serv;
     BOOST_CHECK_MESSAGE(Lookup(ip, serv, port, false),
                         strprintf("failed to resolve: %s:%i", ip, port));
     return serv;
 }
 
 static std::vector<bool> FromBytes(const uint8_t *source, int vector_size) {
     std::vector<bool> result(vector_size);
     for (int byte_i = 0; byte_i < vector_size / 8; ++byte_i) {
         uint8_t cur_byte = source[byte_i];
         for (int bit_i = 0; bit_i < 8; ++bit_i) {
             result[byte_i * 8 + bit_i] = (cur_byte >> bit_i) & 1;
         }
     }
     return result;
 }
 
 BOOST_FIXTURE_TEST_SUITE(addrman_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(addrman_simple) {
     CAddrManTest addrman;
 
     CNetAddr source = ResolveIP("252.2.2.2");
 
     // Test: Does Addrman respond correctly when empty.
     BOOST_CHECK_EQUAL(addrman.size(), 0U);
     CAddrInfo addr_null = addrman.Select();
     BOOST_CHECK_EQUAL(addr_null.ToString(), "[::]:0");
 
     // Test: Does Addrman::Add work as expected.
     CService addr1 = ResolveService("250.1.1.1", 8333);
     BOOST_CHECK(addrman.Add(CAddress(addr1, NODE_NONE), source));
     BOOST_CHECK_EQUAL(addrman.size(), 1U);
     CAddrInfo addr_ret1 = addrman.Select();
     BOOST_CHECK_EQUAL(addr_ret1.ToString(), "250.1.1.1:8333");
 
     // Test: Does IP address deduplication work correctly.
     //  Expected dup IP should not be added.
     CService addr1_dup = ResolveService("250.1.1.1", 8333);
     BOOST_CHECK(!addrman.Add(CAddress(addr1_dup, NODE_NONE), source));
     BOOST_CHECK_EQUAL(addrman.size(), 1U);
 
     // Test: New table has one addr and we add a diff addr we should
     //  have at least one addr.
     // Note that addrman's size cannot be tested reliably after insertion, as
     // hash collisions may occur. But we can always be sure of at least one
     // success.
     CService addr2 = ResolveService("250.1.1.2", 8333);
     BOOST_CHECK(addrman.Add(CAddress(addr2, NODE_NONE), source));
     BOOST_CHECK(addrman.size() >= 1);
 
     // Test: AddrMan::Clear() should empty the new table.
     addrman.Clear();
     BOOST_CHECK_EQUAL(addrman.size(), 0U);
     CAddrInfo addr_null2 = addrman.Select();
     BOOST_CHECK_EQUAL(addr_null2.ToString(), "[::]:0");
 
     // Test: AddrMan::Add multiple addresses works as expected
     std::vector<CAddress> vAddr;
     vAddr.push_back(CAddress(ResolveService("250.1.1.3", 8333), NODE_NONE));
     vAddr.push_back(CAddress(ResolveService("250.1.1.4", 8333), NODE_NONE));
     BOOST_CHECK(addrman.Add(vAddr, source));
     BOOST_CHECK(addrman.size() >= 1);
 }
 
 BOOST_AUTO_TEST_CASE(addrman_ports) {
     CAddrManTest addrman;
 
     CNetAddr source = ResolveIP("252.2.2.2");
 
     BOOST_CHECK_EQUAL(addrman.size(), 0U);
 
     // Test: Addr with same IP but diff port does not replace existing addr.
     CService addr1 = ResolveService("250.1.1.1", 8333);
     BOOST_CHECK(addrman.Add(CAddress(addr1, NODE_NONE), source));
     BOOST_CHECK_EQUAL(addrman.size(), 1U);
 
     CService addr1_port = ResolveService("250.1.1.1", 8334);
     BOOST_CHECK(!addrman.Add(CAddress(addr1_port, NODE_NONE), source));
     BOOST_CHECK_EQUAL(addrman.size(), 1U);
     CAddrInfo addr_ret2 = addrman.Select();
     BOOST_CHECK_EQUAL(addr_ret2.ToString(), "250.1.1.1:8333");
 
     // Test: Add same IP but diff port to tried table, it doesn't get added.
     //  Perhaps this is not ideal behavior but it is the current behavior.
     addrman.Good(CAddress(addr1_port, NODE_NONE));
     BOOST_CHECK_EQUAL(addrman.size(), 1U);
     bool newOnly = true;
     CAddrInfo addr_ret3 = addrman.Select(newOnly);
     BOOST_CHECK_EQUAL(addr_ret3.ToString(), "250.1.1.1:8333");
 }
 
 BOOST_AUTO_TEST_CASE(addrman_select) {
     CAddrManTest addrman;
 
     CNetAddr source = ResolveIP("252.2.2.2");
 
     // Test: Select from new with 1 addr in new.
     CService addr1 = ResolveService("250.1.1.1", 8333);
     BOOST_CHECK(addrman.Add(CAddress(addr1, NODE_NONE), source));
     BOOST_CHECK_EQUAL(addrman.size(), 1U);
 
     bool newOnly = true;
     CAddrInfo addr_ret1 = addrman.Select(newOnly);
     BOOST_CHECK_EQUAL(addr_ret1.ToString(), "250.1.1.1:8333");
 
     // Test: move addr to tried, select from new expected nothing returned.
     addrman.Good(CAddress(addr1, NODE_NONE));
     BOOST_CHECK_EQUAL(addrman.size(), 1U);
     CAddrInfo addr_ret2 = addrman.Select(newOnly);
     BOOST_CHECK_EQUAL(addr_ret2.ToString(), "[::]:0");
 
     CAddrInfo addr_ret3 = addrman.Select();
     BOOST_CHECK_EQUAL(addr_ret3.ToString(), "250.1.1.1:8333");
 
     BOOST_CHECK_EQUAL(addrman.size(), 1U);
 
     // Add three addresses to new table.
     CService addr2 = ResolveService("250.3.1.1", 8333);
     CService addr3 = ResolveService("250.3.2.2", 9999);
     CService addr4 = ResolveService("250.3.3.3", 9999);
 
     BOOST_CHECK(addrman.Add(CAddress(addr2, NODE_NONE),
                             ResolveService("250.3.1.1", 8333)));
     BOOST_CHECK(addrman.Add(CAddress(addr3, NODE_NONE),
                             ResolveService("250.3.1.1", 8333)));
     BOOST_CHECK(addrman.Add(CAddress(addr4, NODE_NONE),
                             ResolveService("250.4.1.1", 8333)));
 
     // Add three addresses to tried table.
     CService addr5 = ResolveService("250.4.4.4", 8333);
     CService addr6 = ResolveService("250.4.5.5", 7777);
     CService addr7 = ResolveService("250.4.6.6", 8333);
 
     BOOST_CHECK(addrman.Add(CAddress(addr5, NODE_NONE),
                             ResolveService("250.3.1.1", 8333)));
     addrman.Good(CAddress(addr5, NODE_NONE));
     BOOST_CHECK(addrman.Add(CAddress(addr6, NODE_NONE),
                             ResolveService("250.3.1.1", 8333)));
     addrman.Good(CAddress(addr6, NODE_NONE));
     BOOST_CHECK(addrman.Add(CAddress(addr7, NODE_NONE),
                             ResolveService("250.1.1.3", 8333)));
     addrman.Good(CAddress(addr7, NODE_NONE));
 
     // Test: 6 addrs + 1 addr from last test = 7.
     BOOST_CHECK_EQUAL(addrman.size(), 7U);
 
     // Test: Select pulls from new and tried regardless of port number.
     std::set<uint16_t> ports;
     for (int i = 0; i < 20; ++i) {
         ports.insert(addrman.Select().GetPort());
     }
     BOOST_CHECK_EQUAL(ports.size(), 3U);
 }
 
 BOOST_AUTO_TEST_CASE(addrman_new_collisions) {
     CAddrManTest addrman;
 
     CNetAddr source = ResolveIP("252.2.2.2");
 
     BOOST_CHECK_EQUAL(addrman.size(), 0U);
 
     for (unsigned int i = 1; i < 18; i++) {
-        CService addr = ResolveService("250.1.1." + std::to_string(i));
+        CService addr = ResolveService("250.1.1." + ToString(i));
         BOOST_CHECK(addrman.Add(CAddress(addr, NODE_NONE), source));
 
         // Test: No collision in new table yet.
         BOOST_CHECK_EQUAL(addrman.size(), i);
     }
 
     // Test: new table collision!
     CService addr1 = ResolveService("250.1.1.18");
     BOOST_CHECK(addrman.Add(CAddress(addr1, NODE_NONE), source));
     BOOST_CHECK_EQUAL(addrman.size(), 17U);
 
     CService addr2 = ResolveService("250.1.1.19");
     BOOST_CHECK(addrman.Add(CAddress(addr2, NODE_NONE), source));
     BOOST_CHECK_EQUAL(addrman.size(), 18U);
 }
 
 BOOST_AUTO_TEST_CASE(addrman_tried_collisions) {
     CAddrManTest addrman;
 
     CNetAddr source = ResolveIP("252.2.2.2");
 
     BOOST_CHECK_EQUAL(addrman.size(), 0U);
 
     for (unsigned int i = 1; i < 80; i++) {
-        CService addr = ResolveService("250.1.1." + std::to_string(i));
+        CService addr = ResolveService("250.1.1." + ToString(i));
         BOOST_CHECK(addrman.Add(CAddress(addr, NODE_NONE), source));
         addrman.Good(CAddress(addr, NODE_NONE));
 
         // Test: No collision in tried table yet.
         BOOST_CHECK_EQUAL(addrman.size(), i);
     }
 
     // Test: tried table collision!
     CService addr1 = ResolveService("250.1.1.80");
     BOOST_CHECK(addrman.Add(CAddress(addr1, NODE_NONE), source));
     BOOST_CHECK_EQUAL(addrman.size(), 79U);
 
     CService addr2 = ResolveService("250.1.1.81");
     BOOST_CHECK(addrman.Add(CAddress(addr2, NODE_NONE), source));
     BOOST_CHECK_EQUAL(addrman.size(), 80U);
 }
 
 BOOST_AUTO_TEST_CASE(addrman_find) {
     CAddrManTest addrman;
 
     BOOST_CHECK_EQUAL(addrman.size(), 0U);
 
     CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
     CAddress addr2 = CAddress(ResolveService("250.1.2.1", 9999), NODE_NONE);
     CAddress addr3 = CAddress(ResolveService("251.255.2.1", 8333), NODE_NONE);
 
     CNetAddr source1 = ResolveIP("250.1.2.1");
     CNetAddr source2 = ResolveIP("250.1.2.2");
 
     BOOST_CHECK(addrman.Add(addr1, source1));
     BOOST_CHECK(!addrman.Add(addr2, source2));
     BOOST_CHECK(addrman.Add(addr3, source1));
 
     // Test: ensure Find returns an IP matching what we searched on.
     CAddrInfo *info1 = addrman.Find(addr1);
     BOOST_REQUIRE(info1);
     BOOST_CHECK_EQUAL(info1->ToString(), "250.1.2.1:8333");
 
     // Test: Find does not discriminate by port number.
     CAddrInfo *info2 = addrman.Find(addr2);
     BOOST_REQUIRE(info2);
     BOOST_CHECK_EQUAL(info2->ToString(), info1->ToString());
 
     // Test: Find returns another IP matching what we searched on.
     CAddrInfo *info3 = addrman.Find(addr3);
     BOOST_REQUIRE(info3);
     BOOST_CHECK_EQUAL(info3->ToString(), "251.255.2.1:8333");
 }
 
 BOOST_AUTO_TEST_CASE(addrman_create) {
     CAddrManTest addrman;
 
     BOOST_CHECK_EQUAL(addrman.size(), 0U);
 
     CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
     CNetAddr source1 = ResolveIP("250.1.2.1");
 
     int nId;
     CAddrInfo *pinfo = addrman.Create(addr1, source1, &nId);
 
     // Test: The result should be the same as the input addr.
     BOOST_CHECK_EQUAL(pinfo->ToString(), "250.1.2.1:8333");
 
     CAddrInfo *info2 = addrman.Find(addr1);
     BOOST_CHECK_EQUAL(info2->ToString(), "250.1.2.1:8333");
 }
 
 BOOST_AUTO_TEST_CASE(addrman_delete) {
     CAddrManTest addrman;
 
     BOOST_CHECK_EQUAL(addrman.size(), 0U);
 
     CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
     CNetAddr source1 = ResolveIP("250.1.2.1");
 
     int nId;
     addrman.Create(addr1, source1, &nId);
 
     // Test: Delete should actually delete the addr.
     BOOST_CHECK_EQUAL(addrman.size(), 1U);
     addrman.Delete(nId);
     BOOST_CHECK_EQUAL(addrman.size(), 0U);
     CAddrInfo *info2 = addrman.Find(addr1);
     BOOST_CHECK(info2 == nullptr);
 }
 
 BOOST_AUTO_TEST_CASE(addrman_getaddr) {
     CAddrManTest addrman;
 
     // Test: Sanity check, GetAddr should never return anything if addrman
     //  is empty.
     BOOST_CHECK_EQUAL(addrman.size(), 0U);
     std::vector<CAddress> vAddr1 = addrman.GetAddr();
     BOOST_CHECK_EQUAL(vAddr1.size(), 0U);
 
     CAddress addr1 = CAddress(ResolveService("250.250.2.1", 8333), NODE_NONE);
     addr1.nTime = GetAdjustedTime(); // Set time so isTerrible = false
     CAddress addr2 = CAddress(ResolveService("250.251.2.2", 9999), NODE_NONE);
     addr2.nTime = GetAdjustedTime();
     CAddress addr3 = CAddress(ResolveService("251.252.2.3", 8333), NODE_NONE);
     addr3.nTime = GetAdjustedTime();
     CAddress addr4 = CAddress(ResolveService("252.253.3.4", 8333), NODE_NONE);
     addr4.nTime = GetAdjustedTime();
     CAddress addr5 = CAddress(ResolveService("252.254.4.5", 8333), NODE_NONE);
     addr5.nTime = GetAdjustedTime();
     CNetAddr source1 = ResolveIP("250.1.2.1");
     CNetAddr source2 = ResolveIP("250.2.3.3");
 
     // Test: Ensure GetAddr works with new addresses.
     BOOST_CHECK(addrman.Add(addr1, source1));
     BOOST_CHECK(addrman.Add(addr2, source2));
     BOOST_CHECK(addrman.Add(addr3, source1));
     BOOST_CHECK(addrman.Add(addr4, source2));
     BOOST_CHECK(addrman.Add(addr5, source1));
 
     // GetAddr returns 23% of addresses, 23% of 5 is 1 rounded down.
     BOOST_CHECK_EQUAL(addrman.GetAddr().size(), 1U);
 
     // Test: Ensure GetAddr works with new and tried addresses.
     addrman.Good(CAddress(addr1, NODE_NONE));
     addrman.Good(CAddress(addr2, NODE_NONE));
     BOOST_CHECK_EQUAL(addrman.GetAddr().size(), 1U);
 
     // Test: Ensure GetAddr still returns 23% when addrman has many addrs.
     for (unsigned int i = 1; i < (8 * 256); i++) {
         int octet1 = i % 256;
         int octet2 = i >> 8 % 256;
         std::string strAddr =
-            std::to_string(octet1) + "." + std::to_string(octet2) + ".1.23";
+            ToString(octet1) + "." + ToString(octet2) + ".1.23";
         CAddress addr = CAddress(ResolveService(strAddr), NODE_NONE);
 
         // Ensure that for all addrs in addrman, isTerrible == false.
         addr.nTime = GetAdjustedTime();
         addrman.Add(addr, ResolveIP(strAddr));
         if (i % 8 == 0) {
             addrman.Good(addr);
         }
     }
     std::vector<CAddress> vAddr = addrman.GetAddr();
 
     size_t percent23 = (addrman.size() * 23) / 100;
     BOOST_CHECK_EQUAL(vAddr.size(), percent23);
     BOOST_CHECK_EQUAL(vAddr.size(), 461U);
     // (Addrman.size() < number of addresses added) due to address collisions.
     BOOST_CHECK_EQUAL(addrman.size(), 2006U);
 }
 
 BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket_legacy) {
     CAddrManTest addrman;
 
     CAddress addr1 = CAddress(ResolveService("250.1.1.1", 8333), NODE_NONE);
     CAddress addr2 = CAddress(ResolveService("250.1.1.1", 9999), NODE_NONE);
 
     CNetAddr source1 = ResolveIP("250.1.1.1");
 
     CAddrInfo info1 = CAddrInfo(addr1, source1);
 
     uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash();
     uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash();
 
     // use /16
     std::vector<bool> asmap;
 
     BOOST_CHECK_EQUAL(info1.GetTriedBucket(nKey1, asmap), 40);
 
     // Test: Make sure key actually randomizes bucket placement. A fail on
     //  this test could be a security issue.
     BOOST_CHECK(info1.GetTriedBucket(nKey1, asmap) !=
                 info1.GetTriedBucket(nKey2, asmap));
 
     // Test: Two addresses with same IP but different ports can map to
     //  different buckets because they have different keys.
     CAddrInfo info2 = CAddrInfo(addr2, source1);
 
     BOOST_CHECK(info1.GetKey() != info2.GetKey());
     BOOST_CHECK(info1.GetTriedBucket(nKey1, asmap) !=
                 info2.GetTriedBucket(nKey1, asmap));
 
     std::set<int> buckets;
     for (int i = 0; i < 255; i++) {
         CAddrInfo infoi = CAddrInfo(
-            CAddress(ResolveService("250.1.1." + std::to_string(i)), NODE_NONE),
-            ResolveIP("250.1.1." + std::to_string(i)));
+            CAddress(ResolveService("250.1.1." + ToString(i)), NODE_NONE),
+            ResolveIP("250.1.1." + ToString(i)));
         int bucket = infoi.GetTriedBucket(nKey1, asmap);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the same /16 prefix should never get more than 8
     // buckets with legacy grouping
     BOOST_CHECK_EQUAL(buckets.size(), 8U);
 
     buckets.clear();
     for (int j = 0; j < 255; j++) {
         CAddrInfo infoj = CAddrInfo(
-            CAddress(ResolveService("250." + std::to_string(j) + ".1.1"),
-                     NODE_NONE),
-            ResolveIP("250." + std::to_string(j) + ".1.1"));
+            CAddress(ResolveService("250." + ToString(j) + ".1.1"), NODE_NONE),
+            ResolveIP("250." + ToString(j) + ".1.1"));
         int bucket = infoj.GetTriedBucket(nKey1, asmap);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the different /16 prefix should map to more than 8
     // buckets with legacy grouping
     BOOST_CHECK_EQUAL(buckets.size(), 160U);
 }
 
 BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket_legacy) {
     CAddrManTest addrman;
 
     CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
     CAddress addr2 = CAddress(ResolveService("250.1.2.1", 9999), NODE_NONE);
 
     CNetAddr source1 = ResolveIP("250.1.2.1");
 
     CAddrInfo info1 = CAddrInfo(addr1, source1);
 
     uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash();
     uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash();
 
     // use /16
     std::vector<bool> asmap;
 
     // Test: Make sure the buckets are what we expect
     BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, asmap), 786);
     BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, source1, asmap), 786);
 
     // Test: Make sure key actually randomizes bucket placement. A fail on
     //  this test could be a security issue.
     BOOST_CHECK(info1.GetNewBucket(nKey1, asmap) !=
                 info1.GetNewBucket(nKey2, asmap));
 
     // Test: Ports should not affect bucket placement in the addr
     CAddrInfo info2 = CAddrInfo(addr2, source1);
     BOOST_CHECK(info1.GetKey() != info2.GetKey());
     BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, asmap),
                       info2.GetNewBucket(nKey1, asmap));
 
     std::set<int> buckets;
     for (int i = 0; i < 255; i++) {
         CAddrInfo infoi = CAddrInfo(
-            CAddress(ResolveService("250.1.1." + std::to_string(i)), NODE_NONE),
-            ResolveIP("250.1.1." + std::to_string(i)));
+            CAddress(ResolveService("250.1.1." + ToString(i)), NODE_NONE),
+            ResolveIP("250.1.1." + ToString(i)));
         int bucket = infoi.GetNewBucket(nKey1, asmap);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the same group (\16 prefix for IPv4) should
     //  always map to the same bucket.
     BOOST_CHECK_EQUAL(buckets.size(), 1U);
 
     buckets.clear();
     for (int j = 0; j < 4 * 255; j++) {
-        CAddrInfo infoj = CAddrInfo(
-            CAddress(ResolveService(std::to_string(250 + (j / 255)) + "." +
-                                    std::to_string(j % 256) + ".1.1"),
-                     NODE_NONE),
-            ResolveIP("251.4.1.1"));
+        CAddrInfo infoj =
+            CAddrInfo(CAddress(ResolveService(ToString(250 + (j / 255)) + "." +
+                                              ToString(j % 256) + ".1.1"),
+                               NODE_NONE),
+                      ResolveIP("251.4.1.1"));
         int bucket = infoj.GetNewBucket(nKey1, asmap);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the same source groups should map to NO MORE
     //  than 64 buckets.
     BOOST_CHECK(buckets.size() <= 64);
 
     buckets.clear();
     for (int p = 0; p < 255; p++) {
         CAddrInfo infoj =
             CAddrInfo(CAddress(ResolveService("250.1.1.1"), NODE_NONE),
-                      ResolveIP("250." + std::to_string(p) + ".1.1"));
+                      ResolveIP("250." + ToString(p) + ".1.1"));
         int bucket = infoj.GetNewBucket(nKey1, asmap);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the different source groups should map to more
     //  than 64 buckets.
     BOOST_CHECK(buckets.size() > 64);
 }
 
 // The following three test cases use asmap.raw
 // We use an artificial minimal mock mapping
 // 250.0.0.0/8 AS1000
 // 101.1.0.0/16 AS1
 // 101.2.0.0/16 AS2
 // 101.3.0.0/16 AS3
 // 101.4.0.0/16 AS4
 // 101.5.0.0/16 AS5
 // 101.6.0.0/16 AS6
 // 101.7.0.0/16 AS7
 // 101.8.0.0/16 AS8
 BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket) {
     CAddrManTest addrman;
 
     CAddress addr1 = CAddress(ResolveService("250.1.1.1", 8333), NODE_NONE);
     CAddress addr2 = CAddress(ResolveService("250.1.1.1", 9999), NODE_NONE);
 
     CNetAddr source1 = ResolveIP("250.1.1.1");
 
     CAddrInfo info1 = CAddrInfo(addr1, source1);
 
     uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash();
     uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash();
 
     std::vector<bool> asmap = FromBytes(asmap_raw, sizeof(asmap_raw) * 8);
 
     BOOST_CHECK_EQUAL(info1.GetTriedBucket(nKey1, asmap), 236);
 
     // Test: Make sure key actually randomizes bucket placement. A fail on
     //  this test could be a security issue.
     BOOST_CHECK(info1.GetTriedBucket(nKey1, asmap) !=
                 info1.GetTriedBucket(nKey2, asmap));
 
     // Test: Two addresses with same IP but different ports can map to
     //  different buckets because they have different keys.
     CAddrInfo info2 = CAddrInfo(addr2, source1);
 
     BOOST_CHECK(info1.GetKey() != info2.GetKey());
     BOOST_CHECK(info1.GetTriedBucket(nKey1, asmap) !=
                 info2.GetTriedBucket(nKey1, asmap));
 
     std::set<int> buckets;
     for (int j = 0; j < 255; j++) {
         CAddrInfo infoj = CAddrInfo(
-            CAddress(ResolveService("101." + std::to_string(j) + ".1.1"),
-                     NODE_NONE),
-            ResolveIP("101." + std::to_string(j) + ".1.1"));
+            CAddress(ResolveService("101." + ToString(j) + ".1.1"), NODE_NONE),
+            ResolveIP("101." + ToString(j) + ".1.1"));
         int bucket = infoj.GetTriedBucket(nKey1, asmap);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the different /16 prefix MAY map to more than
     // 8 buckets.
     BOOST_CHECK(buckets.size() > 8);
 
     buckets.clear();
     for (int j = 0; j < 255; j++) {
         CAddrInfo infoj = CAddrInfo(
-            CAddress(ResolveService("250." + std::to_string(j) + ".1.1"),
-                     NODE_NONE),
-            ResolveIP("250." + std::to_string(j) + ".1.1"));
+            CAddress(ResolveService("250." + ToString(j) + ".1.1"), NODE_NONE),
+            ResolveIP("250." + ToString(j) + ".1.1"));
         int bucket = infoj.GetTriedBucket(nKey1, asmap);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the different /16 prefix MAY NOT map to more than
     // 8 buckets.
     BOOST_CHECK(buckets.size() == 8);
 }
 
 BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket) {
     CAddrManTest addrman;
 
     CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
     CAddress addr2 = CAddress(ResolveService("250.1.2.1", 9999), NODE_NONE);
 
     CNetAddr source1 = ResolveIP("250.1.2.1");
 
     CAddrInfo info1 = CAddrInfo(addr1, source1);
 
     uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash();
     uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash();
 
     std::vector<bool> asmap = FromBytes(asmap_raw, sizeof(asmap_raw) * 8);
 
     // Test: Make sure the buckets are what we expect
     BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, asmap), 795);
     BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, source1, asmap), 795);
 
     // Test: Make sure key actually randomizes bucket placement. A fail on
     //  this test could be a security issue.
     BOOST_CHECK(info1.GetNewBucket(nKey1, asmap) !=
                 info1.GetNewBucket(nKey2, asmap));
 
     // Test: Ports should not affect bucket placement in the addr
     CAddrInfo info2 = CAddrInfo(addr2, source1);
     BOOST_CHECK(info1.GetKey() != info2.GetKey());
     BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, asmap),
                       info2.GetNewBucket(nKey1, asmap));
 
     std::set<int> buckets;
     for (int i = 0; i < 255; i++) {
         CAddrInfo infoi = CAddrInfo(
-            CAddress(ResolveService("250.1.1." + std::to_string(i)), NODE_NONE),
-            ResolveIP("250.1.1." + std::to_string(i)));
+            CAddress(ResolveService("250.1.1." + ToString(i)), NODE_NONE),
+            ResolveIP("250.1.1." + ToString(i)));
         int bucket = infoi.GetNewBucket(nKey1, asmap);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the same /16 prefix
     // usually map to the same bucket.
     BOOST_CHECK_EQUAL(buckets.size(), 1U);
 
     buckets.clear();
     for (int j = 0; j < 4 * 255; j++) {
-        CAddrInfo infoj = CAddrInfo(
-            CAddress(ResolveService(std::to_string(250 + (j / 255)) + "." +
-                                    std::to_string(j % 256) + ".1.1"),
-                     NODE_NONE),
-            ResolveIP("251.4.1.1"));
+        CAddrInfo infoj =
+            CAddrInfo(CAddress(ResolveService(ToString(250 + (j / 255)) + "." +
+                                              ToString(j % 256) + ".1.1"),
+                               NODE_NONE),
+                      ResolveIP("251.4.1.1"));
         int bucket = infoj.GetNewBucket(nKey1, asmap);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the same source /16 prefix should not map to more
     // than 64 buckets.
     BOOST_CHECK(buckets.size() <= 64);
 
     buckets.clear();
     for (int p = 0; p < 255; p++) {
         CAddrInfo infoj =
             CAddrInfo(CAddress(ResolveService("250.1.1.1"), NODE_NONE),
-                      ResolveIP("101." + std::to_string(p) + ".1.1"));
+                      ResolveIP("101." + ToString(p) + ".1.1"));
         int bucket = infoj.GetNewBucket(nKey1, asmap);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the different source /16 prefixes usually map to
     // MORE than 1 bucket.
     BOOST_CHECK(buckets.size() > 1);
 
     buckets.clear();
     for (int p = 0; p < 255; p++) {
         CAddrInfo infoj =
             CAddrInfo(CAddress(ResolveService("250.1.1.1"), NODE_NONE),
-                      ResolveIP("250." + std::to_string(p) + ".1.1"));
+                      ResolveIP("250." + ToString(p) + ".1.1"));
         int bucket = infoj.GetNewBucket(nKey1, asmap);
         buckets.insert(bucket);
     }
     // Test: IP addresses in the different source /16 prefixes sometimes map to
     // NO MORE than 1 bucket.
     BOOST_CHECK(buckets.size() == 1);
 }
 
 BOOST_AUTO_TEST_CASE(addrman_serialization) {
     std::vector<bool> asmap1 = FromBytes(asmap_raw, sizeof(asmap_raw) * 8);
 
     CAddrManTest addrman_asmap1(true, asmap1);
     CAddrManTest addrman_asmap1_dup(true, asmap1);
     CAddrManTest addrman_noasmap;
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
 
     CAddress addr = CAddress(ResolveService("250.1.1.1"), NODE_NONE);
     CNetAddr default_source;
 
     addrman_asmap1.Add(addr, default_source);
 
     stream << addrman_asmap1;
     // serizalizing/deserializing addrman with the same asmap
     stream >> addrman_asmap1_dup;
 
     std::pair<int, int> bucketAndEntry_asmap1 =
         addrman_asmap1.GetBucketAndEntry(addr);
     std::pair<int, int> bucketAndEntry_asmap1_dup =
         addrman_asmap1_dup.GetBucketAndEntry(addr);
     BOOST_CHECK(bucketAndEntry_asmap1.second != -1);
     BOOST_CHECK(bucketAndEntry_asmap1_dup.second != -1);
 
     BOOST_CHECK(bucketAndEntry_asmap1.first == bucketAndEntry_asmap1_dup.first);
     BOOST_CHECK(bucketAndEntry_asmap1.second ==
                 bucketAndEntry_asmap1_dup.second);
 
     // deserializing asmaped peers.dat to non-asmaped addrman
     stream << addrman_asmap1;
     stream >> addrman_noasmap;
     std::pair<int, int> bucketAndEntry_noasmap =
         addrman_noasmap.GetBucketAndEntry(addr);
     BOOST_CHECK(bucketAndEntry_noasmap.second != -1);
     BOOST_CHECK(bucketAndEntry_asmap1.first != bucketAndEntry_noasmap.first);
     BOOST_CHECK(bucketAndEntry_asmap1.second != bucketAndEntry_noasmap.second);
 
     // deserializing non-asmaped peers.dat to asmaped addrman
     addrman_asmap1.Clear();
     addrman_noasmap.Clear();
     addrman_noasmap.Add(addr, default_source);
     stream << addrman_noasmap;
     stream >> addrman_asmap1;
     std::pair<int, int> bucketAndEntry_asmap1_deser =
         addrman_asmap1.GetBucketAndEntry(addr);
     BOOST_CHECK(bucketAndEntry_asmap1_deser.second != -1);
     BOOST_CHECK(bucketAndEntry_asmap1_deser.first !=
                 bucketAndEntry_noasmap.first);
     BOOST_CHECK(bucketAndEntry_asmap1_deser.first ==
                 bucketAndEntry_asmap1_dup.first);
     BOOST_CHECK(bucketAndEntry_asmap1_deser.second ==
                 bucketAndEntry_asmap1_dup.second);
 
     // used to map to different buckets, now maps to the same bucket.
     addrman_asmap1.Clear();
     addrman_noasmap.Clear();
     CAddress addr1 = CAddress(ResolveService("250.1.1.1"), NODE_NONE);
     CAddress addr2 = CAddress(ResolveService("250.2.1.1"), NODE_NONE);
     addrman_noasmap.Add(addr, default_source);
     addrman_noasmap.Add(addr2, default_source);
     std::pair<int, int> bucketAndEntry_noasmap_addr1 =
         addrman_noasmap.GetBucketAndEntry(addr1);
     std::pair<int, int> bucketAndEntry_noasmap_addr2 =
         addrman_noasmap.GetBucketAndEntry(addr2);
     BOOST_CHECK(bucketAndEntry_noasmap_addr1.first !=
                 bucketAndEntry_noasmap_addr2.first);
     BOOST_CHECK(bucketAndEntry_noasmap_addr1.second !=
                 bucketAndEntry_noasmap_addr2.second);
     stream << addrman_noasmap;
     stream >> addrman_asmap1;
     std::pair<int, int> bucketAndEntry_asmap1_deser_addr1 =
         addrman_asmap1.GetBucketAndEntry(addr1);
     std::pair<int, int> bucketAndEntry_asmap1_deser_addr2 =
         addrman_asmap1.GetBucketAndEntry(addr2);
     BOOST_CHECK(bucketAndEntry_asmap1_deser_addr1.first ==
                 bucketAndEntry_asmap1_deser_addr2.first);
     BOOST_CHECK(bucketAndEntry_asmap1_deser_addr1.second !=
                 bucketAndEntry_asmap1_deser_addr2.second);
 }
 
 BOOST_AUTO_TEST_CASE(addrman_selecttriedcollision) {
     CAddrManTest addrman;
 
     BOOST_CHECK(addrman.size() == 0);
 
     // Empty addrman should return blank addrman info.
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
 
     // Add twenty two addresses.
     CNetAddr source = ResolveIP("252.2.2.2");
     for (unsigned int i = 1; i < 23; i++) {
-        CService addr = ResolveService("250.1.1." + std::to_string(i));
+        CService addr = ResolveService("250.1.1." + ToString(i));
         BOOST_CHECK(addrman.Add(CAddress(addr, NODE_NONE), source));
         addrman.Good(addr);
 
         // No collisions yet.
         BOOST_CHECK(addrman.size() == i);
         BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
     }
 
     // Ensure Good handles duplicates well.
     for (unsigned int i = 1; i < 23; i++) {
-        CService addr = ResolveService("250.1.1." + std::to_string(i));
+        CService addr = ResolveService("250.1.1." + ToString(i));
         addrman.Good(addr);
 
         BOOST_CHECK(addrman.size() == 22);
         BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
     }
 }
 
 BOOST_AUTO_TEST_CASE(addrman_noevict) {
     CAddrManTest addrman;
 
     // Add twenty two addresses.
     CNetAddr source = ResolveIP("252.2.2.2");
     for (unsigned int i = 1; i < 23; i++) {
-        CService addr = ResolveService("250.1.1." + std::to_string(i));
+        CService addr = ResolveService("250.1.1." + ToString(i));
         BOOST_CHECK(addrman.Add(CAddress(addr, NODE_NONE), source));
         addrman.Good(addr);
 
         // No collision yet.
         BOOST_CHECK(addrman.size() == i);
         BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
     }
 
     // Collision between 23 and 19.
     CService addr23 = ResolveService("250.1.1.23");
     BOOST_CHECK(addrman.Add(CAddress(addr23, NODE_NONE), source));
     addrman.Good(addr23);
 
     BOOST_CHECK(addrman.size() == 23);
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "250.1.1.19:0");
 
     // 23 should be discarded and 19 not evicted.
     addrman.ResolveCollisions();
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
 
     // Lets create two collisions.
     for (unsigned int i = 24; i < 33; i++) {
-        CService addr = ResolveService("250.1.1." + std::to_string(i));
+        CService addr = ResolveService("250.1.1." + ToString(i));
         BOOST_CHECK(addrman.Add(CAddress(addr, NODE_NONE), source));
         addrman.Good(addr);
 
         BOOST_CHECK(addrman.size() == i);
         BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
     }
 
     // Cause a collision.
     CService addr33 = ResolveService("250.1.1.33");
     BOOST_CHECK(addrman.Add(CAddress(addr33, NODE_NONE), source));
     addrman.Good(addr33);
     BOOST_CHECK(addrman.size() == 33);
 
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "250.1.1.27:0");
 
     // Cause a second collision.
     BOOST_CHECK(!addrman.Add(CAddress(addr23, NODE_NONE), source));
     addrman.Good(addr23);
     BOOST_CHECK(addrman.size() == 33);
 
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() != "[::]:0");
     addrman.ResolveCollisions();
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
 }
 
 BOOST_AUTO_TEST_CASE(addrman_evictionworks) {
     CAddrManTest addrman;
 
     BOOST_CHECK(addrman.size() == 0);
 
     // Empty addrman should return blank addrman info.
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
 
     // Add twenty two addresses.
     CNetAddr source = ResolveIP("252.2.2.2");
     for (unsigned int i = 1; i < 23; i++) {
-        CService addr = ResolveService("250.1.1." + std::to_string(i));
+        CService addr = ResolveService("250.1.1." + ToString(i));
         BOOST_CHECK(addrman.Add(CAddress(addr, NODE_NONE), source));
         addrman.Good(addr);
 
         // No collision yet.
         BOOST_CHECK(addrman.size() == i);
         BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
     }
 
     // Collision between 23 and 19.
     CService addr = ResolveService("250.1.1.23");
     BOOST_CHECK(addrman.Add(CAddress(addr, NODE_NONE), source));
     addrman.Good(addr);
 
     BOOST_CHECK(addrman.size() == 23);
     CAddrInfo info = addrman.SelectTriedCollision();
     BOOST_CHECK(info.ToString() == "250.1.1.19:0");
 
     // Ensure test of address fails, so that it is evicted.
     addrman.SimConnFail(info);
 
     // Should swap 23 for 19.
     addrman.ResolveCollisions();
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
 
     // If 23 was swapped for 19, then this should cause no collisions.
     BOOST_CHECK(!addrman.Add(CAddress(addr, NODE_NONE), source));
     addrman.Good(addr);
 
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
 
     // If we insert 19 is should collide with 23.
     CService addr19 = ResolveService("250.1.1.19");
     BOOST_CHECK(!addrman.Add(CAddress(addr19, NODE_NONE), source));
     addrman.Good(addr19);
 
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "250.1.1.23:0");
 
     addrman.ResolveCollisions();
     BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/blockchain_tests.cpp b/src/test/blockchain_tests.cpp
index 6dd61b527..8a817d688 100644
--- a/src/test/blockchain_tests.cpp
+++ b/src/test/blockchain_tests.cpp
@@ -1,69 +1,70 @@
 #include <rpc/blockchain.h>
 
 #include <chain.h>
+#include <util/string.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <cstdlib>
 
 /**
  * Equality between doubles is imprecise. Comparison should be done
  * with a small threshold of tolerance, rather than exact equality.
  */
 static bool DoubleEquals(double a, double b, double epsilon) {
     return std::abs(a - b) < epsilon;
 }
 
 static CBlockIndex *CreateBlockIndexWithNbits(uint32_t nbits) {
     CBlockIndex *block_index = new CBlockIndex();
     block_index->nHeight = 46367;
     block_index->nTime = 1269211443;
     block_index->nBits = nbits;
     return block_index;
 }
 
 static void RejectDifficultyMismatch(double difficulty,
                                      double expected_difficulty) {
     BOOST_CHECK_MESSAGE(DoubleEquals(difficulty, expected_difficulty, 0.00001),
-                        "Difficulty was " + std::to_string(difficulty) +
+                        "Difficulty was " + ToString(difficulty) +
                             " but was expected to be " +
-                            std::to_string(expected_difficulty));
+                            ToString(expected_difficulty));
 }
 
 /**
  * Given a BlockIndex with the provided nbits,
  * verify that the expected difficulty results.
  */
 static void TestDifficulty(uint32_t nbits, double expected_difficulty) {
     CBlockIndex *block_index = CreateBlockIndexWithNbits(nbits);
     double difficulty = GetDifficulty(block_index);
     delete block_index;
 
     RejectDifficultyMismatch(difficulty, expected_difficulty);
 }
 
 BOOST_FIXTURE_TEST_SUITE(blockchain_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(get_difficulty_for_very_low_target) {
     TestDifficulty(0x1f111111, 0.000001);
 }
 
 BOOST_AUTO_TEST_CASE(get_difficulty_for_low_target) {
     TestDifficulty(0x1ef88f6f, 0.000016);
 }
 
 BOOST_AUTO_TEST_CASE(get_difficulty_for_mid_target) {
     TestDifficulty(0x1df88f6f, 0.004023);
 }
 
 BOOST_AUTO_TEST_CASE(get_difficulty_for_high_target) {
     TestDifficulty(0x1cf88f6f, 1.029916);
 }
 
 BOOST_AUTO_TEST_CASE(get_difficulty_for_very_high_target) {
     TestDifficulty(0x12345678, 5913134931067755359633408.0);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/excessiveblock_tests.cpp b/src/test/excessiveblock_tests.cpp
index dc0a4fe2c..1cf26edc4 100644
--- a/src/test/excessiveblock_tests.cpp
+++ b/src/test/excessiveblock_tests.cpp
@@ -1,78 +1,77 @@
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <consensus/consensus.h>
 #include <rpc/server.h>
 #include <util/ref.h>
+#include <util/string.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/test/unit_test.hpp>
 
 #include <limits>
 #include <string>
 
 extern UniValue CallRPC(const std::string &args, const util::Ref &context);
 
 class ExcessiveBlockTestingSetup : public TestingSetup {
 public:
     UniValue CallRPC(const std::string &args) {
         const util::Ref context{m_node};
         return ::CallRPC(args, context);
     }
 };
 
 BOOST_FIXTURE_TEST_SUITE(excessiveblock_tests, ExcessiveBlockTestingSetup)
 
 BOOST_AUTO_TEST_CASE(excessiveblock_rpc) {
     BOOST_CHECK_NO_THROW(CallRPC("getexcessiveblock"));
 
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock not_uint"),
                       std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock 1000000 not_uint"),
                       std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock 1000000 1"),
                       std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock -1"), std::runtime_error);
 
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock 0"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock 1"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("setexcessiveblock 1000"), std::runtime_error);
-    BOOST_CHECK_THROW(CallRPC(std::string("setexcessiveblock ") +
-                              std::to_string(ONE_MEGABYTE - 1)),
-                      std::runtime_error);
-    BOOST_CHECK_THROW(CallRPC(std::string("setexcessiveblock ") +
-                              std::to_string(ONE_MEGABYTE)),
-                      std::runtime_error);
+    BOOST_CHECK_THROW(
+        CallRPC(std::string("setexcessiveblock ") + ToString(ONE_MEGABYTE - 1)),
+        std::runtime_error);
+    BOOST_CHECK_THROW(
+        CallRPC(std::string("setexcessiveblock ") + ToString(ONE_MEGABYTE)),
+        std::runtime_error);
 
     BOOST_CHECK_NO_THROW(CallRPC(std::string("setexcessiveblock ") +
-                                 std::to_string(ONE_MEGABYTE + 1)));
+                                 ToString(ONE_MEGABYTE + 1)));
     BOOST_CHECK_NO_THROW(CallRPC(std::string("setexcessiveblock ") +
-                                 std::to_string(ONE_MEGABYTE + 10)));
+                                 ToString(ONE_MEGABYTE + 10)));
 
     // Default can be higher than 1MB in future - test it too
     BOOST_CHECK_NO_THROW(CallRPC(std::string("setexcessiveblock ") +
-                                 std::to_string(DEFAULT_MAX_BLOCK_SIZE)));
+                                 ToString(DEFAULT_MAX_BLOCK_SIZE)));
     BOOST_CHECK_NO_THROW(CallRPC(std::string("setexcessiveblock ") +
-                                 std::to_string(DEFAULT_MAX_BLOCK_SIZE * 8)));
+                                 ToString(DEFAULT_MAX_BLOCK_SIZE * 8)));
 
     BOOST_CHECK_NO_THROW(
         CallRPC(std::string("setexcessiveblock ") +
-                std::to_string(std::numeric_limits<int64_t>::max())));
-
-    BOOST_CHECK_THROW(
-        CallRPC(
-            std::string("setexcessiveblock ") +
-            std::to_string(uint64_t(std::numeric_limits<int64_t>::max()) + 1)),
-        std::runtime_error);
+                ToString(std::numeric_limits<int64_t>::max())));
 
     BOOST_CHECK_THROW(
         CallRPC(std::string("setexcessiveblock ") +
-                std::to_string(std::numeric_limits<uint64_t>::max())),
+                ToString(uint64_t(std::numeric_limits<int64_t>::max()) + 1)),
         std::runtime_error);
+
+    BOOST_CHECK_THROW(CallRPC(std::string("setexcessiveblock ") +
+                              ToString(std::numeric_limits<uint64_t>::max())),
+                      std::runtime_error);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/key_tests.cpp b/src/test/key_tests.cpp
index ef77b5746..ac2a12336 100644
--- a/src/test/key_tests.cpp
+++ b/src/test/key_tests.cpp
@@ -1,409 +1,410 @@
 // Copyright (c) 2012-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.
 
 #include <key.h>
 
 #include <chainparams.h> // For Params()
 #include <key_io.h>
 #include <uint256.h>
 #include <util/strencodings.h>
+#include <util/string.h>
 #include <util/system.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <string>
 #include <vector>
 
 static const std::string strSecret1 =
     "5HxWvvfubhXpYYpS3tJkw6fq9jE9j18THftkZjHHfmFiWtmAbrj";
 static const std::string strSecret2 =
     "5KC4ejrDjv152FGwP386VD1i2NYc5KkfSMyv1nGy1VGDxGHqVY3";
 static const std::string strSecret1C =
     "Kwr371tjA9u2rFSMZjTNun2PXXP3WPZu2afRHTcta6KxEUdm1vEw";
 static const std::string strTestSecret1C =
     "cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN";
 static const std::string strSecret2C =
     "L3Hq7a8FEQwJkW1M2GNKDW28546Vp5miewcCzSqUD9kCAXrJdS3g";
 static const std::string addr1 = "1QFqqMUD55ZV3PJEJZtaKCsQmjLT6JkjvJ";
 static const std::string addr2 = "1F5y5E5FMc5YzdJtB9hLaUe43GDxEKXENJ";
 static const std::string addr1C = "1NoJrossxPBKfCHuJXT4HadJrXRE9Fxiqs";
 static const std::string addr2C = "1CRj2HyM1CXWzHAXLQtiGLyggNT9WQqsDs";
 
 static const std::string strAddressBad = "1HV9Lc3sNHZxwj4Zk6fB38tEmBryq2cBiF";
 
 // get r value produced by ECDSA signing algorithm
 // (assumes ECDSA r is encoded in the canonical manner)
 static std::vector<uint8_t> get_r_ECDSA(std::vector<uint8_t> sigECDSA) {
     std::vector<uint8_t> ret(32, 0);
 
     assert(sigECDSA[2] == 2);
     int rlen = sigECDSA[3];
     assert(rlen <= 33);
     assert(sigECDSA[4 + rlen] == 2);
     if (rlen == 33) {
         assert(sigECDSA[4] == 0);
         std::copy(sigECDSA.begin() + 5, sigECDSA.begin() + 37, ret.begin());
     } else {
         std::copy(sigECDSA.begin() + 4, sigECDSA.begin() + (4 + rlen),
                   ret.begin() + (32 - rlen));
     }
     return ret;
 }
 
 BOOST_FIXTURE_TEST_SUITE(key_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(internal_test) {
     // test get_r_ECDSA (defined above) to make sure it's working properly
     BOOST_CHECK(get_r_ECDSA(ParseHex(
                     "3045022100c6ab5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                     "24c22e00b7bc7944a1f7802206ff23df3802e241ee234a8b66c40"
                     "c82e56a6cc37f9b50463111c9f9229b8f3b3")) ==
                 ParseHex("c6ab5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                          "24c22e00b7bc7944a1f78"));
     BOOST_CHECK(get_r_ECDSA(ParseHex(
                     "3045022046ab5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                     "24c22e00b7bc7944a1f7802206ff23df3802e241ee234a8b66c40"
                     "c82e56a6cc37f9b50463111c9f9229b8f3b3")) ==
                 ParseHex("46ab5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                          "24c22e00b7bc7944a1f78"));
     BOOST_CHECK(get_r_ECDSA(ParseHex(
                     "3045021f4b5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                     "24c22e00b7bc7944a1f7802206ff23df3802e241ee234a8b66c40"
                     "c82e56a6cc37f9b50463111c9f9229b8f3b3")) ==
                 ParseHex("004b5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                          "24c22e00b7bc7944a1f78"));
     BOOST_CHECK(get_r_ECDSA(ParseHex(
                     "3045021e5f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                     "24c22e00b7bc7944a1f7802206ff23df3802e241ee234a8b66c40"
                     "c82e56a6cc37f9b50463111c9f9229b8f3b3")) ==
                 ParseHex("00005f8acfccc114da39dd5ad0b1ef4d39df6a721e8"
                          "24c22e00b7bc7944a1f78"));
 }
 
 BOOST_AUTO_TEST_CASE(encode_decode_secret_test) {
     const auto mainParams = CreateChainParams(CBaseChainParams::MAIN);
     const auto testParams = CreateChainParams(CBaseChainParams::TESTNET);
     const auto regParams = CreateChainParams(CBaseChainParams::TESTNET);
 
     {
         // Check the mainnet base58 key
         CKey mainKey = DecodeSecret(strSecret1C, *mainParams);
         BOOST_CHECK(mainKey.IsValid() && mainKey.IsCompressed());
 
         CKey testKey = DecodeSecret(strSecret1C, *testParams);
         BOOST_CHECK(!testKey.IsValid());
 
         CKey regKey = DecodeSecret(strSecret1C, *regParams);
         BOOST_CHECK(!regKey.IsValid());
     }
 
     {
         // Check the testnet and regnet base58 key
         CKey mainKey = DecodeSecret(strTestSecret1C, *mainParams);
         BOOST_CHECK(!mainKey.IsValid());
 
         CKey testKey = DecodeSecret(strTestSecret1C, *testParams);
         BOOST_CHECK(testKey.IsValid() && testKey.IsCompressed());
 
         CKey regKey = DecodeSecret(strTestSecret1C, *regParams);
         BOOST_CHECK(regKey.IsValid() && regKey.IsCompressed());
     }
 
     CKey mainKey = DecodeSecret(strSecret1C, *mainParams);
     CKey testKey = DecodeSecret(strTestSecret1C, *testParams);
 
     // Check key conversion.
     BOOST_CHECK_EQUAL(EncodeSecret(mainKey, *mainParams), strSecret1C);
     BOOST_CHECK_EQUAL(EncodeSecret(mainKey, *testParams), strTestSecret1C);
     BOOST_CHECK_EQUAL(EncodeSecret(mainKey, *regParams), strTestSecret1C);
     BOOST_CHECK_EQUAL(EncodeSecret(testKey, *mainParams), strSecret1C);
     BOOST_CHECK_EQUAL(EncodeSecret(testKey, *testParams), strTestSecret1C);
     BOOST_CHECK_EQUAL(EncodeSecret(testKey, *regParams), strTestSecret1C);
 }
 
 BOOST_AUTO_TEST_CASE(key_test1) {
     CKey key1 = DecodeSecret(strSecret1);
     BOOST_CHECK(key1.IsValid() && !key1.IsCompressed());
     CKey key2 = DecodeSecret(strSecret2);
     BOOST_CHECK(key2.IsValid() && !key2.IsCompressed());
     CKey key1C = DecodeSecret(strSecret1C);
     BOOST_CHECK(key1C.IsValid() && key1C.IsCompressed());
     CKey key2C = DecodeSecret(strSecret2C);
     BOOST_CHECK(key2C.IsValid() && key2C.IsCompressed());
     CKey bad_key = DecodeSecret(strAddressBad);
     BOOST_CHECK(!bad_key.IsValid());
 
     CPubKey pubkey1 = key1.GetPubKey();
     CPubKey pubkey2 = key2.GetPubKey();
     CPubKey pubkey1C = key1C.GetPubKey();
     CPubKey pubkey2C = key2C.GetPubKey();
 
     BOOST_CHECK(key1.VerifyPubKey(pubkey1));
     BOOST_CHECK(!key1.VerifyPubKey(pubkey1C));
     BOOST_CHECK(!key1.VerifyPubKey(pubkey2));
     BOOST_CHECK(!key1.VerifyPubKey(pubkey2C));
 
     BOOST_CHECK(!key1C.VerifyPubKey(pubkey1));
     BOOST_CHECK(key1C.VerifyPubKey(pubkey1C));
     BOOST_CHECK(!key1C.VerifyPubKey(pubkey2));
     BOOST_CHECK(!key1C.VerifyPubKey(pubkey2C));
 
     BOOST_CHECK(!key2.VerifyPubKey(pubkey1));
     BOOST_CHECK(!key2.VerifyPubKey(pubkey1C));
     BOOST_CHECK(key2.VerifyPubKey(pubkey2));
     BOOST_CHECK(!key2.VerifyPubKey(pubkey2C));
 
     BOOST_CHECK(!key2C.VerifyPubKey(pubkey1));
     BOOST_CHECK(!key2C.VerifyPubKey(pubkey1C));
     BOOST_CHECK(!key2C.VerifyPubKey(pubkey2));
     BOOST_CHECK(key2C.VerifyPubKey(pubkey2C));
 
     const CChainParams &chainParams = Params();
     BOOST_CHECK(DecodeDestination(addr1, chainParams) ==
                 CTxDestination(PKHash(pubkey1)));
     BOOST_CHECK(DecodeDestination(addr2, chainParams) ==
                 CTxDestination(PKHash(pubkey2)));
     BOOST_CHECK(DecodeDestination(addr1C, chainParams) ==
                 CTxDestination(PKHash(pubkey1C)));
     BOOST_CHECK(DecodeDestination(addr2C, chainParams) ==
                 CTxDestination(PKHash(pubkey2C)));
 
     for (int n = 0; n < 16; n++) {
         std::string strMsg = strprintf("Very secret message %i: 11", n);
         uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
 
         // normal ECDSA signatures
 
         std::vector<uint8_t> sign1, sign2, sign1C, sign2C;
 
         BOOST_CHECK(key1.SignECDSA(hashMsg, sign1));
         BOOST_CHECK(key2.SignECDSA(hashMsg, sign2));
         BOOST_CHECK(key1C.SignECDSA(hashMsg, sign1C));
         BOOST_CHECK(key2C.SignECDSA(hashMsg, sign2C));
 
         BOOST_CHECK(pubkey1.VerifyECDSA(hashMsg, sign1));
         BOOST_CHECK(!pubkey1.VerifyECDSA(hashMsg, sign2));
         BOOST_CHECK(pubkey1.VerifyECDSA(hashMsg, sign1C));
         BOOST_CHECK(!pubkey1.VerifyECDSA(hashMsg, sign2C));
 
         BOOST_CHECK(!pubkey2.VerifyECDSA(hashMsg, sign1));
         BOOST_CHECK(pubkey2.VerifyECDSA(hashMsg, sign2));
         BOOST_CHECK(!pubkey2.VerifyECDSA(hashMsg, sign1C));
         BOOST_CHECK(pubkey2.VerifyECDSA(hashMsg, sign2C));
 
         BOOST_CHECK(pubkey1C.VerifyECDSA(hashMsg, sign1));
         BOOST_CHECK(!pubkey1C.VerifyECDSA(hashMsg, sign2));
         BOOST_CHECK(pubkey1C.VerifyECDSA(hashMsg, sign1C));
         BOOST_CHECK(!pubkey1C.VerifyECDSA(hashMsg, sign2C));
 
         BOOST_CHECK(!pubkey2C.VerifyECDSA(hashMsg, sign1));
         BOOST_CHECK(pubkey2C.VerifyECDSA(hashMsg, sign2));
         BOOST_CHECK(!pubkey2C.VerifyECDSA(hashMsg, sign1C));
         BOOST_CHECK(pubkey2C.VerifyECDSA(hashMsg, sign2C));
 
         // compact ECDSA signatures (with key recovery)
 
         std::vector<uint8_t> csign1, csign2, csign1C, csign2C;
 
         BOOST_CHECK(key1.SignCompact(hashMsg, csign1));
         BOOST_CHECK(key2.SignCompact(hashMsg, csign2));
         BOOST_CHECK(key1C.SignCompact(hashMsg, csign1C));
         BOOST_CHECK(key2C.SignCompact(hashMsg, csign2C));
 
         CPubKey rkey1, rkey2, rkey1C, rkey2C;
 
         BOOST_CHECK(rkey1.RecoverCompact(hashMsg, csign1));
         BOOST_CHECK(rkey2.RecoverCompact(hashMsg, csign2));
         BOOST_CHECK(rkey1C.RecoverCompact(hashMsg, csign1C));
         BOOST_CHECK(rkey2C.RecoverCompact(hashMsg, csign2C));
 
         BOOST_CHECK(rkey1 == pubkey1);
         BOOST_CHECK(rkey2 == pubkey2);
         BOOST_CHECK(rkey1C == pubkey1C);
         BOOST_CHECK(rkey2C == pubkey2C);
 
         // Schnorr signatures
 
         std::vector<uint8_t> ssign1, ssign2, ssign1C, ssign2C;
 
         BOOST_CHECK(key1.SignSchnorr(hashMsg, ssign1));
         BOOST_CHECK(key2.SignSchnorr(hashMsg, ssign2));
         BOOST_CHECK(key1C.SignSchnorr(hashMsg, ssign1C));
         BOOST_CHECK(key2C.SignSchnorr(hashMsg, ssign2C));
 
         BOOST_CHECK(pubkey1.VerifySchnorr(hashMsg, ssign1));
         BOOST_CHECK(!pubkey1.VerifySchnorr(hashMsg, ssign2));
         BOOST_CHECK(pubkey1.VerifySchnorr(hashMsg, ssign1C));
         BOOST_CHECK(!pubkey1.VerifySchnorr(hashMsg, ssign2C));
 
         BOOST_CHECK(!pubkey2.VerifySchnorr(hashMsg, ssign1));
         BOOST_CHECK(pubkey2.VerifySchnorr(hashMsg, ssign2));
         BOOST_CHECK(!pubkey2.VerifySchnorr(hashMsg, ssign1C));
         BOOST_CHECK(pubkey2.VerifySchnorr(hashMsg, ssign2C));
 
         BOOST_CHECK(pubkey1C.VerifySchnorr(hashMsg, ssign1));
         BOOST_CHECK(!pubkey1C.VerifySchnorr(hashMsg, ssign2));
         BOOST_CHECK(pubkey1C.VerifySchnorr(hashMsg, ssign1C));
         BOOST_CHECK(!pubkey1C.VerifySchnorr(hashMsg, ssign2C));
 
         BOOST_CHECK(!pubkey2C.VerifySchnorr(hashMsg, ssign1));
         BOOST_CHECK(pubkey2C.VerifySchnorr(hashMsg, ssign2));
         BOOST_CHECK(!pubkey2C.VerifySchnorr(hashMsg, ssign1C));
         BOOST_CHECK(pubkey2C.VerifySchnorr(hashMsg, ssign2C));
 
         // check deterministicity of ECDSA & Schnorr
         BOOST_CHECK(sign1 == sign1C);
         BOOST_CHECK(sign2 == sign2C);
         BOOST_CHECK(ssign1 == ssign1C);
         BOOST_CHECK(ssign2 == ssign2C);
 
         // Extract r value from ECDSA and Schnorr. Make sure they are
         // distinct (nonce reuse would be dangerous and can leak private key).
         std::vector<uint8_t> rE1 = get_r_ECDSA(sign1);
         BOOST_CHECK(ssign1.size() == 64);
         std::vector<uint8_t> rS1(ssign1.begin(), ssign1.begin() + 32);
         BOOST_CHECK(rE1.size() == 32);
         BOOST_CHECK(rS1.size() == 32);
         BOOST_CHECK(rE1 != rS1);
 
         std::vector<uint8_t> rE2 = get_r_ECDSA(sign2);
         BOOST_CHECK(ssign2.size() == 64);
         std::vector<uint8_t> rS2(ssign2.begin(), ssign2.begin() + 32);
         BOOST_CHECK(rE2.size() == 32);
         BOOST_CHECK(rS2.size() == 32);
         BOOST_CHECK(rE2 != rS2);
     }
 
     // test deterministic signing expected values
 
     std::vector<uint8_t> detsig, detsigc;
     std::string strMsg = "Very deterministic message";
     uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
     // ECDSA
     BOOST_CHECK(key1.SignECDSA(hashMsg, detsig));
     BOOST_CHECK(key1C.SignECDSA(hashMsg, detsigc));
     BOOST_CHECK(detsig == detsigc);
     BOOST_CHECK(detsig ==
                 ParseHex("304402200c648ad9936cae4006f0b0d7bcbacdcdf5a14260eb550"
                          "c31ddb1eb1a13b1b58602201b868673bb5926d1610a07cd03692d"
                          "fdcb98ed059314f66b457a794f2c4b8e79"));
     BOOST_CHECK(key2.SignECDSA(hashMsg, detsig));
     BOOST_CHECK(key2C.SignECDSA(hashMsg, detsigc));
     BOOST_CHECK(detsig == detsigc);
     BOOST_CHECK(detsig ==
                 ParseHex("304402205fb8ff5dbba6110d877169812f5cd939866d9487c6b62"
                          "5785c6876e4fb8ea69a0220711dc4ecff142f7f808905c04bbd41"
                          "89e3d2c689c4be396ed22883c463d6ad7a"));
     // Compact
     BOOST_CHECK(key1.SignCompact(hashMsg, detsig));
     BOOST_CHECK(key1C.SignCompact(hashMsg, detsigc));
     BOOST_CHECK(detsig ==
                 ParseHex("1b8c56f224d51415e6ce329144aa1e1c1563e297a005f450df015"
                          "14f3d047681760277e79d57502df27b8feebb001a588aa3a8c2bc"
                          "f5b2367273c15f840638cfc8"));
     BOOST_CHECK(detsigc ==
                 ParseHex("1f8c56f224d51415e6ce329144aa1e1c1563e297a005f450df015"
                          "14f3d047681760277e79d57502df27b8feebb001a588aa3a8c2bc"
                          "f5b2367273c15f840638cfc8"));
     BOOST_CHECK(key2.SignCompact(hashMsg, detsig));
     BOOST_CHECK(key2C.SignCompact(hashMsg, detsigc));
     BOOST_CHECK(detsig ==
                 ParseHex("1c9ffc56b38fbfc0e3eb2c42dff99d2375982449f35019c1b3d56"
                          "ca62bef187c5103e483a0ad481eaacc224fef4ee2995027300d5f"
                          "2457f7a20c43547aeddbae6e"));
     BOOST_CHECK(detsigc ==
                 ParseHex("209ffc56b38fbfc0e3eb2c42dff99d2375982449f35019c1b3d56"
                          "ca62bef187c5103e483a0ad481eaacc224fef4ee2995027300d5f"
                          "2457f7a20c43547aeddbae6e"));
     // Schnorr
     BOOST_CHECK(key1.SignSchnorr(hashMsg, detsig));
     BOOST_CHECK(key1C.SignSchnorr(hashMsg, detsigc));
     BOOST_CHECK(detsig == detsigc);
     BOOST_CHECK(detsig ==
                 ParseHex("2c56731ac2f7a7e7f11518fc7722a166b02438924ca9d8b4d1113"
                          "47b81d0717571846de67ad3d913a8fdf9d8f3f73161a4c48ae81c"
                          "b183b214765feb86e255ce"));
     BOOST_CHECK(key2.SignSchnorr(hashMsg, detsig));
     BOOST_CHECK(key2C.SignSchnorr(hashMsg, detsigc));
     BOOST_CHECK(detsig == detsigc);
     BOOST_CHECK(detsig ==
                 ParseHex("e7167ae0afbba6019b4c7fcfe6de79165d555e8295bd72da1b8aa"
                          "1a5b54305880517cace1bcb0cb515e2eeaffd49f1e4dd49fd7282"
                          "6b4b1573c84da49a38405d"));
 }
 
 BOOST_AUTO_TEST_CASE(key_signature_tests) {
     // When entropy is specified, we should see at least one high R signature
     // within 20 signatures
     CKey key = DecodeSecret(strSecret1);
     std::string msg = "A message to be signed";
     uint256 msg_hash = Hash(msg.begin(), msg.end());
     std::vector<uint8_t> sig;
     bool found = false;
 
     for (int i = 1; i <= 20; ++i) {
         sig.clear();
         BOOST_CHECK(key.SignECDSA(msg_hash, sig, false, i));
         found = sig[3] == 0x21 && sig[4] == 0x00;
         if (found) {
             break;
         }
     }
     BOOST_CHECK(found);
 
     // When entropy is not specified, we should always see low R signatures that
     // are less than 70 bytes in 256 tries We should see at least one signature
     // that is less than 70 bytes.
     found = true;
     bool found_small = false;
     for (int i = 0; i < 256; ++i) {
         sig.clear();
-        msg = "A message to be signed" + std::to_string(i);
+        msg = "A message to be signed" + ToString(i);
         msg_hash = Hash(msg.begin(), msg.end());
         BOOST_CHECK(key.SignECDSA(msg_hash, sig));
         found = sig[3] == 0x20;
         BOOST_CHECK(sig.size() <= 70);
         found_small |= sig.size() < 70;
     }
     BOOST_CHECK(found);
     BOOST_CHECK(found_small);
 }
 
 BOOST_AUTO_TEST_CASE(key_key_negation) {
     // create a dummy hash for signature comparison
     uint8_t rnd[8];
     std::string str = "Bitcoin key verification\n";
     GetRandBytes(rnd, sizeof(rnd));
     uint256 hash;
     CHash256()
         .Write((uint8_t *)str.data(), str.size())
         .Write(rnd, sizeof(rnd))
         .Finalize(hash.begin());
 
     // import the static test key
     CKey key = DecodeSecret(strSecret1C);
 
     // create a signature
     std::vector<uint8_t> vch_sig;
     std::vector<uint8_t> vch_sig_cmp;
     key.SignECDSA(hash, vch_sig);
 
     // negate the key twice
     BOOST_CHECK(key.GetPubKey().data()[0] == 0x03);
     key.Negate();
     // after the first negation, the signature must be different
     key.SignECDSA(hash, vch_sig_cmp);
     BOOST_CHECK(vch_sig_cmp != vch_sig);
     BOOST_CHECK(key.GetPubKey().data()[0] == 0x02);
     key.Negate();
     // after the second negation, we should have the original key and thus the
     // same signature
     key.SignECDSA(hash, vch_sig_cmp);
     BOOST_CHECK(vch_sig_cmp == vch_sig);
     BOOST_CHECK(key.GetPubKey().data()[0] == 0x03);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index ab78c0775..22a985599 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -1,750 +1,751 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <miner.h>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <coins.h>
 #include <config.h>
 #include <consensus/consensus.h>
 #include <consensus/merkle.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <policy/policy.h>
 #include <script/standard.h>
 #include <txmempool.h>
 #include <uint256.h>
 #include <util/strencodings.h>
+#include <util/string.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <validation.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <memory>
 
 namespace miner_tests {
 struct MinerTestingSetup : public TestingSetup {
     void TestPackageSelection(const CChainParams &chainparams,
                               const CScript &scriptPubKey,
                               const std::vector<CTransactionRef> &txFirst)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_node.mempool->cs);
     bool TestSequenceLocks(const CTransaction &tx, int flags)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_node.mempool->cs) {
         return CheckSequenceLocks(*m_node.mempool, tx, flags);
     }
     BlockAssembler AssemblerForTest(const CChainParams &params);
 };
 } // namespace miner_tests
 
 BOOST_FIXTURE_TEST_SUITE(miner_tests, MinerTestingSetup)
 
 // BOOST_CHECK_EXCEPTION predicates to check the specific validation error
 class HasReason {
 public:
     explicit HasReason(const std::string &reason) : m_reason(reason) {}
     bool operator()(const std::runtime_error &e) const {
         return std::string(e.what()).find(m_reason) != std::string::npos;
     };
 
 private:
     const std::string m_reason;
 };
 
 static CFeeRate blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE_PER_KB);
 
 BlockAssembler MinerTestingSetup::AssemblerForTest(const CChainParams &params) {
     BlockAssembler::Options options;
     options.blockMinFeeRate = blockMinFeeRate;
     return BlockAssembler(params, *m_node.mempool, options);
 }
 
 constexpr static struct {
     uint8_t extranonce;
     uint32_t nonce;
 } blockinfo[] = {
     {4, 0xa4a3e223}, {2, 0x15c32f9e}, {1, 0x0375b547}, {1, 0x7004a8a5},
     {2, 0xce440296}, {2, 0x52cfe198}, {1, 0x77a72cd0}, {2, 0xbb5d6f84},
     {2, 0x83f30c2c}, {1, 0x48a73d5b}, {1, 0xef7dcd01}, {2, 0x6809c6c4},
     {2, 0x0883ab3c}, {1, 0x087bbbe2}, {2, 0x2104a814}, {2, 0xdffb6daa},
     {1, 0xee8a0a08}, {2, 0xba4237c1}, {1, 0xa70349dc}, {1, 0x344722bb},
     {3, 0xd6294733}, {2, 0xec9f5c94}, {2, 0xca2fbc28}, {1, 0x6ba4f406},
     {2, 0x015d4532}, {1, 0x6e119b7c}, {2, 0x43e8f314}, {2, 0x27962f38},
     {2, 0xb571b51b}, {2, 0xb36bee23}, {2, 0xd17924a8}, {2, 0x6bc212d9},
     {1, 0x630d4948}, {2, 0x9a4c4ebb}, {2, 0x554be537}, {1, 0xd63ddfc7},
     {2, 0xa10acc11}, {1, 0x759a8363}, {2, 0xfb73090d}, {1, 0xe82c6a34},
     {1, 0xe33e92d7}, {3, 0x658ef5cb}, {2, 0xba32ff22}, {5, 0x0227a10c},
     {1, 0xa9a70155}, {5, 0xd096d809}, {1, 0x37176174}, {1, 0x830b8d0f},
     {1, 0xc6e3910e}, {2, 0x823f3ca8}, {1, 0x99850849}, {1, 0x7521fb81},
     {1, 0xaacaabab}, {1, 0xd645a2eb}, {5, 0x7aea1781}, {5, 0x9d6e4b78},
     {1, 0x4ce90fd8}, {1, 0xabdc832d}, {6, 0x4a34f32a}, {2, 0xf2524c1c},
     {2, 0x1bbeb08a}, {1, 0xad47f480}, {1, 0x9f026aeb}, {1, 0x15a95049},
     {2, 0xd1cb95b2}, {2, 0xf84bbda5}, {1, 0x0fa62cd1}, {1, 0xe05f9169},
     {1, 0x78d194a9}, {5, 0x3e38147b}, {5, 0x737ba0d4}, {1, 0x63378e10},
     {1, 0x6d5f91cf}, {2, 0x88612eb8}, {2, 0xe9639484}, {1, 0xb7fabc9d},
     {2, 0x19b01592}, {1, 0x5a90dd31}, {2, 0x5bd7e028}, {2, 0x94d00323},
     {1, 0xa9b9c01a}, {1, 0x3a40de61}, {1, 0x56e7eec7}, {5, 0x859f7ef6},
     {1, 0xfd8e5630}, {1, 0x2b0c9f7f}, {1, 0xba700e26}, {1, 0x7170a408},
     {1, 0x70de86a8}, {1, 0x74d64cd5}, {1, 0x49e738a1}, {2, 0x6910b602},
     {0, 0x643c565f}, {1, 0x54264b3f}, {2, 0x97ea6396}, {2, 0x55174459},
     {2, 0x03e8779a}, {1, 0x98f34d8f}, {1, 0xc07b2b07}, {1, 0xdfe29668},
     {1, 0x3141c7c1}, {1, 0xb3b595f4}, {1, 0x735abf08}, {5, 0x623bfbce},
     {2, 0xd351e722}, {1, 0xf4ca48c9}, {1, 0x5b19c670}, {1, 0xa164bf0e},
     {2, 0xbbbeb305}, {2, 0xfe1c810a},
 };
 
 static CBlockIndex CreateBlockIndex(int nHeight)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     CBlockIndex index;
     index.nHeight = nHeight;
     index.pprev = ::ChainActive().Tip();
     return index;
 }
 
 // Test suite for ancestor feerate transaction selection.
 // Implemented as an additional function, rather than a separate test case,
 // to allow reusing the blockchain created in CreateNewBlock_validity.
 void MinerTestingSetup::TestPackageSelection(
     const CChainParams &chainparams, const CScript &scriptPubKey,
     const std::vector<CTransactionRef> &txFirst) {
     // Test the ancestor feerate transaction selection.
     TestMemPoolEntryHelper entry;
 
     // Test that a medium fee transaction will be selected after a higher fee
     // rate package with a low fee rate parent.
     CMutableTransaction tx;
     tx.vin.resize(1);
     tx.vin[0].scriptSig = CScript() << OP_1;
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vout.resize(1);
     tx.vout[0].nValue = int64_t(5000000000LL - 1000) * SATOSHI;
     // This tx has a low fee: 1000 satoshis.
     // Save this txid for later use.
     TxId parentTxId = tx.GetId();
     m_node.mempool->addUnchecked(entry.Fee(1000 * SATOSHI)
                                      .Time(GetTime())
                                      .SpendsCoinbase(true)
                                      .FromTx(tx));
 
     // This tx has a medium fee: 10000 satoshis.
     tx.vin[0].prevout = COutPoint(txFirst[1]->GetId(), 0);
     tx.vout[0].nValue = int64_t(5000000000LL - 10000) * SATOSHI;
     TxId mediumFeeTxId = tx.GetId();
     m_node.mempool->addUnchecked(entry.Fee(10000 * SATOSHI)
                                      .Time(GetTime())
                                      .SpendsCoinbase(true)
                                      .FromTx(tx));
 
     // This tx has a high fee, but depends on the first transaction.
     tx.vin[0].prevout = COutPoint(parentTxId, 0);
     // 50k satoshi fee.
     tx.vout[0].nValue = int64_t(5000000000LL - 1000 - 50000) * SATOSHI;
     TxId highFeeTxId = tx.GetId();
     m_node.mempool->addUnchecked(entry.Fee(50000 * SATOSHI)
                                      .Time(GetTime())
                                      .SpendsCoinbase(false)
                                      .FromTx(tx));
 
     std::unique_ptr<CBlockTemplate> pblocktemplate =
         AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
     BOOST_CHECK(pblocktemplate->block.vtx[1]->GetId() == parentTxId);
     BOOST_CHECK(pblocktemplate->block.vtx[2]->GetId() == highFeeTxId);
     BOOST_CHECK(pblocktemplate->block.vtx[3]->GetId() == mediumFeeTxId);
 
     // Test that a package below the block min tx fee doesn't get included
     tx.vin[0].prevout = COutPoint(highFeeTxId, 0);
     // 0 fee.
     tx.vout[0].nValue = int64_t(5000000000LL - 1000 - 50000) * SATOSHI;
     TxId freeTxId = tx.GetId();
     m_node.mempool->addUnchecked(entry.Fee(Amount::zero()).FromTx(tx));
     size_t freeTxSize = GetSerializeSize(tx, PROTOCOL_VERSION);
 
     // Calculate a fee on child transaction that will put the package just
     // below the block min tx fee (assuming 1 child tx of the same size).
     Amount feeToUse = blockMinFeeRate.GetFee(2 * freeTxSize) - SATOSHI;
 
     tx.vin[0].prevout = COutPoint(freeTxId, 0);
     tx.vout[0].nValue =
         int64_t(5000000000LL - 1000 - 50000) * SATOSHI - feeToUse;
     TxId lowFeeTxId = tx.GetId();
     m_node.mempool->addUnchecked(entry.Fee(feeToUse).FromTx(tx));
     pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
     // Verify that the free tx and the low fee tx didn't get selected.
     for (const auto &txn : pblocktemplate->block.vtx) {
         BOOST_CHECK(txn->GetId() != freeTxId);
         BOOST_CHECK(txn->GetId() != lowFeeTxId);
     }
 
     // Test that packages above the min relay fee do get included, even if one
     // of the transactions is below the min relay fee. Remove the low fee
     // transaction and replace with a higher fee transaction
     m_node.mempool->removeRecursive(CTransaction(tx),
                                     MemPoolRemovalReason::REPLACED);
     // Now we should be just over the min relay fee.
     tx.vout[0].nValue -= 2 * SATOSHI;
     lowFeeTxId = tx.GetId();
     m_node.mempool->addUnchecked(entry.Fee(feeToUse + 2 * SATOSHI).FromTx(tx));
     pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
     BOOST_CHECK(pblocktemplate->block.vtx[4]->GetId() == freeTxId);
     BOOST_CHECK(pblocktemplate->block.vtx[5]->GetId() == lowFeeTxId);
 
     // Test that transaction selection properly updates ancestor fee
     // calculations as ancestor transactions get included in a block. Add a
     // 0-fee transaction that has 2 outputs.
     tx.vin[0].prevout = COutPoint(txFirst[2]->GetId(), 0);
     tx.vout.resize(2);
     tx.vout[0].nValue = int64_t(5000000000LL - 100000000) * SATOSHI;
     // 1BCC output.
     tx.vout[1].nValue = 100000000 * SATOSHI;
     TxId freeTxId2 = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(Amount::zero()).SpendsCoinbase(true).FromTx(tx));
 
     // This tx can't be mined by itself.
     tx.vin[0].prevout = COutPoint(freeTxId2, 0);
     tx.vout.resize(1);
     feeToUse = blockMinFeeRate.GetFee(freeTxSize);
     tx.vout[0].nValue = int64_t(5000000000LL - 100000000) * SATOSHI - feeToUse;
     TxId lowFeeTxId2 = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(feeToUse).SpendsCoinbase(false).FromTx(tx));
     pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
 
     // Verify that this tx isn't selected.
     for (const auto &txn : pblocktemplate->block.vtx) {
         BOOST_CHECK(txn->GetId() != freeTxId2);
         BOOST_CHECK(txn->GetId() != lowFeeTxId2);
     }
 
     // This tx will be mineable, and should cause lowFeeTxId2 to be selected as
     // well.
     tx.vin[0].prevout = COutPoint(freeTxId2, 1);
     // 10k satoshi fee.
     tx.vout[0].nValue = (100000000 - 10000) * SATOSHI;
     m_node.mempool->addUnchecked(entry.Fee(10000 * SATOSHI).FromTx(tx));
     pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
     BOOST_CHECK(pblocktemplate->block.vtx[8]->GetId() == lowFeeTxId2);
 }
 
 void TestCoinbaseMessageEB(uint64_t eb, std::string cbmsg,
                            const CTxMemPool &mempool) {
     GlobalConfig config;
     config.SetMaxBlockSize(eb);
 
     CScript scriptPubKey =
         CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112"
                               "de5c384df7ba0b8d578a4c702b6bf11d5f")
                   << OP_CHECKSIG;
 
     std::unique_ptr<CBlockTemplate> pblocktemplate =
         BlockAssembler(config, mempool).CreateNewBlock(scriptPubKey);
 
     CBlock *pblock = &pblocktemplate->block;
 
     // IncrementExtraNonce creates a valid coinbase and merkleRoot
     unsigned int extraNonce = 0;
     IncrementExtraNonce(pblock, ::ChainActive().Tip(), config.GetMaxBlockSize(),
                         extraNonce);
     unsigned int nHeight = ::ChainActive().Tip()->nHeight + 1;
     std::vector<uint8_t> vec(cbmsg.begin(), cbmsg.end());
     BOOST_CHECK(pblock->vtx[0]->vin[0].scriptSig ==
                 (CScript() << nHeight << CScriptNum(extraNonce) << vec));
 }
 
 // Coinbase scriptSig has to contains the correct EB value
 // converted to MB, rounded down to the first decimal
 BOOST_AUTO_TEST_CASE(CheckCoinbase_EB) {
     TestCoinbaseMessageEB(1000001, "/EB1.0/", *m_node.mempool);
     TestCoinbaseMessageEB(2000000, "/EB2.0/", *m_node.mempool);
     TestCoinbaseMessageEB(8000000, "/EB8.0/", *m_node.mempool);
     TestCoinbaseMessageEB(8320000, "/EB8.3/", *m_node.mempool);
 }
 
 // NOTE: These tests rely on CreateNewBlock doing its own self-validation!
 BOOST_AUTO_TEST_CASE(CreateNewBlock_validity) {
     // Note that by default, these tests run with size accounting enabled.
     GlobalConfig config;
     const CChainParams &chainparams = config.GetChainParams();
     CScript scriptPubKey =
         CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112"
                               "de5c384df7ba0b8d578a4c702b6bf11d5f")
                   << OP_CHECKSIG;
     std::unique_ptr<CBlockTemplate> pblocktemplate;
     CMutableTransaction tx;
     CScript script;
     TestMemPoolEntryHelper entry;
     entry.nFee = 11 * SATOSHI;
     entry.nHeight = 11;
 
     fCheckpointsEnabled = false;
 
     // Simple block creation, nothing special yet:
     BOOST_CHECK(pblocktemplate =
                     AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
 
     // We can't make transactions until we have inputs.
     // Therefore, load 110 blocks :)
     static_assert(sizeof(blockinfo) / sizeof(*blockinfo) == 110,
                   "Should have 110 blocks to import");
     int baseheight = 0;
     std::vector<CTransactionRef> txFirst;
     for (size_t i = 0; i < sizeof(blockinfo) / sizeof(*blockinfo); ++i) {
         // pointer for convenience.
         CBlock *pblock = &pblocktemplate->block;
         {
             LOCK(cs_main);
             pblock->nVersion = 1;
             pblock->nTime = ::ChainActive().Tip()->GetMedianTimePast() + 1;
             CMutableTransaction txCoinbase(*pblock->vtx[0]);
             txCoinbase.nVersion = 1;
             txCoinbase.vin[0].scriptSig = CScript();
             txCoinbase.vin[0].scriptSig.push_back(blockinfo[i].extranonce);
             txCoinbase.vin[0].scriptSig.push_back(::ChainActive().Height());
             txCoinbase.vout.resize(1);
             txCoinbase.vout[0].scriptPubKey = CScript();
             pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
             if (txFirst.size() == 0) {
                 baseheight = ::ChainActive().Height();
             }
             if (txFirst.size() < 4) {
                 txFirst.push_back(pblock->vtx[0]);
             }
             pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
             pblock->nNonce = blockinfo[i].nonce;
         }
         std::shared_ptr<const CBlock> shared_pblock =
             std::make_shared<const CBlock>(*pblock);
         BOOST_CHECK(
             Assert(m_node.chainman)
                 ->ProcessNewBlock(config, shared_pblock, true, nullptr));
         pblock->hashPrevBlock = pblock->GetHash();
     }
 
     LOCK(cs_main);
     LOCK(m_node.mempool->cs);
 
     // Just to make sure we can still make simple blocks.
     BOOST_CHECK(pblocktemplate =
                     AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
 
     const Amount BLOCKSUBSIDY = 50 * COIN;
     const Amount LOWFEE = CENT;
     const Amount HIGHFEE = COIN;
     const Amount HIGHERFEE = 4 * COIN;
 
     // block size > limit
     tx.vin.resize(1);
     tx.vin[0].scriptSig = CScript();
     // 18 * (520char + DROP) + OP_1 = 9433 bytes
     std::vector<uint8_t> vchData(520);
     for (unsigned int i = 0; i < 18; ++i) {
         tx.vin[0].scriptSig << vchData << OP_DROP;
     }
 
     tx.vin[0].scriptSig << OP_1;
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vout.resize(1);
     tx.vout[0].nValue = BLOCKSUBSIDY;
     for (unsigned int i = 0; i < 128; ++i) {
         tx.vout[0].nValue -= LOWFEE;
         const TxId txid = tx.GetId();
         // Only first tx spends coinbase.
         bool spendsCoinbase = i == 0;
         m_node.mempool->addUnchecked(entry.Fee(LOWFEE)
                                          .Time(GetTime())
                                          .SpendsCoinbase(spendsCoinbase)
                                          .FromTx(tx));
         tx.vin[0].prevout = COutPoint(txid, 0);
     }
 
     BOOST_CHECK(pblocktemplate =
                     AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
     m_node.mempool->clear();
 
     // Orphan in mempool, template creation fails.
     m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).FromTx(tx));
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
     m_node.mempool->clear();
 
     // Child with higher priority than parent.
     tx.vin[0].scriptSig = CScript() << OP_1;
     tx.vin[0].prevout = COutPoint(txFirst[1]->GetId(), 0);
     tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
     TxId txid = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     tx.vin[0].prevout = COutPoint(txid, 0);
     tx.vin.resize(2);
     tx.vin[1].scriptSig = CScript() << OP_1;
     tx.vin[1].prevout = COutPoint(txFirst[0]->GetId(), 0);
     // First txn output + fresh coinbase - new txn fee.
     tx.vout[0].nValue = tx.vout[0].nValue + BLOCKSUBSIDY - HIGHERFEE;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(HIGHERFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     BOOST_CHECK(pblocktemplate =
                     AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
     m_node.mempool->clear();
 
     // Coinbase in mempool, template creation fails.
     tx.vin.resize(1);
     tx.vin[0].prevout = COutPoint();
     tx.vin[0].scriptSig = CScript() << OP_0 << OP_1;
     tx.vout[0].nValue = Amount::zero();
     txid = tx.GetId();
     // Give it a fee so it'll get mined.
     m_node.mempool->addUnchecked(
         entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
     // Should throw bad-tx-coinbase
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("bad-tx-coinbase"));
     m_node.mempool->clear();
 
     // Double spend txn pair in mempool, template creation fails.
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vin[0].scriptSig = CScript() << OP_1;
     tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
     tx.vout[0].scriptPubKey = CScript() << OP_1;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     tx.vout[0].scriptPubKey = CScript() << OP_2;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
     m_node.mempool->clear();
 
     // Subsidy changing.
     int nHeight = ::ChainActive().Height();
     // Create an actual 209999-long block chain (without valid blocks).
     while (::ChainActive().Tip()->nHeight < 209999) {
         CBlockIndex *prev = ::ChainActive().Tip();
         CBlockIndex *next = new CBlockIndex();
         next->phashBlock = new BlockHash(InsecureRand256());
         ::ChainstateActive().CoinsTip().SetBestBlock(next->GetBlockHash());
         next->pprev = prev;
         next->nHeight = prev->nHeight + 1;
         next->BuildSkip();
         ::ChainActive().SetTip(next);
     }
     BOOST_CHECK(pblocktemplate =
                     AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
     // Extend to a 210000-long block chain.
     while (::ChainActive().Tip()->nHeight < 210000) {
         CBlockIndex *prev = ::ChainActive().Tip();
         CBlockIndex *next = new CBlockIndex();
         next->phashBlock = new BlockHash(InsecureRand256());
         ::ChainstateActive().CoinsTip().SetBestBlock(next->GetBlockHash());
         next->pprev = prev;
         next->nHeight = prev->nHeight + 1;
         next->BuildSkip();
         ::ChainActive().SetTip(next);
     }
 
     BOOST_CHECK(pblocktemplate =
                     AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
 
     // Invalid p2sh txn in mempool, template creation fails
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vin[0].scriptSig = CScript() << OP_1;
     tx.vout[0].nValue = BLOCKSUBSIDY - LOWFEE;
     script = CScript() << OP_0;
     tx.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(script));
     txid = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     tx.vin[0].prevout = COutPoint(txid, 0);
     tx.vin[0].scriptSig = CScript()
                           << std::vector<uint8_t>(script.begin(), script.end());
     tx.vout[0].nValue -= LOWFEE;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
     // Should throw blk-bad-inputs
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("blk-bad-inputs"));
     m_node.mempool->clear();
 
     // Delete the dummy blocks again.
     while (::ChainActive().Tip()->nHeight > nHeight) {
         CBlockIndex *del = ::ChainActive().Tip();
         ::ChainActive().SetTip(del->pprev);
         ::ChainstateActive().CoinsTip().SetBestBlock(
             del->pprev->GetBlockHash());
         delete del->phashBlock;
         delete del;
     }
 
     // non-final txs in mempool
     SetMockTime(::ChainActive().Tip()->GetMedianTimePast() + 1);
     uint32_t flags = LOCKTIME_VERIFY_SEQUENCE | LOCKTIME_MEDIAN_TIME_PAST;
     // height map
     std::vector<int> prevheights;
 
     // Relative height locked.
     tx.nVersion = 2;
     tx.vin.resize(1);
     prevheights.resize(1);
     // Only 1 transaction.
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vin[0].scriptSig = CScript() << OP_1;
     // txFirst[0] is the 2nd block
     tx.vin[0].nSequence = ::ChainActive().Tip()->nHeight + 1;
     prevheights[0] = baseheight + 1;
     tx.vout.resize(1);
     tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
     tx.vout[0].scriptPubKey = CScript() << OP_1;
     tx.nLockTime = 0;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
 
     const Consensus::Params &params = chainparams.GetConsensus();
 
     {
         // Locktime passes.
         TxValidationState state;
         BOOST_CHECK(ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
     }
 
     // Sequence locks fail.
     BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags));
     // Sequence locks pass on 2nd block.
     BOOST_CHECK(
         SequenceLocks(CTransaction(tx), flags, prevheights,
                       CreateBlockIndex(::ChainActive().Tip()->nHeight + 2)));
 
     // Relative time locked.
     tx.vin[0].prevout = COutPoint(txFirst[1]->GetId(), 0);
     // txFirst[1] is the 3rd block.
     tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG |
                           (((::ChainActive().Tip()->GetMedianTimePast() + 1 -
                              ::ChainActive()[1]->GetMedianTimePast()) >>
                             CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) +
                            1);
     prevheights[0] = baseheight + 2;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));
 
     {
         // Locktime passes.
         TxValidationState state;
         BOOST_CHECK(ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
     }
 
     // Sequence locks fail.
     BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags));
 
     for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++) {
         // Trick the MedianTimePast.
         ::ChainActive()
             .Tip()
             ->GetAncestor(::ChainActive().Tip()->nHeight - i)
             ->nTime += 512;
     }
     // Sequence locks pass 512 seconds later.
     BOOST_CHECK(
         SequenceLocks(CTransaction(tx), flags, prevheights,
                       CreateBlockIndex(::ChainActive().Tip()->nHeight + 1)));
     for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++) {
         // Undo tricked MTP.
         ::ChainActive()
             .Tip()
             ->GetAncestor(::ChainActive().Tip()->nHeight - i)
             ->nTime -= 512;
     }
 
     // Absolute height locked.
     tx.vin[0].prevout = COutPoint(txFirst[2]->GetId(), 0);
     tx.vin[0].nSequence = CTxIn::SEQUENCE_FINAL - 1;
     prevheights[0] = baseheight + 3;
     tx.nLockTime = ::ChainActive().Tip()->nHeight + 1;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));
 
     {
         // Locktime fails.
         TxValidationState state;
         BOOST_CHECK(!ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
         BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-txns-nonfinal");
     }
 
     // Sequence locks pass.
     BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags));
 
     {
         // Locktime passes on 2nd block.
         TxValidationState state;
         int64_t nMedianTimePast = ::ChainActive().Tip()->GetMedianTimePast();
         BOOST_CHECK(ContextualCheckTransaction(
             params, CTransaction(tx), state, ::ChainActive().Tip()->nHeight + 2,
             nMedianTimePast, nMedianTimePast));
     }
 
     // Absolute time locked.
     tx.vin[0].prevout = COutPoint(txFirst[3]->GetId(), 0);
     tx.nLockTime = ::ChainActive().Tip()->GetMedianTimePast();
     prevheights.resize(1);
     prevheights[0] = baseheight + 4;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));
 
     {
         // Locktime fails.
         TxValidationState state;
         BOOST_CHECK(!ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
         BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-txns-nonfinal");
     }
 
     // Sequence locks pass.
     BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags));
 
     {
         // Locktime passes 1 second later.
         TxValidationState state;
         int64_t nMedianTimePast =
             ::ChainActive().Tip()->GetMedianTimePast() + 1;
         BOOST_CHECK(ContextualCheckTransaction(
             params, CTransaction(tx), state, ::ChainActive().Tip()->nHeight + 1,
             nMedianTimePast, nMedianTimePast));
     }
 
     // mempool-dependent transactions (not added)
     tx.vin[0].prevout = COutPoint(txid, 0);
     prevheights[0] = ::ChainActive().Tip()->nHeight + 1;
     tx.nLockTime = 0;
     tx.vin[0].nSequence = 0;
 
     {
         // Locktime passes.
         TxValidationState state;
         BOOST_CHECK(ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
     }
 
     // Sequence locks pass.
     BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags));
     tx.vin[0].nSequence = 1;
     // Sequence locks fail.
     BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags));
     tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;
     // Sequence locks pass.
     BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags));
     tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | 1;
     // Sequence locks fail.
     BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags));
 
     pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
     BOOST_CHECK(pblocktemplate);
 
     // None of the of the absolute height/time locked tx should have made it
     // into the template because we still check IsFinalTx in CreateNewBlock, but
     // relative locked txs will if inconsistently added to g_mempool. For now
     // these will still generate a valid template until BIP68 soft fork.
     BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 3UL);
     // However if we advance height by 1 and time by 512, all of them should be
     // mined.
     for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++) {
         // Trick the MedianTimePast.
         ::ChainActive()
             .Tip()
             ->GetAncestor(::ChainActive().Tip()->nHeight - i)
             ->nTime += 512;
     }
     ::ChainActive().Tip()->nHeight++;
     SetMockTime(::ChainActive().Tip()->GetMedianTimePast() + 1);
 
     BOOST_CHECK(pblocktemplate =
                     AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
     BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 5UL);
 
     ::ChainActive().Tip()->nHeight--;
     SetMockTime(0);
     m_node.mempool->clear();
 
     TestPackageSelection(chainparams, scriptPubKey, txFirst);
 
     fCheckpointsEnabled = true;
 }
 
 void CheckBlockMaxSize(const Config &config, const CTxMemPool &mempool,
                        uint64_t size, uint64_t expected) {
-    gArgs.ForceSetArg("-blockmaxsize", std::to_string(size));
+    gArgs.ForceSetArg("-blockmaxsize", ToString(size));
 
     BlockAssembler ba(config, mempool);
     BOOST_CHECK_EQUAL(ba.GetMaxGeneratedBlockSize(), expected);
 }
 
 BOOST_AUTO_TEST_CASE(BlockAssembler_construction) {
     GlobalConfig config;
 
     // We are working on a fake chain and need to protect ourselves.
     LOCK(cs_main);
 
     // Test around historical 1MB (plus one byte because that's mandatory)
     config.SetMaxBlockSize(ONE_MEGABYTE + 1);
     CheckBlockMaxSize(config, *m_node.mempool, 0, 1000);
     CheckBlockMaxSize(config, *m_node.mempool, 1000, 1000);
     CheckBlockMaxSize(config, *m_node.mempool, 1001, 1001);
     CheckBlockMaxSize(config, *m_node.mempool, 12345, 12345);
 
     CheckBlockMaxSize(config, *m_node.mempool, ONE_MEGABYTE - 1001,
                       ONE_MEGABYTE - 1001);
     CheckBlockMaxSize(config, *m_node.mempool, ONE_MEGABYTE - 1000,
                       ONE_MEGABYTE - 1000);
     CheckBlockMaxSize(config, *m_node.mempool, ONE_MEGABYTE - 999,
                       ONE_MEGABYTE - 999);
     CheckBlockMaxSize(config, *m_node.mempool, ONE_MEGABYTE,
                       ONE_MEGABYTE - 999);
 
     // Test around default cap
     config.SetMaxBlockSize(DEFAULT_MAX_BLOCK_SIZE);
 
     // Now we can use the default max block size.
     CheckBlockMaxSize(config, *m_node.mempool, DEFAULT_MAX_BLOCK_SIZE - 1001,
                       DEFAULT_MAX_BLOCK_SIZE - 1001);
     CheckBlockMaxSize(config, *m_node.mempool, DEFAULT_MAX_BLOCK_SIZE - 1000,
                       DEFAULT_MAX_BLOCK_SIZE - 1000);
     CheckBlockMaxSize(config, *m_node.mempool, DEFAULT_MAX_BLOCK_SIZE - 999,
                       DEFAULT_MAX_BLOCK_SIZE - 1000);
     CheckBlockMaxSize(config, *m_node.mempool, DEFAULT_MAX_BLOCK_SIZE,
                       DEFAULT_MAX_BLOCK_SIZE - 1000);
 
     // If the parameter is not specified, we use
     // DEFAULT_MAX_GENERATED_BLOCK_SIZE
     {
         gArgs.ClearForcedArg("-blockmaxsize");
         BlockAssembler ba(config, *m_node.mempool);
         BOOST_CHECK_EQUAL(ba.GetMaxGeneratedBlockSize(),
                           DEFAULT_MAX_GENERATED_BLOCK_SIZE);
     }
 }
 
 BOOST_AUTO_TEST_CASE(TestCBlockTemplateEntry) {
     const CTransaction tx;
     CTransactionRef txRef = MakeTransactionRef(tx);
     CBlockTemplateEntry txEntry(txRef, 1 * SATOSHI, 10);
     BOOST_CHECK_MESSAGE(txEntry.tx == txRef, "Transactions did not match");
     BOOST_CHECK_EQUAL(txEntry.fees, 1 * SATOSHI);
     BOOST_CHECK_EQUAL(txEntry.sigOpCount, 10);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
index 4b40e65d4..9e04bb746 100644
--- a/src/test/net_tests.cpp
+++ b/src/test/net_tests.cpp
@@ -1,355 +1,356 @@
 // Copyright (c) 2012-2019 The Bitcoin Core developers
 // Copyright (c) 2017-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #include <net.h>
 
 #include <addrdb.h>
 #include <addrman.h>
 #include <chainparams.h>
 #include <clientversion.h>
 #include <config.h>
 #include <netbase.h>
 #include <serialize.h>
 #include <streams.h>
+#include <util/string.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <memory>
 #include <string>
 
 class CAddrManSerializationMock : public CAddrMan {
 public:
     virtual void Serialize(CDataStream &s) const = 0;
 
     //! Ensure that bucket placement is always the same for testing purposes.
     void MakeDeterministic() {
         nKey.SetNull();
         insecure_rand = FastRandomContext(true);
     }
 };
 
 class CAddrManUncorrupted : public CAddrManSerializationMock {
 public:
     void Serialize(CDataStream &s) const override { CAddrMan::Serialize(s); }
 };
 
 class CAddrManCorrupted : public CAddrManSerializationMock {
 public:
     void Serialize(CDataStream &s) const override {
         // Produces corrupt output that claims addrman has 20 addrs when it only
         // has one addr.
         uint8_t nVersion = 1;
         s << nVersion;
         s << uint8_t(32);
         s << nKey;
         s << 10; // nNew
         s << 10; // nTried
 
         int nUBuckets = ADDRMAN_NEW_BUCKET_COUNT ^ (1 << 30);
         s << nUBuckets;
 
         CService serv;
         BOOST_CHECK(Lookup("252.1.1.1", serv, 7777, false));
         CAddress addr = CAddress(serv, NODE_NONE);
         CNetAddr resolved;
         BOOST_CHECK(LookupHost("252.2.2.2", resolved, false));
         CAddrInfo info = CAddrInfo(addr, resolved);
         s << info;
     }
 };
 
 class NetTestConfig : public DummyConfig {
 public:
     bool SetMaxBlockSize(uint64_t maxBlockSize) override {
         nMaxBlockSize = maxBlockSize;
         return true;
     }
     uint64_t GetMaxBlockSize() const override { return nMaxBlockSize; }
 
 private:
     uint64_t nMaxBlockSize;
 };
 
 static CDataStream AddrmanToStream(CAddrManSerializationMock &_addrman) {
     CDataStream ssPeersIn(SER_DISK, CLIENT_VERSION);
     ssPeersIn << Params().DiskMagic();
     ssPeersIn << _addrman;
     std::string str = ssPeersIn.str();
     std::vector<uint8_t> vchData(str.begin(), str.end());
     return CDataStream(vchData, SER_DISK, CLIENT_VERSION);
 }
 
 BOOST_FIXTURE_TEST_SUITE(net_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(cnode_listen_port) {
     // test default
     unsigned short port = GetListenPort();
     BOOST_CHECK(port == Params().GetDefaultPort());
     // test set port
     unsigned short altPort = 12345;
-    BOOST_CHECK(gArgs.SoftSetArg("-port", std::to_string(altPort)));
+    BOOST_CHECK(gArgs.SoftSetArg("-port", ToString(altPort)));
     port = GetListenPort();
     BOOST_CHECK(port == altPort);
 }
 
 BOOST_AUTO_TEST_CASE(caddrdb_read) {
     CAddrManUncorrupted addrmanUncorrupted;
     addrmanUncorrupted.MakeDeterministic();
 
     CService addr1, addr2, addr3;
     BOOST_CHECK(Lookup("250.7.1.1", addr1, 8333, false));
     BOOST_CHECK(Lookup("250.7.2.2", addr2, 9999, false));
     BOOST_CHECK(Lookup("250.7.3.3", addr3, 9999, false));
     BOOST_CHECK(Lookup(std::string("250.7.3.3", 9), addr3, 9999, false));
     BOOST_CHECK(
         !Lookup(std::string("250.7.3.3\0example.com", 21), addr3, 9999, false));
 
     // Add three addresses to new table.
     CService source;
     BOOST_CHECK(Lookup("252.5.1.1", source, 8333, false));
     BOOST_CHECK(addrmanUncorrupted.Add(CAddress(addr1, NODE_NONE), source));
     BOOST_CHECK(addrmanUncorrupted.Add(CAddress(addr2, NODE_NONE), source));
     BOOST_CHECK(addrmanUncorrupted.Add(CAddress(addr3, NODE_NONE), source));
 
     // Test that the de-serialization does not throw an exception.
     CDataStream ssPeers1 = AddrmanToStream(addrmanUncorrupted);
     bool exceptionThrown = false;
     CAddrMan addrman1;
 
     BOOST_CHECK(addrman1.size() == 0);
     try {
         uint8_t pchMsgTmp[4];
         ssPeers1 >> pchMsgTmp;
         ssPeers1 >> addrman1;
     } catch (const std::exception &) {
         exceptionThrown = true;
     }
 
     BOOST_CHECK(addrman1.size() == 3);
     BOOST_CHECK(exceptionThrown == false);
 
     // Test that CAddrDB::Read creates an addrman with the correct number of
     // addrs.
     CDataStream ssPeers2 = AddrmanToStream(addrmanUncorrupted);
 
     CAddrMan addrman2;
     CAddrDB adb(Params());
     BOOST_CHECK(addrman2.size() == 0);
     BOOST_CHECK(adb.Read(addrman2, ssPeers2));
     BOOST_CHECK(addrman2.size() == 3);
 }
 
 BOOST_AUTO_TEST_CASE(caddrdb_read_corrupted) {
     CAddrManCorrupted addrmanCorrupted;
     addrmanCorrupted.MakeDeterministic();
 
     // Test that the de-serialization of corrupted addrman throws an exception.
     CDataStream ssPeers1 = AddrmanToStream(addrmanCorrupted);
     bool exceptionThrown = false;
     CAddrMan addrman1;
     BOOST_CHECK(addrman1.size() == 0);
     try {
         uint8_t pchMsgTmp[4];
         ssPeers1 >> pchMsgTmp;
         ssPeers1 >> addrman1;
     } catch (const std::exception &) {
         exceptionThrown = true;
     }
     // Even through de-serialization failed addrman is not left in a clean
     // state.
     BOOST_CHECK(addrman1.size() == 1);
     BOOST_CHECK(exceptionThrown);
 
     // Test that CAddrDB::Read leaves addrman in a clean state if
     // de-serialization fails.
     CDataStream ssPeers2 = AddrmanToStream(addrmanCorrupted);
 
     CAddrMan addrman2;
     CAddrDB adb(Params());
     BOOST_CHECK(addrman2.size() == 0);
     BOOST_CHECK(!adb.Read(addrman2, ssPeers2));
     BOOST_CHECK(addrman2.size() == 0);
 }
 
 BOOST_AUTO_TEST_CASE(cnode_simple_test) {
     SOCKET hSocket = INVALID_SOCKET;
     NodeId id = 0;
     int height = 0;
 
     in_addr ipv4Addr;
     ipv4Addr.s_addr = 0xa0b0c001;
 
     CAddress addr = CAddress(CService(ipv4Addr, 7777), NODE_NETWORK);
     std::string pszDest;
 
     auto pnode1 = std::make_unique<CNode>(id++, NODE_NETWORK, height, hSocket,
                                           addr, 0, 0, 0, CAddress(), pszDest,
                                           ConnectionType::OUTBOUND);
     BOOST_CHECK(pnode1->IsInboundConn() == false);
 
     auto pnode2 = std::make_unique<CNode>(id++, NODE_NETWORK, height, hSocket,
                                           addr, 1, 1, 1, CAddress(), pszDest,
                                           ConnectionType::INBOUND);
     BOOST_CHECK(pnode2->IsInboundConn() == true);
 }
 
 BOOST_AUTO_TEST_CASE(test_getSubVersionEB) {
     BOOST_CHECK_EQUAL(getSubVersionEB(13800000000), "13800.0");
     BOOST_CHECK_EQUAL(getSubVersionEB(3800000000), "3800.0");
     BOOST_CHECK_EQUAL(getSubVersionEB(14000000), "14.0");
     BOOST_CHECK_EQUAL(getSubVersionEB(1540000), "1.5");
     BOOST_CHECK_EQUAL(getSubVersionEB(1560000), "1.5");
     BOOST_CHECK_EQUAL(getSubVersionEB(210000), "0.2");
     BOOST_CHECK_EQUAL(getSubVersionEB(10000), "0.0");
     BOOST_CHECK_EQUAL(getSubVersionEB(0), "0.0");
 }
 
 BOOST_AUTO_TEST_CASE(test_userAgent) {
     NetTestConfig config;
 
     config.SetMaxBlockSize(8000000);
     const std::string uacomment = "A very nice comment";
     gArgs.ForceSetMultiArg("-uacomment", {uacomment});
 
     const std::string versionMessage =
-        "/Bitcoin ABC:" + std::to_string(CLIENT_VERSION_MAJOR) + "." +
-        std::to_string(CLIENT_VERSION_MINOR) + "." +
-        std::to_string(CLIENT_VERSION_REVISION) + "(EB8.0; " + uacomment + ")/";
+        "/Bitcoin ABC:" + ToString(CLIENT_VERSION_MAJOR) + "." +
+        ToString(CLIENT_VERSION_MINOR) + "." +
+        ToString(CLIENT_VERSION_REVISION) + "(EB8.0; " + uacomment + ")/";
 
     BOOST_CHECK_EQUAL(userAgent(config), versionMessage);
 }
 
 BOOST_AUTO_TEST_CASE(LimitedAndReachable_Network) {
     BOOST_CHECK_EQUAL(IsReachable(NET_IPV4), true);
     BOOST_CHECK_EQUAL(IsReachable(NET_IPV6), true);
     BOOST_CHECK_EQUAL(IsReachable(NET_ONION), true);
 
     SetReachable(NET_IPV4, false);
     SetReachable(NET_IPV6, false);
     SetReachable(NET_ONION, false);
 
     BOOST_CHECK_EQUAL(IsReachable(NET_IPV4), false);
     BOOST_CHECK_EQUAL(IsReachable(NET_IPV6), false);
     BOOST_CHECK_EQUAL(IsReachable(NET_ONION), false);
 
     SetReachable(NET_IPV4, true);
     SetReachable(NET_IPV6, true);
     SetReachable(NET_ONION, true);
 
     BOOST_CHECK_EQUAL(IsReachable(NET_IPV4), true);
     BOOST_CHECK_EQUAL(IsReachable(NET_IPV6), true);
     BOOST_CHECK_EQUAL(IsReachable(NET_ONION), true);
 }
 
 BOOST_AUTO_TEST_CASE(LimitedAndReachable_NetworkCaseUnroutableAndInternal) {
     BOOST_CHECK_EQUAL(IsReachable(NET_UNROUTABLE), true);
     BOOST_CHECK_EQUAL(IsReachable(NET_INTERNAL), true);
 
     SetReachable(NET_UNROUTABLE, false);
     SetReachable(NET_INTERNAL, false);
 
     // Ignored for both networks
     BOOST_CHECK_EQUAL(IsReachable(NET_UNROUTABLE), true);
     BOOST_CHECK_EQUAL(IsReachable(NET_INTERNAL), true);
 }
 
 CNetAddr UtilBuildAddress(uint8_t p1, uint8_t p2, uint8_t p3, uint8_t p4) {
     uint8_t ip[] = {p1, p2, p3, p4};
 
     struct sockaddr_in sa;
     // initialize the memory block
     memset(&sa, 0, sizeof(sockaddr_in));
     memcpy(&(sa.sin_addr), &ip, sizeof(ip));
     return CNetAddr(sa.sin_addr);
 }
 
 BOOST_AUTO_TEST_CASE(LimitedAndReachable_CNetAddr) {
     // 1.1.1.1
     CNetAddr addr = UtilBuildAddress(0x001, 0x001, 0x001, 0x001);
 
     SetReachable(NET_IPV4, true);
     BOOST_CHECK_EQUAL(IsReachable(addr), true);
 
     SetReachable(NET_IPV4, false);
     BOOST_CHECK_EQUAL(IsReachable(addr), false);
 
     // have to reset this, because this is stateful.
     SetReachable(NET_IPV4, true);
 }
 
 BOOST_AUTO_TEST_CASE(LocalAddress_BasicLifecycle) {
     // 2.1.1.1:1000
     CService addr =
         CService(UtilBuildAddress(0x002, 0x001, 0x001, 0x001), 1000);
 
     SetReachable(NET_IPV4, true);
 
     BOOST_CHECK_EQUAL(IsLocal(addr), false);
     BOOST_CHECK_EQUAL(AddLocal(addr, 1000), true);
     BOOST_CHECK_EQUAL(IsLocal(addr), true);
 
     RemoveLocal(addr);
     BOOST_CHECK_EQUAL(IsLocal(addr), false);
 }
 
 // prior to PR #14728, this test triggers an undefined behavior
 BOOST_AUTO_TEST_CASE(ipv4_peer_with_ipv6_addrMe_test) {
     // set up local addresses; all that's necessary to reproduce the bug is
     // that a normal IPv4 address is among the entries, but if this address is
     // !IsRoutable the undefined behavior is easier to trigger deterministically
     {
         LOCK(cs_mapLocalHost);
         in_addr ipv4AddrLocal;
         ipv4AddrLocal.s_addr = 0x0100007f;
         CNetAddr addr = CNetAddr(ipv4AddrLocal);
         LocalServiceInfo lsi;
         lsi.nScore = 23;
         lsi.nPort = 42;
         mapLocalHost[addr] = lsi;
     }
 
     // create a peer with an IPv4 address
     in_addr ipv4AddrPeer;
     ipv4AddrPeer.s_addr = 0xa0b0c001;
     CAddress addr = CAddress(CService(ipv4AddrPeer, 7777), NODE_NETWORK);
     std::unique_ptr<CNode> pnode = std::make_unique<CNode>(
         0, NODE_NETWORK, 0, INVALID_SOCKET, addr, 0, 0, 0, CAddress{},
         std::string{}, ConnectionType::OUTBOUND);
     pnode->fSuccessfullyConnected.store(true);
 
     // the peer claims to be reaching us via IPv6
     in6_addr ipv6AddrLocal;
     memset(ipv6AddrLocal.s6_addr, 0, 16);
     ipv6AddrLocal.s6_addr[0] = 0xcc;
     CAddress addrLocal = CAddress(CService(ipv6AddrLocal, 7777), NODE_NETWORK);
     pnode->SetAddrLocal(addrLocal);
 
     // before patch, this causes undefined behavior detectable with clang's
     // -fsanitize=memory
     AdvertiseLocal(&*pnode);
 
     // suppress no-checks-run warning; if this test fails, it's by triggering a
     // sanitizer
     BOOST_CHECK(1);
 }
 
 BOOST_AUTO_TEST_CASE(PoissonNextSend) {
     g_mock_deterministic_tests = true;
 
     int64_t now = 5000;
     int average_interval_seconds = 600;
 
     auto poisson = ::PoissonNextSend(now, average_interval_seconds);
     std::chrono::microseconds poisson_chrono =
         ::PoissonNextSend(std::chrono::microseconds{now},
                           std::chrono::seconds{average_interval_seconds});
 
     BOOST_CHECK_EQUAL(poisson, poisson_chrono.count());
 
     g_mock_deterministic_tests = false;
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/settings_tests.cpp b/src/test/settings_tests.cpp
index 027156d83..c254a6fe5 100644
--- a/src/test/settings_tests.cpp
+++ b/src/test/settings_tests.cpp
@@ -1,295 +1,295 @@
 // Copyright (c) 2011-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.
 
 #include <util/settings.h>
 
 #include <test/util/setup_common.h>
 #include <test/util/str.h>
 #include <util/strencodings.h>
+#include <util/string.h>
 #include <util/system.h>
 
 #include <univalue.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <vector>
 
 inline bool operator==(const util::SettingsValue &a,
                        const util::SettingsValue &b) {
     return a.write() == b.write();
 }
 
 inline std::ostream &operator<<(std::ostream &os,
                                 const util::SettingsValue &value) {
     os << value.write();
     return os;
 }
 
 inline std::ostream &
 operator<<(std::ostream &os,
            const std::pair<std::string, util::SettingsValue> &kv) {
     util::SettingsValue out(util::SettingsValue::VOBJ);
     out.__pushKV(kv.first, kv.second);
     os << out.write();
     return os;
 }
 
 inline void WriteText(const fs::path &path, const std::string &text) {
     fsbridge::ofstream file;
     file.open(path);
     file << text;
 }
 
 BOOST_FIXTURE_TEST_SUITE(settings_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(ReadWrite) {
     fs::path path = GetDataDir() / "settings.json";
 
     WriteText(path, R"({
         "string": "string",
         "num": 5,
         "bool": true,
         "null": null
     })");
 
     std::map<std::string, util::SettingsValue> expected{
         {"string", "string"},
         {"num", 5},
         {"bool", true},
         {"null", {}},
     };
 
     // Check file read.
     std::map<std::string, util::SettingsValue> values;
     std::vector<std::string> errors;
     BOOST_CHECK(util::ReadSettings(path, values, errors));
     BOOST_CHECK_EQUAL_COLLECTIONS(values.begin(), values.end(),
                                   expected.begin(), expected.end());
     BOOST_CHECK(errors.empty());
 
     // Check no errors if file doesn't exist.
     fs::remove(path);
     BOOST_CHECK(util::ReadSettings(path, values, errors));
     BOOST_CHECK(values.empty());
     BOOST_CHECK(errors.empty());
 
     // Check duplicate keys not allowed
     WriteText(path, R"({
         "dupe": "string",
         "dupe": "dupe"
     })");
     BOOST_CHECK(!util::ReadSettings(path, values, errors));
     std::vector<std::string> dup_keys = {strprintf(
         "Found duplicate key dupe in settings file %s", path.string())};
     BOOST_CHECK_EQUAL_COLLECTIONS(errors.begin(), errors.end(),
                                   dup_keys.begin(), dup_keys.end());
 
     // Check non-kv json files not allowed
     WriteText(path, R"("non-kv")");
     BOOST_CHECK(!util::ReadSettings(path, values, errors));
     std::vector<std::string> non_kv = {
         strprintf("Found non-object value \"non-kv\" in settings file %s",
                   path.string())};
     BOOST_CHECK_EQUAL_COLLECTIONS(errors.begin(), errors.end(), non_kv.begin(),
                                   non_kv.end());
 
     // Check invalid json not allowed
     WriteText(path, R"(invalid json)");
     BOOST_CHECK(!util::ReadSettings(path, values, errors));
     std::vector<std::string> fail_parse = {
         strprintf("Unable to parse settings file %s", path.string())};
     BOOST_CHECK_EQUAL_COLLECTIONS(errors.begin(), errors.end(),
                                   fail_parse.begin(), fail_parse.end());
 }
 
 //! Check settings struct contents against expected json strings.
 static void CheckValues(const util::Settings &settings,
                         const std::string &single_val,
                         const std::string &list_val) {
     util::SettingsValue single_value =
         GetSetting(settings, "section", "name", false, false);
     util::SettingsValue list_value(util::SettingsValue::VARR);
     for (const auto &item :
          GetSettingsList(settings, "section", "name", false)) {
         list_value.push_back(item);
     }
     BOOST_CHECK_EQUAL(single_value.write().c_str(), single_val);
     BOOST_CHECK_EQUAL(list_value.write().c_str(), list_val);
 };
 
 // Simple settings merge test case.
 BOOST_AUTO_TEST_CASE(Simple) {
     util::Settings settings;
     settings.command_line_options["name"].push_back("val1");
     settings.command_line_options["name"].push_back("val2");
     settings.ro_config["section"]["name"].push_back(2);
 
     // The last given arg takes precedence when specified via commandline.
     CheckValues(settings, R"("val2")", R"(["val1","val2",2])");
 
     util::Settings settings2;
     settings2.ro_config["section"]["name"].push_back("val2");
     settings2.ro_config["section"]["name"].push_back("val3");
 
     // The first given arg takes precedence when specified via config file.
     CheckValues(settings2, R"("val2")", R"(["val2","val3"])");
 }
 
 // Confirm that a high priority setting overrides a lower priority setting even
 // if the high priority setting is null. This behavior is useful for a high
 // priority setting source to be able to effectively reset any setting back to
 // its default value.
 BOOST_AUTO_TEST_CASE(NullOverride) {
     util::Settings settings;
     settings.command_line_options["name"].push_back("value");
     BOOST_CHECK_EQUAL(
         R"("value")",
         GetSetting(settings, "section", "name", false, false).write().c_str());
     settings.forced_settings["name"] = {};
     BOOST_CHECK_EQUAL(
         R"(null)",
         GetSetting(settings, "section", "name", false, false).write().c_str());
 }
 
 // Test different ways settings can be merged, and verify results. This test can
 // be used to confirm that updates to settings code don't change behavior
 // unintentionally.
 struct MergeTestingSetup : public BasicTestingSetup {
     //! Max number of actions to sequence together. Can decrease this when
     //! debugging to make test results easier to understand.
     static constexpr int MAX_ACTIONS = 3;
 
     enum Action { END, SET, NEGATE, SECTION_SET, SECTION_NEGATE };
     using ActionList = Action[MAX_ACTIONS];
 
     //! Enumerate all possible test configurations.
     template <typename Fn> void ForEachMergeSetup(Fn &&fn) {
         ActionList arg_actions = {};
         // command_line_options do not have sections. Only iterate over SET and
         // NEGATE
         ForEachNoDup(arg_actions, SET, NEGATE, [&] {
             ActionList conf_actions = {};
             ForEachNoDup(conf_actions, SET, SECTION_NEGATE, [&] {
                 for (bool force_set : {false, true}) {
                     for (bool ignore_default_section_config : {false, true}) {
                         fn(arg_actions, conf_actions, force_set,
                            ignore_default_section_config);
                     }
                 }
             });
         });
     }
 };
 
 // Regression test covering different ways config settings can be merged. The
 // test parses and merges settings, representing the results as strings that get
 // compared against an expected hash. To debug, the result strings can be dumped
 // to a file (see comments below).
 BOOST_FIXTURE_TEST_CASE(Merge, MergeTestingSetup) {
     CHash256 out_sha;
     FILE *out_file = nullptr;
     if (const char *out_path = getenv("SETTINGS_MERGE_TEST_OUT")) {
         out_file = fsbridge::fopen(out_path, "w");
         if (!out_file) {
             throw std::system_error(errno, std::generic_category(),
                                     "fopen failed");
         }
     }
 
     const std::string &network = CBaseChainParams::MAIN;
     ForEachMergeSetup([&](const ActionList &arg_actions,
                           const ActionList &conf_actions, bool force_set,
                           bool ignore_default_section_config) {
         std::string desc;
         int value_suffix = 0;
         util::Settings settings;
 
         const std::string &name =
             ignore_default_section_config ? "wallet" : "server";
         auto push_values = [&](Action action, const char *value_prefix,
                                const std::string &name_prefix,
                                std::vector<util::SettingsValue> &dest) {
             if (action == SET || action == SECTION_SET) {
                 for (int i = 0; i < 2; ++i) {
-                    dest.push_back(value_prefix +
-                                   std::to_string(++value_suffix));
+                    dest.push_back(value_prefix + ToString(++value_suffix));
                     desc +=
                         " " + name_prefix + name + "=" + dest.back().get_str();
                 }
             } else if (action == NEGATE || action == SECTION_NEGATE) {
                 dest.push_back(false);
                 desc += " " + name_prefix + "no" + name;
             }
         };
 
         if (force_set) {
             settings.forced_settings[name] = "forced";
             desc += " " + name + "=forced";
         }
         for (Action arg_action : arg_actions) {
             push_values(arg_action, "a", "-",
                         settings.command_line_options[name]);
         }
         for (Action conf_action : conf_actions) {
             bool use_section =
                 conf_action == SECTION_SET || conf_action == SECTION_NEGATE;
             push_values(conf_action, "c", use_section ? network + "." : "",
                         settings.ro_config[use_section ? network : ""][name]);
         }
 
         desc += " || ";
         desc +=
             GetSetting(settings, network, name, ignore_default_section_config,
                        /* get_chain_name= */ false)
                 .write();
         desc += " |";
         for (const auto &s : GetSettingsList(settings, network, name,
                                              ignore_default_section_config)) {
             desc += " ";
             desc += s.write();
         }
         desc += " |";
         if (OnlyHasDefaultSectionSetting(settings, network, name)) {
             desc += " ignored";
         }
         desc += "\n";
 
         out_sha.Write((const uint8_t *)desc.data(), desc.size());
         if (out_file) {
             BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) ==
                           desc.size());
         }
     });
 
     if (out_file) {
         if (fclose(out_file)) {
             throw std::system_error(errno, std::generic_category(),
                                     "fclose failed");
         }
         out_file = nullptr;
     }
 
     uint8_t out_sha_bytes[CSHA256::OUTPUT_SIZE];
     out_sha.Finalize(out_sha_bytes);
     std::string out_sha_hex =
         HexStr(std::begin(out_sha_bytes), std::end(out_sha_bytes));
 
     // If check below fails, should manually dump the results with:
     //
     //   SETTINGS_MERGE_TEST_OUT=results.txt ./test_bitcoin
     //   --run_test=settings_tests/Merge
     //
     // And verify diff against previous results to make sure the changes are
     // expected.
     //
     // Results file is formatted like:
     //
     //   <input> || GetSetting() | GetSettingsList() |
     //   OnlyHasDefaultSectionSetting()
     BOOST_CHECK_EQUAL(
         out_sha_hex,
         "79db02d74e3e193196541b67c068b40ebd0c124a24b3ecbe9cbf7e85b1c4ba7a");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/timedata_tests.cpp b/src/test/timedata_tests.cpp
index d8e5af57a..0602eb1de 100644
--- a/src/test/timedata_tests.cpp
+++ b/src/test/timedata_tests.cpp
@@ -1,111 +1,112 @@
 // Copyright (c) 2011-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.
 //
 #include <timedata.h>
 
 #include <netaddress.h>
 #include <noui.h>
 #include <test/util/logging.h>
+#include <util/string.h>
 #include <warnings.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <string>
 
 BOOST_FIXTURE_TEST_SUITE(timedata_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(util_MedianFilter) {
     CMedianFilter<int> filter(5, 15);
 
     BOOST_CHECK_EQUAL(filter.median(), 15);
 
     filter.input(20); // [15 20]
     BOOST_CHECK_EQUAL(filter.median(), 17);
 
     filter.input(30); // [15 20 30]
     BOOST_CHECK_EQUAL(filter.median(), 20);
 
     filter.input(3); // [3 15 20 30]
     BOOST_CHECK_EQUAL(filter.median(), 17);
 
     filter.input(7); // [3 7 15 20 30]
     BOOST_CHECK_EQUAL(filter.median(), 15);
 
     filter.input(18); // [3 7 18 20 30]
     BOOST_CHECK_EQUAL(filter.median(), 18);
 
     filter.input(0); // [0 3 7 18 30]
     BOOST_CHECK_EQUAL(filter.median(), 7);
 }
 
 static void MultiAddTimeData(int n, int64_t offset) {
     static int cnt = 0;
     for (int i = 0; i < n; ++i) {
         CNetAddr addr;
-        addr.SetInternal(std::to_string(++cnt));
+        addr.SetInternal(ToString(++cnt));
         AddTimeData(addr, offset);
     }
 }
 
 BOOST_AUTO_TEST_CASE(addtimedata) {
     BOOST_CHECK_EQUAL(GetTimeOffset(), 0);
 
     // Part 1: Add large offsets to test a warning message that our clock may be
     // wrong.
     MultiAddTimeData(3, DEFAULT_MAX_TIME_ADJUSTMENT + 1);
     // Filter size is 1 + 3 = 4: It is always initialized with a single element
     // (offset 0)
 
     {
         ASSERT_DEBUG_LOG(
             "Please check that your computer's date and time are correct!");
         // filter size 5
         MultiAddTimeData(1, DEFAULT_MAX_TIME_ADJUSTMENT + 1);
     }
 
     BOOST_CHECK(GetWarnings(true).find("clock is wrong") != std::string::npos);
 
     // nTimeOffset is not changed if the median of offsets exceeds
     // DEFAULT_MAX_TIME_ADJUSTMENT
     BOOST_CHECK_EQUAL(GetTimeOffset(), 0);
 
     // Part 2: Test positive and negative medians by adding more offsets
     // filter size 9
     MultiAddTimeData(4, 100);
     BOOST_CHECK_EQUAL(GetTimeOffset(), 100);
     // filter size 19
     MultiAddTimeData(10, -100);
     BOOST_CHECK_EQUAL(GetTimeOffset(), -100);
 
     // Part 3: Test behaviour when filter has reached maximum number of offsets
     const int MAX_SAMPLES = 200;
     int nfill = (MAX_SAMPLES - 3 - 19) / 2; // 89
     MultiAddTimeData(nfill, 100);
     // filter size MAX_SAMPLES - 3
     MultiAddTimeData(nfill, -100);
     BOOST_CHECK_EQUAL(GetTimeOffset(), -100);
 
     MultiAddTimeData(2, 100);
     // filter size MAX_SAMPLES -1, median is the initial 0 offset
     // since we added same number of positive/negative offsets
 
     BOOST_CHECK_EQUAL(GetTimeOffset(), 0);
 
     // After the number of offsets has reached MAX_SAMPLES -1 (=199),
     // nTimeOffset will never change because it is only updated when the number
     // of elements in the filter becomes odd. It was decided not to fix this
     // because it prevents possible attacks. See the comment in AddTimeData() or
     // issue #4521 for a more detailed explanation.
 
     // filter median is 100 now, but nTimeOffset will not change
     MultiAddTimeData(2, 100);
     BOOST_CHECK_EQUAL(GetTimeOffset(), 0);
 
     // We want this test to end with nTimeOffset==0, otherwise subsequent tests
     // of the suite will fail.
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/transaction_tests.cpp b/src/test/transaction_tests.cpp
index 5b46e1e7b..d8d9be2b7 100644
--- a/src/test/transaction_tests.cpp
+++ b/src/test/transaction_tests.cpp
@@ -1,888 +1,889 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h> // For CChainParams
 #include <checkqueue.h>
 #include <clientversion.h>
 #include <config.h>
 #include <consensus/tx_check.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <key.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <script/script.h>
 #include <script/script_error.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
 #include <script/standard.h>
 #include <streams.h>
 #include <util/strencodings.h>
+#include <util/string.h>
 #include <util/system.h>
 #include <validation.h>
 
 #include <test/data/tx_invalid.json.h>
 #include <test/data/tx_valid.json.h>
 #include <test/jsonutil.h>
 #include <test/scriptflags.h>
 #include <test/util/setup_common.h>
 #include <test/util/transaction_utils.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <univalue.h>
 
 #include <map>
 #include <string>
 
 typedef std::vector<uint8_t> valtype;
 
 BOOST_FIXTURE_TEST_SUITE(transaction_tests, BasicTestingSetup)
 
 static COutPoint buildOutPoint(const UniValue &vinput) {
     TxId txid;
     txid.SetHex(vinput[0].get_str());
     return COutPoint(txid, vinput[1].get_int());
 }
 
 BOOST_AUTO_TEST_CASE(tx_valid) {
     // Read tests from test/data/tx_valid.json
     // Format is an array of arrays
     // Inner arrays are either [ "comment" ]
     // or [[[prevout hash, prevout index, prevout scriptPubKey], [input 2],
     // ...],"], serializedTransaction, verifyFlags
     // ... where all scripts are stringified scripts.
     //
     // verifyFlags is a comma separated list of script verification flags to
     // apply, or "NONE"
     UniValue tests = read_json(
         std::string(json_tests::tx_valid,
                     json_tests::tx_valid + sizeof(json_tests::tx_valid)));
 
     ScriptError err;
     for (size_t idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
         if (test[0].isArray()) {
             if (test.size() != 3 || !test[1].isStr() || !test[2].isStr()) {
                 BOOST_ERROR("Bad test: " << strTest);
                 continue;
             }
 
             std::map<COutPoint, CScript> mapprevOutScriptPubKeys;
             std::map<COutPoint, Amount> mapprevOutValues;
             UniValue inputs = test[0].get_array();
             bool fValid = true;
             for (size_t inpIdx = 0; inpIdx < inputs.size(); inpIdx++) {
                 const UniValue &input = inputs[inpIdx];
                 if (!input.isArray()) {
                     fValid = false;
                     break;
                 }
                 UniValue vinput = input.get_array();
                 if (vinput.size() < 3 || vinput.size() > 4) {
                     fValid = false;
                     break;
                 }
                 COutPoint outpoint = buildOutPoint(vinput);
                 mapprevOutScriptPubKeys[outpoint] =
                     ParseScript(vinput[2].get_str());
                 if (vinput.size() >= 4) {
                     mapprevOutValues[outpoint] =
                         vinput[3].get_int64() * SATOSHI;
                 }
             }
             if (!fValid) {
                 BOOST_ERROR("Bad test: " << strTest);
                 continue;
             }
 
             std::string transaction = test[1].get_str();
             CDataStream stream(ParseHex(transaction), SER_NETWORK,
                                PROTOCOL_VERSION);
             CTransaction tx(deserialize, stream);
 
             TxValidationState state;
             BOOST_CHECK_MESSAGE(tx.IsCoinBase()
                                     ? CheckCoinbase(tx, state)
                                     : CheckRegularTransaction(tx, state),
                                 strTest);
             BOOST_CHECK(state.IsValid());
 
             // Check that CheckCoinbase reject non-coinbase transactions and
             // vice versa.
             BOOST_CHECK_MESSAGE(!(tx.IsCoinBase()
                                       ? CheckRegularTransaction(tx, state)
                                       : CheckCoinbase(tx, state)),
                                 strTest);
             BOOST_CHECK(state.IsInvalid());
 
             PrecomputedTransactionData txdata(tx);
             for (size_t i = 0; i < tx.vin.size(); i++) {
                 if (!mapprevOutScriptPubKeys.count(tx.vin[i].prevout)) {
                     BOOST_ERROR("Bad test: " << strTest);
                     break;
                 }
 
                 Amount amount = Amount::zero();
                 if (mapprevOutValues.count(tx.vin[i].prevout)) {
                     amount = mapprevOutValues[tx.vin[i].prevout];
                 }
 
                 uint32_t verify_flags = ParseScriptFlags(test[2].get_str());
                 BOOST_CHECK_MESSAGE(
                     VerifyScript(
                         tx.vin[i].scriptSig,
                         mapprevOutScriptPubKeys[tx.vin[i].prevout],
                         verify_flags,
                         TransactionSignatureChecker(&tx, i, amount, txdata),
                         &err),
                     strTest);
                 BOOST_CHECK_MESSAGE(err == ScriptError::OK,
                                     ScriptErrorString(err));
             }
         }
     }
 }
 
 BOOST_AUTO_TEST_CASE(tx_invalid) {
     // Read tests from test/data/tx_invalid.json
     // Format is an array of arrays
     // Inner arrays are either [ "comment" ]
     // or [[[prevout hash, prevout index, prevout scriptPubKey], [input 2],
     // ...],"], serializedTransaction, verifyFlags
     // ... where all scripts are stringified scripts.
     //
     // verifyFlags is a comma separated list of script verification flags to
     // apply, or "NONE"
     UniValue tests = read_json(
         std::string(json_tests::tx_invalid,
                     json_tests::tx_invalid + sizeof(json_tests::tx_invalid)));
 
     // Initialize to ScriptError::OK. The tests expect err to be changed to a
     // value other than ScriptError::OK.
     ScriptError err = ScriptError::OK;
     for (size_t idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
         if (test[0].isArray()) {
             if (test.size() != 3 || !test[1].isStr() || !test[2].isStr()) {
                 BOOST_ERROR("Bad test: " << strTest);
                 continue;
             }
 
             std::map<COutPoint, CScript> mapprevOutScriptPubKeys;
             std::map<COutPoint, Amount> mapprevOutValues;
             UniValue inputs = test[0].get_array();
             bool fValid = true;
             for (size_t inpIdx = 0; inpIdx < inputs.size(); inpIdx++) {
                 const UniValue &input = inputs[inpIdx];
                 if (!input.isArray()) {
                     fValid = false;
                     break;
                 }
                 UniValue vinput = input.get_array();
                 if (vinput.size() < 3 || vinput.size() > 4) {
                     fValid = false;
                     break;
                 }
                 COutPoint outpoint = buildOutPoint(vinput);
                 mapprevOutScriptPubKeys[outpoint] =
                     ParseScript(vinput[2].get_str());
                 if (vinput.size() >= 4) {
                     mapprevOutValues[outpoint] =
                         vinput[3].get_int64() * SATOSHI;
                 }
             }
             if (!fValid) {
                 BOOST_ERROR("Bad test: " << strTest);
                 continue;
             }
 
             std::string transaction = test[1].get_str();
             CDataStream stream(ParseHex(transaction), SER_NETWORK,
                                PROTOCOL_VERSION);
             CTransaction tx(deserialize, stream);
 
             TxValidationState state;
             fValid = CheckRegularTransaction(tx, state) && state.IsValid();
 
             PrecomputedTransactionData txdata(tx);
             for (size_t i = 0; i < tx.vin.size() && fValid; i++) {
                 if (!mapprevOutScriptPubKeys.count(tx.vin[i].prevout)) {
                     BOOST_ERROR("Bad test: " << strTest);
                     break;
                 }
 
                 Amount amount = Amount::zero();
                 if (0 != mapprevOutValues.count(tx.vin[i].prevout)) {
                     amount = mapprevOutValues[tx.vin[i].prevout];
                 }
 
                 uint32_t verify_flags = ParseScriptFlags(test[2].get_str());
                 fValid = VerifyScript(
                     tx.vin[i].scriptSig,
                     mapprevOutScriptPubKeys[tx.vin[i].prevout], verify_flags,
                     TransactionSignatureChecker(&tx, i, amount, txdata), &err);
             }
             BOOST_CHECK_MESSAGE(!fValid, strTest);
             BOOST_CHECK_MESSAGE(err != ScriptError::OK, ScriptErrorString(err));
         }
     }
 }
 
 BOOST_AUTO_TEST_CASE(basic_transaction_tests) {
     // Random real transaction
     // (e2769b09e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436)
     uint8_t ch[] = {
         0x01, 0x00, 0x00, 0x00, 0x01, 0x6b, 0xff, 0x7f, 0xcd, 0x4f, 0x85, 0x65,
         0xef, 0x40, 0x6d, 0xd5, 0xd6, 0x3d, 0x4f, 0xf9, 0x4f, 0x31, 0x8f, 0xe8,
         0x20, 0x27, 0xfd, 0x4d, 0xc4, 0x51, 0xb0, 0x44, 0x74, 0x01, 0x9f, 0x74,
         0xb4, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x49, 0x30, 0x46, 0x02, 0x21, 0x00,
         0xda, 0x0d, 0xc6, 0xae, 0xce, 0xfe, 0x1e, 0x06, 0xef, 0xdf, 0x05, 0x77,
         0x37, 0x57, 0xde, 0xb1, 0x68, 0x82, 0x09, 0x30, 0xe3, 0xb0, 0xd0, 0x3f,
         0x46, 0xf5, 0xfc, 0xf1, 0x50, 0xbf, 0x99, 0x0c, 0x02, 0x21, 0x00, 0xd2,
         0x5b, 0x5c, 0x87, 0x04, 0x00, 0x76, 0xe4, 0xf2, 0x53, 0xf8, 0x26, 0x2e,
         0x76, 0x3e, 0x2d, 0xd5, 0x1e, 0x7f, 0xf0, 0xbe, 0x15, 0x77, 0x27, 0xc4,
         0xbc, 0x42, 0x80, 0x7f, 0x17, 0xbd, 0x39, 0x01, 0x41, 0x04, 0xe6, 0xc2,
         0x6e, 0xf6, 0x7d, 0xc6, 0x10, 0xd2, 0xcd, 0x19, 0x24, 0x84, 0x78, 0x9a,
         0x6c, 0xf9, 0xae, 0xa9, 0x93, 0x0b, 0x94, 0x4b, 0x7e, 0x2d, 0xb5, 0x34,
         0x2b, 0x9d, 0x9e, 0x5b, 0x9f, 0xf7, 0x9a, 0xff, 0x9a, 0x2e, 0xe1, 0x97,
         0x8d, 0xd7, 0xfd, 0x01, 0xdf, 0xc5, 0x22, 0xee, 0x02, 0x28, 0x3d, 0x3b,
         0x06, 0xa9, 0xd0, 0x3a, 0xcf, 0x80, 0x96, 0x96, 0x8d, 0x7d, 0xbb, 0x0f,
         0x91, 0x78, 0xff, 0xff, 0xff, 0xff, 0x02, 0x8b, 0xa7, 0x94, 0x0e, 0x00,
         0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xba, 0xde, 0xec, 0xfd, 0xef,
         0x05, 0x07, 0x24, 0x7f, 0xc8, 0xf7, 0x42, 0x41, 0xd7, 0x3b, 0xc0, 0x39,
         0x97, 0x2d, 0x7b, 0x88, 0xac, 0x40, 0x94, 0xa8, 0x02, 0x00, 0x00, 0x00,
         0x00, 0x19, 0x76, 0xa9, 0x14, 0xc1, 0x09, 0x32, 0x48, 0x3f, 0xec, 0x93,
         0xed, 0x51, 0xf5, 0xfe, 0x95, 0xe7, 0x25, 0x59, 0xf2, 0xcc, 0x70, 0x43,
         0xf9, 0x88, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00};
     std::vector<uint8_t> vch(ch, ch + sizeof(ch) - 1);
     CDataStream stream(vch, SER_DISK, CLIENT_VERSION);
     CMutableTransaction tx;
     stream >> tx;
     TxValidationState state;
     BOOST_CHECK_MESSAGE(CheckRegularTransaction(CTransaction(tx), state) &&
                             state.IsValid(),
                         "Simple deserialized transaction should be valid.");
 
     // Check that duplicate txins fail
     tx.vin.push_back(tx.vin[0]);
     BOOST_CHECK_MESSAGE(!CheckRegularTransaction(CTransaction(tx), state) ||
                             !state.IsValid(),
                         "Transaction with duplicate txins should be invalid.");
 }
 
 BOOST_AUTO_TEST_CASE(test_Get) {
     FillableSigningProvider keystore;
     CCoinsView coinsDummy;
     CCoinsViewCache coins(&coinsDummy);
     std::vector<CMutableTransaction> dummyTransactions = SetupDummyInputs(
         keystore, coins, {{11 * CENT, 50 * CENT, 21 * CENT, 22 * CENT}});
 
     CMutableTransaction t1;
     t1.vin.resize(3);
     t1.vin[0].prevout = COutPoint(dummyTransactions[0].GetId(), 1);
     t1.vin[0].scriptSig << std::vector<uint8_t>(65, 0);
     t1.vin[1].prevout = COutPoint(dummyTransactions[1].GetId(), 0);
     t1.vin[1].scriptSig << std::vector<uint8_t>(65, 0)
                         << std::vector<uint8_t>(33, 4);
     t1.vin[2].prevout = COutPoint(dummyTransactions[1].GetId(), 1);
     t1.vin[2].scriptSig << std::vector<uint8_t>(65, 0)
                         << std::vector<uint8_t>(33, 4);
     t1.vout.resize(2);
     t1.vout[0].nValue = 90 * CENT;
     t1.vout[0].scriptPubKey << OP_1;
 
     BOOST_CHECK(AreInputsStandard(CTransaction(t1), coins,
                                   STANDARD_SCRIPT_VERIFY_FLAGS));
     BOOST_CHECK_EQUAL(coins.GetValueIn(CTransaction(t1)),
                       (50 + 21 + 22) * CENT);
 }
 
 static void CreateCreditAndSpend(const FillableSigningProvider &keystore,
                                  const CScript &outscript,
                                  CTransactionRef &output,
                                  CMutableTransaction &input,
                                  bool success = true) {
     CMutableTransaction outputm;
     outputm.nVersion = 1;
     outputm.vin.resize(1);
     outputm.vin[0].prevout = COutPoint();
     outputm.vin[0].scriptSig = CScript();
     outputm.vout.resize(1);
     outputm.vout[0].nValue = SATOSHI;
     outputm.vout[0].scriptPubKey = outscript;
     CDataStream ssout(SER_NETWORK, PROTOCOL_VERSION);
     ssout << outputm;
     ssout >> output;
     BOOST_CHECK_EQUAL(output->vin.size(), 1UL);
     BOOST_CHECK(output->vin[0] == outputm.vin[0]);
     BOOST_CHECK_EQUAL(output->vout.size(), 1UL);
     BOOST_CHECK(output->vout[0] == outputm.vout[0]);
 
     CMutableTransaction inputm;
     inputm.nVersion = 1;
     inputm.vin.resize(1);
     inputm.vin[0].prevout = COutPoint(output->GetId(), 0);
     inputm.vout.resize(1);
     inputm.vout[0].nValue = SATOSHI;
     inputm.vout[0].scriptPubKey = CScript();
     bool ret =
         SignSignature(keystore, *output, inputm, 0, SigHashType().withForkId());
     BOOST_CHECK_EQUAL(ret, success);
     CDataStream ssin(SER_NETWORK, PROTOCOL_VERSION);
     ssin << inputm;
     ssin >> input;
     BOOST_CHECK_EQUAL(input.vin.size(), 1UL);
     BOOST_CHECK(input.vin[0] == inputm.vin[0]);
     BOOST_CHECK_EQUAL(input.vout.size(), 1UL);
     BOOST_CHECK(input.vout[0] == inputm.vout[0]);
 }
 
 static void CheckWithFlag(const CTransactionRef &output,
                           const CMutableTransaction &input, int flags,
                           bool success) {
     ScriptError error;
     CTransaction inputi(input);
     bool ret = VerifyScript(
         inputi.vin[0].scriptSig, output->vout[0].scriptPubKey,
         flags | SCRIPT_ENABLE_SIGHASH_FORKID,
         TransactionSignatureChecker(&inputi, 0, output->vout[0].nValue),
         &error);
     BOOST_CHECK_EQUAL(ret, success);
 }
 
 static CScript PushAll(const std::vector<valtype> &values) {
     CScript result;
     for (const valtype &v : values) {
         if (v.size() == 0) {
             result << OP_0;
         } else if (v.size() == 1 && v[0] >= 1 && v[0] <= 16) {
             result << CScript::EncodeOP_N(v[0]);
         } else {
             result << v;
         }
     }
     return result;
 }
 
 static void ReplaceRedeemScript(CScript &script, const CScript &redeemScript) {
     std::vector<valtype> stack;
     EvalScript(stack, script, SCRIPT_VERIFY_STRICTENC, BaseSignatureChecker());
     BOOST_CHECK(stack.size() > 0);
     stack.back() =
         std::vector<uint8_t>(redeemScript.begin(), redeemScript.end());
     script = PushAll(stack);
 }
 
 BOOST_AUTO_TEST_CASE(test_big_transaction) {
     CKey key;
     key.MakeNewKey(false);
     FillableSigningProvider keystore;
     BOOST_CHECK(keystore.AddKeyPubKey(key, key.GetPubKey()));
     CScript scriptPubKey = CScript()
                            << ToByteVector(key.GetPubKey()) << OP_CHECKSIG;
 
     std::vector<SigHashType> sigHashes;
     sigHashes.emplace_back(SIGHASH_NONE | SIGHASH_FORKID);
     sigHashes.emplace_back(SIGHASH_SINGLE | SIGHASH_FORKID);
     sigHashes.emplace_back(SIGHASH_ALL | SIGHASH_FORKID);
     sigHashes.emplace_back(SIGHASH_NONE | SIGHASH_FORKID |
                            SIGHASH_ANYONECANPAY);
     sigHashes.emplace_back(SIGHASH_SINGLE | SIGHASH_FORKID |
                            SIGHASH_ANYONECANPAY);
     sigHashes.emplace_back(SIGHASH_ALL | SIGHASH_FORKID | SIGHASH_ANYONECANPAY);
 
     CMutableTransaction mtx;
     mtx.nVersion = 1;
 
     // create a big transaction of 4500 inputs signed by the same key.
     const static size_t OUTPUT_COUNT = 4500;
     mtx.vout.reserve(OUTPUT_COUNT);
 
     for (size_t ij = 0; ij < OUTPUT_COUNT; ij++) {
         size_t i = mtx.vin.size();
         TxId prevId(uint256S("0000000000000000000000000000000000000000000000000"
                              "000000000000100"));
         COutPoint outpoint(prevId, i);
 
         mtx.vin.resize(mtx.vin.size() + 1);
         mtx.vin[i].prevout = outpoint;
         mtx.vin[i].scriptSig = CScript();
 
         mtx.vout.emplace_back(1000 * SATOSHI, CScript() << OP_1);
     }
 
     // sign all inputs
     for (size_t i = 0; i < mtx.vin.size(); i++) {
         bool hashSigned =
             SignSignature(keystore, scriptPubKey, mtx, i, 1000 * SATOSHI,
                           sigHashes.at(i % sigHashes.size()));
         BOOST_CHECK_MESSAGE(hashSigned, "Failed to sign test transaction");
     }
 
     CTransaction tx(mtx);
 
     // check all inputs concurrently, with the cache
     PrecomputedTransactionData txdata(tx);
     boost::thread_group threadGroup;
     CCheckQueue<CScriptCheck> scriptcheckqueue(128);
     CCheckQueueControl<CScriptCheck> control(&scriptcheckqueue);
 
     for (int i = 0; i < 20; i++) {
         threadGroup.create_thread(std::bind(&CCheckQueue<CScriptCheck>::Thread,
                                             std::ref(scriptcheckqueue)));
     }
 
     std::vector<Coin> coins;
     for (size_t i = 0; i < mtx.vin.size(); i++) {
         CTxOut out;
         out.nValue = 1000 * SATOSHI;
         out.scriptPubKey = scriptPubKey;
         coins.emplace_back(std::move(out), 1, false);
     }
 
     for (size_t i = 0; i < mtx.vin.size(); i++) {
         std::vector<CScriptCheck> vChecks;
         CScriptCheck check(coins[tx.vin[i].prevout.GetN()].GetTxOut(), tx, i,
                            STANDARD_SCRIPT_VERIFY_FLAGS, false, txdata);
         vChecks.push_back(CScriptCheck());
         check.swap(vChecks.back());
         control.Add(vChecks);
     }
 
     bool controlCheck = control.Wait();
     BOOST_CHECK(controlCheck);
 
     threadGroup.interrupt_all();
     threadGroup.join_all();
 }
 
 SignatureData CombineSignatures(const CMutableTransaction &input1,
                                 const CMutableTransaction &input2,
                                 const CTransactionRef tx) {
     SignatureData sigdata;
     sigdata = DataFromTransaction(input1, 0, tx->vout[0]);
     sigdata.MergeSignatureData(DataFromTransaction(input2, 0, tx->vout[0]));
     ProduceSignature(
         DUMMY_SIGNING_PROVIDER,
         MutableTransactionSignatureCreator(&input1, 0, tx->vout[0].nValue),
         tx->vout[0].scriptPubKey, sigdata);
     return sigdata;
 }
 
 BOOST_AUTO_TEST_CASE(test_witness) {
     FillableSigningProvider keystore, keystore2;
     CKey key1, key2, key3, key1L, key2L;
     CPubKey pubkey1, pubkey2, pubkey3, pubkey1L, pubkey2L;
     key1.MakeNewKey(true);
     key2.MakeNewKey(true);
     key3.MakeNewKey(true);
     key1L.MakeNewKey(false);
     key2L.MakeNewKey(false);
     pubkey1 = key1.GetPubKey();
     pubkey2 = key2.GetPubKey();
     pubkey3 = key3.GetPubKey();
     pubkey1L = key1L.GetPubKey();
     pubkey2L = key2L.GetPubKey();
     BOOST_CHECK(keystore.AddKeyPubKey(key1, pubkey1));
     BOOST_CHECK(keystore.AddKeyPubKey(key2, pubkey2));
     BOOST_CHECK(keystore.AddKeyPubKey(key1L, pubkey1L));
     BOOST_CHECK(keystore.AddKeyPubKey(key2L, pubkey2L));
     CScript scriptPubkey1, scriptPubkey2, scriptPubkey1L, scriptPubkey2L,
         scriptMulti;
     scriptPubkey1 << ToByteVector(pubkey1) << OP_CHECKSIG;
     scriptPubkey2 << ToByteVector(pubkey2) << OP_CHECKSIG;
     scriptPubkey1L << ToByteVector(pubkey1L) << OP_CHECKSIG;
     scriptPubkey2L << ToByteVector(pubkey2L) << OP_CHECKSIG;
     std::vector<CPubKey> oneandthree;
     oneandthree.push_back(pubkey1);
     oneandthree.push_back(pubkey3);
     scriptMulti = GetScriptForMultisig(2, oneandthree);
     BOOST_CHECK(keystore.AddCScript(scriptPubkey1));
     BOOST_CHECK(keystore.AddCScript(scriptPubkey2));
     BOOST_CHECK(keystore.AddCScript(scriptPubkey1L));
     BOOST_CHECK(keystore.AddCScript(scriptPubkey2L));
     BOOST_CHECK(keystore.AddCScript(scriptMulti));
     BOOST_CHECK(keystore2.AddCScript(scriptMulti));
     BOOST_CHECK(keystore2.AddKeyPubKey(key3, pubkey3));
 
     CTransactionRef output1, output2;
     CMutableTransaction input1, input2;
 
     // Normal pay-to-compressed-pubkey.
     CreateCreditAndSpend(keystore, scriptPubkey1, output1, input1);
     CreateCreditAndSpend(keystore, scriptPubkey2, output2, input2);
     CheckWithFlag(output1, input1, 0, true);
     CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
     CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
     CheckWithFlag(output1, input2, 0, false);
     CheckWithFlag(output1, input2, SCRIPT_VERIFY_P2SH, false);
     CheckWithFlag(output1, input2, STANDARD_SCRIPT_VERIFY_FLAGS, false);
 
     // P2SH pay-to-compressed-pubkey.
     CreateCreditAndSpend(keystore,
                          GetScriptForDestination(ScriptHash(scriptPubkey1)),
                          output1, input1);
     CreateCreditAndSpend(keystore,
                          GetScriptForDestination(ScriptHash(scriptPubkey2)),
                          output2, input2);
     ReplaceRedeemScript(input2.vin[0].scriptSig, scriptPubkey1);
     CheckWithFlag(output1, input1, 0, true);
     CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
     CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
     CheckWithFlag(output1, input2, 0, true);
     CheckWithFlag(output1, input2, SCRIPT_VERIFY_P2SH, false);
     CheckWithFlag(output1, input2, STANDARD_SCRIPT_VERIFY_FLAGS, false);
 
     // Normal pay-to-uncompressed-pubkey.
     CreateCreditAndSpend(keystore, scriptPubkey1L, output1, input1);
     CreateCreditAndSpend(keystore, scriptPubkey2L, output2, input2);
     CheckWithFlag(output1, input1, 0, true);
     CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
     CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
     CheckWithFlag(output1, input2, 0, false);
     CheckWithFlag(output1, input2, SCRIPT_VERIFY_P2SH, false);
     CheckWithFlag(output1, input2, STANDARD_SCRIPT_VERIFY_FLAGS, false);
 
     // P2SH pay-to-uncompressed-pubkey.
     CreateCreditAndSpend(keystore,
                          GetScriptForDestination(ScriptHash(scriptPubkey1L)),
                          output1, input1);
     CreateCreditAndSpend(keystore,
                          GetScriptForDestination(ScriptHash(scriptPubkey2L)),
                          output2, input2);
     ReplaceRedeemScript(input2.vin[0].scriptSig, scriptPubkey1L);
     CheckWithFlag(output1, input1, 0, true);
     CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
     CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
     CheckWithFlag(output1, input2, 0, true);
     CheckWithFlag(output1, input2, SCRIPT_VERIFY_P2SH, false);
     CheckWithFlag(output1, input2, STANDARD_SCRIPT_VERIFY_FLAGS, false);
 
     // Normal 2-of-2 multisig
     CreateCreditAndSpend(keystore, scriptMulti, output1, input1, false);
     CheckWithFlag(output1, input1, 0, false);
     CreateCreditAndSpend(keystore2, scriptMulti, output2, input2, false);
     CheckWithFlag(output2, input2, 0, false);
     BOOST_CHECK(*output1 == *output2);
     UpdateInput(input1.vin[0], CombineSignatures(input1, input2, output1));
     CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
 
     // P2SH 2-of-2 multisig
     CreateCreditAndSpend(keystore,
                          GetScriptForDestination(ScriptHash(scriptMulti)),
                          output1, input1, false);
     CheckWithFlag(output1, input1, 0, true);
     CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, false);
     CreateCreditAndSpend(keystore2,
                          GetScriptForDestination(ScriptHash(scriptMulti)),
                          output2, input2, false);
     CheckWithFlag(output2, input2, 0, true);
     CheckWithFlag(output2, input2, SCRIPT_VERIFY_P2SH, false);
     BOOST_CHECK(*output1 == *output2);
     UpdateInput(input1.vin[0], CombineSignatures(input1, input2, output1));
     CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
     CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
 }
 
 BOOST_AUTO_TEST_CASE(test_IsStandard) {
     LOCK(cs_main);
     FillableSigningProvider keystore;
     CCoinsView coinsDummy;
     CCoinsViewCache coins(&coinsDummy);
     std::vector<CMutableTransaction> dummyTransactions = SetupDummyInputs(
         keystore, coins, {{11 * CENT, 50 * CENT, 21 * CENT, 22 * CENT}});
 
     CMutableTransaction t;
     t.vin.resize(1);
     t.vin[0].prevout = COutPoint(dummyTransactions[0].GetId(), 1);
     t.vin[0].scriptSig << std::vector<uint8_t>(65, 0);
     t.vout.resize(1);
     t.vout[0].nValue = 90 * CENT;
     CKey key;
     key.MakeNewKey(true);
     t.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
 
     std::string reason;
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
 
     // Check dust with default relay fee:
     Amount nDustThreshold = 3 * 182 * dustRelayFee.GetFeePerK() / 1000;
     BOOST_CHECK_EQUAL(nDustThreshold, 546 * SATOSHI);
     // dust:
     t.vout[0].nValue = nDustThreshold - SATOSHI;
     reason.clear();
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     BOOST_CHECK_EQUAL(reason, "dust");
     // not dust:
     t.vout[0].nValue = nDustThreshold;
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
 
     // Disallowed nVersion
     t.nVersion = -1;
     reason.clear();
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     BOOST_CHECK_EQUAL(reason, "version");
 
     t.nVersion = 0;
     reason.clear();
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     BOOST_CHECK_EQUAL(reason, "version");
 
     t.nVersion = 3;
     reason.clear();
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     BOOST_CHECK_EQUAL(reason, "version");
 
     // Allowed nVersion
     t.nVersion = 1;
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
 
     t.nVersion = 2;
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
 
     // Check dust with odd relay fee to verify rounding:
     // nDustThreshold = 182 * 1234 / 1000 * 3
     dustRelayFee = CFeeRate(1234 * SATOSHI);
     // dust:
     t.vout[0].nValue = (672 - 1) * SATOSHI;
     reason.clear();
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     BOOST_CHECK_EQUAL(reason, "dust");
     // not dust:
     t.vout[0].nValue = 672 * SATOSHI;
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
     dustRelayFee = CFeeRate(DUST_RELAY_TX_FEE);
 
     t.vout[0].scriptPubKey = CScript() << OP_1;
     reason.clear();
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     BOOST_CHECK_EQUAL(reason, "scriptpubkey");
 
     // MAX_OP_RETURN_RELAY-byte TX_NULL_DATA (standard)
     t.vout[0].scriptPubKey =
         CScript() << OP_RETURN
                   << ParseHex("646578784062697477617463682e636f2092c558ed52c56d"
                               "8dd14ca76226bc936a84820d898443873eb03d8854b21fa3"
                               "952b99a2981873e74509281730d78a21786d34a38bd1ebab"
                               "822fad42278f7f4420db6ab1fd2b6826148d4f73bb41ec2d"
                               "40a6d5793d66e17074a0c56a8a7df21062308f483dd6e38d"
                               "53609d350038df0a1b2a9ac8332016e0b904f66880dd0108"
                               "81c4e8074cce8e4ad6c77cb3460e01bf0e7e811b5f945f83"
                               "732ba6677520a893d75d9a966cb8f85dc301656b1635c631"
                               "f5d00d4adf73f2dd112ca75cf19754651909becfbe65aed1"
                               "3afb2ab8");
     BOOST_CHECK_EQUAL(MAX_OP_RETURN_RELAY, t.vout[0].scriptPubKey.size());
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
 
     // MAX_OP_RETURN_RELAY+1-byte TX_NULL_DATA (non-standard)
     t.vout[0].scriptPubKey =
         CScript() << OP_RETURN
                   << ParseHex("646578784062697477617463682e636f2092c558ed52c56d"
                               "8dd14ca76226bc936a84820d898443873eb03d8854b21fa3"
                               "952b99a2981873e74509281730d78a21786d34a38bd1ebab"
                               "822fad42278f7f4420db6ab1fd2b6826148d4f73bb41ec2d"
                               "40a6d5793d66e17074a0c56a8a7df21062308f483dd6e38d"
                               "53609d350038df0a1b2a9ac8332016e0b904f66880dd0108"
                               "81c4e8074cce8e4ad6c77cb3460e01bf0e7e811b5f945f83"
                               "732ba6677520a893d75d9a966cb8f85dc301656b1635c631"
                               "f5d00d4adf73f2dd112ca75cf19754651909becfbe65aed1"
                               "3afb2ab800");
     BOOST_CHECK_EQUAL(MAX_OP_RETURN_RELAY + 1, t.vout[0].scriptPubKey.size());
     reason.clear();
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     BOOST_CHECK_EQUAL(reason, "scriptpubkey");
 
     /**
      * Check when a custom value is used for -datacarriersize .
      */
     unsigned newMaxSize = 90;
-    gArgs.ForceSetArg("-datacarriersize", std::to_string(newMaxSize));
+    gArgs.ForceSetArg("-datacarriersize", ToString(newMaxSize));
 
     // Max user provided payload size is standard
     t.vout[0].scriptPubKey =
         CScript() << OP_RETURN
                   << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef3804678afdb0fe5548"
                               "271967f1a67130b7105cd6a828e03909a67962e0ea1f61de"
                               "b649f6bc3f4cef3877696e64657878");
     BOOST_CHECK_EQUAL(t.vout[0].scriptPubKey.size(), newMaxSize);
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
 
     // Max user provided payload size + 1 is non-standard
     t.vout[0].scriptPubKey =
         CScript() << OP_RETURN
                   << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef3804678afdb0fe5548"
                               "271967f1a67130b7105cd6a828e03909a67962e0ea1f61de"
                               "b649f6bc3f4cef3877696e6465787800");
     BOOST_CHECK_EQUAL(t.vout[0].scriptPubKey.size(), newMaxSize + 1);
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
 
     // Clear custom confirguration.
     gArgs.ClearForcedArg("-datacarriersize");
 
     // Data payload can be encoded in any way...
     t.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("");
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
     t.vout[0].scriptPubKey = CScript()
                              << OP_RETURN << ParseHex("00") << ParseHex("01");
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
     // OP_RESERVED *is* considered to be a PUSHDATA type opcode by IsPushOnly()!
     t.vout[0].scriptPubKey = CScript() << OP_RETURN << OP_RESERVED << -1 << 0
                                        << ParseHex("01") << 2 << 3 << 4 << 5
                                        << 6 << 7 << 8 << 9 << 10 << 11 << 12
                                        << 13 << 14 << 15 << 16;
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
     t.vout[0].scriptPubKey = CScript()
                              << OP_RETURN << 0 << ParseHex("01") << 2
                              << ParseHex("fffffffffffffffffffffffffffffffffffff"
                                          "fffffffffffffffffffffffffffffffffff");
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
 
     // ...so long as it only contains PUSHDATA's
     t.vout[0].scriptPubKey = CScript() << OP_RETURN << OP_RETURN;
     reason.clear();
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     BOOST_CHECK_EQUAL(reason, "scriptpubkey");
 
     // TX_NULL_DATA w/o PUSHDATA
     t.vout.resize(1);
     t.vout[0].scriptPubKey = CScript() << OP_RETURN;
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
 
     // Only one TX_NULL_DATA permitted in all cases
     t.vout.resize(2);
     t.vout[0].scriptPubKey =
         CScript() << OP_RETURN
                   << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef38");
     t.vout[1].scriptPubKey =
         CScript() << OP_RETURN
                   << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef38");
     reason.clear();
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     BOOST_CHECK_EQUAL(reason, "multi-op-return");
 
     t.vout[0].scriptPubKey =
         CScript() << OP_RETURN
                   << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef38");
     t.vout[1].scriptPubKey = CScript() << OP_RETURN;
     reason.clear();
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     BOOST_CHECK_EQUAL(reason, "multi-op-return");
 
     t.vout[0].scriptPubKey = CScript() << OP_RETURN;
     t.vout[1].scriptPubKey = CScript() << OP_RETURN;
     reason.clear();
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     BOOST_CHECK_EQUAL(reason, "multi-op-return");
 
     // Check large scriptSig (non-standard if size is >1650 bytes)
     t.vout.resize(1);
     t.vout[0].nValue = MAX_MONEY;
     t.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
     // OP_PUSHDATA2 with len (3 bytes) + data (1647 bytes) = 1650 bytes
     t.vin[0].scriptSig = CScript() << std::vector<uint8_t>(1647, 0); // 1650
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
 
     t.vin[0].scriptSig = CScript() << std::vector<uint8_t>(1648, 0); // 1651
     reason.clear();
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     BOOST_CHECK_EQUAL(reason, "scriptsig-size");
 
     // Check scriptSig format (non-standard if there are any other ops than just
     // PUSHs)
     t.vin[0].scriptSig = CScript()
                          // OP_n (single byte pushes: n = 1, 0, -1, 16)
                          << OP_TRUE << OP_0 << OP_1NEGATE
                          << OP_16
                          // OP_PUSHx [...x bytes...]
                          << std::vector<uint8_t>(75, 0)
                          // OP_PUSHDATA1 x [...x bytes...]
                          << std::vector<uint8_t>(235, 0)
                          // OP_PUSHDATA2 x [...x bytes...]
                          << std::vector<uint8_t>(1234, 0) << OP_9;
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
 
     const std::vector<uint8_t> non_push_ops = {
         // arbitrary set of non-push operations
         OP_NOP,
         OP_VERIFY,
         OP_IF,
         OP_ROT,
         OP_3DUP,
         OP_SIZE,
         OP_EQUAL,
         OP_ADD,
         OP_SUB,
         OP_HASH256,
         OP_CODESEPARATOR,
         OP_CHECKSIG,
         OP_CHECKLOCKTIMEVERIFY};
 
     CScript::const_iterator pc = t.vin[0].scriptSig.begin();
     while (pc < t.vin[0].scriptSig.end()) {
         opcodetype opcode;
         CScript::const_iterator prev_pc = pc;
         // advance to next op
         t.vin[0].scriptSig.GetOp(pc, opcode);
         // for the sake of simplicity, we only replace single-byte push
         // operations
         if (opcode >= 1 && opcode <= OP_PUSHDATA4) {
             continue;
         }
 
         int index = prev_pc - t.vin[0].scriptSig.begin();
         // save op
         uint8_t orig_op = *prev_pc;
         // replace current push-op with each non-push-op
         for (auto op : non_push_ops) {
             t.vin[0].scriptSig[index] = op;
             BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
             BOOST_CHECK_EQUAL(reason, "scriptsig-not-pushonly");
         }
         // restore op
         t.vin[0].scriptSig[index] = orig_op;
         BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
     }
 
     // Check bare multisig (standard if policy flag fIsBareMultisigStd is set)
     fIsBareMultisigStd = true;
     // simple 1-of-1
     t.vout[0].scriptPubKey = GetScriptForMultisig(1, {key.GetPubKey()});
     t.vin[0].scriptSig = CScript() << std::vector<uint8_t>(65, 0);
     BOOST_CHECK(IsStandardTx(CTransaction(t), reason));
 
     fIsBareMultisigStd = false;
     reason.clear();
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     BOOST_CHECK_EQUAL(reason, "bare-multisig");
     fIsBareMultisigStd = DEFAULT_PERMIT_BAREMULTISIG;
 }
 
 BOOST_AUTO_TEST_CASE(txsize_activation_test) {
     const Config &config = GetConfig();
     const Consensus::Params &params = config.GetChainParams().GetConsensus();
     const int32_t magneticAnomalyActivationHeight =
         params.magneticAnomalyHeight;
 
     // A minimaly sized transction.
     CTransaction minTx;
     TxValidationState state;
 
     BOOST_CHECK(ContextualCheckTransaction(
         params, minTx, state, magneticAnomalyActivationHeight - 1, 5678, 1234));
     BOOST_CHECK(!ContextualCheckTransaction(
         params, minTx, state, magneticAnomalyActivationHeight, 5678, 1234));
     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-txns-undersize");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/util/setup_common.h b/src/test/util/setup_common.h
index ef2a76440..594978472 100644
--- a/src/test/util/setup_common.h
+++ b/src/test/util/setup_common.h
@@ -1,203 +1,204 @@
 // Copyright (c) 2015-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_TEST_UTIL_SETUP_COMMON_H
 #define BITCOIN_TEST_UTIL_SETUP_COMMON_H
 
 #include <amount.h>
 #include <chainparamsbase.h>
 #include <fs.h>
 #include <key.h>
 #include <node/context.h>
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <random.h>
 #include <scheduler.h>
 #include <util/check.h>
+#include <util/string.h>
 #include <util/system.h>
 
 #include <boost/thread.hpp> // For boost::thread_group
 
 #include <type_traits>
 
 /**
  * Version of Boost::test prior to 1.64 have issues when dealing with nullptr_t.
  * In order to work around this, we ensure that the null pointers are typed in a
  * way that Boost will like better.
  *
  * TODO: Use nullptr directly once the minimum version of boost is 1.64 or more.
  */
 #define NULLPTR(T) static_cast<T *>(nullptr)
 
 // Enable BOOST_CHECK_EQUAL for enum class types
 template <typename T>
 std::ostream &operator<<(
     typename std::enable_if<std::is_enum<T>::value, std::ostream>::type &stream,
     const T &e) {
     return stream << static_cast<typename std::underlying_type<T>::type>(e);
 }
 
 /**
  * This global and the helpers that use it are not thread-safe.
  *
  * If thread-safety is needed, the global could be made thread_local (given
  * that thread_local is supported on all architectures we support) or a
  * per-thread instance could be used in the multi-threaded test.
  */
 extern FastRandomContext g_insecure_rand_ctx;
 
 /**
  * Flag to make GetRand in random.h return the same number
  */
 extern bool g_mock_deterministic_tests;
 
 enum class SeedRand {
     ZEROS, //!< Seed with a compile time constant of zeros
     SEED,  //!< Call the Seed() helper
 };
 
 /**
  * Seed the given random ctx or use the seed passed in via an
  * environment var
  */
 void Seed(FastRandomContext &ctx);
 
 static inline void SeedInsecureRand(SeedRand seed = SeedRand::SEED) {
     if (seed == SeedRand::ZEROS) {
         g_insecure_rand_ctx = FastRandomContext(/* deterministic */ true);
     } else {
         Seed(g_insecure_rand_ctx);
     }
 }
 
 static inline uint32_t InsecureRand32() {
     return g_insecure_rand_ctx.rand32();
 }
 static inline uint160 InsecureRand160() {
     return g_insecure_rand_ctx.rand160();
 }
 static inline uint256 InsecureRand256() {
     return g_insecure_rand_ctx.rand256();
 }
 static inline uint64_t InsecureRandBits(int bits) {
     return g_insecure_rand_ctx.randbits(bits);
 }
 static inline uint64_t InsecureRandRange(uint64_t range) {
     return g_insecure_rand_ctx.randrange(range);
 }
 static inline bool InsecureRandBool() {
     return g_insecure_rand_ctx.randbool();
 }
 
 static constexpr Amount CENT(COIN / 100);
 
 extern std::vector<const char *> fixture_extra_args;
 
 /**
  * Basic testing setup.
  * This just configures logging, data dir and chain parameters.
  */
 struct BasicTestingSetup {
     ECCVerifyHandle globalVerifyHandle;
     NodeContext m_node;
 
     explicit BasicTestingSetup(
         const std::string &chainName = CBaseChainParams::MAIN,
         const std::vector<const char *> &extra_args = {});
     ~BasicTestingSetup();
 
 private:
     const fs::path m_path_root;
 };
 
 /**
  * Testing setup that configures a complete environment.
  * Included are coins database, script check threads setup.
  */
 struct TestingSetup : public BasicTestingSetup {
     boost::thread_group threadGroup;
 
     explicit TestingSetup(const std::string &chainName = CBaseChainParams::MAIN,
                           const std::vector<const char *> &extra_args = {});
     ~TestingSetup();
 };
 
 /** Identical to TestingSetup, but chain set to regtest */
 struct RegTestingSetup : public TestingSetup {
     RegTestingSetup() : TestingSetup{CBaseChainParams::REGTEST} {}
 };
 
 class CBlock;
 class CMutableTransaction;
 class CScript;
 
 //
 // Testing fixture that pre-creates a
 // 100-block REGTEST-mode block chain
 //
 struct TestChain100Setup : public RegTestingSetup {
     TestChain100Setup();
 
     // Create a new block with just given transactions, coinbase paying to
     // scriptPubKey, and try to add it to the current chain.
     CBlock CreateAndProcessBlock(const std::vector<CMutableTransaction> &txns,
                                  const CScript &scriptPubKey);
 
     ~TestChain100Setup();
 
     // For convenience, coinbase transactions.
     std::vector<CTransactionRef> m_coinbase_txns;
     // private/public key needed to spend coinbase transactions.
     CKey coinbaseKey;
 };
 
 class CTxMemPoolEntry;
 
 struct TestMemPoolEntryHelper {
     // Default values
     Amount nFee;
     int64_t nTime;
     unsigned int nHeight;
     bool spendsCoinbase;
     unsigned int nSigOpCount;
 
     TestMemPoolEntryHelper()
         : nFee(), nTime(0), nHeight(1), spendsCoinbase(false), nSigOpCount(1) {}
 
     CTxMemPoolEntry FromTx(const CMutableTransaction &tx);
     CTxMemPoolEntry FromTx(const CTransactionRef &tx);
 
     // Change the default value
     TestMemPoolEntryHelper &Fee(Amount _fee) {
         nFee = _fee;
         return *this;
     }
     TestMemPoolEntryHelper &Time(int64_t _time) {
         nTime = _time;
         return *this;
     }
     TestMemPoolEntryHelper &Height(unsigned int _height) {
         nHeight = _height;
         return *this;
     }
     TestMemPoolEntryHelper &SpendsCoinbase(bool _flag) {
         spendsCoinbase = _flag;
         return *this;
     }
     TestMemPoolEntryHelper &SigOpCount(unsigned int _nSigOpCount) {
         nSigOpCount = _nSigOpCount;
         return *this;
     }
 };
 
 enum class ScriptError;
 
 // define implicit conversions here so that these types may be used in
 // BOOST_*_EQUAL
 std::ostream &operator<<(std::ostream &os, const uint256 &num);
 std::ostream &operator<<(std::ostream &os, const ScriptError &err);
 
 CBlock getBlock13b8a();
 
 #endif // BITCOIN_TEST_UTIL_SETUP_COMMON_H
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index 2423e155e..d7e3ae1a2 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -1,2527 +1,2527 @@
 // Copyright (c) 2011-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.
 
 #include <util/system.h>
 
 #include <chainparams.h>
 #include <clientversion.h>
 #include <hash.h> // For Hash()
 #include <key.h>  // For CKey
 #include <sync.h>
 #include <test/util/logging.h>
 #include <test/util/str.h>
 #include <uint256.h>
 #include <util/message.h> // For MessageSign(), MessageVerify(), MESSAGE_MAGIC
 #include <util/moneystr.h>
 #include <util/spanparsing.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/time.h>
 #include <util/vector.h>
 
 #include <test/util/setup_common.h>
 
 #include <univalue.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <array>
 #include <cstdint>
 #include <utility>
 #ifndef WIN32
 #include <csignal>
 #include <sys/types.h>
 #include <sys/wait.h>
 #endif
 #include <thread>
 #include <vector>
 
 /* defined in logging.cpp */
 namespace BCLog {
 std::string LogEscapeMessage(const std::string &str);
 }
 
 BOOST_FIXTURE_TEST_SUITE(util_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(util_criticalsection) {
     RecursiveMutex cs;
 
     do {
         LOCK(cs);
         break;
 
         BOOST_ERROR("break was swallowed!");
     } while (0);
 
     do {
         TRY_LOCK(cs, lockTest);
         if (lockTest) {
             // Needed to suppress "Test case [...] did not check any assertions"
             BOOST_CHECK(true);
             break;
         }
 
         BOOST_ERROR("break was swallowed!");
     } while (0);
 }
 
 static const uint8_t ParseHex_expected[65] = {
     0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67,
     0xf1, 0xa6, 0x71, 0x30, 0xb7, 0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0,
     0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, 0xde, 0xb6,
     0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04,
     0xe5, 0x1e, 0xc1, 0x12, 0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b,
     0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, 0x1d, 0x5f};
 BOOST_AUTO_TEST_CASE(util_ParseHex) {
     std::vector<uint8_t> result;
     std::vector<uint8_t> expected(
         ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected));
     // Basic test vector
     result = ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0"
                       "ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d"
                       "578a4c702b6bf11d5f");
     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(),
                                   expected.begin(), expected.end());
 
     // Spaces between bytes must be supported
     result = ParseHex("12 34 56 78");
     BOOST_CHECK(result.size() == 4 && result[0] == 0x12 && result[1] == 0x34 &&
                 result[2] == 0x56 && result[3] == 0x78);
 
     // Leading space must be supported (used in BerkeleyEnvironment::Salvage)
     result = ParseHex(" 89 34 56 78");
     BOOST_CHECK(result.size() == 4 && result[0] == 0x89 && result[1] == 0x34 &&
                 result[2] == 0x56 && result[3] == 0x78);
 
     // Stop parsing at invalid value
     result = ParseHex("1234 invalid 1234");
     BOOST_CHECK(result.size() == 2 && result[0] == 0x12 && result[1] == 0x34);
 }
 
 BOOST_AUTO_TEST_CASE(util_HexStr) {
     BOOST_CHECK_EQUAL(HexStr(ParseHex_expected,
                              ParseHex_expected + sizeof(ParseHex_expected)),
                       "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0"
                       "ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d"
                       "578a4c702b6bf11d5f");
 
     BOOST_CHECK_EQUAL(HexStr(ParseHex_expected + sizeof(ParseHex_expected),
                              ParseHex_expected + sizeof(ParseHex_expected)),
                       "");
 
     BOOST_CHECK_EQUAL(HexStr(ParseHex_expected, ParseHex_expected), "");
 
     std::vector<uint8_t> ParseHex_vec(ParseHex_expected, ParseHex_expected + 5);
 
     BOOST_CHECK_EQUAL(HexStr(ParseHex_vec.rbegin(), ParseHex_vec.rend()),
                       "b0fd8a6704");
 
     BOOST_CHECK_EQUAL(
         HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected),
                std::reverse_iterator<const uint8_t *>(ParseHex_expected)),
         "");
 
     BOOST_CHECK_EQUAL(
         HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 1),
                std::reverse_iterator<const uint8_t *>(ParseHex_expected)),
         "04");
 
     BOOST_CHECK_EQUAL(
         HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 5),
                std::reverse_iterator<const uint8_t *>(ParseHex_expected)),
         "b0fd8a6704");
 
     BOOST_CHECK_EQUAL(
         HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 65),
                std::reverse_iterator<const uint8_t *>(ParseHex_expected)),
         "5f1df16b2b704c8a578d0bbaf74d385cde12c11ee50455f3c438ef4c3fbcf649b6de61"
         "1feae06279a60939e028a8d65c10b73071a6f16719274855feb0fd8a6704");
 }
 
 BOOST_AUTO_TEST_CASE(util_Join) {
     // Normal version
     BOOST_CHECK_EQUAL(Join({}, ", "), "");
     BOOST_CHECK_EQUAL(Join({"foo"}, ", "), "foo");
     BOOST_CHECK_EQUAL(Join({"foo", "bar"}, ", "), "foo, bar");
 
     // Version with unary operator
     const auto op_upper = [](const std::string &s) { return ToUpper(s); };
     BOOST_CHECK_EQUAL(Join<std::string>({}, ", ", op_upper), "");
     BOOST_CHECK_EQUAL(Join<std::string>({"foo"}, ", ", op_upper), "FOO");
     BOOST_CHECK_EQUAL(Join<std::string>({"foo", "bar"}, ", ", op_upper),
                       "FOO, BAR");
 }
 
 BOOST_AUTO_TEST_CASE(util_FormatParseISO8601DateTime) {
     BOOST_CHECK_EQUAL(FormatISO8601DateTime(1317425777),
                       "2011-09-30T23:36:17Z");
     BOOST_CHECK_EQUAL(FormatISO8601DateTime(0), "1970-01-01T00:00:00Z");
 
     BOOST_CHECK_EQUAL(ParseISO8601DateTime("1970-01-01T00:00:00Z"), 0);
     BOOST_CHECK_EQUAL(ParseISO8601DateTime("1960-01-01T00:00:00Z"), 0);
     BOOST_CHECK_EQUAL(ParseISO8601DateTime("2011-09-30T23:36:17Z"), 1317425777);
 
     auto time = GetSystemTimeInSeconds();
     BOOST_CHECK_EQUAL(ParseISO8601DateTime(FormatISO8601DateTime(time)), time);
 }
 
 BOOST_AUTO_TEST_CASE(util_FormatISO8601Date) {
     BOOST_CHECK_EQUAL(FormatISO8601Date(1317425777), "2011-09-30");
 }
 
 struct TestArgsManager : public ArgsManager {
     TestArgsManager() { m_network_only_args.clear(); }
     void ReadConfigString(const std::string str_config) {
         std::istringstream streamConfig(str_config);
         {
             LOCK(cs_args);
             m_settings.ro_config.clear();
             m_config_sections.clear();
         }
         std::string error;
         BOOST_REQUIRE(ReadConfigStream(streamConfig, "", error));
     }
     void SetNetworkOnlyArg(const std::string arg) {
         LOCK(cs_args);
         m_network_only_args.insert(arg);
     }
     void
     SetupArgs(const std::vector<std::pair<std::string, unsigned int>> &args) {
         for (const auto &arg : args) {
             AddArg(arg.first, "", arg.second, OptionsCategory::OPTIONS);
         }
     }
     using ArgsManager::cs_args;
     using ArgsManager::GetSetting;
     using ArgsManager::GetSettingsList;
     using ArgsManager::m_network;
     using ArgsManager::m_settings;
     using ArgsManager::ReadConfigStream;
 };
 
 //! Test GetSetting and GetArg type coercion, negation, and default value
 //! handling.
 class CheckValueTest : public TestChain100Setup {
 public:
     struct Expect {
         util::SettingsValue setting;
         bool default_string = false;
         bool default_int = false;
         bool default_bool = false;
         const char *string_value = nullptr;
         std::optional<int64_t> int_value;
         std::optional<bool> bool_value;
         std::optional<std::vector<std::string>> list_value;
         const char *error = nullptr;
 
         explicit Expect(util::SettingsValue s) : setting(std::move(s)) {}
         Expect &DefaultString() {
             default_string = true;
             return *this;
         }
         Expect &DefaultInt() {
             default_int = true;
             return *this;
         }
         Expect &DefaultBool() {
             default_bool = true;
             return *this;
         }
         Expect &String(const char *s) {
             string_value = s;
             return *this;
         }
         Expect &Int(int64_t i) {
             int_value = i;
             return *this;
         }
         Expect &Bool(bool b) {
             bool_value = b;
             return *this;
         }
         Expect &List(std::vector<std::string> m) {
             list_value = std::move(m);
             return *this;
         }
         Expect &Error(const char *e) {
             error = e;
             return *this;
         }
     };
 
     void CheckValue(unsigned int flags, const char *arg, const Expect &expect) {
         TestArgsManager test;
         test.SetupArgs({{"-value", flags}});
         const char *argv[] = {"ignored", arg};
         std::string error;
         bool success = test.ParseParameters(arg ? 2 : 1, (char **)argv, error);
 
         BOOST_CHECK_EQUAL(test.GetSetting("-value").write(),
                           expect.setting.write());
         auto settings_list = test.GetSettingsList("-value");
         if (expect.setting.isNull() || expect.setting.isFalse()) {
             BOOST_CHECK_EQUAL(settings_list.size(), 0);
         } else {
             BOOST_CHECK_EQUAL(settings_list.size(), 1);
             BOOST_CHECK_EQUAL(settings_list[0].write(), expect.setting.write());
         }
 
         if (expect.error) {
             BOOST_CHECK(!success);
             BOOST_CHECK_NE(error.find(expect.error), std::string::npos);
         } else {
             BOOST_CHECK(success);
             BOOST_CHECK_EQUAL(error, "");
         }
 
         if (expect.default_string) {
             BOOST_CHECK_EQUAL(test.GetArg("-value", "zzzzz"), "zzzzz");
         } else if (expect.string_value) {
             BOOST_CHECK_EQUAL(test.GetArg("-value", "zzzzz"),
                               expect.string_value);
         } else {
             BOOST_CHECK(!success);
         }
 
         if (expect.default_int) {
             BOOST_CHECK_EQUAL(test.GetArg("-value", 99999), 99999);
         } else if (expect.int_value) {
             BOOST_CHECK_EQUAL(test.GetArg("-value", 99999), *expect.int_value);
         } else {
             BOOST_CHECK(!success);
         }
 
         if (expect.default_bool) {
             BOOST_CHECK_EQUAL(test.GetBoolArg("-value", false), false);
             BOOST_CHECK_EQUAL(test.GetBoolArg("-value", true), true);
         } else if (expect.bool_value) {
             BOOST_CHECK_EQUAL(test.GetBoolArg("-value", false),
                               *expect.bool_value);
             BOOST_CHECK_EQUAL(test.GetBoolArg("-value", true),
                               *expect.bool_value);
         } else {
             BOOST_CHECK(!success);
         }
 
         if (expect.list_value) {
             auto l = test.GetArgs("-value");
             BOOST_CHECK_EQUAL_COLLECTIONS(l.begin(), l.end(),
                                           expect.list_value->begin(),
                                           expect.list_value->end());
         } else {
             BOOST_CHECK(!success);
         }
     }
 };
 
 BOOST_FIXTURE_TEST_CASE(util_CheckValue, CheckValueTest) {
     using M = ArgsManager;
 
     CheckValue(M::ALLOW_ANY, nullptr,
                Expect{{}}.DefaultString().DefaultInt().DefaultBool().List({}));
     CheckValue(M::ALLOW_ANY, "-novalue",
                Expect{false}.String("0").Int(0).Bool(false).List({}));
     CheckValue(M::ALLOW_ANY, "-novalue=",
                Expect{false}.String("0").Int(0).Bool(false).List({}));
     CheckValue(M::ALLOW_ANY, "-novalue=0",
                Expect{true}.String("1").Int(1).Bool(true).List({"1"}));
     CheckValue(M::ALLOW_ANY, "-novalue=1",
                Expect{false}.String("0").Int(0).Bool(false).List({}));
     CheckValue(M::ALLOW_ANY, "-novalue=2",
                Expect{false}.String("0").Int(0).Bool(false).List({}));
     CheckValue(M::ALLOW_ANY, "-novalue=abc",
                Expect{true}.String("1").Int(1).Bool(true).List({"1"}));
     CheckValue(M::ALLOW_ANY, "-value",
                Expect{""}.String("").Int(0).Bool(true).List({""}));
     CheckValue(M::ALLOW_ANY,
                "-value=", Expect{""}.String("").Int(0).Bool(true).List({""}));
     CheckValue(M::ALLOW_ANY, "-value=0",
                Expect{"0"}.String("0").Int(0).Bool(false).List({"0"}));
     CheckValue(M::ALLOW_ANY, "-value=1",
                Expect{"1"}.String("1").Int(1).Bool(true).List({"1"}));
     CheckValue(M::ALLOW_ANY, "-value=2",
                Expect{"2"}.String("2").Int(2).Bool(true).List({"2"}));
     CheckValue(M::ALLOW_ANY, "-value=abc",
                Expect{"abc"}.String("abc").Int(0).Bool(false).List({"abc"}));
 }
 
 BOOST_AUTO_TEST_CASE(util_ParseParameters) {
     TestArgsManager testArgs;
     const auto a = std::make_pair("-a", ArgsManager::ALLOW_ANY);
     const auto b = std::make_pair("-b", ArgsManager::ALLOW_ANY);
     const auto ccc = std::make_pair("-ccc", ArgsManager::ALLOW_ANY);
     const auto d = std::make_pair("-d", ArgsManager::ALLOW_ANY);
 
     const char *argv_test[] = {"-ignored",      "-a", "-b",  "-ccc=argument",
                                "-ccc=multiple", "f",  "-d=e"};
 
     std::string error;
     LOCK(testArgs.cs_args);
     testArgs.SetupArgs({a, b, ccc, d});
     BOOST_CHECK(testArgs.ParseParameters(0, (char **)argv_test, error));
     BOOST_CHECK(testArgs.m_settings.command_line_options.empty() &&
                 testArgs.m_settings.ro_config.empty());
 
     BOOST_CHECK(testArgs.ParseParameters(1, (char **)argv_test, error));
     BOOST_CHECK(testArgs.m_settings.command_line_options.empty() &&
                 testArgs.m_settings.ro_config.empty());
 
     BOOST_CHECK(testArgs.ParseParameters(7, (char **)argv_test, error));
     // expectation: -ignored is ignored (program name argument),
     // -a, -b and -ccc end up in map, -d ignored because it is after
     // a non-option argument (non-GNU option parsing)
     BOOST_CHECK(testArgs.m_settings.command_line_options.size() == 3 &&
                 testArgs.m_settings.ro_config.empty());
     BOOST_CHECK(testArgs.IsArgSet("-a") && testArgs.IsArgSet("-b") &&
                 testArgs.IsArgSet("-ccc") && !testArgs.IsArgSet("f") &&
                 !testArgs.IsArgSet("-d"));
     BOOST_CHECK(testArgs.m_settings.command_line_options.count("a") &&
                 testArgs.m_settings.command_line_options.count("b") &&
                 testArgs.m_settings.command_line_options.count("ccc") &&
                 !testArgs.m_settings.command_line_options.count("f") &&
                 !testArgs.m_settings.command_line_options.count("d"));
 
     BOOST_CHECK(testArgs.m_settings.command_line_options["a"].size() == 1);
     BOOST_CHECK(
         testArgs.m_settings.command_line_options["a"].front().get_str() == "");
     BOOST_CHECK(testArgs.m_settings.command_line_options["ccc"].size() == 2);
     BOOST_CHECK(
         testArgs.m_settings.command_line_options["ccc"].front().get_str() ==
         "argument");
     BOOST_CHECK(
         testArgs.m_settings.command_line_options["ccc"].back().get_str() ==
         "multiple");
     BOOST_CHECK(testArgs.GetArgs("-ccc").size() == 2);
 }
 
 BOOST_AUTO_TEST_CASE(util_ParseKeyValue) {
     {
         std::string key = "badarg";
         std::string value;
         BOOST_CHECK(!ParseKeyValue(key, value));
     }
     {
         std::string key = "badarg=v";
         std::string value;
         BOOST_CHECK(!ParseKeyValue(key, value));
     }
     {
         std::string key = "-a";
         std::string value;
         BOOST_CHECK(ParseKeyValue(key, value));
         BOOST_CHECK_EQUAL(key, "-a");
         BOOST_CHECK_EQUAL(value, "");
     }
     {
         std::string key = "-a=1";
         std::string value;
         BOOST_CHECK(ParseKeyValue(key, value));
         BOOST_CHECK_EQUAL(key, "-a");
         BOOST_CHECK_EQUAL(value, "1");
     }
     {
         std::string key = "--b";
         std::string value;
         BOOST_CHECK(ParseKeyValue(key, value));
         BOOST_CHECK_EQUAL(key, "-b");
         BOOST_CHECK_EQUAL(value, "");
     }
     {
         std::string key = "--b=abc";
         std::string value;
         BOOST_CHECK(ParseKeyValue(key, value));
         BOOST_CHECK_EQUAL(key, "-b");
         BOOST_CHECK_EQUAL(value, "abc");
     }
 }
 
 BOOST_AUTO_TEST_CASE(util_ParseInvalidParameters) {
     TestArgsManager test;
     test.SetupArgs({{"-registered", ArgsManager::ALLOW_ANY}});
 
     const char *argv[] = {"ignored", "-registered"};
     std::string error;
     BOOST_CHECK(test.ParseParameters(2, (char **)argv, error));
     BOOST_CHECK_EQUAL(error, "");
 
     argv[1] = "-unregistered";
     BOOST_CHECK(!test.ParseParameters(2, (char **)argv, error));
     BOOST_CHECK_EQUAL(error, "Invalid parameter -unregistered");
 
     // Make sure registered parameters prefixed with a chain name trigger
     // errors. (Previously, they were accepted and ignored.)
     argv[1] = "-test.registered";
     BOOST_CHECK(!test.ParseParameters(2, (char **)argv, error));
     BOOST_CHECK_EQUAL(error, "Invalid parameter -test.registered");
 }
 
 static void TestParse(const std::string &str, bool expected_bool,
                       int64_t expected_int) {
     TestArgsManager test;
     test.SetupArgs({{"-value", ArgsManager::ALLOW_ANY}});
     std::string arg = "-value=" + str;
     const char *argv[] = {"ignored", arg.c_str()};
     std::string error;
     BOOST_CHECK(test.ParseParameters(2, (char **)argv, error));
     BOOST_CHECK_EQUAL(test.GetBoolArg("-value", false), expected_bool);
     BOOST_CHECK_EQUAL(test.GetBoolArg("-value", true), expected_bool);
     BOOST_CHECK_EQUAL(test.GetArg("-value", 99998), expected_int);
     BOOST_CHECK_EQUAL(test.GetArg("-value", 99999), expected_int);
 }
 
 // Test bool and int parsing.
 BOOST_AUTO_TEST_CASE(util_ArgParsing) {
     // Some of these cases could be ambiguous or surprising to users, and might
     // be worth triggering errors or warnings in the future. But for now basic
     // test coverage is useful to avoid breaking backwards compatibility
     // unintentionally.
     TestParse("", true, 0);
     TestParse(" ", false, 0);
     TestParse("0", false, 0);
     TestParse("0 ", false, 0);
     TestParse(" 0", false, 0);
     TestParse("+0", false, 0);
     TestParse("-0", false, 0);
     TestParse("5", true, 5);
     TestParse("5 ", true, 5);
     TestParse(" 5", true, 5);
     TestParse("+5", true, 5);
     TestParse("-5", true, -5);
     TestParse("0 5", false, 0);
     TestParse("5 0", true, 5);
     TestParse("050", true, 50);
     TestParse("0.", false, 0);
     TestParse("5.", true, 5);
     TestParse("0.0", false, 0);
     TestParse("0.5", false, 0);
     TestParse("5.0", true, 5);
     TestParse("5.5", true, 5);
     TestParse("x", false, 0);
     TestParse("x0", false, 0);
     TestParse("x5", false, 0);
     TestParse("0x", false, 0);
     TestParse("5x", true, 5);
     TestParse("0x5", false, 0);
     TestParse("false", false, 0);
     TestParse("true", false, 0);
     TestParse("yes", false, 0);
     TestParse("no", false, 0);
 }
 
 BOOST_AUTO_TEST_CASE(util_GetBoolArg) {
     TestArgsManager testArgs;
     const auto a = std::make_pair("-a", ArgsManager::ALLOW_ANY);
     const auto b = std::make_pair("-b", ArgsManager::ALLOW_ANY);
     const auto c = std::make_pair("-c", ArgsManager::ALLOW_ANY);
     const auto d = std::make_pair("-d", ArgsManager::ALLOW_ANY);
     const auto e = std::make_pair("-e", ArgsManager::ALLOW_ANY);
     const auto f = std::make_pair("-f", ArgsManager::ALLOW_ANY);
 
     const char *argv_test[] = {"ignored", "-a",       "-nob",   "-c=0",
                                "-d=1",    "-e=false", "-f=true"};
     std::string error;
     LOCK(testArgs.cs_args);
     testArgs.SetupArgs({a, b, c, d, e, f});
     BOOST_CHECK(testArgs.ParseParameters(7, (char **)argv_test, error));
 
     // Each letter should be set.
     for (const char opt : "abcdef") {
         BOOST_CHECK(testArgs.IsArgSet({'-', opt}) || !opt);
     }
 
     // Nothing else should be in the map
     BOOST_CHECK(testArgs.m_settings.command_line_options.size() == 6 &&
                 testArgs.m_settings.ro_config.empty());
 
     // The -no prefix should get stripped on the way in.
     BOOST_CHECK(!testArgs.IsArgSet("-nob"));
 
     // The -b option is flagged as negated, and nothing else is
     BOOST_CHECK(testArgs.IsArgNegated("-b"));
     BOOST_CHECK(!testArgs.IsArgNegated("-a"));
 
     // Check expected values.
     BOOST_CHECK(testArgs.GetBoolArg("-a", false) == true);
     BOOST_CHECK(testArgs.GetBoolArg("-b", true) == false);
     BOOST_CHECK(testArgs.GetBoolArg("-c", true) == false);
     BOOST_CHECK(testArgs.GetBoolArg("-d", false) == true);
     BOOST_CHECK(testArgs.GetBoolArg("-e", true) == false);
     BOOST_CHECK(testArgs.GetBoolArg("-f", true) == false);
 }
 
 BOOST_AUTO_TEST_CASE(util_GetBoolArgEdgeCases) {
     // Test some awful edge cases that hopefully no user will ever exercise.
     TestArgsManager testArgs;
 
     // Params test
     const auto foo = std::make_pair("-foo", ArgsManager::ALLOW_ANY);
     const auto bar = std::make_pair("-bar", ArgsManager::ALLOW_ANY);
     const char *argv_test[] = {"ignored", "-nofoo", "-foo", "-nobar=0"};
     testArgs.SetupArgs({foo, bar});
     std::string error;
     BOOST_CHECK(testArgs.ParseParameters(4, (char **)argv_test, error));
 
     // This was passed twice, second one overrides the negative setting.
     BOOST_CHECK(!testArgs.IsArgNegated("-foo"));
     BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "");
 
     // A double negative is a positive, and not marked as negated.
     BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
     BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "1");
 
     // Config test
     const char *conf_test = "nofoo=1\nfoo=1\nnobar=0\n";
     BOOST_CHECK(testArgs.ParseParameters(1, (char **)argv_test, error));
     testArgs.ReadConfigString(conf_test);
 
     // This was passed twice, second one overrides the negative setting,
     // and the value.
     BOOST_CHECK(!testArgs.IsArgNegated("-foo"));
     BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "1");
 
     // A double negative is a positive, and does not count as negated.
     BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
     BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "1");
 
     // Combined test
     const char *combo_test_args[] = {"ignored", "-nofoo", "-bar"};
     const char *combo_test_conf = "foo=1\nnobar=1\n";
     BOOST_CHECK(testArgs.ParseParameters(3, (char **)combo_test_args, error));
     testArgs.ReadConfigString(combo_test_conf);
 
     // Command line overrides, but doesn't erase old setting
     BOOST_CHECK(testArgs.IsArgNegated("-foo"));
     BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "0");
     BOOST_CHECK(testArgs.GetArgs("-foo").size() == 0);
 
     // Command line overrides, but doesn't erase old setting
     BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
     BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "");
     BOOST_CHECK(testArgs.GetArgs("-bar").size() == 1 &&
                 testArgs.GetArgs("-bar").front() == "");
 }
 
 BOOST_AUTO_TEST_CASE(util_ReadConfigStream) {
     const char *str_config = "a=\n"
                              "b=1\n"
                              "ccc=argument\n"
                              "ccc=multiple\n"
                              "d=e\n"
                              "nofff=1\n"
                              "noggg=0\n"
                              "h=1\n"
                              "noh=1\n"
                              "noi=1\n"
                              "i=1\n"
                              "sec1.ccc=extend1\n"
                              "\n"
                              "[sec1]\n"
                              "ccc=extend2\n"
                              "d=eee\n"
                              "h=1\n"
                              "[sec2]\n"
                              "ccc=extend3\n"
                              "iii=2\n";
 
     TestArgsManager test_args;
     LOCK(test_args.cs_args);
     const auto a = std::make_pair("-a", ArgsManager::ALLOW_ANY);
     const auto b = std::make_pair("-b", ArgsManager::ALLOW_ANY);
     const auto ccc = std::make_pair("-ccc", ArgsManager::ALLOW_ANY);
     const auto d = std::make_pair("-d", ArgsManager::ALLOW_ANY);
     const auto e = std::make_pair("-e", ArgsManager::ALLOW_ANY);
     const auto fff = std::make_pair("-fff", ArgsManager::ALLOW_ANY);
     const auto ggg = std::make_pair("-ggg", ArgsManager::ALLOW_ANY);
     const auto h = std::make_pair("-h", ArgsManager::ALLOW_ANY);
     const auto i = std::make_pair("-i", ArgsManager::ALLOW_ANY);
     const auto iii = std::make_pair("-iii", ArgsManager::ALLOW_ANY);
     test_args.SetupArgs({a, b, ccc, d, e, fff, ggg, h, i, iii});
 
     test_args.ReadConfigString(str_config);
     // expectation: a, b, ccc, d, fff, ggg, h, i end up in map
     // so do sec1.ccc, sec1.d, sec1.h, sec2.ccc, sec2.iii
 
     BOOST_CHECK(test_args.m_settings.command_line_options.empty());
     BOOST_CHECK(test_args.m_settings.ro_config.size() == 3);
     BOOST_CHECK(test_args.m_settings.ro_config[""].size() == 8);
     BOOST_CHECK(test_args.m_settings.ro_config["sec1"].size() == 3);
     BOOST_CHECK(test_args.m_settings.ro_config["sec2"].size() == 2);
 
     BOOST_CHECK(test_args.m_settings.ro_config[""].count("a") &&
                 test_args.m_settings.ro_config[""].count("b") &&
                 test_args.m_settings.ro_config[""].count("ccc") &&
                 test_args.m_settings.ro_config[""].count("d") &&
                 test_args.m_settings.ro_config[""].count("fff") &&
                 test_args.m_settings.ro_config[""].count("ggg") &&
                 test_args.m_settings.ro_config[""].count("h") &&
                 test_args.m_settings.ro_config[""].count("i"));
     BOOST_CHECK(test_args.m_settings.ro_config["sec1"].count("ccc") &&
                 test_args.m_settings.ro_config["sec1"].count("h") &&
                 test_args.m_settings.ro_config["sec2"].count("ccc") &&
                 test_args.m_settings.ro_config["sec2"].count("iii"));
 
     BOOST_CHECK(test_args.IsArgSet("-a") && test_args.IsArgSet("-b") &&
                 test_args.IsArgSet("-ccc") && test_args.IsArgSet("-d") &&
                 test_args.IsArgSet("-fff") && test_args.IsArgSet("-ggg") &&
                 test_args.IsArgSet("-h") && test_args.IsArgSet("-i") &&
                 !test_args.IsArgSet("-zzz") && !test_args.IsArgSet("-iii"));
 
     BOOST_CHECK(test_args.GetArg("-a", "xxx") == "" &&
                 test_args.GetArg("-b", "xxx") == "1" &&
                 test_args.GetArg("-ccc", "xxx") == "argument" &&
                 test_args.GetArg("-d", "xxx") == "e" &&
                 test_args.GetArg("-fff", "xxx") == "0" &&
                 test_args.GetArg("-ggg", "xxx") == "1" &&
                 test_args.GetArg("-h", "xxx") == "0" &&
                 test_args.GetArg("-i", "xxx") == "1" &&
                 test_args.GetArg("-zzz", "xxx") == "xxx" &&
                 test_args.GetArg("-iii", "xxx") == "xxx");
 
     for (const bool def : {false, true}) {
         BOOST_CHECK(test_args.GetBoolArg("-a", def) &&
                     test_args.GetBoolArg("-b", def) &&
                     !test_args.GetBoolArg("-ccc", def) &&
                     !test_args.GetBoolArg("-d", def) &&
                     !test_args.GetBoolArg("-fff", def) &&
                     test_args.GetBoolArg("-ggg", def) &&
                     !test_args.GetBoolArg("-h", def) &&
                     test_args.GetBoolArg("-i", def) &&
                     test_args.GetBoolArg("-zzz", def) == def &&
                     test_args.GetBoolArg("-iii", def) == def);
     }
 
     BOOST_CHECK(test_args.GetArgs("-a").size() == 1 &&
                 test_args.GetArgs("-a").front() == "");
     BOOST_CHECK(test_args.GetArgs("-b").size() == 1 &&
                 test_args.GetArgs("-b").front() == "1");
     BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2 &&
                 test_args.GetArgs("-ccc").front() == "argument" &&
                 test_args.GetArgs("-ccc").back() == "multiple");
     BOOST_CHECK(test_args.GetArgs("-fff").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-nofff").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-ggg").size() == 1 &&
                 test_args.GetArgs("-ggg").front() == "1");
     BOOST_CHECK(test_args.GetArgs("-noggg").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-h").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-noh").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-i").size() == 1 &&
                 test_args.GetArgs("-i").front() == "1");
     BOOST_CHECK(test_args.GetArgs("-noi").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-zzz").size() == 0);
 
     BOOST_CHECK(!test_args.IsArgNegated("-a"));
     BOOST_CHECK(!test_args.IsArgNegated("-b"));
     BOOST_CHECK(!test_args.IsArgNegated("-ccc"));
     BOOST_CHECK(!test_args.IsArgNegated("-d"));
     BOOST_CHECK(test_args.IsArgNegated("-fff"));
     BOOST_CHECK(!test_args.IsArgNegated("-ggg"));
     // last setting takes precedence
     BOOST_CHECK(test_args.IsArgNegated("-h"));
     // last setting takes precedence
     BOOST_CHECK(!test_args.IsArgNegated("-i"));
     BOOST_CHECK(!test_args.IsArgNegated("-zzz"));
 
     // Test sections work
     test_args.SelectConfigNetwork("sec1");
 
     // same as original
     BOOST_CHECK(test_args.GetArg("-a", "xxx") == "" &&
                 test_args.GetArg("-b", "xxx") == "1" &&
                 test_args.GetArg("-fff", "xxx") == "0" &&
                 test_args.GetArg("-ggg", "xxx") == "1" &&
                 test_args.GetArg("-zzz", "xxx") == "xxx" &&
                 test_args.GetArg("-iii", "xxx") == "xxx");
     // d is overridden
     BOOST_CHECK(test_args.GetArg("-d", "xxx") == "eee");
     // section-specific setting
     BOOST_CHECK(test_args.GetArg("-h", "xxx") == "1");
     // section takes priority for multiple values
     BOOST_CHECK(test_args.GetArg("-ccc", "xxx") == "extend1");
     // check multiple values works
     const std::vector<std::string> sec1_ccc_expected = {"extend1", "extend2",
                                                         "argument", "multiple"};
     const auto &sec1_ccc_res = test_args.GetArgs("-ccc");
     BOOST_CHECK_EQUAL_COLLECTIONS(sec1_ccc_res.begin(), sec1_ccc_res.end(),
                                   sec1_ccc_expected.begin(),
                                   sec1_ccc_expected.end());
 
     test_args.SelectConfigNetwork("sec2");
 
     // same as original
     BOOST_CHECK(test_args.GetArg("-a", "xxx") == "" &&
                 test_args.GetArg("-b", "xxx") == "1" &&
                 test_args.GetArg("-d", "xxx") == "e" &&
                 test_args.GetArg("-fff", "xxx") == "0" &&
                 test_args.GetArg("-ggg", "xxx") == "1" &&
                 test_args.GetArg("-zzz", "xxx") == "xxx" &&
                 test_args.GetArg("-h", "xxx") == "0");
     // section-specific setting
     BOOST_CHECK(test_args.GetArg("-iii", "xxx") == "2");
     // section takes priority for multiple values
     BOOST_CHECK(test_args.GetArg("-ccc", "xxx") == "extend3");
     // check multiple values works
     const std::vector<std::string> sec2_ccc_expected = {"extend3", "argument",
                                                         "multiple"};
     const auto &sec2_ccc_res = test_args.GetArgs("-ccc");
     BOOST_CHECK_EQUAL_COLLECTIONS(sec2_ccc_res.begin(), sec2_ccc_res.end(),
                                   sec2_ccc_expected.begin(),
                                   sec2_ccc_expected.end());
 
     // Test section only options
 
     test_args.SetNetworkOnlyArg("-d");
     test_args.SetNetworkOnlyArg("-ccc");
     test_args.SetNetworkOnlyArg("-h");
 
     test_args.SelectConfigNetwork(CBaseChainParams::MAIN);
     BOOST_CHECK(test_args.GetArg("-d", "xxx") == "e");
     BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2);
     BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0");
 
     test_args.SelectConfigNetwork("sec1");
     BOOST_CHECK(test_args.GetArg("-d", "xxx") == "eee");
     BOOST_CHECK(test_args.GetArgs("-d").size() == 1);
     BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2);
     BOOST_CHECK(test_args.GetArg("-h", "xxx") == "1");
 
     test_args.SelectConfigNetwork("sec2");
     BOOST_CHECK(test_args.GetArg("-d", "xxx") == "xxx");
     BOOST_CHECK(test_args.GetArgs("-d").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-ccc").size() == 1);
     BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0");
 }
 
 BOOST_AUTO_TEST_CASE(util_GetArg) {
     TestArgsManager testArgs;
     LOCK(testArgs.cs_args);
     testArgs.m_settings.command_line_options.clear();
     testArgs.m_settings.command_line_options["strtest1"] = {"string..."};
     // strtest2 undefined on purpose
     testArgs.m_settings.command_line_options["inttest1"] = {"12345"};
     testArgs.m_settings.command_line_options["inttest2"] = {
         "81985529216486895"};
     // inttest3 undefined on purpose
     testArgs.m_settings.command_line_options["booltest1"] = {""};
     // booltest2 undefined on purpose
     testArgs.m_settings.command_line_options["booltest3"] = {"0"};
     testArgs.m_settings.command_line_options["booltest4"] = {"1"};
 
     // priorities
     testArgs.m_settings.command_line_options["pritest1"] = {"a", "b"};
     testArgs.m_settings.ro_config[""]["pritest2"] = {"a", "b"};
     testArgs.m_settings.command_line_options["pritest3"] = {"a"};
     testArgs.m_settings.ro_config[""]["pritest3"] = {"b"};
     testArgs.m_settings.command_line_options["pritest4"] = {"a", "b"};
     testArgs.m_settings.ro_config[""]["pritest4"] = {"c", "d"};
 
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");
     BOOST_CHECK_EQUAL(testArgs.GetArg("inttest1", -1), 12345);
     BOOST_CHECK_EQUAL(testArgs.GetArg("inttest2", -1), 81985529216486895LL);
     BOOST_CHECK_EQUAL(testArgs.GetArg("inttest3", -1), -1);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), true);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest2", false), false);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest3", false), false);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest4", false), true);
 
     BOOST_CHECK_EQUAL(testArgs.GetArg("pritest1", "default"), "b");
     BOOST_CHECK_EQUAL(testArgs.GetArg("pritest2", "default"), "a");
     BOOST_CHECK_EQUAL(testArgs.GetArg("pritest3", "default"), "a");
     BOOST_CHECK_EQUAL(testArgs.GetArg("pritest4", "default"), "b");
 }
 
 BOOST_AUTO_TEST_CASE(util_ClearForcedArg) {
     TestArgsManager testArgs;
     LOCK(testArgs.cs_args);
 
     // Clear command line arg
     testArgs.m_settings.command_line_options["cmdarg"] = {"cmdval"};
     BOOST_CHECK_EQUAL(testArgs.GetArg("cmdarg", "default"), "cmdval");
     testArgs.ClearForcedArg("cmdarg");
     BOOST_CHECK_EQUAL(testArgs.GetArg("cmdarg", "default"), "cmdval");
 
     // Clear config arg
     testArgs.m_settings.ro_config[""]["configarg"] = {"configval"};
     BOOST_CHECK_EQUAL(testArgs.GetArg("configarg", "default"), "configval");
     testArgs.ClearForcedArg("configarg");
     BOOST_CHECK_EQUAL(testArgs.GetArg("configarg", "default"), "configval");
 
     // Clear forced arg
     testArgs.m_settings.forced_settings["forcedarg"] = {"forcedval"};
     BOOST_CHECK_EQUAL(testArgs.GetArg("forcedarg", "default"), "forcedval");
     testArgs.ClearForcedArg("forcedarg");
     BOOST_CHECK_EQUAL(testArgs.GetArg("forcedarg", "default"), "default");
 }
 
 BOOST_AUTO_TEST_CASE(util_SetArg) {
     TestArgsManager testArgs;
 
     // SoftSetArg
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "default");
     BOOST_CHECK_EQUAL(testArgs.SoftSetArg("strtest1", "string..."), true);
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest1").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest1").front(), "string...");
     BOOST_CHECK_EQUAL(testArgs.SoftSetArg("strtest1", "...gnirts"), false);
     testArgs.ClearForcedArg("strtest1");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "default");
     BOOST_CHECK_EQUAL(testArgs.SoftSetArg("strtest1", "...gnirts"), true);
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "...gnirts");
 
     // SoftSetBoolArg
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), false);
     BOOST_CHECK_EQUAL(testArgs.SoftSetBoolArg("booltest1", true), true);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), true);
     BOOST_CHECK_EQUAL(testArgs.SoftSetBoolArg("booltest1", false), false);
     testArgs.ClearForcedArg("booltest1");
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", true), true);
     BOOST_CHECK_EQUAL(testArgs.SoftSetBoolArg("booltest1", false), true);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", true), false);
 
     // ForceSetArg
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");
     testArgs.ForceSetArg("strtest2", "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "string...");
     testArgs.ForceSetArg("strtest2", "...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "...gnirts");
 
     // ForceSetMultiArg
     testArgs.ForceSetMultiArg("strtest2", {"string...", "...gnirts"});
     BOOST_CHECK_THROW(testArgs.GetArg("strtest2", "default"),
                       std::runtime_error);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 2);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").back(), "...gnirts");
     testArgs.ClearForcedArg("strtest2");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 0);
 
     // If there are multi args, ForceSetArg should erase them
     testArgs.ForceSetMultiArg("strtest2", {"string..."});
     BOOST_CHECK_THROW(testArgs.GetArg("strtest2", "default"),
                       std::runtime_error);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "string...");
     testArgs.ForceSetArg("strtest2", "...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "...gnirts");
 }
 
 BOOST_AUTO_TEST_CASE(util_GetChainName) {
     TestArgsManager test_args;
     const auto testnet = std::make_pair("-testnet", ArgsManager::ALLOW_ANY);
     const auto regtest = std::make_pair("-regtest", ArgsManager::ALLOW_ANY);
     test_args.SetupArgs({testnet, regtest});
 
     const char *argv_testnet[] = {"cmd", "-testnet"};
     const char *argv_regtest[] = {"cmd", "-regtest"};
     const char *argv_test_no_reg[] = {"cmd", "-testnet", "-noregtest"};
     const char *argv_both[] = {"cmd", "-testnet", "-regtest"};
 
     // equivalent to "-testnet"
     // regtest in testnet section is ignored
     const char *testnetconf = "testnet=1\nregtest=0\n[test]\nregtest=1";
     std::string error;
 
     BOOST_CHECK(test_args.ParseParameters(0, (char **)argv_testnet, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "main");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_testnet, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_regtest, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "regtest");
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_test_no_reg, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_both, error));
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
     BOOST_CHECK(test_args.ParseParameters(0, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_regtest, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_test_no_reg, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_both, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
     // check setting the network to test (and thus making
     // [test] regtest=1 potentially relevant) doesn't break things
     test_args.SelectConfigNetwork("test");
 
     BOOST_CHECK(test_args.ParseParameters(0, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_regtest, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_test_no_reg, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_both, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 }
 
 // Test different ways settings can be merged, and verify results. This test can
 // be used to confirm that updates to settings code don't change behavior
 // unintentionally.
 //
 // The test covers:
 //
 // - Combining different setting actions. Possible actions are: configuring a
 //   setting, negating a setting (adding "-no" prefix), and configuring/negating
 //   settings in a network section (adding "main." or "test." prefixes).
 //
 // - Combining settings from command line arguments and a config file.
 //
 // - Combining SoftSet and ForceSet calls.
 //
 // - Testing "main" and "test" network values to make sure settings from network
 //   sections are applied and to check for mainnet-specific behaviors like
 //   inheriting settings from the default section.
 //
 // - Testing network-specific settings like "-wallet", that may be ignored
 //   outside a network section, and non-network specific settings like "-server"
 //   that aren't sensitive to the network.
 //
 struct ArgsMergeTestingSetup : public BasicTestingSetup {
     //! Max number of actions to sequence together. Can decrease this when
     //! debugging to make test results easier to understand.
     static constexpr int MAX_ACTIONS = 3;
 
     enum Action { NONE, SET, NEGATE, SECTION_SET, SECTION_NEGATE };
     using ActionList = Action[MAX_ACTIONS];
 
     //! Enumerate all possible test configurations.
     template <typename Fn> void ForEachMergeSetup(Fn &&fn) {
         ActionList arg_actions = {};
         // command_line_options do not have sections. Only iterate over SET and
         // NEGATE
         ForEachNoDup(arg_actions, SET, NEGATE, [&] {
             ActionList conf_actions = {};
             ForEachNoDup(conf_actions, SET, SECTION_NEGATE, [&] {
                 for (bool soft_set : {false, true}) {
                     for (bool force_set : {false, true}) {
                         for (const std::string &section :
                              {CBaseChainParams::MAIN,
                               CBaseChainParams::TESTNET}) {
                             for (const std::string &network :
                                  {CBaseChainParams::MAIN,
                                   CBaseChainParams::TESTNET}) {
                                 for (bool net_specific : {false, true}) {
                                     fn(arg_actions, conf_actions, soft_set,
                                        force_set, section, network,
                                        net_specific);
                                 }
                             }
                         }
                     }
                 }
             });
         });
     }
 
     //! Translate actions into a list of <key>=<value> setting strings.
     std::vector<std::string> GetValues(const ActionList &actions,
                                        const std::string &section,
                                        const std::string &name,
                                        const std::string &value_prefix) {
         std::vector<std::string> values;
         int suffix = 0;
         for (Action action : actions) {
             if (action == NONE) {
                 break;
             }
             std::string prefix;
             if (action == SECTION_SET || action == SECTION_NEGATE) {
                 prefix = section + ".";
             }
             if (action == SET || action == SECTION_SET) {
                 for (int i = 0; i < 2; ++i) {
                     values.push_back(prefix + name + "=" + value_prefix +
-                                     std::to_string(++suffix));
+                                     ToString(++suffix));
                 }
             }
             if (action == NEGATE || action == SECTION_NEGATE) {
                 values.push_back(prefix + "no" + name + "=1");
             }
         }
         return values;
     }
 };
 
 // Regression test covering different ways config settings can be merged. The
 // test parses and merges settings, representing the results as strings that get
 // compared against an expected hash. To debug, the result strings can be dumped
 // to a file (see comments below).
 BOOST_FIXTURE_TEST_CASE(util_ArgsMerge, ArgsMergeTestingSetup) {
     CHash256 out_sha;
     FILE *out_file = nullptr;
     if (const char *out_path = getenv("ARGS_MERGE_TEST_OUT")) {
         out_file = fsbridge::fopen(out_path, "w");
         if (!out_file) {
             throw std::system_error(errno, std::generic_category(),
                                     "fopen failed");
         }
     }
 
     ForEachMergeSetup([&](const ActionList &arg_actions,
                           const ActionList &conf_actions, bool soft_set,
                           bool force_set, const std::string &section,
                           const std::string &network, bool net_specific) {
         TestArgsManager parser;
         LOCK(parser.cs_args);
 
         std::string desc = "net=";
         desc += network;
         parser.m_network = network;
 
         const std::string &name = net_specific ? "wallet" : "server";
         const std::string key = "-" + name;
         parser.AddArg(key, name, ArgsManager::ALLOW_ANY,
                       OptionsCategory::OPTIONS);
         if (net_specific) {
             parser.SetNetworkOnlyArg(key);
         }
 
         auto args = GetValues(arg_actions, section, name, "a");
         std::vector<const char *> argv = {"ignored"};
         for (auto &arg : args) {
             arg.insert(0, "-");
             desc += " ";
             desc += arg;
             argv.push_back(arg.c_str());
         }
         std::string error;
         BOOST_CHECK(parser.ParseParameters(argv.size(), argv.data(), error));
         BOOST_CHECK_EQUAL(error, "");
 
         std::string conf;
         for (auto &conf_val : GetValues(conf_actions, section, name, "c")) {
             desc += " ";
             desc += conf_val;
             conf += conf_val;
             conf += "\n";
         }
         std::istringstream conf_stream(conf);
         BOOST_CHECK(parser.ReadConfigStream(conf_stream, "filepath", error));
         BOOST_CHECK_EQUAL(error, "");
 
         if (soft_set) {
             desc += " soft";
             parser.SoftSetArg(key, "soft1");
             parser.SoftSetArg(key, "soft2");
         }
 
         if (force_set) {
             desc += " force";
             parser.ForceSetArg(key, "force1");
             parser.ForceSetArg(key, "force2");
         }
 
         desc += " || ";
 
         if (!parser.IsArgSet(key)) {
             desc += "unset";
             BOOST_CHECK(!parser.IsArgNegated(key));
             BOOST_CHECK_EQUAL(parser.GetArg(key, "default"), "default");
             BOOST_CHECK(parser.GetArgs(key).empty());
         } else if (parser.IsArgNegated(key)) {
             desc += "negated";
             BOOST_CHECK_EQUAL(parser.GetArg(key, "default"), "0");
             BOOST_CHECK(parser.GetArgs(key).empty());
         } else {
             desc += parser.GetArg(key, "default");
             desc += " |";
             for (const auto &arg : parser.GetArgs(key)) {
                 desc += " ";
                 desc += arg;
             }
         }
 
         std::set<std::string> ignored = parser.GetUnsuitableSectionOnlyArgs();
         if (!ignored.empty()) {
             desc += " | ignored";
             for (const auto &arg : ignored) {
                 desc += " ";
                 desc += arg;
             }
         }
 
         desc += "\n";
 
         out_sha.Write((const uint8_t *)desc.data(), desc.size());
         if (out_file) {
             BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) ==
                           desc.size());
         }
     });
 
     if (out_file) {
         if (fclose(out_file)) {
             throw std::system_error(errno, std::generic_category(),
                                     "fclose failed");
         }
         out_file = nullptr;
     }
 
     uint8_t out_sha_bytes[CSHA256::OUTPUT_SIZE];
     out_sha.Finalize(out_sha_bytes);
     std::string out_sha_hex =
         HexStr(std::begin(out_sha_bytes), std::end(out_sha_bytes));
 
     // If check below fails, should manually dump the results with:
     //
     //   ARGS_MERGE_TEST_OUT=results.txt ./test_bitcoin
     //   --run_test=util_tests/util_ArgsMerge
     //
     // And verify diff against previous results to make sure the changes are
     // expected.
     //
     // Results file is formatted like:
     //
     //   <input> || <IsArgSet/IsArgNegated/GetArg output> | <GetArgs output> |
     //   <GetUnsuitable output>
     BOOST_CHECK_EQUAL(
         out_sha_hex,
         "8fd4877bb8bf337badca950ede6c917441901962f160e52514e06a60dea46cde");
 }
 
 // Similar test as above, but for ArgsManager::GetChainName function.
 struct ChainMergeTestingSetup : public BasicTestingSetup {
     static constexpr int MAX_ACTIONS = 2;
 
     enum Action {
         NONE,
         ENABLE_TEST,
         DISABLE_TEST,
         NEGATE_TEST,
         ENABLE_REG,
         DISABLE_REG,
         NEGATE_REG
     };
     using ActionList = Action[MAX_ACTIONS];
 
     //! Enumerate all possible test configurations.
     template <typename Fn> void ForEachMergeSetup(Fn &&fn) {
         ActionList arg_actions = {};
         ForEachNoDup(arg_actions, ENABLE_TEST, NEGATE_REG, [&] {
             ActionList conf_actions = {};
             ForEachNoDup(conf_actions, ENABLE_TEST, NEGATE_REG,
                          [&] { fn(arg_actions, conf_actions); });
         });
     }
 };
 
 BOOST_FIXTURE_TEST_CASE(util_ChainMerge, ChainMergeTestingSetup) {
     CHash256 out_sha;
     FILE *out_file = nullptr;
     if (const char *out_path = getenv("CHAIN_MERGE_TEST_OUT")) {
         out_file = fsbridge::fopen(out_path, "w");
         if (!out_file) {
             throw std::system_error(errno, std::generic_category(),
                                     "fopen failed");
         }
     }
 
     ForEachMergeSetup([&](const ActionList &arg_actions,
                           const ActionList &conf_actions) {
         TestArgsManager parser;
         LOCK(parser.cs_args);
         parser.AddArg("-regtest", "regtest", ArgsManager::ALLOW_ANY,
                       OptionsCategory::OPTIONS);
         parser.AddArg("-testnet", "testnet", ArgsManager::ALLOW_ANY,
                       OptionsCategory::OPTIONS);
 
         auto arg = [](Action action) -> const char * {
             switch (action) {
                 case ENABLE_TEST:
                     return "-testnet=1";
                 case DISABLE_TEST:
                     return "-testnet=0";
                 case NEGATE_TEST:
                     return "-notestnet=1";
                 case ENABLE_REG:
                     return "-regtest=1";
                 case DISABLE_REG:
                     return "-regtest=0";
                 case NEGATE_REG:
                     return "-noregtest=1";
                 default:
                     return nullptr;
             }
         };
 
         std::string desc;
         std::vector<const char *> argv = {"ignored"};
         for (Action action : arg_actions) {
             const char *argstr = arg(action);
             if (!argstr) {
                 break;
             }
             argv.push_back(argstr);
             desc += " ";
             desc += argv.back();
         }
         std::string error;
         BOOST_CHECK(parser.ParseParameters(argv.size(), argv.data(), error));
         BOOST_CHECK_EQUAL(error, "");
 
         std::string conf;
         for (Action action : conf_actions) {
             const char *argstr = arg(action);
             if (!argstr) {
                 break;
             }
             desc += " ";
             desc += argstr + 1;
             conf += argstr + 1;
             conf += "\n";
         }
         std::istringstream conf_stream(conf);
         BOOST_CHECK(parser.ReadConfigStream(conf_stream, "filepath", error));
         BOOST_CHECK_EQUAL(error, "");
 
         desc += " || ";
         try {
             desc += parser.GetChainName();
         } catch (const std::runtime_error &e) {
             desc += "error: ";
             desc += e.what();
         }
         desc += "\n";
 
         out_sha.Write((const uint8_t *)desc.data(), desc.size());
         if (out_file) {
             BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) ==
                           desc.size());
         }
     });
 
     if (out_file) {
         if (fclose(out_file)) {
             throw std::system_error(errno, std::generic_category(),
                                     "fclose failed");
         }
         out_file = nullptr;
     }
 
     uint8_t out_sha_bytes[CSHA256::OUTPUT_SIZE];
     out_sha.Finalize(out_sha_bytes);
     std::string out_sha_hex =
         HexStr(std::begin(out_sha_bytes), std::end(out_sha_bytes));
 
     // If check below fails, should manually dump the results with:
     //
     //   CHAIN_MERGE_TEST_OUT=results.txt ./test_bitcoin
     //   --run_test=util_tests/util_ChainMerge
     //
     // And verify diff against previous results to make sure the changes are
     // expected.
     //
     // Results file is formatted like:
     //
     //   <input> || <output>
     BOOST_CHECK_EQUAL(
         out_sha_hex,
         "f0b3a3c29869edc765d579c928f7f1690a71fbb673b49ccf39cbc4de18156a0d");
 }
 
 BOOST_AUTO_TEST_CASE(util_ReadWriteSettings) {
     // Test writing setting.
     TestArgsManager args1;
     args1.LockSettings([&](util::Settings &settings) {
         settings.rw_settings["name"] = "value";
     });
     args1.WriteSettingsFile();
 
     // Test reading setting.
     TestArgsManager args2;
     args2.ReadSettingsFile();
     args2.LockSettings([&](util::Settings &settings) {
         BOOST_CHECK_EQUAL(settings.rw_settings["name"].get_str(), "value");
     });
 
     // Test error logging, and remove previously written setting.
     {
         ASSERT_DEBUG_LOG("Failed renaming settings file");
         fs::remove(GetDataDir() / "settings.json");
         fs::create_directory(GetDataDir() / "settings.json");
         args2.WriteSettingsFile();
         fs::remove(GetDataDir() / "settings.json");
     }
 }
 
 BOOST_AUTO_TEST_CASE(util_FormatMoney) {
     BOOST_CHECK_EQUAL(FormatMoney(Amount::zero()), "0.00");
     BOOST_CHECK_EQUAL(FormatMoney(123456789 * (COIN / 10000)), "12345.6789");
     BOOST_CHECK_EQUAL(FormatMoney(-1 * COIN), "-1.00");
 
     BOOST_CHECK_EQUAL(FormatMoney(100000000 * COIN), "100000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(10000000 * COIN), "10000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(1000000 * COIN), "1000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(100000 * COIN), "100000.00");
     BOOST_CHECK_EQUAL(FormatMoney(10000 * COIN), "10000.00");
     BOOST_CHECK_EQUAL(FormatMoney(1000 * COIN), "1000.00");
     BOOST_CHECK_EQUAL(FormatMoney(100 * COIN), "100.00");
     BOOST_CHECK_EQUAL(FormatMoney(10 * COIN), "10.00");
     BOOST_CHECK_EQUAL(FormatMoney(COIN), "1.00");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 10), "0.10");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 100), "0.01");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 1000), "0.001");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 10000), "0.0001");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 100000), "0.00001");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 1000000), "0.000001");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 10000000), "0.0000001");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 100000000), "0.00000001");
 }
 
 BOOST_AUTO_TEST_CASE(util_ParseMoney) {
     Amount ret = Amount::zero();
     BOOST_CHECK(ParseMoney("0.0", ret));
     BOOST_CHECK_EQUAL(ret, Amount::zero());
 
     BOOST_CHECK(ParseMoney("12345.6789", ret));
     BOOST_CHECK_EQUAL(ret, 123456789 * (COIN / 10000));
 
     BOOST_CHECK(ParseMoney("100000000.00", ret));
     BOOST_CHECK_EQUAL(ret, 100000000 * COIN);
     BOOST_CHECK(ParseMoney("10000000.00", ret));
     BOOST_CHECK_EQUAL(ret, 10000000 * COIN);
     BOOST_CHECK(ParseMoney("1000000.00", ret));
     BOOST_CHECK_EQUAL(ret, 1000000 * COIN);
     BOOST_CHECK(ParseMoney("100000.00", ret));
     BOOST_CHECK_EQUAL(ret, 100000 * COIN);
     BOOST_CHECK(ParseMoney("10000.00", ret));
     BOOST_CHECK_EQUAL(ret, 10000 * COIN);
     BOOST_CHECK(ParseMoney("1000.00", ret));
     BOOST_CHECK_EQUAL(ret, 1000 * COIN);
     BOOST_CHECK(ParseMoney("100.00", ret));
     BOOST_CHECK_EQUAL(ret, 100 * COIN);
     BOOST_CHECK(ParseMoney("10.00", ret));
     BOOST_CHECK_EQUAL(ret, 10 * COIN);
     BOOST_CHECK(ParseMoney("1.00", ret));
     BOOST_CHECK_EQUAL(ret, COIN);
     BOOST_CHECK(ParseMoney("1", ret));
     BOOST_CHECK_EQUAL(ret, COIN);
     BOOST_CHECK(ParseMoney("   1", ret));
     BOOST_CHECK_EQUAL(ret, COIN);
     BOOST_CHECK(ParseMoney("1   ", ret));
     BOOST_CHECK_EQUAL(ret, COIN);
     BOOST_CHECK(ParseMoney("  1 ", ret));
     BOOST_CHECK_EQUAL(ret, COIN);
     BOOST_CHECK(ParseMoney("0.1", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 10);
     BOOST_CHECK(ParseMoney("0.01", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 100);
     BOOST_CHECK(ParseMoney("0.001", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 1000);
     BOOST_CHECK(ParseMoney("0.0001", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 10000);
     BOOST_CHECK(ParseMoney("0.00001", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 100000);
     BOOST_CHECK(ParseMoney("0.000001", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 1000000);
     BOOST_CHECK(ParseMoney("0.0000001", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 10000000);
     BOOST_CHECK(ParseMoney("0.00000001", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 100000000);
     BOOST_CHECK(ParseMoney(" 0.00000001 ", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 100000000);
     BOOST_CHECK(ParseMoney("0.00000001 ", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 100000000);
     BOOST_CHECK(ParseMoney(" 0.00000001", ret));
     BOOST_CHECK_EQUAL(ret, COIN / 100000000);
 
     // Parsing amount that can not be represented in ret should fail
     BOOST_CHECK(!ParseMoney("0.000000001", ret));
 
     // Parsing empty string should fail
     BOOST_CHECK(!ParseMoney("", ret));
     BOOST_CHECK(!ParseMoney(" ", ret));
     BOOST_CHECK(!ParseMoney("  ", ret));
 
     // Parsing two numbers should fail
     BOOST_CHECK(!ParseMoney("1 2", ret));
     BOOST_CHECK(!ParseMoney(" 1 2 ", ret));
     BOOST_CHECK(!ParseMoney(" 1.2 3 ", ret));
     BOOST_CHECK(!ParseMoney(" 1 2.3 ", ret));
 
     // Attempted 63 bit overflow should fail
     BOOST_CHECK(!ParseMoney("92233720368.54775808", ret));
 
     // Parsing negative amounts must fail
     BOOST_CHECK(!ParseMoney("-1", ret));
 
     // Parsing strings with embedded NUL characters should fail
     BOOST_CHECK(!ParseMoney(std::string("\0-1", 3), ret));
     BOOST_CHECK(!ParseMoney(std::string("\01", 2), ret));
     BOOST_CHECK(!ParseMoney(std::string("1\0", 2), ret));
 }
 
 BOOST_AUTO_TEST_CASE(util_IsHex) {
     BOOST_CHECK(IsHex("00"));
     BOOST_CHECK(IsHex("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
     BOOST_CHECK(IsHex("ff"));
     BOOST_CHECK(IsHex("FF"));
 
     BOOST_CHECK(!IsHex(""));
     BOOST_CHECK(!IsHex("0"));
     BOOST_CHECK(!IsHex("a"));
     BOOST_CHECK(!IsHex("eleven"));
     BOOST_CHECK(!IsHex("00xx00"));
     BOOST_CHECK(!IsHex("0x0000"));
 }
 
 BOOST_AUTO_TEST_CASE(util_IsHexNumber) {
     BOOST_CHECK(IsHexNumber("0x0"));
     BOOST_CHECK(IsHexNumber("0"));
     BOOST_CHECK(IsHexNumber("0x10"));
     BOOST_CHECK(IsHexNumber("10"));
     BOOST_CHECK(IsHexNumber("0xff"));
     BOOST_CHECK(IsHexNumber("ff"));
     BOOST_CHECK(IsHexNumber("0xFfa"));
     BOOST_CHECK(IsHexNumber("Ffa"));
     BOOST_CHECK(IsHexNumber("0x00112233445566778899aabbccddeeffAABBCCDDEEFF"));
     BOOST_CHECK(IsHexNumber("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
 
     BOOST_CHECK(!IsHexNumber(""));      // empty string not allowed
     BOOST_CHECK(!IsHexNumber("0x"));    // empty string after prefix not allowed
     BOOST_CHECK(!IsHexNumber("0x0 "));  // no spaces at end,
     BOOST_CHECK(!IsHexNumber(" 0x0"));  // or beginning,
     BOOST_CHECK(!IsHexNumber("0x 0"));  // or middle,
     BOOST_CHECK(!IsHexNumber(" "));     // etc.
     BOOST_CHECK(!IsHexNumber("0x0ga")); // invalid character
     BOOST_CHECK(!IsHexNumber("x0"));    // broken prefix
     BOOST_CHECK(!IsHexNumber("0x0x00")); // two prefixes not allowed
 }
 
 BOOST_AUTO_TEST_CASE(util_seed_insecure_rand) {
     SeedInsecureRand(SeedRand::ZEROS);
     for (int mod = 2; mod < 11; mod++) {
         int mask = 1;
         // Really rough binomial confidence approximation.
         int err =
             30 * 10000. / mod * sqrt((1. / mod * (1 - 1. / mod)) / 10000.);
         // mask is 2^ceil(log2(mod))-1
         while (mask < mod - 1) {
             mask = (mask << 1) + 1;
         }
 
         int count = 0;
         // How often does it get a zero from the uniform range [0,mod)?
         for (int i = 0; i < 10000; i++) {
             uint32_t rval;
             do {
                 rval = InsecureRand32() & mask;
             } while (rval >= uint32_t(mod));
             count += rval == 0;
         }
         BOOST_CHECK(count <= 10000 / mod + err);
         BOOST_CHECK(count >= 10000 / mod - err);
     }
 }
 
 BOOST_AUTO_TEST_CASE(util_TimingResistantEqual) {
     BOOST_CHECK(TimingResistantEqual(std::string(""), std::string("")));
     BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("")));
     BOOST_CHECK(!TimingResistantEqual(std::string(""), std::string("abc")));
     BOOST_CHECK(!TimingResistantEqual(std::string("a"), std::string("aa")));
     BOOST_CHECK(!TimingResistantEqual(std::string("aa"), std::string("a")));
     BOOST_CHECK(TimingResistantEqual(std::string("abc"), std::string("abc")));
     BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("aba")));
 }
 
 /* Test strprintf formatting directives.
  * Put a string before and after to ensure sanity of element sizes on stack. */
 #define B "check_prefix"
 #define E "check_postfix"
 BOOST_AUTO_TEST_CASE(strprintf_numbers) {
     int64_t s64t = -9223372036854775807LL;   /* signed 64 bit test value */
     uint64_t u64t = 18446744073709551615ULL; /* unsigned 64 bit test value */
     BOOST_CHECK(strprintf("%s %d %s", B, s64t, E) == B
                 " -9223372036854775807 " E);
     BOOST_CHECK(strprintf("%s %u %s", B, u64t, E) == B
                 " 18446744073709551615 " E);
     BOOST_CHECK(strprintf("%s %x %s", B, u64t, E) == B " ffffffffffffffff " E);
 
     size_t st = 12345678;    /* unsigned size_t test value */
     ssize_t sst = -12345678; /* signed size_t test value */
     BOOST_CHECK(strprintf("%s %d %s", B, sst, E) == B " -12345678 " E);
     BOOST_CHECK(strprintf("%s %u %s", B, st, E) == B " 12345678 " E);
     BOOST_CHECK(strprintf("%s %x %s", B, st, E) == B " bc614e " E);
 
     ptrdiff_t pt = 87654321;   /* positive ptrdiff_t test value */
     ptrdiff_t spt = -87654321; /* negative ptrdiff_t test value */
     BOOST_CHECK(strprintf("%s %d %s", B, spt, E) == B " -87654321 " E);
     BOOST_CHECK(strprintf("%s %u %s", B, pt, E) == B " 87654321 " E);
     BOOST_CHECK(strprintf("%s %x %s", B, pt, E) == B " 5397fb1 " E);
 }
 #undef B
 #undef E
 
 /* Check for mingw/wine issue #3494
  * Remove this test before time.ctime(0xffffffff) == 'Sun Feb  7 07:28:15 2106'
  */
 BOOST_AUTO_TEST_CASE(gettime) {
     BOOST_CHECK((GetTime() & ~0xFFFFFFFFLL) == 0);
 }
 
 BOOST_AUTO_TEST_CASE(util_time_GetTime) {
     SetMockTime(111);
     // Check that mock time does not change after a sleep
     for (const auto &num_sleep : {0, 1}) {
         UninterruptibleSleep(std::chrono::milliseconds{num_sleep});
         BOOST_CHECK_EQUAL(111, GetTime()); // Deprecated time getter
         BOOST_CHECK_EQUAL(111, GetTime<std::chrono::seconds>().count());
         BOOST_CHECK_EQUAL(111000, GetTime<std::chrono::milliseconds>().count());
         BOOST_CHECK_EQUAL(111000000,
                           GetTime<std::chrono::microseconds>().count());
     }
 
     SetMockTime(0);
     // Check that system time changes after a sleep
     const auto ms_0 = GetTime<std::chrono::milliseconds>();
     const auto us_0 = GetTime<std::chrono::microseconds>();
     UninterruptibleSleep(std::chrono::milliseconds{1});
     BOOST_CHECK(ms_0 < GetTime<std::chrono::milliseconds>());
     BOOST_CHECK(us_0 < GetTime<std::chrono::microseconds>());
 }
 
 BOOST_AUTO_TEST_CASE(test_IsDigit) {
     BOOST_CHECK_EQUAL(IsDigit('0'), true);
     BOOST_CHECK_EQUAL(IsDigit('1'), true);
     BOOST_CHECK_EQUAL(IsDigit('8'), true);
     BOOST_CHECK_EQUAL(IsDigit('9'), true);
 
     BOOST_CHECK_EQUAL(IsDigit('0' - 1), false);
     BOOST_CHECK_EQUAL(IsDigit('9' + 1), false);
     BOOST_CHECK_EQUAL(IsDigit(0), false);
     BOOST_CHECK_EQUAL(IsDigit(1), false);
     BOOST_CHECK_EQUAL(IsDigit(8), false);
     BOOST_CHECK_EQUAL(IsDigit(9), false);
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseInt32) {
     int32_t n;
     // Valid values
     BOOST_CHECK(ParseInt32("1234", nullptr));
     BOOST_CHECK(ParseInt32("0", &n) && n == 0);
     BOOST_CHECK(ParseInt32("1234", &n) && n == 1234);
     BOOST_CHECK(ParseInt32("01234", &n) && n == 1234); // no octal
     BOOST_CHECK(ParseInt32("2147483647", &n) && n == 2147483647);
     // (-2147483647 - 1) equals INT_MIN
     BOOST_CHECK(ParseInt32("-2147483648", &n) && n == (-2147483647 - 1));
     BOOST_CHECK(ParseInt32("-1234", &n) && n == -1234);
     // Invalid values
     BOOST_CHECK(!ParseInt32("", &n));
     BOOST_CHECK(!ParseInt32(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseInt32("1 ", &n));
     BOOST_CHECK(!ParseInt32("1a", &n));
     BOOST_CHECK(!ParseInt32("aap", &n));
     BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
     BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
     const char test_bytes[] = {'1', 0, '1'};
     std::string teststr(test_bytes, sizeof(test_bytes));
     BOOST_CHECK(!ParseInt32(teststr, &n)); // no embedded NULs
     // Overflow and underflow
     BOOST_CHECK(!ParseInt32("-2147483649", nullptr));
     BOOST_CHECK(!ParseInt32("2147483648", nullptr));
     BOOST_CHECK(!ParseInt32("-32482348723847471234", nullptr));
     BOOST_CHECK(!ParseInt32("32482348723847471234", nullptr));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseInt64) {
     int64_t n;
     // Valid values
     BOOST_CHECK(ParseInt64("1234", nullptr));
     BOOST_CHECK(ParseInt64("0", &n) && n == 0LL);
     BOOST_CHECK(ParseInt64("1234", &n) && n == 1234LL);
     BOOST_CHECK(ParseInt64("01234", &n) && n == 1234LL); // no octal
     BOOST_CHECK(ParseInt64("2147483647", &n) && n == 2147483647LL);
     BOOST_CHECK(ParseInt64("-2147483648", &n) && n == -2147483648LL);
     BOOST_CHECK(ParseInt64("9223372036854775807", &n) &&
                 n == (int64_t)9223372036854775807);
     BOOST_CHECK(ParseInt64("-9223372036854775808", &n) &&
                 n == (int64_t)-9223372036854775807 - 1);
     BOOST_CHECK(ParseInt64("-1234", &n) && n == -1234LL);
     // Invalid values
     BOOST_CHECK(!ParseInt64("", &n));
     BOOST_CHECK(!ParseInt64(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseInt64("1 ", &n));
     BOOST_CHECK(!ParseInt64("1a", &n));
     BOOST_CHECK(!ParseInt64("aap", &n));
     BOOST_CHECK(!ParseInt64("0x1", &n)); // no hex
     const char test_bytes[] = {'1', 0, '1'};
     std::string teststr(test_bytes, sizeof(test_bytes));
     BOOST_CHECK(!ParseInt64(teststr, &n)); // no embedded NULs
     // Overflow and underflow
     BOOST_CHECK(!ParseInt64("-9223372036854775809", nullptr));
     BOOST_CHECK(!ParseInt64("9223372036854775808", nullptr));
     BOOST_CHECK(!ParseInt64("-32482348723847471234", nullptr));
     BOOST_CHECK(!ParseInt64("32482348723847471234", nullptr));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseUInt32) {
     uint32_t n;
     // Valid values
     BOOST_CHECK(ParseUInt32("1234", nullptr));
     BOOST_CHECK(ParseUInt32("0", &n) && n == 0);
     BOOST_CHECK(ParseUInt32("1234", &n) && n == 1234);
     BOOST_CHECK(ParseUInt32("01234", &n) && n == 1234); // no octal
     BOOST_CHECK(ParseUInt32("2147483647", &n) && n == 2147483647);
     BOOST_CHECK(ParseUInt32("2147483648", &n) && n == (uint32_t)2147483648);
     BOOST_CHECK(ParseUInt32("4294967295", &n) && n == (uint32_t)4294967295);
     // Invalid values
     BOOST_CHECK(!ParseUInt32("", &n));
     BOOST_CHECK(!ParseUInt32(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseUInt32(" -1", &n));
     BOOST_CHECK(!ParseUInt32("1 ", &n));
     BOOST_CHECK(!ParseUInt32("1a", &n));
     BOOST_CHECK(!ParseUInt32("aap", &n));
     BOOST_CHECK(!ParseUInt32("0x1", &n)); // no hex
     BOOST_CHECK(!ParseUInt32("0x1", &n)); // no hex
     const char test_bytes[] = {'1', 0, '1'};
     std::string teststr(test_bytes, sizeof(test_bytes));
     BOOST_CHECK(!ParseUInt32(teststr, &n)); // no embedded NULs
     // Overflow and underflow
     BOOST_CHECK(!ParseUInt32("-2147483648", &n));
     BOOST_CHECK(!ParseUInt32("4294967296", &n));
     BOOST_CHECK(!ParseUInt32("-1234", &n));
     BOOST_CHECK(!ParseUInt32("-32482348723847471234", nullptr));
     BOOST_CHECK(!ParseUInt32("32482348723847471234", nullptr));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseUInt64) {
     uint64_t n;
     // Valid values
     BOOST_CHECK(ParseUInt64("1234", nullptr));
     BOOST_CHECK(ParseUInt64("0", &n) && n == 0LL);
     BOOST_CHECK(ParseUInt64("1234", &n) && n == 1234LL);
     BOOST_CHECK(ParseUInt64("01234", &n) && n == 1234LL); // no octal
     BOOST_CHECK(ParseUInt64("2147483647", &n) && n == 2147483647LL);
     BOOST_CHECK(ParseUInt64("9223372036854775807", &n) &&
                 n == 9223372036854775807ULL);
     BOOST_CHECK(ParseUInt64("9223372036854775808", &n) &&
                 n == 9223372036854775808ULL);
     BOOST_CHECK(ParseUInt64("18446744073709551615", &n) &&
                 n == 18446744073709551615ULL);
     // Invalid values
     BOOST_CHECK(!ParseUInt64("", &n));
     BOOST_CHECK(!ParseUInt64(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseUInt64(" -1", &n));
     BOOST_CHECK(!ParseUInt64("1 ", &n));
     BOOST_CHECK(!ParseUInt64("1a", &n));
     BOOST_CHECK(!ParseUInt64("aap", &n));
     BOOST_CHECK(!ParseUInt64("0x1", &n)); // no hex
     const char test_bytes[] = {'1', 0, '1'};
     std::string teststr(test_bytes, sizeof(test_bytes));
     BOOST_CHECK(!ParseUInt64(teststr, &n)); // no embedded NULs
     // Overflow and underflow
     BOOST_CHECK(!ParseUInt64("-9223372036854775809", nullptr));
     BOOST_CHECK(!ParseUInt64("18446744073709551616", nullptr));
     BOOST_CHECK(!ParseUInt64("-32482348723847471234", nullptr));
     BOOST_CHECK(!ParseUInt64("-2147483648", &n));
     BOOST_CHECK(!ParseUInt64("-9223372036854775808", &n));
     BOOST_CHECK(!ParseUInt64("-1234", &n));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseDouble) {
     double n;
     // Valid values
     BOOST_CHECK(ParseDouble("1234", nullptr));
     BOOST_CHECK(ParseDouble("0", &n) && n == 0.0);
     BOOST_CHECK(ParseDouble("1234", &n) && n == 1234.0);
     BOOST_CHECK(ParseDouble("01234", &n) && n == 1234.0); // no octal
     BOOST_CHECK(ParseDouble("2147483647", &n) && n == 2147483647.0);
     BOOST_CHECK(ParseDouble("-2147483648", &n) && n == -2147483648.0);
     BOOST_CHECK(ParseDouble("-1234", &n) && n == -1234.0);
     BOOST_CHECK(ParseDouble("1e6", &n) && n == 1e6);
     BOOST_CHECK(ParseDouble("-1e6", &n) && n == -1e6);
     // Invalid values
     BOOST_CHECK(!ParseDouble("", &n));
     BOOST_CHECK(!ParseDouble(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseDouble("1 ", &n));
     BOOST_CHECK(!ParseDouble("1a", &n));
     BOOST_CHECK(!ParseDouble("aap", &n));
     BOOST_CHECK(!ParseDouble("0x1", &n)); // no hex
     const char test_bytes[] = {'1', 0, '1'};
     std::string teststr(test_bytes, sizeof(test_bytes));
     BOOST_CHECK(!ParseDouble(teststr, &n)); // no embedded NULs
     // Overflow and underflow
     BOOST_CHECK(!ParseDouble("-1e10000", nullptr));
     BOOST_CHECK(!ParseDouble("1e10000", nullptr));
 }
 
 BOOST_AUTO_TEST_CASE(test_FormatParagraph) {
     BOOST_CHECK_EQUAL(FormatParagraph("", 79, 0), "");
     BOOST_CHECK_EQUAL(FormatParagraph("test", 79, 0), "test");
     BOOST_CHECK_EQUAL(FormatParagraph(" test", 79, 0), " test");
     BOOST_CHECK_EQUAL(FormatParagraph("test test", 79, 0), "test test");
     BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 0), "test\ntest");
     BOOST_CHECK_EQUAL(FormatParagraph("testerde test", 4, 0), "testerde\ntest");
     BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 4), "test\n    test");
 
     // Make sure we don't indent a fully-new line following a too-long line
     // ending
     BOOST_CHECK_EQUAL(FormatParagraph("test test\nabc", 4, 4),
                       "test\n    test\nabc");
 
     BOOST_CHECK_EQUAL(
         FormatParagraph("This_is_a_very_long_test_string_without_any_spaces_so_"
                         "it_should_just_get_returned_as_is_despite_the_length "
                         "until it gets here",
                         79),
         "This_is_a_very_long_test_string_without_any_spaces_so_it_should_just_"
         "get_returned_as_is_despite_the_length\nuntil it gets here");
 
     // Test wrap length is exact
     BOOST_CHECK_EQUAL(
         FormatParagraph("a b c d e f g h i j k l m n o p q r s t u v w x y z 1 "
                         "2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p",
                         79),
         "a b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 "
         "a b c de\nf g h i j k l m n o p");
     BOOST_CHECK_EQUAL(
         FormatParagraph("x\na b c d e f g h i j k l m n o p q r s t u v w x y "
                         "z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p",
                         79),
         "x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 "
         "8 9 a b c de\nf g h i j k l m n o p");
     // Indent should be included in length of lines
     BOOST_CHECK_EQUAL(
         FormatParagraph("x\na b c d e f g h i j k l m n o p q r s t u v w x y "
                         "z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p q "
                         "r s t u v w x y z 0 1 2 3 4 5 6 7 8 9 a b c d e fg h "
                         "i j k",
                         79, 4),
         "x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 "
         "8 9 a b c de\n    f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 "
         "5 6 7 8 9 a b c d e fg\n    h i j k");
 
     BOOST_CHECK_EQUAL(
         FormatParagraph("This is a very long test string. This is a second "
                         "sentence in the very long test string.",
                         79),
         "This is a very long test string. This is a second sentence in the "
         "very long\ntest string.");
     BOOST_CHECK_EQUAL(
         FormatParagraph("This is a very long test string.\nThis is a second "
                         "sentence in the very long test string. This is a "
                         "third sentence in the very long test string.",
                         79),
         "This is a very long test string.\nThis is a second sentence in the "
         "very long test string. This is a third\nsentence in the very long "
         "test string.");
     BOOST_CHECK_EQUAL(
         FormatParagraph("This is a very long test string.\n\nThis is a second "
                         "sentence in the very long test string. This is a "
                         "third sentence in the very long test string.",
                         79),
         "This is a very long test string.\n\nThis is a second sentence in the "
         "very long test string. This is a third\nsentence in the very long "
         "test string.");
     BOOST_CHECK_EQUAL(
         FormatParagraph(
             "Testing that normal newlines do not get indented.\nLike here.",
             79),
         "Testing that normal newlines do not get indented.\nLike here.");
 }
 
 BOOST_AUTO_TEST_CASE(test_FormatSubVersion) {
     std::vector<std::string> comments;
     comments.push_back(std::string("comment1"));
     std::vector<std::string> comments2;
     comments2.push_back(std::string("comment1"));
     // Semicolon is discouraged but not forbidden by BIP-0014
     comments2.push_back(SanitizeString(
         std::string("Comment2; .,_?@-; !\"#$%&'()*+/<=>[]\\^`{|}~"),
         SAFE_CHARS_UA_COMMENT));
     BOOST_CHECK_EQUAL(
         FormatSubVersion("Test", 99900, std::vector<std::string>()),
         std::string("/Test:0.9.99/"));
     BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, comments),
                       std::string("/Test:0.9.99(comment1)/"));
     BOOST_CHECK_EQUAL(
         FormatSubVersion("Test", 99900, comments2),
         std::string("/Test:0.9.99(comment1; Comment2; .,_?@-; )/"));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseFixedPoint) {
     int64_t amount = 0;
     BOOST_CHECK(ParseFixedPoint("0", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 0LL);
     BOOST_CHECK(ParseFixedPoint("1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 100000000LL);
     BOOST_CHECK(ParseFixedPoint("0.0", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 0LL);
     BOOST_CHECK(ParseFixedPoint("-0.1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, -10000000LL);
     BOOST_CHECK(ParseFixedPoint("1.1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 110000000LL);
     BOOST_CHECK(ParseFixedPoint("1.10000000000000000", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 110000000LL);
     BOOST_CHECK(ParseFixedPoint("1.1e1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 1100000000LL);
     BOOST_CHECK(ParseFixedPoint("1.1e-1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 11000000LL);
     BOOST_CHECK(ParseFixedPoint("1000", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 100000000000LL);
     BOOST_CHECK(ParseFixedPoint("-1000", 8, &amount));
     BOOST_CHECK_EQUAL(amount, -100000000000LL);
     BOOST_CHECK(ParseFixedPoint("0.00000001", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 1LL);
     BOOST_CHECK(ParseFixedPoint("0.0000000100000000", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 1LL);
     BOOST_CHECK(ParseFixedPoint("-0.00000001", 8, &amount));
     BOOST_CHECK_EQUAL(amount, -1LL);
     BOOST_CHECK(ParseFixedPoint("1000000000.00000001", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 100000000000000001LL);
     BOOST_CHECK(ParseFixedPoint("9999999999.99999999", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 999999999999999999LL);
     BOOST_CHECK(ParseFixedPoint("-9999999999.99999999", 8, &amount));
     BOOST_CHECK_EQUAL(amount, -999999999999999999LL);
 
     BOOST_CHECK(!ParseFixedPoint("", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("a-1000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-a1000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-1000a", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-01000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("00.1", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint(".1", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("--0.1", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("0.000000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-0.000000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("0.00000001000000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-10000000000.00000000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("10000000000.00000000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-10000000000.00000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("10000000000.00000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-10000000000.00000009", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("10000000000.00000009", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-99999999999.99999999", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("99999909999.09999999", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("92233720368.54775807", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("92233720368.54775808", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-92233720368.54775808", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-92233720368.54775809", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("1.1e", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("1.1e-", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("1.", 8, &amount));
 }
 
 static void TestOtherThread(fs::path dirname, std::string lockname,
                             bool *result) {
     *result = LockDirectory(dirname, lockname);
 }
 
 #ifndef WIN32 // Cannot do this test on WIN32 due to lack of fork()
 static constexpr char LockCommand = 'L';
 static constexpr char UnlockCommand = 'U';
 static constexpr char ExitCommand = 'X';
 
 static void TestOtherProcess(fs::path dirname, std::string lockname, int fd) {
     char ch;
     while (true) {
         // Wait for command
         int rv = read(fd, &ch, 1);
         assert(rv == 1);
         switch (ch) {
             case LockCommand:
                 ch = LockDirectory(dirname, lockname);
                 rv = write(fd, &ch, 1);
                 assert(rv == 1);
                 break;
             case UnlockCommand:
                 ReleaseDirectoryLocks();
                 ch = true; // Always succeeds
                 rv = write(fd, &ch, 1);
                 assert(rv == 1);
                 break;
             case ExitCommand:
                 close(fd);
                 // As an alternative to exit() which runs the exit handlers
                 // (which seem to be flakey with Boost test suite with JUNIT
                 // logging in a forked process), just vanish this process as
                 // fast as possible. `quick_exit()` would also work, but it is
                 // not available on all non glibc platforms.
                 // Using exec also stops valgrind from thinking it needs to
                 // analyze the memory leaks in this forked process.
                 execlp("true", "true", (char *)NULL);
             default:
                 assert(0);
         }
     }
 }
 #endif
 
 BOOST_AUTO_TEST_CASE(test_LockDirectory) {
     fs::path dirname = GetDataDir() / "lock_dir";
     const std::string lockname = ".lock";
 #ifndef WIN32
     // Revert SIGCHLD to default, otherwise boost.test will catch and fail on
     // it: there is BOOST_TEST_IGNORE_SIGCHLD but that only works when defined
     // at build-time of the boost library
     void (*old_handler)(int) = signal(SIGCHLD, SIG_DFL);
 
     // Fork another process for testing before creating the lock, so that we
     // won't fork while holding the lock (which might be undefined, and is not
     // relevant as test case as that is avoided with -daemonize).
     int fd[2];
     BOOST_CHECK_EQUAL(socketpair(AF_UNIX, SOCK_STREAM, 0, fd), 0);
     pid_t pid = fork();
     if (!pid) {
         BOOST_CHECK_EQUAL(close(fd[1]), 0); // Child: close parent end
         TestOtherProcess(dirname, lockname, fd[0]);
     }
     BOOST_CHECK_EQUAL(close(fd[0]), 0); // Parent: close child end
 #endif
     // Lock on non-existent directory should fail
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), false);
 
     fs::create_directories(dirname);
 
     // Probing lock on new directory should succeed
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
 
     // Persistent lock on new directory should succeed
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), true);
 
     // Another lock on the directory from the same thread should succeed
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), true);
 
     // Another lock on the directory from a different thread within the same
     // process should succeed
     bool threadresult;
     std::thread thr(TestOtherThread, dirname, lockname, &threadresult);
     thr.join();
     BOOST_CHECK_EQUAL(threadresult, true);
 #ifndef WIN32
     // Try to acquire lock in child process while we're holding it, this should
     // fail.
     char ch;
     BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
     BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
     BOOST_CHECK_EQUAL((bool)ch, false);
 
     // Give up our lock
     ReleaseDirectoryLocks();
     // Probing lock from our side now should succeed, but not hold on to the
     // lock.
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
 
     // Try to acquire the lock in the child process, this should be successful.
     BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
     BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
     BOOST_CHECK_EQUAL((bool)ch, true);
 
     // When we try to probe the lock now, it should fail.
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), false);
 
     // Unlock the lock in the child process
     BOOST_CHECK_EQUAL(write(fd[1], &UnlockCommand, 1), 1);
     BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
     BOOST_CHECK_EQUAL((bool)ch, true);
 
     // When we try to probe the lock now, it should succeed.
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
 
     // Re-lock the lock in the child process, then wait for it to exit, check
     // successful return. After that, we check that exiting the process
     // has released the lock as we would expect by probing it.
     int processstatus;
     BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
     BOOST_CHECK_EQUAL(write(fd[1], &ExitCommand, 1), 1);
     BOOST_CHECK_EQUAL(waitpid(pid, &processstatus, 0), pid);
     BOOST_CHECK_EQUAL(processstatus, 0);
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
 
     // Restore SIGCHLD
     signal(SIGCHLD, old_handler);
     BOOST_CHECK_EQUAL(close(fd[1]), 0); // Close our side of the socketpair
 #endif
     // Clean up
     ReleaseDirectoryLocks();
     fs::remove_all(dirname);
 }
 
 BOOST_AUTO_TEST_CASE(test_DirIsWritable) {
     // Should be able to write to the data dir.
     fs::path tmpdirname = GetDataDir();
     BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), true);
 
     // Should not be able to write to a non-existent dir.
     tmpdirname = tmpdirname / fs::unique_path();
     BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), false);
 
     fs::create_directory(tmpdirname);
     // Should be able to write to it now.
     BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), true);
     fs::remove(tmpdirname);
 }
 
 template <int F, int T>
 static void CheckConvertBits(const std::vector<uint8_t> &in,
                              const std::vector<uint8_t> &expected) {
     std::vector<uint8_t> outpad;
     bool ret = ConvertBits<F, T, true>([&](uint8_t c) { outpad.push_back(c); },
                                        in.begin(), in.end());
     BOOST_CHECK(ret);
     BOOST_CHECK(outpad == expected);
 
     const bool dopad = (in.size() * F) % T;
     std::vector<uint8_t> outnopad;
     ret = ConvertBits<F, T, false>([&](uint8_t c) { outnopad.push_back(c); },
                                    in.begin(), in.end());
     BOOST_CHECK(ret != (dopad && !outpad.empty() && outpad.back()));
 
     if (dopad) {
         // We should have skipped the last digit.
         outnopad.push_back(expected.back());
     }
 
     BOOST_CHECK(outnopad == expected);
 
     // Check the other way around.
     // Check with padding. We may get an extra 0 in that case.
     std::vector<uint8_t> origpad;
     ret = ConvertBits<T, F, true>([&](uint8_t c) { origpad.push_back(c); },
                                   expected.begin(), expected.end());
     BOOST_CHECK(ret);
 
     std::vector<uint8_t> orignopad;
     ret = ConvertBits<T, F, false>([&](uint8_t c) { orignopad.push_back(c); },
                                    expected.begin(), expected.end());
     BOOST_CHECK(ret != ((expected.size() * T) % F && !origpad.empty() &&
                         origpad.back()));
     BOOST_CHECK(orignopad == in);
 
     if (dopad) {
         BOOST_CHECK_EQUAL(origpad.back(), 0);
         origpad.pop_back();
     }
 
     BOOST_CHECK(origpad == in);
 }
 
 BOOST_AUTO_TEST_CASE(test_ConvertBits) {
     CheckConvertBits<8, 5>({}, {});
     CheckConvertBits<8, 5>({0xff}, {0x1f, 0x1c});
     CheckConvertBits<8, 5>({0xff, 0xff}, {0x1f, 0x1f, 0x1f, 0x10});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff}, {0x1f, 0x1f, 0x1f, 0x1f, 0x1e});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff, 0xff},
                            {0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x18});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff, 0xff, 0xff},
                            {0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff, 0xff, 0xff},
                            {0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff, 0xff, 0xff},
                            {0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f});
     CheckConvertBits<8, 5>({0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
                            {0x00, 0x04, 0x11, 0x14, 0x0a, 0x19, 0x1c, 0x09,
                             0x15, 0x0f, 0x06, 0x1e, 0x1e});
     CheckConvertBits<8, 5>({0x00}, {0x00, 0x00});
     CheckConvertBits<8, 5>({0xf8}, {0x1f, 0x00});
     CheckConvertBits<8, 5>({0x00, 0x00}, {0x00, 0x00, 0x00, 0x00});
 }
 
 BOOST_AUTO_TEST_CASE(test_ToLower) {
     BOOST_CHECK_EQUAL(ToLower('@'), '@');
     BOOST_CHECK_EQUAL(ToLower('A'), 'a');
     BOOST_CHECK_EQUAL(ToLower('Z'), 'z');
     BOOST_CHECK_EQUAL(ToLower('['), '[');
     BOOST_CHECK_EQUAL(ToLower(0), 0);
     BOOST_CHECK_EQUAL(ToLower('\xff'), '\xff');
 
     BOOST_CHECK_EQUAL(ToLower(""), "");
     BOOST_CHECK_EQUAL(ToLower("#HODL"), "#hodl");
     BOOST_CHECK_EQUAL(ToLower("\x00\xfe\xff"), "\x00\xfe\xff");
 }
 
 BOOST_AUTO_TEST_CASE(test_ToUpper) {
     BOOST_CHECK_EQUAL(ToUpper('`'), '`');
     BOOST_CHECK_EQUAL(ToUpper('a'), 'A');
     BOOST_CHECK_EQUAL(ToUpper('z'), 'Z');
     BOOST_CHECK_EQUAL(ToUpper('{'), '{');
     BOOST_CHECK_EQUAL(ToUpper(0), 0);
     BOOST_CHECK_EQUAL(ToUpper('\xff'), '\xff');
 
     BOOST_CHECK_EQUAL(ToUpper(""), "");
     BOOST_CHECK_EQUAL(ToUpper("#hodl"), "#HODL");
     BOOST_CHECK_EQUAL(ToUpper("\x00\xfe\xff"), "\x00\xfe\xff");
 }
 
 BOOST_AUTO_TEST_CASE(test_Capitalize) {
     BOOST_CHECK_EQUAL(Capitalize(""), "");
     BOOST_CHECK_EQUAL(Capitalize("bitcoin"), "Bitcoin");
     BOOST_CHECK_EQUAL(Capitalize("\x00\xfe\xff"), "\x00\xfe\xff");
 }
 
 static std::string SpanToStr(Span<const char> &span) {
     return std::string(span.begin(), span.end());
 }
 
 BOOST_AUTO_TEST_CASE(test_spanparsing) {
     using namespace spanparsing;
     std::string input;
     Span<const char> sp;
     bool success;
 
     // Const(...): parse a constant, update span to skip it if successful
     input = "MilkToastHoney";
     sp = MakeSpan(input);
     success = Const("", sp); // empty
     BOOST_CHECK(success);
     BOOST_CHECK_EQUAL(SpanToStr(sp), "MilkToastHoney");
 
     success = Const("Milk", sp);
     BOOST_CHECK(success);
     BOOST_CHECK_EQUAL(SpanToStr(sp), "ToastHoney");
 
     success = Const("Bread", sp);
     BOOST_CHECK(!success);
 
     success = Const("Toast", sp);
     BOOST_CHECK(success);
     BOOST_CHECK_EQUAL(SpanToStr(sp), "Honey");
 
     success = Const("Honeybadger", sp);
     BOOST_CHECK(!success);
 
     success = Const("Honey", sp);
     BOOST_CHECK(success);
     BOOST_CHECK_EQUAL(SpanToStr(sp), "");
 
     // Func(...): parse a function call, update span to argument if successful
     input = "Foo(Bar(xy,z()))";
     sp = MakeSpan(input);
 
     success = Func("FooBar", sp);
     BOOST_CHECK(!success);
 
     success = Func("Foo(", sp);
     BOOST_CHECK(!success);
 
     success = Func("Foo", sp);
     BOOST_CHECK(success);
     BOOST_CHECK_EQUAL(SpanToStr(sp), "Bar(xy,z())");
 
     success = Func("Bar", sp);
     BOOST_CHECK(success);
     BOOST_CHECK_EQUAL(SpanToStr(sp), "xy,z()");
 
     success = Func("xy", sp);
     BOOST_CHECK(!success);
 
     // Expr(...): return expression that span begins with, update span to skip
     // it
     Span<const char> result;
 
     input = "(n*(n-1))/2";
     sp = MakeSpan(input);
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "(n*(n-1))/2");
     BOOST_CHECK_EQUAL(SpanToStr(sp), "");
 
     input = "foo,bar";
     sp = MakeSpan(input);
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "foo");
     BOOST_CHECK_EQUAL(SpanToStr(sp), ",bar");
 
     input = "(aaaaa,bbbbb()),c";
     sp = MakeSpan(input);
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "(aaaaa,bbbbb())");
     BOOST_CHECK_EQUAL(SpanToStr(sp), ",c");
 
     input = "xyz)foo";
     sp = MakeSpan(input);
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "xyz");
     BOOST_CHECK_EQUAL(SpanToStr(sp), ")foo");
 
     input = "((a),(b),(c)),xxx";
     sp = MakeSpan(input);
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "((a),(b),(c))");
     BOOST_CHECK_EQUAL(SpanToStr(sp), ",xxx");
 
     // Split(...): split a string on every instance of sep, return vector
     std::vector<Span<const char>> results;
 
     input = "xxx";
     results = Split(MakeSpan(input), 'x');
     BOOST_CHECK_EQUAL(results.size(), 4);
     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "");
     BOOST_CHECK_EQUAL(SpanToStr(results[1]), "");
     BOOST_CHECK_EQUAL(SpanToStr(results[2]), "");
     BOOST_CHECK_EQUAL(SpanToStr(results[3]), "");
 
     input = "one#two#three";
     results = Split(MakeSpan(input), '-');
     BOOST_CHECK_EQUAL(results.size(), 1);
     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "one#two#three");
 
     input = "one#two#three";
     results = Split(MakeSpan(input), '#');
     BOOST_CHECK_EQUAL(results.size(), 3);
     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "one");
     BOOST_CHECK_EQUAL(SpanToStr(results[1]), "two");
     BOOST_CHECK_EQUAL(SpanToStr(results[2]), "three");
 
     input = "*foo*bar*";
     results = Split(MakeSpan(input), '*');
     BOOST_CHECK_EQUAL(results.size(), 4);
     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "");
     BOOST_CHECK_EQUAL(SpanToStr(results[1]), "foo");
     BOOST_CHECK_EQUAL(SpanToStr(results[2]), "bar");
     BOOST_CHECK_EQUAL(SpanToStr(results[3]), "");
 }
 
 BOOST_AUTO_TEST_CASE(test_LogEscapeMessage) {
     // ASCII and UTF-8 must pass through unaltered.
     BOOST_CHECK_EQUAL(BCLog::LogEscapeMessage("Valid log message貓"),
                       "Valid log message貓");
     // Newlines must pass through unaltered.
     BOOST_CHECK_EQUAL(BCLog::LogEscapeMessage("Message\n with newlines\n"),
                       "Message\n with newlines\n");
     // Other control characters are escaped in C syntax.
     BOOST_CHECK_EQUAL(
         BCLog::LogEscapeMessage("\x01\x7f Corrupted log message\x0d"),
         R"(\x01\x7f Corrupted log message\x0d)");
     // Embedded NULL characters are escaped too.
     const std::string NUL("O\x00O", 3);
     BOOST_CHECK_EQUAL(BCLog::LogEscapeMessage(NUL), R"(O\x00O)");
 }
 
 namespace {
 
 struct Tracker {
     //! Points to the original object (possibly itself) we moved/copied from
     const Tracker *origin;
     //! How many copies where involved between the original object and this one
     //! (moves are not counted)
     int copies;
 
     Tracker() noexcept : origin(this), copies(0) {}
     Tracker(const Tracker &t) noexcept
         : origin(t.origin), copies(t.copies + 1) {}
     Tracker(Tracker &&t) noexcept : origin(t.origin), copies(t.copies) {}
     Tracker &operator=(const Tracker &t) noexcept {
         origin = t.origin;
         copies = t.copies + 1;
         return *this;
     }
     Tracker &operator=(Tracker &&t) noexcept {
         origin = t.origin;
         copies = t.copies;
         return *this;
     }
 };
 
 } // namespace
 
 BOOST_AUTO_TEST_CASE(test_tracked_vector) {
     Tracker t1;
     Tracker t2;
     Tracker t3;
 
     BOOST_CHECK(t1.origin == &t1);
     BOOST_CHECK(t2.origin == &t2);
     BOOST_CHECK(t3.origin == &t3);
 
     auto v1 = Vector(t1);
     BOOST_CHECK_EQUAL(v1.size(), 1);
     BOOST_CHECK(v1[0].origin == &t1);
     BOOST_CHECK_EQUAL(v1[0].copies, 1);
 
     auto v2 = Vector(std::move(t2));
     BOOST_CHECK_EQUAL(v2.size(), 1);
     BOOST_CHECK(v2[0].origin == &t2);
     BOOST_CHECK_EQUAL(v2[0].copies, 0);
 
     auto v3 = Vector(t1, std::move(t2));
     BOOST_CHECK_EQUAL(v3.size(), 2);
     BOOST_CHECK(v3[0].origin == &t1);
     BOOST_CHECK(v3[1].origin == &t2);
     BOOST_CHECK_EQUAL(v3[0].copies, 1);
     BOOST_CHECK_EQUAL(v3[1].copies, 0);
 
     auto v4 = Vector(std::move(v3[0]), v3[1], std::move(t3));
     BOOST_CHECK_EQUAL(v4.size(), 3);
     BOOST_CHECK(v4[0].origin == &t1);
     BOOST_CHECK(v4[1].origin == &t2);
     BOOST_CHECK(v4[2].origin == &t3);
     BOOST_CHECK_EQUAL(v4[0].copies, 1);
     BOOST_CHECK_EQUAL(v4[1].copies, 1);
     BOOST_CHECK_EQUAL(v4[2].copies, 0);
 
     auto v5 = Cat(v1, v4);
     BOOST_CHECK_EQUAL(v5.size(), 4);
     BOOST_CHECK(v5[0].origin == &t1);
     BOOST_CHECK(v5[1].origin == &t1);
     BOOST_CHECK(v5[2].origin == &t2);
     BOOST_CHECK(v5[3].origin == &t3);
     BOOST_CHECK_EQUAL(v5[0].copies, 2);
     BOOST_CHECK_EQUAL(v5[1].copies, 2);
     BOOST_CHECK_EQUAL(v5[2].copies, 2);
     BOOST_CHECK_EQUAL(v5[3].copies, 1);
 
     auto v6 = Cat(std::move(v1), v3);
     BOOST_CHECK_EQUAL(v6.size(), 3);
     BOOST_CHECK(v6[0].origin == &t1);
     BOOST_CHECK(v6[1].origin == &t1);
     BOOST_CHECK(v6[2].origin == &t2);
     BOOST_CHECK_EQUAL(v6[0].copies, 1);
     BOOST_CHECK_EQUAL(v6[1].copies, 2);
     BOOST_CHECK_EQUAL(v6[2].copies, 1);
 
     auto v7 = Cat(v2, std::move(v4));
     BOOST_CHECK_EQUAL(v7.size(), 4);
     BOOST_CHECK(v7[0].origin == &t2);
     BOOST_CHECK(v7[1].origin == &t1);
     BOOST_CHECK(v7[2].origin == &t2);
     BOOST_CHECK(v7[3].origin == &t3);
     BOOST_CHECK_EQUAL(v7[0].copies, 1);
     BOOST_CHECK_EQUAL(v7[1].copies, 1);
     BOOST_CHECK_EQUAL(v7[2].copies, 1);
     BOOST_CHECK_EQUAL(v7[3].copies, 0);
 
     auto v8 = Cat(std::move(v2), std::move(v3));
     BOOST_CHECK_EQUAL(v8.size(), 3);
     BOOST_CHECK(v8[0].origin == &t2);
     BOOST_CHECK(v8[1].origin == &t1);
     BOOST_CHECK(v8[2].origin == &t2);
     BOOST_CHECK_EQUAL(v8[0].copies, 0);
     BOOST_CHECK_EQUAL(v8[1].copies, 1);
     BOOST_CHECK_EQUAL(v8[2].copies, 0);
 }
 
 BOOST_AUTO_TEST_CASE(message_sign) {
     const std::array<uint8_t, 32> privkey_bytes = {
         {// just some random data
          // derived address from this private key:
          // 15CRxFdyRpGZLW9w8HnHvVduizdL5jKNbs
          0xD9, 0x7F, 0x51, 0x08, 0xF1, 0x1C, 0xDA, 0x6E, 0xEE, 0xBA, 0xAA,
          0x42, 0x0F, 0xEF, 0x07, 0x26, 0xB1, 0xF8, 0x98, 0x06, 0x0B, 0x98,
          0x48, 0x9F, 0xA3, 0x09, 0x84, 0x63, 0xC0, 0x03, 0x28, 0x66}};
 
     const std::string message = "Trust no one";
 
     const std::string expected_signature =
         "IED/"
         "JtZs3huKX9JEQIBPZPSZwOiMyDQ+"
         "yNWQvL7YcFzCOGTcfleWOWSvfggenKCinqvOX8t1Iw+HYZqQjxzXQm0=";
 
     CKey privkey;
     std::string generated_signature;
 
     BOOST_REQUIRE_MESSAGE(!privkey.IsValid(),
                           "Confirm the private key is invalid");
 
     BOOST_CHECK_MESSAGE(!MessageSign(privkey, message, generated_signature),
                         "Sign with an invalid private key");
 
     privkey.Set(privkey_bytes.begin(), privkey_bytes.end(), true);
 
     BOOST_REQUIRE_MESSAGE(privkey.IsValid(),
                           "Confirm the private key is valid");
 
     BOOST_CHECK_MESSAGE(MessageSign(privkey, message, generated_signature),
                         "Sign with a valid private key");
 
     BOOST_CHECK_EQUAL(expected_signature, generated_signature);
 }
 
 BOOST_AUTO_TEST_CASE(message_verify) {
     const auto params = CreateChainParams(CBaseChainParams::MAIN);
     BOOST_CHECK_EQUAL(MessageVerify(*params, "invalid address",
                                     "signature should be irrelevant",
                                     "message too"),
                       MessageVerificationResult::ERR_INVALID_ADDRESS);
 
     BOOST_CHECK_EQUAL(
         MessageVerify(*params, "3B5fQsEXEaV8v6U3ejYc8XaKXAkyQj2MjV",
                       "signature should be irrelevant", "message too"),
         MessageVerificationResult::ERR_ADDRESS_NO_KEY);
 
     BOOST_CHECK_EQUAL(MessageVerify(*params,
                                     "1KqbBpLy5FARmTPD4VZnDDpYjkUvkr82Pm",
                                     "invalid signature, not in base64 encoding",
                                     "message should be irrelevant"),
                       MessageVerificationResult::ERR_MALFORMED_SIGNATURE);
 
     BOOST_CHECK_EQUAL(
         MessageVerify(*params, "1KqbBpLy5FARmTPD4VZnDDpYjkUvkr82Pm",
                       "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
                       "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
                       "message should be irrelevant"),
         MessageVerificationResult::ERR_PUBKEY_NOT_RECOVERED);
 
     BOOST_CHECK_EQUAL(
         MessageVerify(*params, "15CRxFdyRpGZLW9w8HnHvVduizdL5jKNbs",
                       "IPojfrX2dfPnH26UegfbGQQLrdK844DlHq5157/P6h57WyuS/Qsl+h/"
                       "WSVGDF4MUi4rWSswW38oimDYfNNUBUOk=",
                       "I never signed this"),
         MessageVerificationResult::ERR_NOT_SIGNED);
 
     BOOST_CHECK_EQUAL(
         MessageVerify(*params, "15CRxFdyRpGZLW9w8HnHvVduizdL5jKNbs",
                       "IPojfrX2dfPnH26UegfbGQQLrdK844DlHq5157/P6h57WyuS/Qsl+h/"
                       "WSVGDF4MUi4rWSswW38oimDYfNNUBUOk=",
                       "Trust no one"),
         MessageVerificationResult::OK);
 
     BOOST_CHECK_EQUAL(
         MessageVerify(*params, "11canuhp9X2NocwCq7xNrQYTmUgZAnLK3",
                       "IIcaIENoYW5jZWxsb3Igb24gYnJpbmsgb2Ygc2Vjb25kIGJhaWxvdXQg"
                       "Zm9yIGJhbmtzIAaHRtbCeDZINyavx14=",
                       "Trust me"),
         MessageVerificationResult::OK);
 }
 
 BOOST_AUTO_TEST_CASE(message_hash) {
     const std::string unsigned_tx = "...";
     const std::string prefixed_message =
         std::string(1, (char)MESSAGE_MAGIC.length()) + MESSAGE_MAGIC +
         std::string(1, (char)unsigned_tx.length()) + unsigned_tx;
 
     const uint256 signature_hash = Hash(unsigned_tx.begin(), unsigned_tx.end());
     const uint256 message_hash1 =
         Hash(prefixed_message.begin(), prefixed_message.end());
     const uint256 message_hash2 = MessageHash(unsigned_tx);
 
     BOOST_CHECK_EQUAL(message_hash1, message_hash2);
     BOOST_CHECK_NE(message_hash1, signature_hash);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/util_threadnames_tests.cpp b/src/test/util_threadnames_tests.cpp
index e652f712d..455bebb86 100644
--- a/src/test/util_threadnames_tests.cpp
+++ b/src/test/util_threadnames_tests.cpp
@@ -1,69 +1,70 @@
 // 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 <util/string.h>
 #include <util/threadnames.h>
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <mutex>
 #include <set>
 #include <thread>
 #include <vector>
 
 BOOST_FIXTURE_TEST_SUITE(util_threadnames_tests, BasicTestingSetup)
 
 const std::string TEST_THREAD_NAME_BASE = "test_thread.";
 
 /**
  * Run a bunch of threads to all call util::ThreadRename.
  *
  * @return the set of name each thread has after attempted renaming.
  */
 std::set<std::string> RenameEnMasse(int num_threads) {
     std::vector<std::thread> threads;
     std::set<std::string> names;
     std::mutex lock;
 
     auto RenameThisThread = [&](int i) {
-        util::ThreadRename(TEST_THREAD_NAME_BASE + std::to_string(i));
+        util::ThreadRename(TEST_THREAD_NAME_BASE + ToString(i));
         std::lock_guard<std::mutex> guard(lock);
         names.insert(util::ThreadGetInternalName());
     };
 
     for (int i = 0; i < num_threads; ++i) {
         threads.push_back(std::thread(RenameThisThread, i));
     }
 
     for (std::thread &thread : threads) {
         thread.join();
     }
 
     return names;
 }
 
 /**
  * Rename a bunch of threads with the same basename (expect_multiple=true),
  * ensuring suffixes are applied properly.
  */
 BOOST_AUTO_TEST_CASE(util_threadnames_test_rename_threaded) {
     BOOST_CHECK_EQUAL(util::ThreadGetInternalName(), "");
 
     std::set<std::string> names = RenameEnMasse(100);
 
     BOOST_CHECK_EQUAL(names.size(), 100);
 
     // Names "test_thread.[n]" should exist for n = [0, 99]
     for (int i = 0; i < 100; ++i) {
-        BOOST_CHECK(names.find(TEST_THREAD_NAME_BASE + std::to_string(i)) !=
+        BOOST_CHECK(names.find(TEST_THREAD_NAME_BASE + ToString(i)) !=
                     names.end());
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/util/string.h b/src/util/string.h
index 09e8f45e5..835222703 100644
--- a/src/util/string.h
+++ b/src/util/string.h
@@ -1,62 +1,74 @@
 // Copyright (c) 2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_UTIL_STRING_H
 #define BITCOIN_UTIL_STRING_H
 
 #include <attributes.h>
 
 #include <cstring>
+#include <locale>
+#include <sstream>
 #include <string>
 #include <vector>
 
 NODISCARD inline std::string
 TrimString(const std::string &str, const std::string &pattern = " \f\n\r\t\v") {
     std::string::size_type front = str.find_first_not_of(pattern);
     if (front == std::string::npos) {
         return std::string();
     }
     std::string::size_type end = str.find_last_not_of(pattern);
     return str.substr(front, end - front + 1);
 }
 
 /**
  * Join a list of items
  *
  * @param list       The list to join
  * @param separator  The separator
  * @param unary_op   Apply this operator to each item in the list
  */
 template <typename T, typename BaseType, typename UnaryOp>
 auto Join(const std::vector<T> &list, const BaseType &separator,
           UnaryOp unary_op) -> decltype(unary_op(list.at(0))) {
     decltype(unary_op(list.at(0))) ret;
     for (size_t i = 0; i < list.size(); ++i) {
         if (i > 0) {
             ret += separator;
         }
         ret += unary_op(list.at(i));
     }
     return ret;
 }
 
 template <typename T> T Join(const std::vector<T> &list, const T &separator) {
     return Join(list, separator, [](const T &i) { return i; });
 }
 
 // Explicit overload needed for c_str arguments, which would otherwise cause a
 // substitution failure in the template above.
 inline std::string Join(const std::vector<std::string> &list,
                         const std::string &separator) {
     return Join<std::string>(list, separator);
 }
 
 /**
  * Check if a string does not contain any embedded NUL (\0) characters
  */
 NODISCARD inline bool ValidAsCString(const std::string &str) noexcept {
     return str.size() == strlen(str.c_str());
 }
 
+/**
+ * Locale-independent version of std::to_string
+ */
+template <typename T> std::string ToString(const T &t) {
+    std::ostringstream oss;
+    oss.imbue(std::locale::classic());
+    oss << t;
+    return oss.str();
+}
+
 #endif // BITCOIN_UTIL_STRING_H
diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
index 15acb3009..48a12821d 100644
--- a/src/wallet/scriptpubkeyman.cpp
+++ b/src/wallet/scriptpubkeyman.cpp
@@ -1,2258 +1,2257 @@
 // 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.
 
 #include <chainparams.h>
 #include <config.h>
 #include <key_io.h>
 #include <outputtype.h>
 #include <script/descriptor.h>
 #include <script/sign.h>
 #include <util/bip32.h>
 #include <util/strencodings.h>
+#include <util/string.h>
 #include <util/translation.h>
 #include <wallet/scriptpubkeyman.h>
 
 bool LegacyScriptPubKeyMan::GetNewDestination(const OutputType type,
                                               CTxDestination &dest,
                                               std::string &error) {
     LOCK(cs_KeyStore);
     error.clear();
 
     // Generate a new key that is added to wallet
     CPubKey new_key;
     if (!GetKeyFromPool(new_key, type)) {
         error = _("Error: Keypool ran out, please call keypoolrefill first")
                     .translated;
         return false;
     }
     LearnRelatedScripts(new_key, type);
     dest = GetDestinationForKey(new_key, type);
     return true;
 }
 
 typedef std::vector<uint8_t> valtype;
 
 namespace {
 
 /**
  * This is an enum that tracks the execution context of a script, similar to
  * SigVersion in script/interpreter. It is separate however because we want to
  * distinguish between top-level scriptPubKey execution and P2SH redeemScript
  * execution (a distinction that has no impact on consensus rules).
  */
 enum class IsMineSigVersion {
     TOP = 0,  //! scriptPubKey execution
     P2SH = 1, //! P2SH redeemScript
 };
 
 /**
  * This is an internal representation of isminetype + invalidity.
  * Its order is significant, as we return the max of all explored
  * possibilities.
  */
 enum class IsMineResult {
     NO = 0,         //! Not ours
     WATCH_ONLY = 1, //! Included in watch-only balance
     SPENDABLE = 2,  //! Included in all balances
     INVALID = 3,    //! Not spendable by anyone (P2SH inside P2SH)
 };
 
 bool HaveKeys(const std::vector<valtype> &pubkeys,
               const LegacyScriptPubKeyMan &keystore) {
     for (const valtype &pubkey : pubkeys) {
         CKeyID keyID = CPubKey(pubkey).GetID();
         if (!keystore.HaveKey(keyID)) {
             return false;
         }
     }
     return true;
 }
 
 IsMineResult IsMineInner(const LegacyScriptPubKeyMan &keystore,
                          const CScript &scriptPubKey,
                          IsMineSigVersion sigversion) {
     IsMineResult ret = IsMineResult::NO;
 
     std::vector<valtype> vSolutions;
     txnouttype whichType = Solver(scriptPubKey, vSolutions);
 
     CKeyID keyID;
     switch (whichType) {
         case TX_NONSTANDARD:
         case TX_NULL_DATA:
             break;
         case TX_PUBKEY:
             keyID = CPubKey(vSolutions[0]).GetID();
             if (keystore.HaveKey(keyID)) {
                 ret = std::max(ret, IsMineResult::SPENDABLE);
             }
             break;
         case TX_PUBKEYHASH:
             keyID = CKeyID(uint160(vSolutions[0]));
             if (keystore.HaveKey(keyID)) {
                 ret = std::max(ret, IsMineResult::SPENDABLE);
             }
             break;
         case TX_SCRIPTHASH: {
             if (sigversion != IsMineSigVersion::TOP) {
                 // P2SH inside P2SH is invalid.
                 return IsMineResult::INVALID;
             }
             CScriptID scriptID = CScriptID(uint160(vSolutions[0]));
             CScript subscript;
             if (keystore.GetCScript(scriptID, subscript)) {
                 ret = std::max(ret, IsMineInner(keystore, subscript,
                                                 IsMineSigVersion::P2SH));
             }
             break;
         }
         case TX_MULTISIG: {
             // Never treat bare multisig outputs as ours (they can still be made
             // watchonly-though)
             if (sigversion == IsMineSigVersion::TOP) {
                 break;
             }
 
             // Only consider transactions "mine" if we own ALL the keys
             // involved. Multi-signature transactions that are partially owned
             // (somebody else has a key that can spend them) enable
             // spend-out-from-under-you attacks, especially in shared-wallet
             // situations.
             std::vector<valtype> keys(vSolutions.begin() + 1,
                                       vSolutions.begin() + vSolutions.size() -
                                           1);
             if (HaveKeys(keys, keystore)) {
                 ret = std::max(ret, IsMineResult::SPENDABLE);
             }
             break;
         }
     }
 
     if (ret == IsMineResult::NO && keystore.HaveWatchOnly(scriptPubKey)) {
         ret = std::max(ret, IsMineResult::WATCH_ONLY);
     }
     return ret;
 }
 
 } // namespace
 
 isminetype LegacyScriptPubKeyMan::IsMine(const CScript &script) const {
     switch (IsMineInner(*this, script, IsMineSigVersion::TOP)) {
         case IsMineResult::INVALID:
         case IsMineResult::NO:
             return ISMINE_NO;
         case IsMineResult::WATCH_ONLY:
             return ISMINE_WATCH_ONLY;
         case IsMineResult::SPENDABLE:
             return ISMINE_SPENDABLE;
     }
     assert(false);
 }
 
 bool LegacyScriptPubKeyMan::CheckDecryptionKey(
     const CKeyingMaterial &master_key, bool accept_no_keys) {
     {
         LOCK(cs_KeyStore);
         assert(mapKeys.empty());
 
         // Always pass when there are no encrypted keys
         bool keyPass = mapCryptedKeys.empty();
         bool keyFail = false;
         CryptedKeyMap::const_iterator mi = mapCryptedKeys.begin();
         for (; mi != mapCryptedKeys.end(); ++mi) {
             const CPubKey &vchPubKey = (*mi).second.first;
             const std::vector<uint8_t> &vchCryptedSecret = (*mi).second.second;
             CKey key;
             if (!DecryptKey(master_key, vchCryptedSecret, vchPubKey, key)) {
                 keyFail = true;
                 break;
             }
             keyPass = true;
             if (fDecryptionThoroughlyChecked) {
                 break;
             }
         }
         if (keyPass && keyFail) {
             LogPrintf("The wallet is probably corrupted: Some keys decrypt but "
                       "not all.\n");
             throw std::runtime_error(
                 "Error unlocking wallet: some keys decrypt but not all. Your "
                 "wallet file may be corrupt.");
         }
         if (keyFail || (!keyPass && !accept_no_keys)) {
             return false;
         }
         fDecryptionThoroughlyChecked = true;
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::Encrypt(const CKeyingMaterial &master_key,
                                     WalletBatch *batch) {
     LOCK(cs_KeyStore);
     encrypted_batch = batch;
     if (!mapCryptedKeys.empty()) {
         encrypted_batch = nullptr;
         return false;
     }
 
     KeyMap keys_to_encrypt;
     // Clear mapKeys so AddCryptedKeyInner will succeed.
     keys_to_encrypt.swap(mapKeys);
     for (const KeyMap::value_type &mKey : keys_to_encrypt) {
         const CKey &key = mKey.second;
         CPubKey vchPubKey = key.GetPubKey();
         CKeyingMaterial vchSecret(key.begin(), key.end());
         std::vector<uint8_t> vchCryptedSecret;
         if (!EncryptSecret(master_key, vchSecret, vchPubKey.GetHash(),
                            vchCryptedSecret)) {
             encrypted_batch = nullptr;
             return false;
         }
         if (!AddCryptedKey(vchPubKey, vchCryptedSecret)) {
             encrypted_batch = nullptr;
             return false;
         }
     }
     encrypted_batch = nullptr;
     return true;
 }
 
 bool LegacyScriptPubKeyMan::GetReservedDestination(const OutputType type,
                                                    bool internal,
                                                    CTxDestination &address,
                                                    int64_t &index,
                                                    CKeyPool &keypool) {
     LOCK(cs_KeyStore);
     if (!CanGetAddresses(internal)) {
         return false;
     }
 
     if (!ReserveKeyFromKeyPool(index, keypool, internal)) {
         return false;
     }
     address = GetDestinationForKey(keypool.vchPubKey, type);
     return true;
 }
 
 void LegacyScriptPubKeyMan::MarkUnusedAddresses(const CScript &script) {
     LOCK(cs_KeyStore);
     // extract addresses and check if they match with an unused keypool key
     for (const auto &keyid : GetAffectedKeys(script, *this)) {
         std::map<CKeyID, int64_t>::const_iterator mi =
             m_pool_key_to_index.find(keyid);
         if (mi != m_pool_key_to_index.end()) {
             WalletLogPrintf("%s: Detected a used keypool key, mark all keypool "
                             "key up to this key as used\n",
                             __func__);
             MarkReserveKeysAsUsed(mi->second);
 
             if (!TopUp()) {
                 WalletLogPrintf(
                     "%s: Topping up keypool failed (locked wallet)\n",
                     __func__);
             }
         }
     }
 }
 
 void LegacyScriptPubKeyMan::UpgradeKeyMetadata() {
     LOCK(cs_KeyStore);
     if (m_storage.IsLocked() ||
         m_storage.IsWalletFlagSet(WALLET_FLAG_KEY_ORIGIN_METADATA)) {
         return;
     }
 
     auto batch = std::make_unique<WalletBatch>(m_storage.GetDatabase());
     for (auto &meta_pair : mapKeyMetadata) {
         CKeyMetadata &meta = meta_pair.second;
         // If the hdKeypath is "s", that's the seed and it doesn't have a key
         // origin
         if (!meta.hd_seed_id.IsNull() && !meta.has_key_origin &&
             meta.hdKeypath != "s") {
             CKey key;
             GetKey(meta.hd_seed_id, key);
             CExtKey masterKey;
             masterKey.SetSeed(key.begin(), key.size());
             // Add to map
             CKeyID master_id = masterKey.key.GetPubKey().GetID();
             std::copy(master_id.begin(), master_id.begin() + 4,
                       meta.key_origin.fingerprint);
             if (!ParseHDKeypath(meta.hdKeypath, meta.key_origin.path)) {
                 throw std::runtime_error("Invalid stored hdKeypath");
             }
             meta.has_key_origin = true;
             if (meta.nVersion < CKeyMetadata::VERSION_WITH_KEY_ORIGIN) {
                 meta.nVersion = CKeyMetadata::VERSION_WITH_KEY_ORIGIN;
             }
 
             // Write meta to wallet
             CPubKey pubkey;
             if (GetPubKey(meta_pair.first, pubkey)) {
                 batch->WriteKeyMetadata(meta, pubkey, true);
             }
         }
     }
 }
 
 bool LegacyScriptPubKeyMan::SetupGeneration(bool force) {
     if ((CanGenerateKeys() && !force) || m_storage.IsLocked()) {
         return false;
     }
 
     SetHDSeed(GenerateNewSeed());
     if (!NewKeyPool()) {
         return false;
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::IsHDEnabled() const {
     return !hdChain.seed_id.IsNull();
 }
 
 bool LegacyScriptPubKeyMan::CanGetAddresses(bool internal) const {
     LOCK(cs_KeyStore);
     // Check if the keypool has keys
     bool keypool_has_keys;
     if (internal && m_storage.CanSupportFeature(FEATURE_HD_SPLIT)) {
         keypool_has_keys = setInternalKeyPool.size() > 0;
     } else {
         keypool_has_keys = KeypoolCountExternalKeys() > 0;
     }
     // If the keypool doesn't have keys, check if we can generate them
     if (!keypool_has_keys) {
         return CanGenerateKeys();
     }
     return keypool_has_keys;
 }
 
 bool LegacyScriptPubKeyMan::Upgrade(int prev_version, bilingual_str &error) {
     LOCK(cs_KeyStore);
     bool hd_upgrade = false;
     bool split_upgrade = false;
     if (m_storage.CanSupportFeature(FEATURE_HD) && !IsHDEnabled()) {
         WalletLogPrintf("Upgrading wallet to HD\n");
         m_storage.SetMinVersion(FEATURE_HD);
 
         // generate a new master key
         CPubKey masterPubKey = GenerateNewSeed();
         SetHDSeed(masterPubKey);
         hd_upgrade = true;
     }
     // Upgrade to HD chain split if necessary
     if (m_storage.CanSupportFeature(FEATURE_HD_SPLIT) &&
         CHDChain::VERSION_HD_CHAIN_SPLIT) {
         WalletLogPrintf("Upgrading wallet to use HD chain split\n");
         m_storage.SetMinVersion(FEATURE_PRE_SPLIT_KEYPOOL);
         split_upgrade = FEATURE_HD_SPLIT > prev_version;
     }
     // Mark all keys currently in the keypool as pre-split
     if (split_upgrade) {
         MarkPreSplitKeys();
     }
     // Regenerate the keypool if upgraded to HD
     if (hd_upgrade) {
         if (!TopUp()) {
             error = _("Unable to generate keys");
             return false;
         }
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::HavePrivateKeys() const {
     LOCK(cs_KeyStore);
     return !mapKeys.empty() || !mapCryptedKeys.empty();
 }
 
 void LegacyScriptPubKeyMan::RewriteDB() {
     LOCK(cs_KeyStore);
     setInternalKeyPool.clear();
     setExternalKeyPool.clear();
     m_pool_key_to_index.clear();
     // Note: can't top-up keypool here, because wallet is locked.
     // User will be prompted to unlock wallet the next operation
     // that requires a new key.
 }
 
 static int64_t GetOldestKeyTimeInPool(const std::set<int64_t> &setKeyPool,
                                       WalletBatch &batch) {
     if (setKeyPool.empty()) {
         return GetTime();
     }
 
     CKeyPool keypool;
     int64_t nIndex = *(setKeyPool.begin());
     if (!batch.ReadPool(nIndex, keypool)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": read oldest key in keypool failed");
     }
 
     assert(keypool.vchPubKey.IsValid());
     return keypool.nTime;
 }
 
 int64_t LegacyScriptPubKeyMan::GetOldestKeyPoolTime() const {
     LOCK(cs_KeyStore);
 
     WalletBatch batch(m_storage.GetDatabase());
 
     // load oldest key from keypool, get time and return
     int64_t oldestKey = GetOldestKeyTimeInPool(setExternalKeyPool, batch);
     if (IsHDEnabled() && m_storage.CanSupportFeature(FEATURE_HD_SPLIT)) {
         oldestKey = std::max(GetOldestKeyTimeInPool(setInternalKeyPool, batch),
                              oldestKey);
         if (!set_pre_split_keypool.empty()) {
             oldestKey =
                 std::max(GetOldestKeyTimeInPool(set_pre_split_keypool, batch),
                          oldestKey);
         }
     }
 
     return oldestKey;
 }
 
 size_t LegacyScriptPubKeyMan::KeypoolCountExternalKeys() const {
     LOCK(cs_KeyStore);
     return setExternalKeyPool.size() + set_pre_split_keypool.size();
 }
 
 unsigned int LegacyScriptPubKeyMan::GetKeyPoolSize() const {
     LOCK(cs_KeyStore);
     return setInternalKeyPool.size() + setExternalKeyPool.size() +
            set_pre_split_keypool.size();
 }
 
 int64_t LegacyScriptPubKeyMan::GetTimeFirstKey() const {
     LOCK(cs_KeyStore);
     return nTimeFirstKey;
 }
 
 std::unique_ptr<SigningProvider>
 LegacyScriptPubKeyMan::GetSolvingProvider(const CScript &script) const {
     return std::make_unique<LegacySigningProvider>(*this);
 }
 
 bool LegacyScriptPubKeyMan::CanProvide(const CScript &script,
                                        SignatureData &sigdata) {
     if (IsMine(script) != ISMINE_NO) {
         // If it IsMine, we can always provide in some way
         return true;
     }
     if (HaveCScript(CScriptID(script))) {
         // We can still provide some stuff if we have the script, but IsMine
         // failed because we don't have keys
         return true;
     }
     // If, given the stuff in sigdata, we could make a valid sigature, then
     // we can provide for this script
     ProduceSignature(*this, DUMMY_SIGNATURE_CREATOR, script, sigdata);
     if (!sigdata.signatures.empty()) {
         // If we could make signatures, make sure we have a private key to
         // actually make a signature
         bool has_privkeys = false;
         for (const auto &key_sig_pair : sigdata.signatures) {
             has_privkeys |= HaveKey(key_sig_pair.first);
         }
         return has_privkeys;
     }
     return false;
 }
 
 bool LegacyScriptPubKeyMan::SignTransaction(
     CMutableTransaction &tx, const std::map<COutPoint, Coin> &coins,
     SigHashType sighash, std::map<int, std::string> &input_errors) const {
     return ::SignTransaction(tx, this, coins, sighash, input_errors);
 }
 
 SigningResult LegacyScriptPubKeyMan::SignMessage(const std::string &message,
                                                  const PKHash &pkhash,
                                                  std::string &str_sig) const {
     CKeyID key_id(pkhash);
     CKey key;
     if (!GetKey(key_id, key)) {
         return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
     }
 
     if (MessageSign(key, message, str_sig)) {
         return SigningResult::OK;
     }
     return SigningResult::SIGNING_FAILED;
 }
 
 TransactionError
 LegacyScriptPubKeyMan::FillPSBT(PartiallySignedTransaction &psbtx,
                                 SigHashType sighash_type, bool sign,
                                 bool bip32derivs) const {
     for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
         PSBTInput &input = psbtx.inputs.at(i);
 
         if (PSBTInputSigned(input)) {
             continue;
         }
 
         // Verify input looks sane. This will check that we have at most one
         // uxto, witness or non-witness.
         if (!input.IsSane()) {
             return TransactionError::INVALID_PSBT;
         }
 
         // Get the Sighash type
         if (sign && input.sighash_type.getRawSigHashType() > 0 &&
             input.sighash_type != sighash_type) {
             return TransactionError::SIGHASH_MISMATCH;
         }
 
         if (input.utxo.IsNull()) {
             // There's no UTXO so we can just skip this now
             continue;
         }
         SignatureData sigdata;
         input.FillSignatureData(sigdata);
         SignPSBTInput(HidingSigningProvider(this, !sign, !bip32derivs), psbtx,
                       i, sighash_type);
     }
 
     // Fill in the bip32 keypaths and redeemscripts for the outputs so that
     // hardware wallets can identify change
     for (size_t i = 0; i < psbtx.tx->vout.size(); ++i) {
         UpdatePSBTOutput(HidingSigningProvider(this, true, !bip32derivs), psbtx,
                          i);
     }
 
     return TransactionError::OK;
 }
 
 std::unique_ptr<CKeyMetadata>
 LegacyScriptPubKeyMan::GetMetadata(const CTxDestination &dest) const {
     LOCK(cs_KeyStore);
 
     CKeyID key_id = GetKeyForDestination(*this, dest);
     if (!key_id.IsNull()) {
         auto it = mapKeyMetadata.find(key_id);
         if (it != mapKeyMetadata.end()) {
             return std::make_unique<CKeyMetadata>(it->second);
         }
     }
 
     CScript scriptPubKey = GetScriptForDestination(dest);
     auto it = m_script_metadata.find(CScriptID(scriptPubKey));
     if (it != m_script_metadata.end()) {
         return std::make_unique<CKeyMetadata>(it->second);
     }
 
     return nullptr;
 }
 
 uint256 LegacyScriptPubKeyMan::GetID() const {
     return UINT256_ONE();
 }
 
 /**
  * Update wallet first key creation time. This should be called whenever keys
  * are added to the wallet, with the oldest key creation time.
  */
 void LegacyScriptPubKeyMan::UpdateTimeFirstKey(int64_t nCreateTime) {
     AssertLockHeld(cs_KeyStore);
     if (nCreateTime <= 1) {
         // Cannot determine birthday information, so set the wallet birthday to
         // the beginning of time.
         nTimeFirstKey = 1;
     } else if (!nTimeFirstKey || nCreateTime < nTimeFirstKey) {
         nTimeFirstKey = nCreateTime;
     }
 }
 
 bool LegacyScriptPubKeyMan::LoadKey(const CKey &key, const CPubKey &pubkey) {
     return AddKeyPubKeyInner(key, pubkey);
 }
 
 bool LegacyScriptPubKeyMan::AddKeyPubKey(const CKey &secret,
                                          const CPubKey &pubkey) {
     LOCK(cs_KeyStore);
     WalletBatch batch(m_storage.GetDatabase());
     return LegacyScriptPubKeyMan::AddKeyPubKeyWithDB(batch, secret, pubkey);
 }
 
 bool LegacyScriptPubKeyMan::AddKeyPubKeyWithDB(WalletBatch &batch,
                                                const CKey &secret,
                                                const CPubKey &pubkey) {
     AssertLockHeld(cs_KeyStore);
 
     // Make sure we aren't adding private keys to private key disabled wallets
     assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
 
     // FillableSigningProvider has no concept of wallet databases, but calls
     // AddCryptedKey which is overridden below. To avoid flushes, the database
     // handle is tunneled through to it.
     bool needsDB = !encrypted_batch;
     if (needsDB) {
         encrypted_batch = &batch;
     }
     if (!AddKeyPubKeyInner(secret, pubkey)) {
         if (needsDB) {
             encrypted_batch = nullptr;
         }
         return false;
     }
 
     if (needsDB) {
         encrypted_batch = nullptr;
     }
 
     // Check if we need to remove from watch-only.
     CScript script;
     script = GetScriptForDestination(PKHash(pubkey));
     if (HaveWatchOnly(script)) {
         RemoveWatchOnly(script);
     }
 
     script = GetScriptForRawPubKey(pubkey);
     if (HaveWatchOnly(script)) {
         RemoveWatchOnly(script);
     }
 
     if (!m_storage.HasEncryptionKeys()) {
         return batch.WriteKey(pubkey, secret.GetPrivKey(),
                               mapKeyMetadata[pubkey.GetID()]);
     }
     m_storage.UnsetBlankWalletFlag(batch);
     return true;
 }
 
 bool LegacyScriptPubKeyMan::LoadCScript(const CScript &redeemScript) {
     /**
      * A sanity check was added in pull #3843 to avoid adding redeemScripts that
      * never can be redeemed. However, old wallets may still contain these. Do
      * not add them to the wallet and warn.
      */
     if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE) {
         std::string strAddr =
             EncodeDestination(ScriptHash(redeemScript), GetConfig());
         WalletLogPrintf("%s: Warning: This wallet contains a redeemScript "
                         "of size %i which exceeds maximum size %i thus can "
                         "never be redeemed. Do not use address %s.\n",
                         __func__, redeemScript.size(), MAX_SCRIPT_ELEMENT_SIZE,
                         strAddr);
         return true;
     }
 
     return FillableSigningProvider::AddCScript(redeemScript);
 }
 
 void LegacyScriptPubKeyMan::LoadKeyMetadata(const CKeyID &keyID,
                                             const CKeyMetadata &meta) {
     LOCK(cs_KeyStore);
     UpdateTimeFirstKey(meta.nCreateTime);
     mapKeyMetadata[keyID] = meta;
 }
 
 void LegacyScriptPubKeyMan::LoadScriptMetadata(const CScriptID &script_id,
                                                const CKeyMetadata &meta) {
     LOCK(cs_KeyStore);
     UpdateTimeFirstKey(meta.nCreateTime);
     m_script_metadata[script_id] = meta;
 }
 
 bool LegacyScriptPubKeyMan::AddKeyPubKeyInner(const CKey &key,
                                               const CPubKey &pubkey) {
     LOCK(cs_KeyStore);
     if (!m_storage.HasEncryptionKeys()) {
         return FillableSigningProvider::AddKeyPubKey(key, pubkey);
     }
 
     if (m_storage.IsLocked()) {
         return false;
     }
 
     std::vector<uint8_t> vchCryptedSecret;
     CKeyingMaterial vchSecret(key.begin(), key.end());
     if (!EncryptSecret(m_storage.GetEncryptionKey(), vchSecret,
                        pubkey.GetHash(), vchCryptedSecret)) {
         return false;
     }
 
     if (!AddCryptedKey(pubkey, vchCryptedSecret)) {
         return false;
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::LoadCryptedKey(
     const CPubKey &vchPubKey, const std::vector<uint8_t> &vchCryptedSecret) {
     return AddCryptedKeyInner(vchPubKey, vchCryptedSecret);
 }
 
 bool LegacyScriptPubKeyMan::AddCryptedKeyInner(
     const CPubKey &vchPubKey, const std::vector<uint8_t> &vchCryptedSecret) {
     LOCK(cs_KeyStore);
     assert(mapKeys.empty());
 
     mapCryptedKeys[vchPubKey.GetID()] = make_pair(vchPubKey, vchCryptedSecret);
     return true;
 }
 
 bool LegacyScriptPubKeyMan::AddCryptedKey(
     const CPubKey &vchPubKey, const std::vector<uint8_t> &vchCryptedSecret) {
     if (!AddCryptedKeyInner(vchPubKey, vchCryptedSecret)) {
         return false;
     }
 
     LOCK(cs_KeyStore);
     if (encrypted_batch) {
         return encrypted_batch->WriteCryptedKey(
             vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]);
     }
 
     return WalletBatch(m_storage.GetDatabase())
         .WriteCryptedKey(vchPubKey, vchCryptedSecret,
                          mapKeyMetadata[vchPubKey.GetID()]);
 }
 
 bool LegacyScriptPubKeyMan::HaveWatchOnly(const CScript &dest) const {
     LOCK(cs_KeyStore);
     return setWatchOnly.count(dest) > 0;
 }
 
 bool LegacyScriptPubKeyMan::HaveWatchOnly() const {
     LOCK(cs_KeyStore);
     return (!setWatchOnly.empty());
 }
 
 static bool ExtractPubKey(const CScript &dest, CPubKey &pubKeyOut) {
     std::vector<std::vector<uint8_t>> solutions;
     return Solver(dest, solutions) == TX_PUBKEY &&
            (pubKeyOut = CPubKey(solutions[0])).IsFullyValid();
 }
 
 bool LegacyScriptPubKeyMan::RemoveWatchOnly(const CScript &dest) {
     {
         LOCK(cs_KeyStore);
         setWatchOnly.erase(dest);
         CPubKey pubKey;
         if (ExtractPubKey(dest, pubKey)) {
             mapWatchKeys.erase(pubKey.GetID());
         }
     }
 
     if (!HaveWatchOnly()) {
         NotifyWatchonlyChanged(false);
     }
 
     return WalletBatch(m_storage.GetDatabase()).EraseWatchOnly(dest);
 }
 
 bool LegacyScriptPubKeyMan::LoadWatchOnly(const CScript &dest) {
     return AddWatchOnlyInMem(dest);
 }
 
 bool LegacyScriptPubKeyMan::AddWatchOnlyInMem(const CScript &dest) {
     LOCK(cs_KeyStore);
     setWatchOnly.insert(dest);
     CPubKey pubKey;
     if (ExtractPubKey(dest, pubKey)) {
         mapWatchKeys[pubKey.GetID()] = pubKey;
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::AddWatchOnlyWithDB(WalletBatch &batch,
                                                const CScript &dest) {
     if (!AddWatchOnlyInMem(dest)) {
         return false;
     }
 
     const CKeyMetadata &meta = m_script_metadata[CScriptID(dest)];
     UpdateTimeFirstKey(meta.nCreateTime);
     NotifyWatchonlyChanged(true);
     if (batch.WriteWatchOnly(dest, meta)) {
         m_storage.UnsetBlankWalletFlag(batch);
         return true;
     }
     return false;
 }
 
 bool LegacyScriptPubKeyMan::AddWatchOnlyWithDB(WalletBatch &batch,
                                                const CScript &dest,
                                                int64_t create_time) {
     m_script_metadata[CScriptID(dest)].nCreateTime = create_time;
     return AddWatchOnlyWithDB(batch, dest);
 }
 
 bool LegacyScriptPubKeyMan::AddWatchOnly(const CScript &dest) {
     WalletBatch batch(m_storage.GetDatabase());
     return AddWatchOnlyWithDB(batch, dest);
 }
 
 bool LegacyScriptPubKeyMan::AddWatchOnly(const CScript &dest,
                                          int64_t nCreateTime) {
     m_script_metadata[CScriptID(dest)].nCreateTime = nCreateTime;
     return AddWatchOnly(dest);
 }
 
 void LegacyScriptPubKeyMan::SetHDChain(const CHDChain &chain, bool memonly) {
     LOCK(cs_KeyStore);
     if (!memonly && !WalletBatch(m_storage.GetDatabase()).WriteHDChain(chain)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing chain failed");
     }
 
     hdChain = chain;
 }
 
 bool LegacyScriptPubKeyMan::HaveKey(const CKeyID &address) const {
     LOCK(cs_KeyStore);
     if (!m_storage.HasEncryptionKeys()) {
         return FillableSigningProvider::HaveKey(address);
     }
     return mapCryptedKeys.count(address) > 0;
 }
 
 bool LegacyScriptPubKeyMan::GetKey(const CKeyID &address, CKey &keyOut) const {
     LOCK(cs_KeyStore);
     if (!m_storage.HasEncryptionKeys()) {
         return FillableSigningProvider::GetKey(address, keyOut);
     }
 
     CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
     if (mi != mapCryptedKeys.end()) {
         const CPubKey &vchPubKey = (*mi).second.first;
         const std::vector<uint8_t> &vchCryptedSecret = (*mi).second.second;
         return DecryptKey(m_storage.GetEncryptionKey(), vchCryptedSecret,
                           vchPubKey, keyOut);
     }
     return false;
 }
 
 bool LegacyScriptPubKeyMan::GetKeyOrigin(const CKeyID &keyID,
                                          KeyOriginInfo &info) const {
     CKeyMetadata meta;
     {
         LOCK(cs_KeyStore);
         auto it = mapKeyMetadata.find(keyID);
         if (it != mapKeyMetadata.end()) {
             meta = it->second;
         }
     }
     if (meta.has_key_origin) {
         std::copy(meta.key_origin.fingerprint, meta.key_origin.fingerprint + 4,
                   info.fingerprint);
         info.path = meta.key_origin.path;
     } else {
         // Single pubkeys get the master fingerprint of themselves
         std::copy(keyID.begin(), keyID.begin() + 4, info.fingerprint);
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::GetWatchPubKey(const CKeyID &address,
                                            CPubKey &pubkey_out) const {
     LOCK(cs_KeyStore);
     WatchKeyMap::const_iterator it = mapWatchKeys.find(address);
     if (it != mapWatchKeys.end()) {
         pubkey_out = it->second;
         return true;
     }
     return false;
 }
 
 bool LegacyScriptPubKeyMan::GetPubKey(const CKeyID &address,
                                       CPubKey &vchPubKeyOut) const {
     LOCK(cs_KeyStore);
     if (!m_storage.HasEncryptionKeys()) {
         if (!FillableSigningProvider::GetPubKey(address, vchPubKeyOut)) {
             return GetWatchPubKey(address, vchPubKeyOut);
         }
         return true;
     }
 
     CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
     if (mi != mapCryptedKeys.end()) {
         vchPubKeyOut = (*mi).second.first;
         return true;
     }
 
     // Check for watch-only pubkeys
     return GetWatchPubKey(address, vchPubKeyOut);
 }
 
 CPubKey LegacyScriptPubKeyMan::GenerateNewKey(WalletBatch &batch,
                                               bool internal) {
     assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
     assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET));
     AssertLockHeld(cs_KeyStore);
     // default to compressed public keys if we want 0.6.0 wallets
     bool fCompressed = m_storage.CanSupportFeature(FEATURE_COMPRPUBKEY);
 
     CKey secret;
 
     // Create new metadata
     int64_t nCreationTime = GetTime();
     CKeyMetadata metadata(nCreationTime);
 
     // use HD key derivation if HD was enabled during wallet creation and a seed
     // is present
     if (IsHDEnabled()) {
         DeriveNewChildKey(
             batch, metadata, secret,
             (m_storage.CanSupportFeature(FEATURE_HD_SPLIT) ? internal : false));
     } else {
         secret.MakeNewKey(fCompressed);
     }
 
     // Compressed public keys were introduced in version 0.6.0
     if (fCompressed) {
         m_storage.SetMinVersion(FEATURE_COMPRPUBKEY);
     }
 
     CPubKey pubkey = secret.GetPubKey();
     assert(secret.VerifyPubKey(pubkey));
 
     mapKeyMetadata[pubkey.GetID()] = metadata;
     UpdateTimeFirstKey(nCreationTime);
 
     if (!AddKeyPubKeyWithDB(batch, secret, pubkey)) {
         throw std::runtime_error(std::string(__func__) + ": AddKey failed");
     }
 
     return pubkey;
 }
 
 const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000;
 
 void LegacyScriptPubKeyMan::DeriveNewChildKey(WalletBatch &batch,
                                               CKeyMetadata &metadata,
                                               CKey &secret, bool internal) {
     // for now we use a fixed keypath scheme of m/0'/0'/k
     // seed (256bit)
     CKey seed;
     // hd master key
     CExtKey masterKey;
     // key at m/0'
     CExtKey accountKey;
     // key at m/0'/0' (external) or m/0'/1' (internal)
     CExtKey chainChildKey;
     // key at m/0'/0'/<n>'
     CExtKey childKey;
 
     // try to get the seed
     if (!GetKey(hdChain.seed_id, seed)) {
         throw std::runtime_error(std::string(__func__) + ": seed not found");
     }
 
     masterKey.SetSeed(seed.begin(), seed.size());
 
     // derive m/0'
     // use hardened derivation (child keys >= 0x80000000 are hardened after
     // bip32)
     masterKey.Derive(accountKey, BIP32_HARDENED_KEY_LIMIT);
 
     // derive m/0'/0' (external chain) OR m/0'/1' (internal chain)
     assert(internal ? m_storage.CanSupportFeature(FEATURE_HD_SPLIT) : true);
     accountKey.Derive(chainChildKey,
                       BIP32_HARDENED_KEY_LIMIT + (internal ? 1 : 0));
 
     // derive child key at next index, skip keys already known to the wallet
     do {
         // always derive hardened keys
         // childIndex | BIP32_HARDENED_KEY_LIMIT = derive childIndex in hardened
         // child-index-range
         // example: 1 | BIP32_HARDENED_KEY_LIMIT == 0x80000001 == 2147483649
         if (internal) {
             chainChildKey.Derive(childKey, hdChain.nInternalChainCounter |
                                                BIP32_HARDENED_KEY_LIMIT);
-            metadata.hdKeypath = "m/0'/1'/" +
-                                 std::to_string(hdChain.nInternalChainCounter) +
-                                 "'";
+            metadata.hdKeypath =
+                "m/0'/1'/" + ToString(hdChain.nInternalChainCounter) + "'";
             metadata.key_origin.path.push_back(0 | BIP32_HARDENED_KEY_LIMIT);
             metadata.key_origin.path.push_back(1 | BIP32_HARDENED_KEY_LIMIT);
             metadata.key_origin.path.push_back(hdChain.nInternalChainCounter |
                                                BIP32_HARDENED_KEY_LIMIT);
             hdChain.nInternalChainCounter++;
         } else {
             chainChildKey.Derive(childKey, hdChain.nExternalChainCounter |
                                                BIP32_HARDENED_KEY_LIMIT);
-            metadata.hdKeypath = "m/0'/0'/" +
-                                 std::to_string(hdChain.nExternalChainCounter) +
-                                 "'";
+            metadata.hdKeypath =
+                "m/0'/0'/" + ToString(hdChain.nExternalChainCounter) + "'";
             metadata.key_origin.path.push_back(0 | BIP32_HARDENED_KEY_LIMIT);
             metadata.key_origin.path.push_back(0 | BIP32_HARDENED_KEY_LIMIT);
             metadata.key_origin.path.push_back(hdChain.nExternalChainCounter |
                                                BIP32_HARDENED_KEY_LIMIT);
             hdChain.nExternalChainCounter++;
         }
     } while (HaveKey(childKey.key.GetPubKey().GetID()));
     secret = childKey.key;
     metadata.hd_seed_id = hdChain.seed_id;
     CKeyID master_id = masterKey.key.GetPubKey().GetID();
     std::copy(master_id.begin(), master_id.begin() + 4,
               metadata.key_origin.fingerprint);
     metadata.has_key_origin = true;
     // update the chain model in the database
     if (!batch.WriteHDChain(hdChain)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": Writing HD chain model failed");
     }
 }
 
 void LegacyScriptPubKeyMan::LoadKeyPool(int64_t nIndex,
                                         const CKeyPool &keypool) {
     LOCK(cs_KeyStore);
     if (keypool.m_pre_split) {
         set_pre_split_keypool.insert(nIndex);
     } else if (keypool.fInternal) {
         setInternalKeyPool.insert(nIndex);
     } else {
         setExternalKeyPool.insert(nIndex);
     }
     m_max_keypool_index = std::max(m_max_keypool_index, nIndex);
     m_pool_key_to_index[keypool.vchPubKey.GetID()] = nIndex;
 
     // If no metadata exists yet, create a default with the pool key's
     // creation time. Note that this may be overwritten by actually
     // stored metadata for that key later, which is fine.
     CKeyID keyid = keypool.vchPubKey.GetID();
     if (mapKeyMetadata.count(keyid) == 0) {
         mapKeyMetadata[keyid] = CKeyMetadata(keypool.nTime);
     }
 }
 
 bool LegacyScriptPubKeyMan::CanGenerateKeys() const {
     // A wallet can generate keys if it has an HD seed (IsHDEnabled) or it is a
     // non-HD wallet (pre FEATURE_HD)
     LOCK(cs_KeyStore);
     return IsHDEnabled() || !m_storage.CanSupportFeature(FEATURE_HD);
 }
 
 CPubKey LegacyScriptPubKeyMan::GenerateNewSeed() {
     assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
     CKey key;
     key.MakeNewKey(true);
     return DeriveNewSeed(key);
 }
 
 CPubKey LegacyScriptPubKeyMan::DeriveNewSeed(const CKey &key) {
     int64_t nCreationTime = GetTime();
     CKeyMetadata metadata(nCreationTime);
 
     // Calculate the seed
     CPubKey seed = key.GetPubKey();
     assert(key.VerifyPubKey(seed));
 
     // Set the hd keypath to "s" -> Seed, refers the seed to itself
     metadata.hdKeypath = "s";
     metadata.has_key_origin = false;
     metadata.hd_seed_id = seed.GetID();
 
     LOCK(cs_KeyStore);
 
     // mem store the metadata
     mapKeyMetadata[seed.GetID()] = metadata;
 
     // Write the key&metadata to the database
     if (!AddKeyPubKey(key, seed)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": AddKeyPubKey failed");
     }
 
     return seed;
 }
 
 void LegacyScriptPubKeyMan::SetHDSeed(const CPubKey &seed) {
     LOCK(cs_KeyStore);
 
     // Store the keyid (hash160) together with the child index counter in the
     // database as a hdchain object.
     CHDChain newHdChain;
     newHdChain.nVersion = m_storage.CanSupportFeature(FEATURE_HD_SPLIT)
                               ? CHDChain::VERSION_HD_CHAIN_SPLIT
                               : CHDChain::VERSION_HD_BASE;
     newHdChain.seed_id = seed.GetID();
     SetHDChain(newHdChain, false);
     NotifyCanGetAddressesChanged();
     WalletBatch batch(m_storage.GetDatabase());
     m_storage.UnsetBlankWalletFlag(batch);
 }
 
 /**
  * Mark old keypool keys as used, and generate all new keys.
  */
 bool LegacyScriptPubKeyMan::NewKeyPool() {
     if (m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         return false;
     }
     LOCK(cs_KeyStore);
     WalletBatch batch(m_storage.GetDatabase());
 
     for (const int64_t nIndex : setInternalKeyPool) {
         batch.ErasePool(nIndex);
     }
     setInternalKeyPool.clear();
 
     for (const int64_t nIndex : setExternalKeyPool) {
         batch.ErasePool(nIndex);
     }
     setExternalKeyPool.clear();
 
     for (int64_t nIndex : set_pre_split_keypool) {
         batch.ErasePool(nIndex);
     }
     set_pre_split_keypool.clear();
 
     m_pool_key_to_index.clear();
 
     if (!TopUp()) {
         return false;
     }
 
     WalletLogPrintf("LegacyScriptPubKeyMan::NewKeyPool rewrote keypool\n");
     return true;
 }
 
 bool LegacyScriptPubKeyMan::TopUp(unsigned int kpSize) {
     if (!CanGenerateKeys()) {
         return false;
     }
     {
         LOCK(cs_KeyStore);
 
         if (m_storage.IsLocked()) {
             return false;
         }
 
         // Top up key pool
         unsigned int nTargetSize;
         if (kpSize > 0) {
             nTargetSize = kpSize;
         } else {
             nTargetSize = std::max<int64_t>(
                 gArgs.GetArg("-keypool", DEFAULT_KEYPOOL_SIZE), 0);
         }
 
         // count amount of available keys (internal, external)
         // make sure the keypool of external and internal keys fits the user
         // selected target (-keypool)
         int64_t missingExternal = std::max<int64_t>(
             std::max<int64_t>(nTargetSize, 1) - setExternalKeyPool.size(), 0);
         int64_t missingInternal = std::max<int64_t>(
             std::max<int64_t>(nTargetSize, 1) - setInternalKeyPool.size(), 0);
 
         if (!IsHDEnabled() || !m_storage.CanSupportFeature(FEATURE_HD_SPLIT)) {
             // don't create extra internal keys
             missingInternal = 0;
         }
         bool internal = false;
         WalletBatch batch(m_storage.GetDatabase());
         for (int64_t i = missingInternal + missingExternal; i--;) {
             if (i < missingInternal) {
                 internal = true;
             }
 
             CPubKey pubkey(GenerateNewKey(batch, internal));
             AddKeypoolPubkeyWithDB(pubkey, internal, batch);
         }
         if (missingInternal + missingExternal > 0) {
             WalletLogPrintf(
                 "keypool added %d keys (%d internal), size=%u (%u internal)\n",
                 missingInternal + missingExternal, missingInternal,
                 setInternalKeyPool.size() + setExternalKeyPool.size() +
                     set_pre_split_keypool.size(),
                 setInternalKeyPool.size());
         }
     }
     NotifyCanGetAddressesChanged();
     return true;
 }
 
 void LegacyScriptPubKeyMan::AddKeypoolPubkeyWithDB(const CPubKey &pubkey,
                                                    const bool internal,
                                                    WalletBatch &batch) {
     LOCK(cs_KeyStore);
     // How in the hell did you use so many keys?
     assert(m_max_keypool_index < std::numeric_limits<int64_t>::max());
     int64_t index = ++m_max_keypool_index;
     if (!batch.WritePool(index, CKeyPool(pubkey, internal))) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing imported pubkey failed");
     }
     if (internal) {
         setInternalKeyPool.insert(index);
     } else {
         setExternalKeyPool.insert(index);
     }
     m_pool_key_to_index[pubkey.GetID()] = index;
 }
 
 void LegacyScriptPubKeyMan::KeepDestination(int64_t nIndex,
                                             const OutputType &type) {
     // Remove from key pool.
     WalletBatch batch(m_storage.GetDatabase());
     batch.ErasePool(nIndex);
     CPubKey pubkey;
     bool have_pk = GetPubKey(m_index_to_reserved_key.at(nIndex), pubkey);
     assert(have_pk);
     LearnRelatedScripts(pubkey, type);
     m_index_to_reserved_key.erase(nIndex);
     WalletLogPrintf("keypool keep %d\n", nIndex);
 }
 
 void LegacyScriptPubKeyMan::ReturnDestination(int64_t nIndex, bool fInternal,
                                               const CTxDestination &) {
     // Return to key pool
     {
         LOCK(cs_KeyStore);
         if (fInternal) {
             setInternalKeyPool.insert(nIndex);
         } else if (!set_pre_split_keypool.empty()) {
             set_pre_split_keypool.insert(nIndex);
         } else {
             setExternalKeyPool.insert(nIndex);
         }
         CKeyID &pubkey_id = m_index_to_reserved_key.at(nIndex);
         m_pool_key_to_index[pubkey_id] = nIndex;
         m_index_to_reserved_key.erase(nIndex);
         NotifyCanGetAddressesChanged();
     }
 
     WalletLogPrintf("keypool return %d\n", nIndex);
 }
 
 bool LegacyScriptPubKeyMan::GetKeyFromPool(CPubKey &result,
                                            const OutputType type,
                                            bool internal) {
     if (!CanGetAddresses(internal)) {
         return false;
     }
 
     CKeyPool keypool;
     LOCK(cs_KeyStore);
     int64_t nIndex;
     if (!ReserveKeyFromKeyPool(nIndex, keypool, internal) &&
         !m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         if (m_storage.IsLocked()) {
             return false;
         }
         WalletBatch batch(m_storage.GetDatabase());
         result = GenerateNewKey(batch, internal);
         return true;
     }
 
     KeepDestination(nIndex, type);
     result = keypool.vchPubKey;
 
     return true;
 }
 
 bool LegacyScriptPubKeyMan::ReserveKeyFromKeyPool(int64_t &nIndex,
                                                   CKeyPool &keypool,
                                                   bool fRequestedInternal) {
     nIndex = -1;
     keypool.vchPubKey = CPubKey();
     {
         LOCK(cs_KeyStore);
 
         bool fReturningInternal = fRequestedInternal;
         fReturningInternal &=
             (IsHDEnabled() && m_storage.CanSupportFeature(FEATURE_HD_SPLIT)) ||
             m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
         bool use_split_keypool = set_pre_split_keypool.empty();
         std::set<int64_t> &setKeyPool =
             use_split_keypool
                 ? (fReturningInternal ? setInternalKeyPool : setExternalKeyPool)
                 : set_pre_split_keypool;
 
         // Get the oldest key
         if (setKeyPool.empty()) {
             return false;
         }
 
         WalletBatch batch(m_storage.GetDatabase());
 
         auto it = setKeyPool.begin();
         nIndex = *it;
         setKeyPool.erase(it);
         if (!batch.ReadPool(nIndex, keypool)) {
             throw std::runtime_error(std::string(__func__) + ": read failed");
         }
         CPubKey pk;
         if (!GetPubKey(keypool.vchPubKey.GetID(), pk)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": unknown key in key pool");
         }
         // If the key was pre-split keypool, we don't care about what type it is
         if (use_split_keypool && keypool.fInternal != fReturningInternal) {
             throw std::runtime_error(std::string(__func__) +
                                      ": keypool entry misclassified");
         }
         if (!keypool.vchPubKey.IsValid()) {
             throw std::runtime_error(std::string(__func__) +
                                      ": keypool entry invalid");
         }
 
         assert(m_index_to_reserved_key.count(nIndex) == 0);
         m_index_to_reserved_key[nIndex] = keypool.vchPubKey.GetID();
         m_pool_key_to_index.erase(keypool.vchPubKey.GetID());
         WalletLogPrintf("keypool reserve %d\n", nIndex);
     }
     NotifyCanGetAddressesChanged();
     return true;
 }
 
 void LegacyScriptPubKeyMan::LearnRelatedScripts(const CPubKey &key,
                                                 OutputType type) {
     // Nothing to do...
 }
 
 void LegacyScriptPubKeyMan::LearnAllRelatedScripts(const CPubKey &key) {
     // Nothing to do...
 }
 
 void LegacyScriptPubKeyMan::MarkReserveKeysAsUsed(int64_t keypool_id) {
     AssertLockHeld(cs_KeyStore);
     bool internal = setInternalKeyPool.count(keypool_id);
     if (!internal) {
         assert(setExternalKeyPool.count(keypool_id) ||
                set_pre_split_keypool.count(keypool_id));
     }
 
     std::set<int64_t> *setKeyPool =
         internal ? &setInternalKeyPool
                  : (set_pre_split_keypool.empty() ? &setExternalKeyPool
                                                   : &set_pre_split_keypool);
     auto it = setKeyPool->begin();
 
     WalletBatch batch(m_storage.GetDatabase());
     while (it != std::end(*setKeyPool)) {
         const int64_t &index = *(it);
         if (index > keypool_id) {
             // set*KeyPool is ordered
             break;
         }
 
         CKeyPool keypool;
         if (batch.ReadPool(index, keypool)) {
             // TODO: This should be unnecessary
             m_pool_key_to_index.erase(keypool.vchPubKey.GetID());
         }
         LearnAllRelatedScripts(keypool.vchPubKey);
         batch.ErasePool(index);
         WalletLogPrintf("keypool index %d removed\n", index);
         it = setKeyPool->erase(it);
     }
 }
 
 std::vector<CKeyID> GetAffectedKeys(const CScript &spk,
                                     const SigningProvider &provider) {
     std::vector<CScript> dummy;
     FlatSigningProvider out;
     InferDescriptor(spk, provider)
         ->Expand(0, DUMMY_SIGNING_PROVIDER, dummy, out);
     std::vector<CKeyID> ret;
     for (const auto &entry : out.pubkeys) {
         ret.push_back(entry.first);
     }
     return ret;
 }
 
 void LegacyScriptPubKeyMan::MarkPreSplitKeys() {
     WalletBatch batch(m_storage.GetDatabase());
     for (auto it = setExternalKeyPool.begin();
          it != setExternalKeyPool.end();) {
         int64_t index = *it;
         CKeyPool keypool;
         if (!batch.ReadPool(index, keypool)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": read keypool entry failed");
         }
         keypool.m_pre_split = true;
         if (!batch.WritePool(index, keypool)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": writing modified keypool entry failed");
         }
         set_pre_split_keypool.insert(index);
         it = setExternalKeyPool.erase(it);
     }
 }
 
 bool LegacyScriptPubKeyMan::AddCScript(const CScript &redeemScript) {
     WalletBatch batch(m_storage.GetDatabase());
     return AddCScriptWithDB(batch, redeemScript);
 }
 
 bool LegacyScriptPubKeyMan::AddCScriptWithDB(WalletBatch &batch,
                                              const CScript &redeemScript) {
     if (!FillableSigningProvider::AddCScript(redeemScript)) {
         return false;
     }
     if (batch.WriteCScript(Hash160(redeemScript), redeemScript)) {
         m_storage.UnsetBlankWalletFlag(batch);
         return true;
     }
     return false;
 }
 
 bool LegacyScriptPubKeyMan::AddKeyOriginWithDB(WalletBatch &batch,
                                                const CPubKey &pubkey,
                                                const KeyOriginInfo &info) {
     LOCK(cs_KeyStore);
     std::copy(info.fingerprint, info.fingerprint + 4,
               mapKeyMetadata[pubkey.GetID()].key_origin.fingerprint);
     mapKeyMetadata[pubkey.GetID()].key_origin.path = info.path;
     mapKeyMetadata[pubkey.GetID()].has_key_origin = true;
     mapKeyMetadata[pubkey.GetID()].hdKeypath = WriteHDKeypath(info.path);
     return batch.WriteKeyMetadata(mapKeyMetadata[pubkey.GetID()], pubkey, true);
 }
 
 bool LegacyScriptPubKeyMan::ImportScripts(const std::set<CScript> scripts,
                                           int64_t timestamp) {
     WalletBatch batch(m_storage.GetDatabase());
     for (const auto &entry : scripts) {
         CScriptID id(entry);
         if (HaveCScript(id)) {
             WalletLogPrintf("Already have script %s, skipping\n",
                             HexStr(entry));
             continue;
         }
         if (!AddCScriptWithDB(batch, entry)) {
             return false;
         }
 
         if (timestamp > 0) {
             m_script_metadata[CScriptID(entry)].nCreateTime = timestamp;
         }
     }
     if (timestamp > 0) {
         UpdateTimeFirstKey(timestamp);
     }
 
     return true;
 }
 
 bool LegacyScriptPubKeyMan::ImportPrivKeys(
     const std::map<CKeyID, CKey> &privkey_map, const int64_t timestamp) {
     WalletBatch batch(m_storage.GetDatabase());
     for (const auto &entry : privkey_map) {
         const CKey &key = entry.second;
         CPubKey pubkey = key.GetPubKey();
         const CKeyID &id = entry.first;
         assert(key.VerifyPubKey(pubkey));
         // Skip if we already have the key
         if (HaveKey(id)) {
             WalletLogPrintf("Already have key with pubkey %s, skipping\n",
                             HexStr(pubkey));
             continue;
         }
         mapKeyMetadata[id].nCreateTime = timestamp;
         // If the private key is not present in the wallet, insert it.
         if (!AddKeyPubKeyWithDB(batch, key, pubkey)) {
             return false;
         }
         UpdateTimeFirstKey(timestamp);
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::ImportPubKeys(
     const std::vector<CKeyID> &ordered_pubkeys,
     const std::map<CKeyID, CPubKey> &pubkey_map,
     const std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> &key_origins,
     const bool add_keypool, const bool internal, const int64_t timestamp) {
     WalletBatch batch(m_storage.GetDatabase());
     for (const auto &entry : key_origins) {
         AddKeyOriginWithDB(batch, entry.second.first, entry.second.second);
     }
     for (const CKeyID &id : ordered_pubkeys) {
         auto entry = pubkey_map.find(id);
         if (entry == pubkey_map.end()) {
             continue;
         }
         const CPubKey &pubkey = entry->second;
         CPubKey temp;
         if (GetPubKey(id, temp)) {
             // Already have pubkey, skipping
             WalletLogPrintf("Already have pubkey %s, skipping\n", HexStr(temp));
             continue;
         }
         if (!AddWatchOnlyWithDB(batch, GetScriptForRawPubKey(pubkey),
                                 timestamp)) {
             return false;
         }
         mapKeyMetadata[id].nCreateTime = timestamp;
 
         // Add to keypool only works with pubkeys
         if (add_keypool) {
             AddKeypoolPubkeyWithDB(pubkey, internal, batch);
             NotifyCanGetAddressesChanged();
         }
     }
     return true;
 }
 
 bool LegacyScriptPubKeyMan::ImportScriptPubKeys(
     const std::set<CScript> &script_pub_keys, const bool have_solving_data,
     const int64_t timestamp) {
     WalletBatch batch(m_storage.GetDatabase());
     for (const CScript &script : script_pub_keys) {
         if (!have_solving_data || !IsMine(script)) {
             // Always call AddWatchOnly for non-solvable watch-only, so that
             // watch timestamp gets updated
             if (!AddWatchOnlyWithDB(batch, script, timestamp)) {
                 return false;
             }
         }
     }
     return true;
 }
 
 std::set<CKeyID> LegacyScriptPubKeyMan::GetKeys() const {
     LOCK(cs_KeyStore);
     if (!m_storage.HasEncryptionKeys()) {
         return FillableSigningProvider::GetKeys();
     }
     std::set<CKeyID> set_address;
     for (const auto &mi : mapCryptedKeys) {
         set_address.insert(mi.first);
     }
     return set_address;
 }
 
 void LegacyScriptPubKeyMan::SetType(OutputType type, bool internal) {}
 
 bool DescriptorScriptPubKeyMan::GetNewDestination(const OutputType type,
                                                   CTxDestination &dest,
                                                   std::string &error) {
     // Returns true if this descriptor supports getting new addresses.
     // Conditions where we may be unable to fetch them (e.g. locked) are caught
     // later
     if (!CanGetAddresses(m_internal)) {
         error = "No addresses available";
         return false;
     }
     {
         LOCK(cs_desc_man);
         // This is a combo descriptor which should not be an active descriptor
         assert(m_wallet_descriptor.descriptor->IsSingleType());
         if (type != m_address_type) {
             throw std::runtime_error(std::string(__func__) +
                                      ": Types are inconsistent");
         }
 
         TopUp();
 
         // Get the scriptPubKey from the descriptor
         FlatSigningProvider out_keys;
         std::vector<CScript> scripts_temp;
         if (m_wallet_descriptor.range_end <= m_max_cached_index && !TopUp(1)) {
             // We can't generate anymore keys
             error = "Error: Keypool ran out, please call keypoolrefill first";
             return false;
         }
         if (!m_wallet_descriptor.descriptor->ExpandFromCache(
                 m_wallet_descriptor.next_index, m_wallet_descriptor.cache,
                 scripts_temp, out_keys)) {
             // We can't generate anymore keys
             error = "Error: Keypool ran out, please call keypoolrefill first";
             return false;
         }
 
         std::optional<OutputType> out_script_type =
             m_wallet_descriptor.descriptor->GetOutputType();
         if (out_script_type && out_script_type == type) {
             ExtractDestination(scripts_temp[0], dest);
         } else {
             throw std::runtime_error(
                 std::string(__func__) +
                 ": Types are inconsistent. Stored type does not match type of "
                 "newly generated address");
         }
         m_wallet_descriptor.next_index++;
         WalletBatch(m_storage.GetDatabase())
             .WriteDescriptor(GetID(), m_wallet_descriptor);
         return true;
     }
 }
 
 isminetype DescriptorScriptPubKeyMan::IsMine(const CScript &script) const {
     LOCK(cs_desc_man);
     if (m_map_script_pub_keys.count(script) > 0) {
         return ISMINE_SPENDABLE;
     }
     return ISMINE_NO;
 }
 
 bool DescriptorScriptPubKeyMan::CheckDecryptionKey(
     const CKeyingMaterial &master_key, bool accept_no_keys) {
     LOCK(cs_desc_man);
     if (!m_map_keys.empty()) {
         return false;
     }
 
     // Always pass when there are no encrypted keys
     bool keyPass = m_map_crypted_keys.empty();
     bool keyFail = false;
     for (const auto &mi : m_map_crypted_keys) {
         const CPubKey &pubkey = mi.second.first;
         const std::vector<uint8_t> &crypted_secret = mi.second.second;
         CKey key;
         if (!DecryptKey(master_key, crypted_secret, pubkey, key)) {
             keyFail = true;
             break;
         }
         keyPass = true;
         if (m_decryption_thoroughly_checked) {
             break;
         }
     }
     if (keyPass && keyFail) {
         LogPrintf("The wallet is probably corrupted: Some keys decrypt but not "
                   "all.\n");
         throw std::runtime_error(
             "Error unlocking wallet: some keys decrypt but not all. Your "
             "wallet file may be corrupt.");
     }
     if (keyFail || (!keyPass && !accept_no_keys)) {
         return false;
     }
     m_decryption_thoroughly_checked = true;
     return true;
 }
 
 bool DescriptorScriptPubKeyMan::Encrypt(const CKeyingMaterial &master_key,
                                         WalletBatch *batch) {
     LOCK(cs_desc_man);
     if (!m_map_crypted_keys.empty()) {
         return false;
     }
 
     for (const KeyMap::value_type &key_in : m_map_keys) {
         const CKey &key = key_in.second;
         CPubKey pubkey = key.GetPubKey();
         CKeyingMaterial secret(key.begin(), key.end());
         std::vector<uint8_t> crypted_secret;
         if (!EncryptSecret(master_key, secret, pubkey.GetHash(),
                            crypted_secret)) {
             return false;
         }
         m_map_crypted_keys[pubkey.GetID()] = make_pair(pubkey, crypted_secret);
         batch->WriteCryptedDescriptorKey(GetID(), pubkey, crypted_secret);
     }
     m_map_keys.clear();
     return true;
 }
 
 bool DescriptorScriptPubKeyMan::GetReservedDestination(const OutputType type,
                                                        bool internal,
                                                        CTxDestination &address,
                                                        int64_t &index,
                                                        CKeyPool &keypool) {
     LOCK(cs_desc_man);
     std::string error;
     bool result = GetNewDestination(type, address, error);
     index = m_wallet_descriptor.next_index - 1;
     return result;
 }
 
 void DescriptorScriptPubKeyMan::ReturnDestination(int64_t index, bool internal,
                                                   const CTxDestination &addr) {
     LOCK(cs_desc_man);
     // Only return when the index was the most recent
     if (m_wallet_descriptor.next_index - 1 == index) {
         m_wallet_descriptor.next_index--;
     }
     WalletBatch(m_storage.GetDatabase())
         .WriteDescriptor(GetID(), m_wallet_descriptor);
     NotifyCanGetAddressesChanged();
 }
 
 std::map<CKeyID, CKey> DescriptorScriptPubKeyMan::GetKeys() const {
     AssertLockHeld(cs_desc_man);
     if (m_storage.HasEncryptionKeys() && !m_storage.IsLocked()) {
         KeyMap keys;
         for (auto key_pair : m_map_crypted_keys) {
             const CPubKey &pubkey = key_pair.second.first;
             const std::vector<uint8_t> &crypted_secret = key_pair.second.second;
             CKey key;
             DecryptKey(m_storage.GetEncryptionKey(), crypted_secret, pubkey,
                        key);
             keys[pubkey.GetID()] = key;
         }
         return keys;
     }
     return m_map_keys;
 }
 
 bool DescriptorScriptPubKeyMan::TopUp(unsigned int size) {
     LOCK(cs_desc_man);
     unsigned int target_size;
     if (size > 0) {
         target_size = size;
     } else {
         target_size = std::max(gArgs.GetArg("-keypool", DEFAULT_KEYPOOL_SIZE),
                                int64_t(1));
     }
 
     // Calculate the new range_end
     int32_t new_range_end =
         std::max(m_wallet_descriptor.next_index + int32_t(target_size),
                  m_wallet_descriptor.range_end);
 
     // If the descriptor is not ranged, we actually just want to fill the first
     // cache item
     if (!m_wallet_descriptor.descriptor->IsRange()) {
         new_range_end = 1;
         m_wallet_descriptor.range_end = 1;
         m_wallet_descriptor.range_start = 0;
     }
 
     FlatSigningProvider provider;
     provider.keys = GetKeys();
 
     WalletBatch batch(m_storage.GetDatabase());
     uint256 id = GetID();
     for (int32_t i = m_max_cached_index + 1; i < new_range_end; ++i) {
         FlatSigningProvider out_keys;
         std::vector<CScript> scripts_temp;
         DescriptorCache temp_cache;
         // Maybe we have a cached xpub and we can expand from the cache first
         if (!m_wallet_descriptor.descriptor->ExpandFromCache(
                 i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
             if (!m_wallet_descriptor.descriptor->Expand(
                     i, provider, scripts_temp, out_keys, &temp_cache)) {
                 return false;
             }
         }
         // Add all of the scriptPubKeys to the scriptPubKey set
         for (const CScript &script : scripts_temp) {
             m_map_script_pub_keys[script] = i;
         }
         for (const auto &pk_pair : out_keys.pubkeys) {
             const CPubKey &pubkey = pk_pair.second;
             if (m_map_pubkeys.count(pubkey) != 0) {
                 // We don't need to give an error here.
                 // It doesn't matter which of many valid indexes the pubkey has,
                 // we just need an index where we can derive it and it's private
                 // key
                 continue;
             }
             m_map_pubkeys[pubkey] = i;
         }
         // Write the cache
         for (const auto &parent_xpub_pair :
              temp_cache.GetCachedParentExtPubKeys()) {
             CExtPubKey xpub;
             if (m_wallet_descriptor.cache.GetCachedParentExtPubKey(
                     parent_xpub_pair.first, xpub)) {
                 if (xpub != parent_xpub_pair.second) {
                     throw std::runtime_error(
                         std::string(__func__) +
                         ": New cached parent xpub does not match already "
                         "cached parent xpub");
                 }
                 continue;
             }
             if (!batch.WriteDescriptorParentCache(parent_xpub_pair.second, id,
                                                   parent_xpub_pair.first)) {
                 throw std::runtime_error(std::string(__func__) +
                                          ": writing cache item failed");
             }
             m_wallet_descriptor.cache.CacheParentExtPubKey(
                 parent_xpub_pair.first, parent_xpub_pair.second);
         }
         for (const auto &derived_xpub_map_pair :
              temp_cache.GetCachedDerivedExtPubKeys()) {
             for (const auto &derived_xpub_pair : derived_xpub_map_pair.second) {
                 CExtPubKey xpub;
                 if (m_wallet_descriptor.cache.GetCachedDerivedExtPubKey(
                         derived_xpub_map_pair.first, derived_xpub_pair.first,
                         xpub)) {
                     if (xpub != derived_xpub_pair.second) {
                         throw std::runtime_error(
                             std::string(__func__) +
                             ": New cached derived xpub does not match already "
                             "cached derived xpub");
                     }
                     continue;
                 }
                 if (!batch.WriteDescriptorDerivedCache(
                         derived_xpub_pair.second, id,
                         derived_xpub_map_pair.first, derived_xpub_pair.first)) {
                     throw std::runtime_error(std::string(__func__) +
                                              ": writing cache item failed");
                 }
                 m_wallet_descriptor.cache.CacheDerivedExtPubKey(
                     derived_xpub_map_pair.first, derived_xpub_pair.first,
                     derived_xpub_pair.second);
             }
         }
         m_max_cached_index++;
     }
     m_wallet_descriptor.range_end = new_range_end;
     batch.WriteDescriptor(GetID(), m_wallet_descriptor);
 
     // By this point, the cache size should be the size of the entire range
     assert(m_wallet_descriptor.range_end - 1 == m_max_cached_index);
 
     NotifyCanGetAddressesChanged();
     return true;
 }
 
 void DescriptorScriptPubKeyMan::MarkUnusedAddresses(const CScript &script) {
     LOCK(cs_desc_man);
     if (IsMine(script)) {
         int32_t index = m_map_script_pub_keys[script];
         if (index >= m_wallet_descriptor.next_index) {
             WalletLogPrintf("%s: Detected a used keypool item at index %d, "
                             "mark all keypool items up to this item as used\n",
                             __func__, index);
             m_wallet_descriptor.next_index = index + 1;
         }
         if (!TopUp()) {
             WalletLogPrintf("%s: Topping up keypool failed (locked wallet)\n",
                             __func__);
         }
     }
 }
 
 void DescriptorScriptPubKeyMan::AddDescriptorKey(const CKey &key,
                                                  const CPubKey &pubkey) {
     LOCK(cs_desc_man);
     WalletBatch batch(m_storage.GetDatabase());
     if (!AddDescriptorKeyWithDB(batch, key, pubkey)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing descriptor private key failed");
     }
 }
 
 bool DescriptorScriptPubKeyMan::AddDescriptorKeyWithDB(WalletBatch &batch,
                                                        const CKey &key,
                                                        const CPubKey &pubkey) {
     AssertLockHeld(cs_desc_man);
     assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
 
     if (m_storage.HasEncryptionKeys()) {
         if (m_storage.IsLocked()) {
             return false;
         }
 
         std::vector<uint8_t> crypted_secret;
         CKeyingMaterial secret(key.begin(), key.end());
         if (!EncryptSecret(m_storage.GetEncryptionKey(), secret,
                            pubkey.GetHash(), crypted_secret)) {
             return false;
         }
 
         m_map_crypted_keys[pubkey.GetID()] = make_pair(pubkey, crypted_secret);
         return batch.WriteCryptedDescriptorKey(GetID(), pubkey, crypted_secret);
     } else {
         m_map_keys[pubkey.GetID()] = key;
         return batch.WriteDescriptorKey(GetID(), pubkey, key.GetPrivKey());
     }
 }
 
 bool DescriptorScriptPubKeyMan::SetupDescriptorGeneration(
     const CExtKey &master_key) {
     LOCK(cs_desc_man);
     assert(m_storage.IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
 
     // Ignore when there is already a descriptor
     if (m_wallet_descriptor.descriptor) {
         return false;
     }
 
     int64_t creation_time = GetTime();
 
     std::string xpub = EncodeExtPubKey(master_key.Neuter());
 
     // Build descriptor string
     std::string desc_prefix;
     std::string desc_suffix = "/*)";
     switch (m_address_type) {
         case OutputType::LEGACY: {
             desc_prefix = "pkh(" + xpub + "/44'";
             break;
         }
         default:
             assert(false);
     }
 
     // Mainnet derives at 0', testnet and regtest derive at 1'
     if (m_storage.GetChainParams().IsTestChain()) {
         desc_prefix += "/1'";
     } else {
         desc_prefix += "/0'";
     }
 
     std::string internal_path = m_internal ? "/1" : "/0";
     std::string desc_str = desc_prefix + "/0'" + internal_path + desc_suffix;
 
     // Make the descriptor
     FlatSigningProvider keys;
     std::string error;
     std::unique_ptr<Descriptor> desc = Parse(desc_str, keys, error, false);
     WalletDescriptor w_desc(std::move(desc), creation_time, 0, 0, 0);
     m_wallet_descriptor = w_desc;
 
     // Store the master private key, and descriptor
     WalletBatch batch(m_storage.GetDatabase());
     if (!AddDescriptorKeyWithDB(batch, master_key.key,
                                 master_key.key.GetPubKey())) {
         throw std::runtime_error(
             std::string(__func__) +
             ": writing descriptor master private key failed");
     }
     if (!batch.WriteDescriptor(GetID(), m_wallet_descriptor)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing descriptor failed");
     }
 
     // TopUp
     TopUp();
 
     m_storage.UnsetBlankWalletFlag(batch);
     return true;
 }
 
 bool DescriptorScriptPubKeyMan::IsHDEnabled() const {
     LOCK(cs_desc_man);
     return m_wallet_descriptor.descriptor->IsRange();
 }
 
 bool DescriptorScriptPubKeyMan::CanGetAddresses(bool internal) const {
     // We can only give out addresses from descriptors that are single type (not
     // combo), ranged, and either have cached keys or can generate more keys
     // (ignoring encryption)
     LOCK(cs_desc_man);
     return m_wallet_descriptor.descriptor->IsSingleType() &&
            m_wallet_descriptor.descriptor->IsRange() &&
            (HavePrivateKeys() ||
             m_wallet_descriptor.next_index < m_wallet_descriptor.range_end);
 }
 
 bool DescriptorScriptPubKeyMan::HavePrivateKeys() const {
     LOCK(cs_desc_man);
     return m_map_keys.size() > 0 || m_map_crypted_keys.size() > 0;
 }
 
 int64_t DescriptorScriptPubKeyMan::GetOldestKeyPoolTime() const {
     // This is only used for getwalletinfo output and isn't relevant to
     // descriptor wallets. The magic number 0 indicates that it shouldn't be
     // displayed so that's what we return.
     return 0;
 }
 
 size_t DescriptorScriptPubKeyMan::KeypoolCountExternalKeys() const {
     if (m_internal) {
         return 0;
     }
     return GetKeyPoolSize();
 }
 
 unsigned int DescriptorScriptPubKeyMan::GetKeyPoolSize() const {
     LOCK(cs_desc_man);
     return m_wallet_descriptor.range_end - m_wallet_descriptor.next_index;
 }
 
 int64_t DescriptorScriptPubKeyMan::GetTimeFirstKey() const {
     LOCK(cs_desc_man);
     return m_wallet_descriptor.creation_time;
 }
 
 std::unique_ptr<FlatSigningProvider>
 DescriptorScriptPubKeyMan::GetSigningProvider(const CScript &script,
                                               bool include_private) const {
     LOCK(cs_desc_man);
 
     // Find the index of the script
     auto it = m_map_script_pub_keys.find(script);
     if (it == m_map_script_pub_keys.end()) {
         return nullptr;
     }
     int32_t index = it->second;
 
     return GetSigningProvider(index, include_private);
 }
 
 std::unique_ptr<FlatSigningProvider>
 DescriptorScriptPubKeyMan::GetSigningProvider(const CPubKey &pubkey) const {
     LOCK(cs_desc_man);
 
     // Find index of the pubkey
     auto it = m_map_pubkeys.find(pubkey);
     if (it == m_map_pubkeys.end()) {
         return nullptr;
     }
     int32_t index = it->second;
 
     // Always try to get the signing provider with private keys. This function
     // should only be called during signing anyways
     return GetSigningProvider(index, true);
 }
 
 std::unique_ptr<FlatSigningProvider>
 DescriptorScriptPubKeyMan::GetSigningProvider(int32_t index,
                                               bool include_private) const {
     AssertLockHeld(cs_desc_man);
     // Get the scripts, keys, and key origins for this script
     std::unique_ptr<FlatSigningProvider> out_keys =
         std::make_unique<FlatSigningProvider>();
     std::vector<CScript> scripts_temp;
     if (!m_wallet_descriptor.descriptor->ExpandFromCache(
             index, m_wallet_descriptor.cache, scripts_temp, *out_keys)) {
         return nullptr;
     }
 
     if (HavePrivateKeys() && include_private) {
         FlatSigningProvider master_provider;
         master_provider.keys = GetKeys();
         m_wallet_descriptor.descriptor->ExpandPrivate(index, master_provider,
                                                       *out_keys);
     }
 
     return out_keys;
 }
 
 std::unique_ptr<SigningProvider>
 DescriptorScriptPubKeyMan::GetSolvingProvider(const CScript &script) const {
     return GetSigningProvider(script, false);
 }
 
 bool DescriptorScriptPubKeyMan::CanProvide(const CScript &script,
                                            SignatureData &sigdata) {
     return IsMine(script);
 }
 
 bool DescriptorScriptPubKeyMan::SignTransaction(
     CMutableTransaction &tx, const std::map<COutPoint, Coin> &coins,
     SigHashType sighash, std::map<int, std::string> &input_errors) const {
     std::unique_ptr<FlatSigningProvider> keys =
         std::make_unique<FlatSigningProvider>();
     for (const auto &coin_pair : coins) {
         std::unique_ptr<FlatSigningProvider> coin_keys =
             GetSigningProvider(coin_pair.second.GetTxOut().scriptPubKey, true);
         if (!coin_keys) {
             continue;
         }
         *keys = Merge(*keys, *coin_keys);
     }
 
     return ::SignTransaction(tx, keys.get(), coins, sighash, input_errors);
 }
 
 SigningResult
 DescriptorScriptPubKeyMan::SignMessage(const std::string &message,
                                        const PKHash &pkhash,
                                        std::string &str_sig) const {
     std::unique_ptr<FlatSigningProvider> keys =
         GetSigningProvider(GetScriptForDestination(pkhash), true);
     if (!keys) {
         return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
     }
 
     CKeyID key_id(pkhash);
     CKey key;
     if (!keys->GetKey(key_id, key)) {
         return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
     }
 
     if (!MessageSign(key, message, str_sig)) {
         return SigningResult::SIGNING_FAILED;
     }
     return SigningResult::OK;
 }
 
 TransactionError
 DescriptorScriptPubKeyMan::FillPSBT(PartiallySignedTransaction &psbtx,
                                     SigHashType sighash_type, bool sign,
                                     bool bip32derivs) const {
     for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
         PSBTInput &input = psbtx.inputs.at(i);
 
         if (PSBTInputSigned(input)) {
             continue;
         }
 
         // Verify input looks sane. This will check that we have at most one
         // uxto, witness or non-witness.
         if (!input.IsSane()) {
             return TransactionError::INVALID_PSBT;
         }
 
         // Get the Sighash type
         if (sign && input.sighash_type.getRawSigHashType() > 0 &&
             input.sighash_type != sighash_type) {
             return TransactionError::SIGHASH_MISMATCH;
         }
 
         // Get the scriptPubKey to know which SigningProvider to use
         CScript script;
         if (!input.utxo.IsNull()) {
             script = input.utxo.scriptPubKey;
         } else {
             // There's no UTXO so we can just skip this now
             continue;
         }
         SignatureData sigdata;
         input.FillSignatureData(sigdata);
 
         std::unique_ptr<FlatSigningProvider> keys =
             std::make_unique<FlatSigningProvider>();
         std::unique_ptr<FlatSigningProvider> script_keys =
             GetSigningProvider(script, sign);
         if (script_keys) {
             *keys = Merge(*keys, *script_keys);
         } else {
             // Maybe there are pubkeys listed that we can sign for
             script_keys = std::make_unique<FlatSigningProvider>();
             for (const auto &pk_pair : input.hd_keypaths) {
                 const CPubKey &pubkey = pk_pair.first;
                 std::unique_ptr<FlatSigningProvider> pk_keys =
                     GetSigningProvider(pubkey);
                 if (pk_keys) {
                     *keys = Merge(*keys, *pk_keys);
                 }
             }
         }
 
         SignPSBTInput(HidingSigningProvider(keys.get(), !sign, !bip32derivs),
                       psbtx, i, sighash_type);
     }
 
     // Fill in the bip32 keypaths and redeemscripts for the outputs so that
     // hardware wallets can identify change
     for (size_t i = 0; i < psbtx.tx->vout.size(); ++i) {
         std::unique_ptr<SigningProvider> keys =
             GetSolvingProvider(psbtx.tx->vout.at(i).scriptPubKey);
         if (!keys) {
             continue;
         }
         UpdatePSBTOutput(HidingSigningProvider(keys.get(), true, !bip32derivs),
                          psbtx, i);
     }
 
     return TransactionError::OK;
 }
 
 std::unique_ptr<CKeyMetadata>
 DescriptorScriptPubKeyMan::GetMetadata(const CTxDestination &dest) const {
     std::unique_ptr<SigningProvider> provider =
         GetSigningProvider(GetScriptForDestination(dest));
     if (provider) {
         KeyOriginInfo orig;
         CKeyID key_id = GetKeyForDestination(*provider, dest);
         if (provider->GetKeyOrigin(key_id, orig)) {
             LOCK(cs_desc_man);
             std::unique_ptr<CKeyMetadata> meta =
                 std::make_unique<CKeyMetadata>();
             meta->key_origin = orig;
             meta->has_key_origin = true;
             meta->nCreateTime = m_wallet_descriptor.creation_time;
             return meta;
         }
     }
     return nullptr;
 }
 
 uint256 DescriptorScriptPubKeyMan::GetID() const {
     LOCK(cs_desc_man);
     std::string desc_str = m_wallet_descriptor.descriptor->ToString();
     uint256 id;
     CSHA256()
         .Write((uint8_t *)desc_str.data(), desc_str.size())
         .Finalize(id.begin());
     return id;
 }
 
 void DescriptorScriptPubKeyMan::SetType(OutputType type, bool internal) {
     this->m_address_type = type;
     this->m_internal = internal;
 }
 
 void DescriptorScriptPubKeyMan::SetCache(const DescriptorCache &cache) {
     LOCK(cs_desc_man);
     m_wallet_descriptor.cache = cache;
     for (int32_t i = m_wallet_descriptor.range_start;
          i < m_wallet_descriptor.range_end; ++i) {
         FlatSigningProvider out_keys;
         std::vector<CScript> scripts_temp;
         if (!m_wallet_descriptor.descriptor->ExpandFromCache(
                 i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
             throw std::runtime_error(
                 "Error: Unable to expand wallet descriptor from cache");
         }
         // Add all of the scriptPubKeys to the scriptPubKey set
         for (const CScript &script : scripts_temp) {
             if (m_map_script_pub_keys.count(script) != 0) {
                 throw std::runtime_error(
                     strprintf("Error: Already loaded script at index %d as "
                               "being at index %d",
                               i, m_map_script_pub_keys[script]));
             }
             m_map_script_pub_keys[script] = i;
         }
         for (const auto &pk_pair : out_keys.pubkeys) {
             const CPubKey &pubkey = pk_pair.second;
             if (m_map_pubkeys.count(pubkey) != 0) {
                 // We don't need to give an error here.
                 // It doesn't matter which of many valid indexes the pubkey has,
                 // we just need an index where we can derive it and it's private
                 // key
                 continue;
             }
             m_map_pubkeys[pubkey] = i;
         }
         m_max_cached_index++;
     }
 }
 
 bool DescriptorScriptPubKeyMan::AddKey(const CKeyID &key_id, const CKey &key) {
     LOCK(cs_desc_man);
     m_map_keys[key_id] = key;
     return true;
 }
 
 bool DescriptorScriptPubKeyMan::AddCryptedKey(
     const CKeyID &key_id, const CPubKey &pubkey,
     const std::vector<uint8_t> &crypted_key) {
     LOCK(cs_desc_man);
     if (!m_map_keys.empty()) {
         return false;
     }
 
     m_map_crypted_keys[key_id] = make_pair(pubkey, crypted_key);
     return true;
 }
 
 bool DescriptorScriptPubKeyMan::HasWalletDescriptor(
     const WalletDescriptor &desc) const {
     LOCK(cs_desc_man);
     return m_wallet_descriptor.descriptor != nullptr &&
            desc.descriptor != nullptr &&
            m_wallet_descriptor.descriptor->ToString() ==
                desc.descriptor->ToString();
 }
 
 void DescriptorScriptPubKeyMan::WriteDescriptor() {
     LOCK(cs_desc_man);
     WalletBatch batch(m_storage.GetDatabase());
     if (!batch.WriteDescriptor(GetID(), m_wallet_descriptor)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing descriptor failed");
     }
 }
 
 const WalletDescriptor DescriptorScriptPubKeyMan::GetWalletDescriptor() const {
     return m_wallet_descriptor;
 }
 
 const std::vector<CScript> DescriptorScriptPubKeyMan::GetScriptPubKeys() const {
     LOCK(cs_desc_man);
     std::vector<CScript> script_pub_keys;
     script_pub_keys.reserve(m_map_script_pub_keys.size());
 
     for (auto const &script_pub_key : m_map_script_pub_keys) {
         script_pub_keys.push_back(script_pub_key.first);
     }
     return script_pub_keys;
 }