diff --git a/src/bench/ccoins_caching.cpp b/src/bench/ccoins_caching.cpp
index 1ec1210f2..da395124c 100644
--- a/src/bench/ccoins_caching.cpp
+++ b/src/bench/ccoins_caching.cpp
@@ -1,91 +1,91 @@
 // Copyright (c) 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 <bench/bench.h>
 #include <coins.h>
 #include <policy/policy.h>
 #include <wallet/crypter.h>
 
 #include <vector>
 
 // FIXME: Dedup with SetupDummyInputs in test/transaction_tests.cpp.
 //
 // Helper: create two dummy transactions, each with
 // two outputs.  The first has 11 and 50 COIN outputs
 // paid to a TX_PUBKEY, the second 21 and 22 COIN outputs
 // paid to a TX_PUBKEYHASH.
 //
 static std::vector<CMutableTransaction>
 SetupDummyInputs(CBasicKeyStore &keystoreRet, CCoinsViewCache &coinsRet) {
     std::vector<CMutableTransaction> dummyTransactions;
     dummyTransactions.resize(2);
 
     // Add some keys to the keystore:
     CKey key[4];
     for (int i = 0; i < 4; i++) {
         key[i].MakeNewKey(i % 2);
         keystoreRet.AddKey(key[i]);
     }
 
     // Create some dummy input transactions
     dummyTransactions[0].vout.resize(2);
     dummyTransactions[0].vout[0].nValue = 11 * COIN;
     dummyTransactions[0].vout[0].scriptPubKey
         << ToByteVector(key[0].GetPubKey()) << OP_CHECKSIG;
     dummyTransactions[0].vout[1].nValue = 50 * COIN;
     dummyTransactions[0].vout[1].scriptPubKey
         << ToByteVector(key[1].GetPubKey()) << OP_CHECKSIG;
     AddCoins(coinsRet, CTransaction(dummyTransactions[0]), 0);
 
     dummyTransactions[1].vout.resize(2);
     dummyTransactions[1].vout[0].nValue = 21 * COIN;
     dummyTransactions[1].vout[0].scriptPubKey =
-        GetScriptForDestination(key[2].GetPubKey().GetID());
+        GetScriptForDestination(PKHash(key[2].GetPubKey()));
     dummyTransactions[1].vout[1].nValue = 22 * COIN;
     dummyTransactions[1].vout[1].scriptPubKey =
-        GetScriptForDestination(key[3].GetPubKey().GetID());
+        GetScriptForDestination(PKHash(key[3].GetPubKey()));
     AddCoins(coinsRet, CTransaction(dummyTransactions[1]), 0);
 
     return dummyTransactions;
 }
 
 // Microbenchmark for simple accesses to a CCoinsViewCache database. Note from
 // laanwj, "replicating the actual usage patterns of the client is hard though,
 // many times micro-benchmarks of the database showed completely different
 // characteristics than e.g. reindex timings. But that's not a requirement of
 // every benchmark."
 // (https://github.com/bitcoin/bitcoin/issues/7883#issuecomment-224807484)
 static void CCoinsCaching(benchmark::State &state) {
     CBasicKeyStore keystore;
     CCoinsView coinsDummy;
     CCoinsViewCache coins(&coinsDummy);
     std::vector<CMutableTransaction> dummyTransactions =
         SetupDummyInputs(keystore, coins);
 
     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 * COIN;
     t1.vout[0].scriptPubKey << OP_1;
 
     // Benchmark.
     while (state.KeepRunning()) {
         CTransaction t(t1);
         bool success =
             AreInputsStandard(t, coins, STANDARD_SCRIPT_VERIFY_FLAGS);
         assert(success);
         Amount value = coins.GetValueIn(t);
         assert(value == (50 + 21 + 22) * COIN);
     }
 }
 
 BENCHMARK(CCoinsCaching, 170 * 1000);
diff --git a/src/bitcoin-tx.cpp b/src/bitcoin-tx.cpp
index 7259948fc..936c4ee3e 100644
--- a/src/bitcoin-tx.cpp
+++ b/src/bitcoin-tx.cpp
@@ -1,909 +1,909 @@
 // 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 <keystore.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <script/sign.h>
 #include <util/moneystr.h>
 #include <util/strencodings.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() {
     gArgs.AddArg("-?", "This help message", ArgsManager::ALLOW_ANY,
                  OptionsCategory::OPTIONS);
     gArgs.AddArg("-create", "Create new, empty TX.", ArgsManager::ALLOW_ANY,
                  OptionsCategory::OPTIONS);
     gArgs.AddArg("-json", "Select JSON output", ArgsManager::ALLOW_ANY,
                  OptionsCategory::OPTIONS);
     gArgs.AddArg("-txid",
                  "Output only the hex-encoded transaction id of the resultant "
                  "transaction.",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     SetupChainParamsBaseOptions();
 
     gArgs.AddArg("delin=N", "Delete input N from TX", ArgsManager::ALLOW_ANY,
                  OptionsCategory::COMMANDS);
     gArgs.AddArg("delout=N", "Delete output N from TX", ArgsManager::ALLOW_ANY,
                  OptionsCategory::COMMANDS);
     gArgs.AddArg("in=TXID:VOUT(:SEQUENCE_NUMBER)", "Add input to TX",
                  ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
     gArgs.AddArg("locktime=N", "Set TX lock time to N", ArgsManager::ALLOW_ANY,
                  OptionsCategory::COMMANDS);
     gArgs.AddArg("nversion=N", "Set TX version to N", ArgsManager::ALLOW_ANY,
                  OptionsCategory::COMMANDS);
     gArgs.AddArg("outaddr=VALUE:ADDRESS", "Add address-based output to TX",
                  ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
     gArgs.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);
     gArgs.AddArg("outdata=[VALUE:]DATA", "Add data-based output to TX",
                  ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
     gArgs.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);
     gArgs.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);
     gArgs.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);
 
     gArgs.AddArg("load=NAME:FILENAME",
                  "Load JSON file FILENAME into register NAME",
                  ArgsManager::ALLOW_ANY, OptionsCategory::REGISTER_COMMANDS);
     gArgs.AddArg("set=NAME:JSON-STRING",
                  "Set register NAME to given JSON-STRING",
                  ArgsManager::ALLOW_ANY, OptionsCategory::REGISTER_COMMANDS);
 
     // Hidden
     gArgs.AddArg("-h", "", ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
     gArgs.AddArg("-help", "", ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
 }
 
 //
 // 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();
     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(CScriptID(scriptPubKey));
+        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.");
     }
 
     // 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(CScriptID(scriptPubKey));
+        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(CScriptID(scriptPubKey));
+        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.");
     }
 
     CBasicKeyStore 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 CKeyStore &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/cashaddrenc.cpp b/src/cashaddrenc.cpp
index 5aacf0c87..a644512d4 100644
--- a/src/cashaddrenc.cpp
+++ b/src/cashaddrenc.cpp
@@ -1,180 +1,180 @@
 // 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 <cashaddrenc.h>
 
 #include <cashaddr.h>
 #include <chainparams.h>
 #include <pubkey.h>
 #include <script/script.h>
 #include <util/strencodings.h>
 
 #include <boost/variant/static_visitor.hpp>
 
 #include <algorithm>
 
 namespace {
 
 // Convert the data part to a 5 bit representation.
 template <class T>
 std::vector<uint8_t> PackAddrData(const T &id, uint8_t type) {
     uint8_t version_byte(type << 3);
     size_t size = id.size();
     uint8_t encoded_size = 0;
     switch (size * 8) {
         case 160:
             encoded_size = 0;
             break;
         case 192:
             encoded_size = 1;
             break;
         case 224:
             encoded_size = 2;
             break;
         case 256:
             encoded_size = 3;
             break;
         case 320:
             encoded_size = 4;
             break;
         case 384:
             encoded_size = 5;
             break;
         case 448:
             encoded_size = 6;
             break;
         case 512:
             encoded_size = 7;
             break;
         default:
             throw std::runtime_error(
                 "Error packing cashaddr: invalid address length");
     }
     version_byte |= encoded_size;
     std::vector<uint8_t> data = {version_byte};
     data.insert(data.end(), std::begin(id), std::end(id));
 
     std::vector<uint8_t> converted;
     // Reserve the number of bytes required for a 5-bit packed version of a
     // hash, with version byte.  Add half a byte(4) so integer math provides
     // the next multiple-of-5 that would fit all the data.
     converted.reserve(((size + 1) * 8 + 4) / 5);
     ConvertBits<8, 5, true>([&](uint8_t c) { converted.push_back(c); },
                             std::begin(data), std::end(data));
 
     return converted;
 }
 
 // Implements encoding of CTxDestination using cashaddr.
 class CashAddrEncoder : public boost::static_visitor<std::string> {
 public:
     CashAddrEncoder(const CChainParams &p) : params(p) {}
 
-    std::string operator()(const CKeyID &id) const {
+    std::string operator()(const PKHash &id) const {
         std::vector<uint8_t> data = PackAddrData(id, PUBKEY_TYPE);
         return cashaddr::Encode(params.CashAddrPrefix(), data);
     }
 
-    std::string operator()(const CScriptID &id) const {
+    std::string operator()(const ScriptHash &id) const {
         std::vector<uint8_t> data = PackAddrData(id, SCRIPT_TYPE);
         return cashaddr::Encode(params.CashAddrPrefix(), data);
     }
 
     std::string operator()(const CNoDestination &) const { return ""; }
 
 private:
     const CChainParams &params;
 };
 
 } // namespace
 
 std::string EncodeCashAddr(const CTxDestination &dst,
                            const CChainParams &params) {
     return boost::apply_visitor(CashAddrEncoder(params), dst);
 }
 
 std::string EncodeCashAddr(const std::string &prefix,
                            const CashAddrContent &content) {
     std::vector<uint8_t> data = PackAddrData(content.hash, content.type);
     return cashaddr::Encode(prefix, data);
 }
 
 CTxDestination DecodeCashAddr(const std::string &addr,
                               const CChainParams &params) {
     CashAddrContent content =
         DecodeCashAddrContent(addr, params.CashAddrPrefix());
     if (content.hash.size() == 0) {
         return CNoDestination{};
     }
 
     return DecodeCashAddrDestination(content);
 }
 
 CashAddrContent DecodeCashAddrContent(const std::string &addr,
                                       const std::string &expectedPrefix) {
     std::string prefix;
     std::vector<uint8_t> payload;
     std::tie(prefix, payload) = cashaddr::Decode(addr, expectedPrefix);
 
     if (prefix != expectedPrefix) {
         return {};
     }
 
     if (payload.empty()) {
         return {};
     }
 
     std::vector<uint8_t> data;
     data.reserve(payload.size() * 5 / 8);
     if (!ConvertBits<5, 8, false>([&](uint8_t c) { data.push_back(c); },
                                   begin(payload), end(payload))) {
         return {};
     }
 
     // Decode type and size from the version.
     uint8_t version = data[0];
     if (version & 0x80) {
         // First bit is reserved.
         return {};
     }
 
     auto type = CashAddrType((version >> 3) & 0x1f);
     uint32_t hash_size = 20 + 4 * (version & 0x03);
     if (version & 0x04) {
         hash_size *= 2;
     }
 
     // Check that we decoded the exact number of bytes we expected.
     if (data.size() != hash_size + 1) {
         return {};
     }
 
     // Pop the version.
     data.erase(data.begin());
     return {type, std::move(data)};
 }
 
 CTxDestination DecodeCashAddrDestination(const CashAddrContent &content) {
     if (content.hash.size() != 20) {
         // Only 20 bytes hash are supported now.
         return CNoDestination{};
     }
 
     uint160 hash;
     std::copy(begin(content.hash), end(content.hash), hash.begin());
 
     switch (content.type) {
         case PUBKEY_TYPE:
-            return CKeyID(hash);
+            return PKHash(hash);
         case SCRIPT_TYPE:
-            return CScriptID(hash);
+            return ScriptHash(hash);
         default:
             return CNoDestination{};
     }
 }
 
 // PackCashAddrContent allows for testing PackAddrData in unittests due to
 // template definitions.
 std::vector<uint8_t> PackCashAddrContent(const CashAddrContent &content) {
     return PackAddrData(content.hash, content.type);
 }
diff --git a/src/key_io.cpp b/src/key_io.cpp
index a2abd215d..7ea205158 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -1,192 +1,192 @@
 // Copyright (c) 2014-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 <key_io.h>
 
 #include <base58.h>
 #include <cashaddrenc.h>
 #include <chainparams.h>
 #include <config.h>
 #include <script/script.h>
 #include <util/strencodings.h>
 
 #include <boost/variant/apply_visitor.hpp>
 #include <boost/variant/static_visitor.hpp>
 
 #include <algorithm>
 #include <cassert>
 #include <cstring>
 
 namespace {
 class DestinationEncoder : public boost::static_visitor<std::string> {
 private:
     const CChainParams &m_params;
 
 public:
     explicit DestinationEncoder(const CChainParams &params)
         : m_params(params) {}
 
-    std::string operator()(const CKeyID &id) const {
+    std::string operator()(const PKHash &id) const {
         std::vector<uint8_t> data =
             m_params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
         data.insert(data.end(), id.begin(), id.end());
         return EncodeBase58Check(data);
     }
 
-    std::string operator()(const CScriptID &id) const {
+    std::string operator()(const ScriptHash &id) const {
         std::vector<uint8_t> data =
             m_params.Base58Prefix(CChainParams::SCRIPT_ADDRESS);
         data.insert(data.end(), id.begin(), id.end());
         return EncodeBase58Check(data);
     }
 
     std::string operator()(const CNoDestination &no) const { return {}; }
 };
 
 CTxDestination DecodeLegacyDestination(const std::string &str,
                                        const CChainParams &params) {
     std::vector<uint8_t> data;
     uint160 hash;
     if (!DecodeBase58Check(str, data)) {
         return CNoDestination();
     }
     // base58-encoded Bitcoin addresses.
     // Public-key-hash-addresses have version 0 (or 111 testnet).
     // The data vector contains RIPEMD160(SHA256(pubkey)), where pubkey is
     // the serialized public key.
     const std::vector<uint8_t> &pubkey_prefix =
         params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
     if (data.size() == hash.size() + pubkey_prefix.size() &&
         std::equal(pubkey_prefix.begin(), pubkey_prefix.end(), data.begin())) {
         std::copy(data.begin() + pubkey_prefix.size(), data.end(),
                   hash.begin());
-        return CKeyID(hash);
+        return PKHash(hash);
     }
     // Script-hash-addresses have version 5 (or 196 testnet).
     // The data vector contains RIPEMD160(SHA256(cscript)), where cscript is
     // the serialized redemption script.
     const std::vector<uint8_t> &script_prefix =
         params.Base58Prefix(CChainParams::SCRIPT_ADDRESS);
     if (data.size() == hash.size() + script_prefix.size() &&
         std::equal(script_prefix.begin(), script_prefix.end(), data.begin())) {
         std::copy(data.begin() + script_prefix.size(), data.end(),
                   hash.begin());
-        return CScriptID(hash);
+        return ScriptHash(hash);
     }
     return CNoDestination();
 }
 } // namespace
 
 CKey DecodeSecret(const std::string &str) {
     CKey key;
     std::vector<uint8_t> data;
     if (DecodeBase58Check(str, data)) {
         const std::vector<uint8_t> &privkey_prefix =
             Params().Base58Prefix(CChainParams::SECRET_KEY);
         if ((data.size() == 32 + privkey_prefix.size() ||
              (data.size() == 33 + privkey_prefix.size() && data.back() == 1)) &&
             std::equal(privkey_prefix.begin(), privkey_prefix.end(),
                        data.begin())) {
             bool compressed = data.size() == 33 + privkey_prefix.size();
             key.Set(data.begin() + privkey_prefix.size(),
                     data.begin() + privkey_prefix.size() + 32, compressed);
         }
     }
     if (!data.empty()) {
         memory_cleanse(data.data(), data.size());
     }
     return key;
 }
 
 std::string EncodeSecret(const CKey &key) {
     assert(key.IsValid());
     std::vector<uint8_t> data = Params().Base58Prefix(CChainParams::SECRET_KEY);
     data.insert(data.end(), key.begin(), key.end());
     if (key.IsCompressed()) {
         data.push_back(1);
     }
     std::string ret = EncodeBase58Check(data);
     memory_cleanse(data.data(), data.size());
     return ret;
 }
 
 CExtPubKey DecodeExtPubKey(const std::string &str) {
     CExtPubKey key;
     std::vector<uint8_t> data;
     if (DecodeBase58Check(str, data)) {
         const std::vector<uint8_t> &prefix =
             Params().Base58Prefix(CChainParams::EXT_PUBLIC_KEY);
         if (data.size() == BIP32_EXTKEY_SIZE + prefix.size() &&
             std::equal(prefix.begin(), prefix.end(), data.begin())) {
             key.Decode(data.data() + prefix.size());
         }
     }
     return key;
 }
 
 std::string EncodeExtPubKey(const CExtPubKey &key) {
     std::vector<uint8_t> data =
         Params().Base58Prefix(CChainParams::EXT_PUBLIC_KEY);
     size_t size = data.size();
     data.resize(size + BIP32_EXTKEY_SIZE);
     key.Encode(data.data() + size);
     std::string ret = EncodeBase58Check(data);
     return ret;
 }
 
 CExtKey DecodeExtKey(const std::string &str) {
     CExtKey key;
     std::vector<uint8_t> data;
     if (DecodeBase58Check(str, data)) {
         const std::vector<uint8_t> &prefix =
             Params().Base58Prefix(CChainParams::EXT_SECRET_KEY);
         if (data.size() == BIP32_EXTKEY_SIZE + prefix.size() &&
             std::equal(prefix.begin(), prefix.end(), data.begin())) {
             key.Decode(data.data() + prefix.size());
         }
     }
     return key;
 }
 
 std::string EncodeExtKey(const CExtKey &key) {
     std::vector<uint8_t> data =
         Params().Base58Prefix(CChainParams::EXT_SECRET_KEY);
     size_t size = data.size();
     data.resize(size + BIP32_EXTKEY_SIZE);
     key.Encode(data.data() + size);
     std::string ret = EncodeBase58Check(data);
     memory_cleanse(data.data(), data.size());
     return ret;
 }
 
 std::string EncodeDestination(const CTxDestination &dest,
                               const Config &config) {
     const CChainParams &params = config.GetChainParams();
     return config.UseCashAddrEncoding() ? EncodeCashAddr(dest, params)
                                         : EncodeLegacyAddr(dest, params);
 }
 
 CTxDestination DecodeDestination(const std::string &addr,
                                  const CChainParams &params) {
     CTxDestination dst = DecodeCashAddr(addr, params);
     if (IsValidDestination(dst)) {
         return dst;
     }
     return DecodeLegacyAddr(addr, params);
 }
 
 bool IsValidDestinationString(const std::string &str,
                               const CChainParams &params) {
     return IsValidDestination(DecodeDestination(str, params));
 }
 
 std::string EncodeLegacyAddr(const CTxDestination &dest,
                              const CChainParams &params) {
     return boost::apply_visitor(DestinationEncoder(params), dest);
 }
 
 CTxDestination DecodeLegacyAddr(const std::string &str,
                                 const CChainParams &params) {
     return DecodeLegacyDestination(str, params);
 }
diff --git a/src/keystore.cpp b/src/keystore.cpp
index afa830242..6dd1f84db 100644
--- a/src/keystore.cpp
+++ b/src/keystore.cpp
@@ -1,178 +1,178 @@
 // Copyright (c) 2009-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 <keystore.h>
 
 #include <key.h>
 #include <pubkey.h>
 #include <util/system.h>
 
 void CBasicKeyStore::ImplicitlyLearnRelatedKeyScripts(const CPubKey &pubkey) {
     AssertLockHeld(cs_KeyStore);
     CKeyID key_id = pubkey.GetID();
     // We must actually know about this key already.
     assert(HaveKey(key_id) || mapWatchKeys.count(key_id));
     // This adds the redeemscripts necessary to detect alternative outputs using
     // the same keys. Also note that having superfluous scripts in the keystore
     // never hurts. They're only used to guide recursion in signing and IsMine
     // logic - if a script is present but we can't do anything with it, it has
     // no effect. "Implicitly" refers to fact that scripts are derived
     // automatically from existing keys, and are present in memory, even without
     // being explicitly loaded (e.g. from a file).
 
     // Right now there are none so do nothing.
 }
 
 bool CBasicKeyStore::GetPubKey(const CKeyID &address,
                                CPubKey &vchPubKeyOut) const {
     CKey key;
     if (!GetKey(address, key)) {
         LOCK(cs_KeyStore);
         WatchKeyMap::const_iterator it = mapWatchKeys.find(address);
         if (it != mapWatchKeys.end()) {
             vchPubKeyOut = it->second;
             return true;
         }
         return false;
     }
     vchPubKeyOut = key.GetPubKey();
     return true;
 }
 
 bool CBasicKeyStore::AddKeyPubKey(const CKey &key, const CPubKey &pubkey) {
     LOCK(cs_KeyStore);
     mapKeys[pubkey.GetID()] = key;
     ImplicitlyLearnRelatedKeyScripts(pubkey);
     return true;
 }
 
 bool CBasicKeyStore::HaveKey(const CKeyID &address) const {
     LOCK(cs_KeyStore);
     return mapKeys.count(address) > 0;
 }
 
 std::set<CKeyID> CBasicKeyStore::GetKeys() const {
     LOCK(cs_KeyStore);
     std::set<CKeyID> set_address;
     for (const auto &mi : mapKeys) {
         set_address.insert(mi.first);
     }
     return set_address;
 }
 
 bool CBasicKeyStore::GetKey(const CKeyID &address, CKey &keyOut) const {
     LOCK(cs_KeyStore);
     KeyMap::const_iterator mi = mapKeys.find(address);
     if (mi != mapKeys.end()) {
         keyOut = mi->second;
         return true;
     }
     return false;
 }
 
 bool CBasicKeyStore::AddCScript(const CScript &redeemScript) {
     if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE) {
         return error("CBasicKeyStore::AddCScript(): redeemScripts > %i bytes "
                      "are invalid",
                      MAX_SCRIPT_ELEMENT_SIZE);
     }
 
     LOCK(cs_KeyStore);
     mapScripts[CScriptID(redeemScript)] = redeemScript;
     return true;
 }
 
 bool CBasicKeyStore::HaveCScript(const CScriptID &hash) const {
     LOCK(cs_KeyStore);
     return mapScripts.count(hash) > 0;
 }
 
 std::set<CScriptID> CBasicKeyStore::GetCScripts() const {
     LOCK(cs_KeyStore);
     std::set<CScriptID> set_script;
     for (const auto &mi : mapScripts) {
         set_script.insert(mi.first);
     }
     return set_script;
 }
 
 bool CBasicKeyStore::GetCScript(const CScriptID &hash,
                                 CScript &redeemScriptOut) const {
     LOCK(cs_KeyStore);
     ScriptMap::const_iterator mi = mapScripts.find(hash);
     if (mi != mapScripts.end()) {
         redeemScriptOut = (*mi).second;
         return true;
     }
     return false;
 }
 
 static bool ExtractPubKey(const CScript &dest, CPubKey &pubKeyOut) {
     // TODO: Use Solver to extract this?
     CScript::const_iterator pc = dest.begin();
     opcodetype opcode;
     std::vector<uint8_t> vch;
     if (!dest.GetOp(pc, opcode, vch) || !CPubKey::ValidSize(vch)) {
         return false;
     }
     pubKeyOut = CPubKey(vch);
     if (!pubKeyOut.IsFullyValid()) {
         return false;
     }
     if (!dest.GetOp(pc, opcode, vch) || opcode != OP_CHECKSIG ||
         dest.GetOp(pc, opcode, vch)) {
         return false;
     }
     return true;
 }
 
 bool CBasicKeyStore::AddWatchOnly(const CScript &dest) {
     LOCK(cs_KeyStore);
     setWatchOnly.insert(dest);
     CPubKey pubKey;
     if (ExtractPubKey(dest, pubKey)) {
         mapWatchKeys[pubKey.GetID()] = pubKey;
         ImplicitlyLearnRelatedKeyScripts(pubKey);
     }
     return true;
 }
 
 bool CBasicKeyStore::RemoveWatchOnly(const CScript &dest) {
     LOCK(cs_KeyStore);
     setWatchOnly.erase(dest);
     CPubKey pubKey;
     if (ExtractPubKey(dest, pubKey)) {
         mapWatchKeys.erase(pubKey.GetID());
     }
     // Related CScripts are not removed; having superfluous scripts around is
     // harmless (see comment in ImplicitlyLearnRelatedKeyScripts).
     return true;
 }
 
 bool CBasicKeyStore::HaveWatchOnly(const CScript &dest) const {
     LOCK(cs_KeyStore);
     return setWatchOnly.count(dest) > 0;
 }
 
 bool CBasicKeyStore::HaveWatchOnly() const {
     LOCK(cs_KeyStore);
     return (!setWatchOnly.empty());
 }
 
 CKeyID GetKeyForDestination(const CKeyStore &store,
                             const CTxDestination &dest) {
     // Only supports destinations which map to single public keys, i.e. P2PKH.
-    if (auto id = boost::get<CKeyID>(&dest)) {
-        return *id;
+    if (auto id = boost::get<PKHash>(&dest)) {
+        return CKeyID(*id);
     }
     return CKeyID();
 }
 
 bool HaveKey(const CKeyStore &store, const CKey &key) {
     CKey key2;
     key2.Set(key.begin(), key.end(), !key.IsCompressed());
     return store.HaveKey(key.GetPubKey().GetID()) ||
            store.HaveKey(key2.GetPubKey().GetID());
 }
diff --git a/src/outputtype.cpp b/src/outputtype.cpp
index e66dfed3d..e77f07056 100644
--- a/src/outputtype.cpp
+++ b/src/outputtype.cpp
@@ -1,60 +1,61 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2017 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <outputtype.h>
 
 #include <keystore.h>
 #include <pubkey.h>
 #include <script/script.h>
 #include <script/standard.h>
 
 #include <cassert>
 #include <string>
 
 static const std::string OUTPUT_TYPE_STRING_LEGACY = "legacy";
 
 bool ParseOutputType(const std::string &type, OutputType &output_type) {
     if (type == OUTPUT_TYPE_STRING_LEGACY) {
         output_type = OutputType::LEGACY;
         return true;
     }
     return false;
 }
 
 const std::string &FormatOutputType(OutputType type) {
     switch (type) {
         case OutputType::LEGACY:
             return OUTPUT_TYPE_STRING_LEGACY;
         default:
             assert(false);
     }
 }
 
 CTxDestination GetDestinationForKey(const CPubKey &key, OutputType type) {
     switch (type) {
         case OutputType::LEGACY:
-            return key.GetID();
+            return PKHash(key);
         default:
             assert(false);
     }
 }
 
 std::vector<CTxDestination> GetAllDestinationsForKey(const CPubKey &key) {
-    return std::vector<CTxDestination>{key.GetID()};
+    PKHash keyid(key);
+    return std::vector<CTxDestination>{std::move(keyid)};
 }
 
 CTxDestination AddAndGetDestinationForScript(CKeyStore &keystore,
                                              const CScript &script,
                                              OutputType type) {
     // Add script to keystore
     keystore.AddCScript(script);
     // Note that scripts over 520 bytes are not yet supported.
     switch (type) {
         case OutputType::LEGACY:
-            return CScriptID(script);
+            return ScriptHash(script);
         default:
             assert(false);
     }
 }
diff --git a/src/qt/coincontroldialog.cpp b/src/qt/coincontroldialog.cpp
index ee8aec6b4..4980b2a46 100644
--- a/src/qt/coincontroldialog.cpp
+++ b/src/qt/coincontroldialog.cpp
@@ -1,833 +1,833 @@
 // 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/coincontroldialog.h>
 #include <qt/forms/ui_coincontroldialog.h>
 
 #include <cashaddrenc.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <policy/policy.h>
 #include <qt/addresstablemodel.h>
 #include <qt/bitcoinunits.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/walletmodel.h>
 #include <wallet/coincontrol.h>
 #include <wallet/wallet.h>
 
 #include <QApplication>
 #include <QCheckBox>
 #include <QCursor>
 #include <QDialogButtonBox>
 #include <QFlags>
 #include <QIcon>
 #include <QSettings>
 #include <QString>
 #include <QTreeWidget>
 #include <QTreeWidgetItem>
 
 QList<Amount> CoinControlDialog::payAmounts;
 bool CoinControlDialog::fSubtractFeeFromAmount = false;
 
 bool CCoinControlWidgetItem::operator<(const QTreeWidgetItem &other) const {
     int column = treeWidget()->sortColumn();
     if (column == CoinControlDialog::COLUMN_AMOUNT ||
         column == CoinControlDialog::COLUMN_DATE ||
         column == CoinControlDialog::COLUMN_CONFIRMATIONS) {
         return data(column, Qt::UserRole).toLongLong() <
                other.data(column, Qt::UserRole).toLongLong();
     }
     return QTreeWidgetItem::operator<(other);
 }
 
 CoinControlDialog::CoinControlDialog(const PlatformStyle *_platformStyle,
                                      QWidget *parent)
     : QDialog(parent), ui(new Ui::CoinControlDialog), model(nullptr),
       platformStyle(_platformStyle) {
     ui->setupUi(this);
 
     // context menu actions
     QAction *copyAddressAction = new QAction(tr("Copy address"), this);
     QAction *copyLabelAction = new QAction(tr("Copy label"), this);
     QAction *copyAmountAction = new QAction(tr("Copy amount"), this);
     // we need to enable/disable this
     copyTransactionHashAction = new QAction(tr("Copy transaction ID"), this);
     // we need to enable/disable this
     lockAction = new QAction(tr("Lock unspent"), this);
     // we need to enable/disable this
     unlockAction = new QAction(tr("Unlock unspent"), this);
 
     // context menu
     contextMenu = new QMenu(this);
     contextMenu->addAction(copyAddressAction);
     contextMenu->addAction(copyLabelAction);
     contextMenu->addAction(copyAmountAction);
     contextMenu->addAction(copyTransactionHashAction);
     contextMenu->addSeparator();
     contextMenu->addAction(lockAction);
     contextMenu->addAction(unlockAction);
 
     // context menu signals
     connect(ui->treeWidget, &QWidget::customContextMenuRequested, this,
             &CoinControlDialog::showMenu);
     connect(copyAddressAction, &QAction::triggered, this,
             &CoinControlDialog::copyAddress);
     connect(copyLabelAction, &QAction::triggered, this,
             &CoinControlDialog::copyLabel);
     connect(copyAmountAction, &QAction::triggered, this,
             &CoinControlDialog::copyAmount);
     connect(copyTransactionHashAction, &QAction::triggered, this,
             &CoinControlDialog::copyTransactionHash);
     connect(lockAction, &QAction::triggered, this,
             &CoinControlDialog::lockCoin);
     connect(unlockAction, &QAction::triggered, this,
             &CoinControlDialog::unlockCoin);
 
     // clipboard actions
     QAction *clipboardQuantityAction = new QAction(tr("Copy quantity"), this);
     QAction *clipboardAmountAction = new QAction(tr("Copy amount"), this);
     QAction *clipboardFeeAction = new QAction(tr("Copy fee"), this);
     QAction *clipboardAfterFeeAction = new QAction(tr("Copy after fee"), this);
     QAction *clipboardBytesAction = new QAction(tr("Copy bytes"), this);
     QAction *clipboardLowOutputAction = new QAction(tr("Copy dust"), this);
     QAction *clipboardChangeAction = new QAction(tr("Copy change"), this);
 
     connect(clipboardQuantityAction, &QAction::triggered, this,
             &CoinControlDialog::clipboardQuantity);
     connect(clipboardAmountAction, &QAction::triggered, this,
             &CoinControlDialog::clipboardAmount);
     connect(clipboardFeeAction, &QAction::triggered, this,
             &CoinControlDialog::clipboardFee);
     connect(clipboardAfterFeeAction, &QAction::triggered, this,
             &CoinControlDialog::clipboardAfterFee);
     connect(clipboardBytesAction, &QAction::triggered, this,
             &CoinControlDialog::clipboardBytes);
     connect(clipboardLowOutputAction, &QAction::triggered, this,
             &CoinControlDialog::clipboardLowOutput);
     connect(clipboardChangeAction, &QAction::triggered, this,
             &CoinControlDialog::clipboardChange);
 
     ui->labelCoinControlQuantity->addAction(clipboardQuantityAction);
     ui->labelCoinControlAmount->addAction(clipboardAmountAction);
     ui->labelCoinControlFee->addAction(clipboardFeeAction);
     ui->labelCoinControlAfterFee->addAction(clipboardAfterFeeAction);
     ui->labelCoinControlBytes->addAction(clipboardBytesAction);
     ui->labelCoinControlLowOutput->addAction(clipboardLowOutputAction);
     ui->labelCoinControlChange->addAction(clipboardChangeAction);
 
     // toggle tree/list mode
     connect(ui->radioTreeMode, &QRadioButton::toggled, this,
             &CoinControlDialog::radioTreeMode);
     connect(ui->radioListMode, &QRadioButton::toggled, this,
             &CoinControlDialog::radioListMode);
 
     // click on checkbox
     connect(ui->treeWidget, &QTreeWidget::itemChanged, this,
             &CoinControlDialog::viewItemChanged);
 
     // click on header
     ui->treeWidget->header()->setSectionsClickable(true);
     connect(ui->treeWidget->header(), &QHeaderView::sectionClicked, this,
             &CoinControlDialog::headerSectionClicked);
 
     // ok button
     connect(ui->buttonBox, &QDialogButtonBox::clicked, this,
             &CoinControlDialog::buttonBoxClicked);
 
     // (un)select all
     connect(ui->pushButtonSelectAll, &QPushButton::clicked, this,
             &CoinControlDialog::buttonSelectAllClicked);
 
     ui->treeWidget->setColumnWidth(COLUMN_CHECKBOX, 84);
     ui->treeWidget->setColumnWidth(COLUMN_AMOUNT, 110);
     ui->treeWidget->setColumnWidth(COLUMN_LABEL, 190);
     ui->treeWidget->setColumnWidth(COLUMN_ADDRESS, 320);
     ui->treeWidget->setColumnWidth(COLUMN_DATE, 130);
     ui->treeWidget->setColumnWidth(COLUMN_CONFIRMATIONS, 110);
     // store transaction hash in this column, but don't show it
     ui->treeWidget->setColumnHidden(COLUMN_TXID, true);
     // store vout index in this column, but don't show it
     ui->treeWidget->setColumnHidden(COLUMN_VOUT_INDEX, true);
 
     // default view is sorted by amount desc
     sortView(COLUMN_AMOUNT, Qt::DescendingOrder);
 
     // restore list mode and sortorder as a convenience feature
     QSettings settings;
     if (settings.contains("nCoinControlMode") &&
         !settings.value("nCoinControlMode").toBool()) {
         ui->radioTreeMode->click();
     }
     if (settings.contains("nCoinControlSortColumn") &&
         settings.contains("nCoinControlSortOrder")) {
         sortView(settings.value("nCoinControlSortColumn").toInt(),
                  (static_cast<Qt::SortOrder>(
                      settings.value("nCoinControlSortOrder").toInt())));
     }
 }
 
 CoinControlDialog::~CoinControlDialog() {
     QSettings settings;
     settings.setValue("nCoinControlMode", ui->radioListMode->isChecked());
     settings.setValue("nCoinControlSortColumn", sortColumn);
     settings.setValue("nCoinControlSortOrder", (int)sortOrder);
 
     delete ui;
 }
 
 void CoinControlDialog::setModel(WalletModel *_model) {
     this->model = _model;
 
     if (_model && _model->getOptionsModel() && _model->getAddressTableModel()) {
         updateView();
         updateLabelLocked();
         CoinControlDialog::updateLabels(_model, this);
     }
 }
 
 // ok button
 void CoinControlDialog::buttonBoxClicked(QAbstractButton *button) {
     if (ui->buttonBox->buttonRole(button) == QDialogButtonBox::AcceptRole) {
         // closes the dialog
         done(QDialog::Accepted);
     }
 }
 
 // (un)select all
 void CoinControlDialog::buttonSelectAllClicked() {
     Qt::CheckState state = Qt::Checked;
     for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++) {
         if (ui->treeWidget->topLevelItem(i)->checkState(COLUMN_CHECKBOX) !=
             Qt::Unchecked) {
             state = Qt::Unchecked;
             break;
         }
     }
     ui->treeWidget->setEnabled(false);
     for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++) {
         if (ui->treeWidget->topLevelItem(i)->checkState(COLUMN_CHECKBOX) !=
             state) {
             ui->treeWidget->topLevelItem(i)->setCheckState(COLUMN_CHECKBOX,
                                                            state);
         }
     }
     ui->treeWidget->setEnabled(true);
     if (state == Qt::Unchecked) {
         // just to be sure
         coinControl()->UnSelectAll();
     }
     CoinControlDialog::updateLabels(model, this);
 }
 
 // context menu
 void CoinControlDialog::showMenu(const QPoint &point) {
     QTreeWidgetItem *item = ui->treeWidget->itemAt(point);
     if (item) {
         contextMenuItem = item;
 
         // disable some items (like Copy Transaction ID, lock, unlock) for tree
         // roots in context menu
         if (item->text(COLUMN_TXID).length() == 64) {
             COutPoint outpoint = buildOutPoint(item);
 
             // transaction hash is 64 characters (this means it is a child node,
             // so it is not a parent node in tree mode)
             copyTransactionHashAction->setEnabled(true);
             if (model->wallet().isLockedCoin(outpoint)) {
                 lockAction->setEnabled(false);
                 unlockAction->setEnabled(true);
             } else {
                 lockAction->setEnabled(true);
                 unlockAction->setEnabled(false);
             }
         } else {
             // this means click on parent node in tree mode -> disable all
             copyTransactionHashAction->setEnabled(false);
             lockAction->setEnabled(false);
             unlockAction->setEnabled(false);
         }
 
         // show context menu
         contextMenu->exec(QCursor::pos());
     }
 }
 
 // context menu action: copy amount
 void CoinControlDialog::copyAmount() {
     GUIUtil::setClipboard(
         BitcoinUnits::removeSpaces(contextMenuItem->text(COLUMN_AMOUNT)));
 }
 
 // context menu action: copy label
 void CoinControlDialog::copyLabel() {
     if (ui->radioTreeMode->isChecked() &&
         contextMenuItem->text(COLUMN_LABEL).length() == 0 &&
         contextMenuItem->parent()) {
         GUIUtil::setClipboard(contextMenuItem->parent()->text(COLUMN_LABEL));
     } else {
         GUIUtil::setClipboard(contextMenuItem->text(COLUMN_LABEL));
     }
 }
 
 // context menu action: copy address
 void CoinControlDialog::copyAddress() {
     if (ui->radioTreeMode->isChecked() &&
         contextMenuItem->text(COLUMN_ADDRESS).length() == 0 &&
         contextMenuItem->parent()) {
         GUIUtil::setClipboard(contextMenuItem->parent()->text(COLUMN_ADDRESS));
     } else {
         GUIUtil::setClipboard(contextMenuItem->text(COLUMN_ADDRESS));
     }
 }
 
 // context menu action: copy transaction id
 void CoinControlDialog::copyTransactionHash() {
     GUIUtil::setClipboard(contextMenuItem->text(COLUMN_TXID));
 }
 
 // context menu action: lock coin
 void CoinControlDialog::lockCoin() {
     if (contextMenuItem->checkState(COLUMN_CHECKBOX) == Qt::Checked) {
         contextMenuItem->setCheckState(COLUMN_CHECKBOX, Qt::Unchecked);
     }
 
     COutPoint outpoint = buildOutPoint(contextMenuItem);
     model->wallet().lockCoin(outpoint);
     contextMenuItem->setDisabled(true);
     contextMenuItem->setIcon(
         COLUMN_CHECKBOX, platformStyle->SingleColorIcon(":/icons/lock_closed"));
     updateLabelLocked();
 }
 
 // context menu action: unlock coin
 void CoinControlDialog::unlockCoin() {
     COutPoint outpoint = buildOutPoint(contextMenuItem);
     model->wallet().unlockCoin(outpoint);
     contextMenuItem->setDisabled(false);
     contextMenuItem->setIcon(COLUMN_CHECKBOX, QIcon());
     updateLabelLocked();
 }
 
 // copy label "Quantity" to clipboard
 void CoinControlDialog::clipboardQuantity() {
     GUIUtil::setClipboard(ui->labelCoinControlQuantity->text());
 }
 
 // copy label "Amount" to clipboard
 void CoinControlDialog::clipboardAmount() {
     GUIUtil::setClipboard(ui->labelCoinControlAmount->text().left(
         ui->labelCoinControlAmount->text().indexOf(" ")));
 }
 
 // copy label "Fee" to clipboard
 void CoinControlDialog::clipboardFee() {
     GUIUtil::setClipboard(
         ui->labelCoinControlFee->text()
             .left(ui->labelCoinControlFee->text().indexOf(" "))
             .replace(ASYMP_UTF8, ""));
 }
 
 // copy label "After fee" to clipboard
 void CoinControlDialog::clipboardAfterFee() {
     GUIUtil::setClipboard(
         ui->labelCoinControlAfterFee->text()
             .left(ui->labelCoinControlAfterFee->text().indexOf(" "))
             .replace(ASYMP_UTF8, ""));
 }
 
 // copy label "Bytes" to clipboard
 void CoinControlDialog::clipboardBytes() {
     GUIUtil::setClipboard(
         ui->labelCoinControlBytes->text().replace(ASYMP_UTF8, ""));
 }
 
 // copy label "Dust" to clipboard
 void CoinControlDialog::clipboardLowOutput() {
     GUIUtil::setClipboard(ui->labelCoinControlLowOutput->text());
 }
 
 // copy label "Change" to clipboard
 void CoinControlDialog::clipboardChange() {
     GUIUtil::setClipboard(
         ui->labelCoinControlChange->text()
             .left(ui->labelCoinControlChange->text().indexOf(" "))
             .replace(ASYMP_UTF8, ""));
 }
 
 // treeview: sort
 void CoinControlDialog::sortView(int column, Qt::SortOrder order) {
     sortColumn = column;
     sortOrder = order;
     ui->treeWidget->sortItems(column, order);
     ui->treeWidget->header()->setSortIndicator(sortColumn, sortOrder);
 }
 
 // treeview: clicked on header
 void CoinControlDialog::headerSectionClicked(int logicalIndex) {
     // click on most left column -> do nothing
     if (logicalIndex == COLUMN_CHECKBOX) {
         ui->treeWidget->header()->setSortIndicator(sortColumn, sortOrder);
     } else {
         if (sortColumn == logicalIndex) {
             sortOrder =
                 ((sortOrder == Qt::AscendingOrder) ? Qt::DescendingOrder
                                                    : Qt::AscendingOrder);
         } else {
             sortColumn = logicalIndex;
             // if label or address then default => asc, else default => desc
             sortOrder =
                 ((sortColumn == COLUMN_LABEL || sortColumn == COLUMN_ADDRESS)
                      ? Qt::AscendingOrder
                      : Qt::DescendingOrder);
         }
 
         sortView(sortColumn, sortOrder);
     }
 }
 
 // toggle tree mode
 void CoinControlDialog::radioTreeMode(bool checked) {
     if (checked && model) {
         updateView();
     }
 }
 
 // toggle list mode
 void CoinControlDialog::radioListMode(bool checked) {
     if (checked && model) {
         updateView();
     }
 }
 
 // checkbox clicked by user
 void CoinControlDialog::viewItemChanged(QTreeWidgetItem *item, int column) {
     // transaction hash is 64 characters (this means it is a child node, so it
     // is not a parent node in tree mode)
     if (column == COLUMN_CHECKBOX && item->text(COLUMN_TXID).length() == 64) {
         COutPoint outpoint = buildOutPoint(item);
 
         if (item->checkState(COLUMN_CHECKBOX) == Qt::Unchecked) {
             coinControl()->UnSelect(outpoint);
         } else if (item->isDisabled()) {
             // locked (this happens if "check all" through parent node)
             item->setCheckState(COLUMN_CHECKBOX, Qt::Unchecked);
         } else {
             coinControl()->Select(outpoint);
         }
 
         // selection changed -> update labels
         if (ui->treeWidget->isEnabled()) {
             // do not update on every click for (un)select all
             CoinControlDialog::updateLabels(model, this);
         }
     }
 
     // TODO: Remove this temporary qt5 fix after Qt5.3 and Qt5.4 are no longer
     // used.
     // Fixed in Qt5.5 and above: https://bugreports.qt.io/browse/QTBUG-43473
     else if (column == COLUMN_CHECKBOX && item->childCount() > 0) {
         if (item->checkState(COLUMN_CHECKBOX) == Qt::PartiallyChecked &&
             item->child(0)->checkState(COLUMN_CHECKBOX) ==
                 Qt::PartiallyChecked) {
             item->setCheckState(COLUMN_CHECKBOX, Qt::Checked);
         }
     }
 }
 
 // shows count of locked unspent outputs
 void CoinControlDialog::updateLabelLocked() {
     std::vector<COutPoint> vOutpts;
     model->wallet().listLockedCoins(vOutpts);
     if (vOutpts.size() > 0) {
         ui->labelLocked->setText(tr("(%1 locked)").arg(vOutpts.size()));
         ui->labelLocked->setVisible(true);
     } else {
         ui->labelLocked->setVisible(false);
     }
 }
 
 void CoinControlDialog::updateLabels(WalletModel *model, QDialog *dialog) {
     if (!model) {
         return;
     }
 
     // nPayAmount
     Amount nPayAmount = Amount::zero();
     bool fDust = false;
     CMutableTransaction txDummy;
     for (const Amount &amount : CoinControlDialog::payAmounts) {
         nPayAmount += amount;
 
         if (amount > Amount::zero()) {
             CTxOut txout(amount,
                          static_cast<CScript>(std::vector<uint8_t>(24, 0)));
             txDummy.vout.push_back(txout);
             fDust |= IsDust(txout, model->node().getDustRelayFee());
         }
     }
 
     Amount nAmount = Amount::zero();
     Amount nPayFee = Amount::zero();
     Amount nAfterFee = Amount::zero();
     Amount nChange = Amount::zero();
     unsigned int nBytes = 0;
     unsigned int nBytesInputs = 0;
     unsigned int nQuantity = 0;
 
     std::vector<COutPoint> vCoinControl;
     coinControl()->ListSelected(vCoinControl);
 
     size_t i = 0;
     for (const auto &out : model->wallet().getCoins(vCoinControl)) {
         if (out.depth_in_main_chain < 0) {
             continue;
         }
 
         // unselect already spent, very unlikely scenario, this could happen
         // when selected are spent elsewhere, like rpc or another computer
         const COutPoint &output = vCoinControl[i++];
         if (out.is_spent) {
             coinControl()->UnSelect(output);
             continue;
         }
 
         // Quantity
         nQuantity++;
 
         // Amount
         nAmount += out.txout.nValue;
 
         // Bytes
         CTxDestination address;
         if (ExtractDestination(out.txout.scriptPubKey, address)) {
             CPubKey pubkey;
-            CKeyID *keyid = boost::get<CKeyID>(&address);
-            if (keyid && model->wallet().getPubKey(*keyid, pubkey)) {
+            PKHash *pkhash = boost::get<PKHash>(&address);
+            if (pkhash && model->wallet().getPubKey(CKeyID(*pkhash), pubkey)) {
                 nBytesInputs += (pubkey.IsCompressed() ? 148 : 180);
             } else {
                 // in all error cases, simply assume 148 here
                 nBytesInputs += 148;
             }
         } else {
             nBytesInputs += 148;
         }
     }
 
     // calculation
     if (nQuantity > 0) {
         // Bytes
         // always assume +1 output for change here
         nBytes = nBytesInputs +
                  ((CoinControlDialog::payAmounts.size() > 0
                        ? CoinControlDialog::payAmounts.size() + 1
                        : 2) *
                   34) +
                  10;
 
         // in the subtract fee from amount case, we can tell if zero change
         // already and subtract the bytes, so that fee calculation afterwards is
         // accurate
         if (CoinControlDialog::fSubtractFeeFromAmount) {
             if (nAmount - nPayAmount == Amount::zero()) {
                 nBytes -= 34;
             }
         }
 
         // Fee
         nPayFee = model->wallet().getMinimumFee(nBytes, *coinControl());
 
         if (nPayAmount > Amount::zero()) {
             nChange = nAmount - nPayAmount;
             if (!CoinControlDialog::fSubtractFeeFromAmount) {
                 nChange -= nPayFee;
             }
 
             // Never create dust outputs; if we would, just add the dust to the
             // fee.
             if (nChange > Amount::zero() && nChange < MIN_CHANGE) {
                 CTxOut txout(nChange,
                              static_cast<CScript>(std::vector<uint8_t>(24, 0)));
                 if (IsDust(txout, model->node().getDustRelayFee())) {
                     nPayFee += nChange;
                     nChange = Amount::zero();
                     if (CoinControlDialog::fSubtractFeeFromAmount) {
                         // we didn't detect lack of change above
                         nBytes -= 34;
                     }
                 }
             }
 
             if (nChange == Amount::zero() &&
                 !CoinControlDialog::fSubtractFeeFromAmount) {
                 nBytes -= 34;
             }
         }
 
         // after fee
         nAfterFee = std::max(nAmount - nPayFee, Amount::zero());
     }
 
     // actually update labels
     int nDisplayUnit = BitcoinUnits::BCH;
     if (model && model->getOptionsModel()) {
         nDisplayUnit = model->getOptionsModel()->getDisplayUnit();
     }
 
     QLabel *l1 = dialog->findChild<QLabel *>("labelCoinControlQuantity");
     QLabel *l2 = dialog->findChild<QLabel *>("labelCoinControlAmount");
     QLabel *l3 = dialog->findChild<QLabel *>("labelCoinControlFee");
     QLabel *l4 = dialog->findChild<QLabel *>("labelCoinControlAfterFee");
     QLabel *l5 = dialog->findChild<QLabel *>("labelCoinControlBytes");
     QLabel *l7 = dialog->findChild<QLabel *>("labelCoinControlLowOutput");
     QLabel *l8 = dialog->findChild<QLabel *>("labelCoinControlChange");
 
     // enable/disable "dust" and "change"
     dialog->findChild<QLabel *>("labelCoinControlLowOutputText")
         ->setEnabled(nPayAmount > Amount::zero());
     dialog->findChild<QLabel *>("labelCoinControlLowOutput")
         ->setEnabled(nPayAmount > Amount::zero());
     dialog->findChild<QLabel *>("labelCoinControlChangeText")
         ->setEnabled(nPayAmount > Amount::zero());
     dialog->findChild<QLabel *>("labelCoinControlChange")
         ->setEnabled(nPayAmount > Amount::zero());
 
     // stats
     // Quantity
     l1->setText(QString::number(nQuantity));
     // Amount
     l2->setText(BitcoinUnits::formatWithUnit(nDisplayUnit, nAmount));
     // Fee
     l3->setText(BitcoinUnits::formatWithUnit(nDisplayUnit, nPayFee));
     // After Fee
     l4->setText(BitcoinUnits::formatWithUnit(nDisplayUnit, nAfterFee));
     // Bytes
     l5->setText(((nBytes > 0) ? ASYMP_UTF8 : "") + QString::number(nBytes));
     // Dust
     l7->setText(fDust ? tr("yes") : tr("no"));
     // Change
     l8->setText(BitcoinUnits::formatWithUnit(nDisplayUnit, nChange));
     if (nPayFee > Amount::zero()) {
         l3->setText(ASYMP_UTF8 + l3->text());
         l4->setText(ASYMP_UTF8 + l4->text());
         if (nChange > Amount::zero() &&
             !CoinControlDialog::fSubtractFeeFromAmount) {
             l8->setText(ASYMP_UTF8 + l8->text());
         }
     }
 
     // turn label red when dust
     l7->setStyleSheet((fDust) ? "color:red;" : "");
 
     // tool tips
     QString toolTipDust =
         tr("This label turns red if any recipient receives an amount smaller "
            "than the current dust threshold.");
 
     // how many satoshis the estimated fee can vary per byte we guess wrong
     double dFeeVary = (nBytes != 0) ? double(nPayFee / SATOSHI) / nBytes : 0;
 
     QString toolTip4 =
         tr("Can vary +/- %1 satoshi(s) per input.").arg(dFeeVary);
 
     l3->setToolTip(toolTip4);
     l4->setToolTip(toolTip4);
     l7->setToolTip(toolTipDust);
     l8->setToolTip(toolTip4);
     dialog->findChild<QLabel *>("labelCoinControlFeeText")
         ->setToolTip(l3->toolTip());
     dialog->findChild<QLabel *>("labelCoinControlAfterFeeText")
         ->setToolTip(l4->toolTip());
     dialog->findChild<QLabel *>("labelCoinControlBytesText")
         ->setToolTip(l5->toolTip());
     dialog->findChild<QLabel *>("labelCoinControlLowOutputText")
         ->setToolTip(l7->toolTip());
     dialog->findChild<QLabel *>("labelCoinControlChangeText")
         ->setToolTip(l8->toolTip());
 
     // Insufficient funds
     QLabel *label = dialog->findChild<QLabel *>("labelCoinControlInsuffFunds");
     if (label) {
         label->setVisible(nChange < Amount::zero());
     }
 }
 
 CCoinControl *CoinControlDialog::coinControl() {
     static CCoinControl coin_control;
     return &coin_control;
 }
 
 COutPoint CoinControlDialog::buildOutPoint(const QTreeWidgetItem *item) {
     TxId txid;
     txid.SetHex(item->text(COLUMN_TXID).toStdString());
     return COutPoint(txid, item->text(COLUMN_VOUT_INDEX).toUInt());
 }
 
 void CoinControlDialog::updateView() {
     if (!model || !model->getOptionsModel() || !model->getAddressTableModel()) {
         return;
     }
 
     bool treeMode = ui->radioTreeMode->isChecked();
 
     ui->treeWidget->clear();
     // performance, otherwise updateLabels would be called for every checked
     // checkbox
     ui->treeWidget->setEnabled(false);
     ui->treeWidget->setAlternatingRowColors(!treeMode);
     QFlags<Qt::ItemFlag> flgCheckbox =
         Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable;
     QFlags<Qt::ItemFlag> flgTristate =
         Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable |
         Qt::ItemIsTristate;
 
     int nDisplayUnit = model->getOptionsModel()->getDisplayUnit();
 
     for (const auto &coins : model->wallet().listCoins()) {
         CCoinControlWidgetItem *itemWalletAddress =
             new CCoinControlWidgetItem();
         itemWalletAddress->setCheckState(COLUMN_CHECKBOX, Qt::Unchecked);
         QString sWalletAddress = QString::fromStdString(
             EncodeCashAddr(coins.first, model->getChainParams()));
         QString sWalletLabel =
             model->getAddressTableModel()->labelForAddress(sWalletAddress);
         if (sWalletLabel.isEmpty()) {
             sWalletLabel = tr("(no label)");
         }
 
         if (treeMode) {
             // wallet address
             ui->treeWidget->addTopLevelItem(itemWalletAddress);
 
             itemWalletAddress->setFlags(flgTristate);
             itemWalletAddress->setCheckState(COLUMN_CHECKBOX, Qt::Unchecked);
 
             // label
             itemWalletAddress->setText(COLUMN_LABEL, sWalletLabel);
 
             // address
             itemWalletAddress->setText(COLUMN_ADDRESS, sWalletAddress);
         }
 
         Amount nSum = Amount::zero();
         int nChildren = 0;
         for (const auto &outpair : coins.second) {
             const COutPoint &output = std::get<0>(outpair);
             const interfaces::WalletTxOut &out = std::get<1>(outpair);
             nSum += out.txout.nValue;
             nChildren++;
 
             CCoinControlWidgetItem *itemOutput;
             if (treeMode) {
                 itemOutput = new CCoinControlWidgetItem(itemWalletAddress);
             } else {
                 itemOutput = new CCoinControlWidgetItem(ui->treeWidget);
             }
             itemOutput->setFlags(flgCheckbox);
             itemOutput->setCheckState(COLUMN_CHECKBOX, Qt::Unchecked);
 
             // address
             CTxDestination outputAddress;
             QString sAddress = "";
             if (ExtractDestination(out.txout.scriptPubKey, outputAddress)) {
                 sAddress = QString::fromStdString(
                     EncodeCashAddr(outputAddress, model->getChainParams()));
 
                 // if listMode or change => show bitcoin address. In tree mode,
                 // address is not shown again for direct wallet address outputs
                 if (!treeMode || (!(sAddress == sWalletAddress))) {
                     itemOutput->setText(COLUMN_ADDRESS, sAddress);
                 }
             }
 
             // label
             if (!(sAddress == sWalletAddress)) {
                 // change tooltip from where the change comes from
                 itemOutput->setToolTip(COLUMN_LABEL, tr("change from %1 (%2)")
                                                          .arg(sWalletLabel)
                                                          .arg(sWalletAddress));
                 itemOutput->setText(COLUMN_LABEL, tr("(change)"));
             } else if (!treeMode) {
                 QString sLabel =
                     model->getAddressTableModel()->labelForAddress(sAddress);
                 if (sLabel.isEmpty()) {
                     sLabel = tr("(no label)");
                 }
                 itemOutput->setText(COLUMN_LABEL, sLabel);
             }
 
             // amount
             itemOutput->setText(
                 COLUMN_AMOUNT,
                 BitcoinUnits::format(nDisplayUnit, out.txout.nValue));
             // padding so that sorting works correctly
             itemOutput->setData(
                 COLUMN_AMOUNT, Qt::UserRole,
                 QVariant(qlonglong(out.txout.nValue / SATOSHI)));
 
             // date
             itemOutput->setText(COLUMN_DATE, GUIUtil::dateTimeStr(out.time));
             itemOutput->setData(COLUMN_DATE, Qt::UserRole,
                                 QVariant((qlonglong)out.time));
 
             // confirmations
             itemOutput->setText(COLUMN_CONFIRMATIONS,
                                 QString::number(out.depth_in_main_chain));
             itemOutput->setData(COLUMN_CONFIRMATIONS, Qt::UserRole,
                                 QVariant((qlonglong)out.depth_in_main_chain));
 
             // transaction id
             itemOutput->setText(
                 COLUMN_TXID, QString::fromStdString(output.GetTxId().GetHex()));
 
             // vout index
             itemOutput->setText(COLUMN_VOUT_INDEX,
                                 QString::number(output.GetN()));
 
             // disable locked coins
             if (model->wallet().isLockedCoin(output)) {
                 // just to be sure
                 coinControl()->UnSelect(output);
                 itemOutput->setDisabled(true);
                 itemOutput->setIcon(
                     COLUMN_CHECKBOX,
                     platformStyle->SingleColorIcon(":/icons/lock_closed"));
             }
 
             // set checkbox
             if (coinControl()->IsSelected(output)) {
                 itemOutput->setCheckState(COLUMN_CHECKBOX, Qt::Checked);
             }
         }
 
         // amount
         if (treeMode) {
             itemWalletAddress->setText(COLUMN_CHECKBOX,
                                        "(" + QString::number(nChildren) + ")");
             itemWalletAddress->setText(
                 COLUMN_AMOUNT, BitcoinUnits::format(nDisplayUnit, nSum));
             itemWalletAddress->setData(COLUMN_AMOUNT, Qt::UserRole,
                                        QVariant(qlonglong(nSum / SATOSHI)));
         }
     }
 
     // expand all partially selected
     if (treeMode) {
         for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++) {
             if (ui->treeWidget->topLevelItem(i)->checkState(COLUMN_CHECKBOX) ==
                 Qt::PartiallyChecked) {
                 ui->treeWidget->topLevelItem(i)->setExpanded(true);
             }
         }
     }
 
     // sort view
     sortView(sortColumn, sortOrder);
     ui->treeWidget->setEnabled(true);
 }
diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
index 553ada8bd..bba3bf4a3 100644
--- a/src/qt/guiutil.cpp
+++ b/src/qt/guiutil.cpp
@@ -1,967 +1,967 @@
 // 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.
 
 #include <qt/guiutil.h>
 
 #include <cashaddrenc.h>
 #include <chainparams.h>
 #include <fs.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <protocol.h>
 #include <qt/bitcoinaddressvalidator.h>
 #include <qt/bitcoinunits.h>
 #include <qt/qvalidatedlineedit.h>
 #include <qt/walletmodel.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 
 #ifdef WIN32
 #ifdef _WIN32_WINNT
 #undef _WIN32_WINNT
 #endif
 #define _WIN32_WINNT 0x0501
 #ifdef _WIN32_IE
 #undef _WIN32_IE
 #endif
 #define _WIN32_IE 0x0501
 #define WIN32_LEAN_AND_MEAN 1
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
 #include <shellapi.h>
 #include <shlobj.h>
 #include <shlwapi.h>
 #endif
 
 #include <QAbstractItemView>
 #include <QApplication>
 #include <QClipboard>
 #include <QDateTime>
 #include <QDesktopServices>
 #include <QDoubleValidator>
 #include <QFileDialog>
 #include <QFont>
 #include <QKeyEvent>
 #include <QLineEdit>
 #include <QMouseEvent>
 #include <QSettings>
 #include <QTextDocument> // for Qt::mightBeRichText
 #include <QThread>
 #include <QUrlQuery>
 
 #if QT_VERSION >= 0x50200
 #include <QFontDatabase>
 #endif
 
 #if defined(Q_OS_MAC)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 
 #include <CoreServices/CoreServices.h>
 
 void ForceActivation();
 #endif
 
 namespace GUIUtil {
 
 QString dateTimeStr(const QDateTime &date) {
     return date.date().toString(Qt::SystemLocaleShortDate) + QString(" ") +
            date.toString("hh:mm");
 }
 
 QString dateTimeStr(qint64 nTime) {
     return dateTimeStr(QDateTime::fromTime_t((qint32)nTime));
 }
 
 QFont fixedPitchFont() {
 #if QT_VERSION >= 0x50200
     return QFontDatabase::systemFont(QFontDatabase::FixedFont);
 #else
     QFont font("Monospace");
     font.setStyleHint(QFont::Monospace);
     return font;
 #endif
 }
 
 static std::string MakeAddrInvalid(std::string addr,
                                    const CChainParams &params) {
     if (addr.size() < 2) {
         return "";
     }
 
     // Checksum is at the end of the address. Swapping chars to make it invalid.
     std::swap(addr[addr.size() - 1], addr[addr.size() - 2]);
     if (!IsValidDestinationString(addr, params)) {
         return addr;
     }
 
     return "";
 }
 
 std::string DummyAddress(const CChainParams &params) {
     // Just some dummy data to generate a convincing random-looking (but
     // consistent) address
     static const std::vector<uint8_t> dummydata = {
         0xeb, 0x15, 0x23, 0x1d, 0xfc, 0xeb, 0x60, 0x92, 0x58, 0x86,
         0xb6, 0x7d, 0x06, 0x52, 0x99, 0x92, 0x59, 0x15, 0xae, 0xb1};
 
-    const CTxDestination dstKey = CKeyID(uint160(dummydata));
+    const CTxDestination dstKey = PKHash(uint160(dummydata));
     return MakeAddrInvalid(EncodeCashAddr(dstKey, params), params);
 }
 
 // Addresses are stored in the database with the encoding that the client was
 // configured with at the time of creation.
 //
 // This converts to cashaddr.
 QString convertToCashAddr(const CChainParams &params, const QString &addr) {
     if (!IsValidDestinationString(addr.toStdString(), params)) {
         // We have something sketchy as input. Do not try to convert.
         return addr;
     }
     CTxDestination dst = DecodeDestination(addr.toStdString(), params);
     return QString::fromStdString(EncodeCashAddr(dst, params));
 }
 
 void setupAddressWidget(QValidatedLineEdit *widget, QWidget *parent) {
     parent->setFocusProxy(widget);
 
     widget->setFont(fixedPitchFont());
     // We don't want translators to use own addresses in translations
     // and this is the only place, where this address is supplied.
     widget->setPlaceholderText(
         QObject::tr("Enter a Bitcoin address (e.g. %1)")
             .arg(QString::fromStdString(DummyAddress(Params()))));
     widget->setValidator(
         new BitcoinAddressEntryValidator(Params().CashAddrPrefix(), parent));
     widget->setCheckValidator(new BitcoinAddressCheckValidator(parent));
 }
 
 bool parseBitcoinURI(const QString &scheme, const QUrl &uri,
                      SendCoinsRecipient *out) {
     // return if URI has wrong scheme.
     if (!uri.isValid() || uri.scheme() != scheme) {
         return false;
     }
 
     SendCoinsRecipient rv;
     rv.address = uri.scheme() + ":" + uri.path();
 
     // Trim any following forward slash which may have been added by the OS
     if (rv.address.endsWith("/")) {
         rv.address.truncate(rv.address.length() - 1);
     }
     rv.amount = Amount::zero();
 
     QUrlQuery uriQuery(uri);
     QList<QPair<QString, QString>> items = uriQuery.queryItems();
     for (QList<QPair<QString, QString>>::iterator i = items.begin();
          i != items.end(); i++) {
         bool fShouldReturnFalse = false;
         if (i->first.startsWith("req-")) {
             i->first.remove(0, 4);
             fShouldReturnFalse = true;
         }
 
         if (i->first == "label") {
             rv.label = i->second;
             fShouldReturnFalse = false;
         }
         if (i->first == "message") {
             rv.message = i->second;
             fShouldReturnFalse = false;
         } else if (i->first == "amount") {
             if (!i->second.isEmpty()) {
                 if (!BitcoinUnits::parse(BitcoinUnits::BCH, i->second,
                                          &rv.amount)) {
                     return false;
                 }
             }
             fShouldReturnFalse = false;
         }
 
         if (fShouldReturnFalse) {
             return false;
         }
     }
     if (out) {
         *out = rv;
     }
     return true;
 }
 
 bool parseBitcoinURI(const QString &scheme, QString uri,
                      SendCoinsRecipient *out) {
     //
     //    Cannot handle this later, because bitcoincash://
     //    will cause Qt to see the part after // as host,
     //    which will lower-case it (and thus invalidate the address).
     if (uri.startsWith(scheme + "://", Qt::CaseInsensitive)) {
         uri.replace(0, scheme.length() + 3, scheme + ":");
     }
     QUrl uriInstance(uri);
     return parseBitcoinURI(scheme, uriInstance, out);
 }
 
 QString formatBitcoinURI(const SendCoinsRecipient &info) {
     return formatBitcoinURI(Params(), info);
 }
 
 QString formatBitcoinURI(const CChainParams &params,
                          const SendCoinsRecipient &info) {
     QString ret = convertToCashAddr(params, info.address);
     int paramCount = 0;
 
     if (info.amount != Amount::zero()) {
         ret +=
             QString("?amount=%1")
                 .arg(BitcoinUnits::format(BitcoinUnits::BCH, info.amount, false,
                                           BitcoinUnits::separatorNever));
         paramCount++;
     }
 
     if (!info.label.isEmpty()) {
         QString lbl(QUrl::toPercentEncoding(info.label));
         ret += QString("%1label=%2").arg(paramCount == 0 ? "?" : "&").arg(lbl);
         paramCount++;
     }
 
     if (!info.message.isEmpty()) {
         QString msg(QUrl::toPercentEncoding(info.message));
         ret +=
             QString("%1message=%2").arg(paramCount == 0 ? "?" : "&").arg(msg);
         paramCount++;
     }
 
     return ret;
 }
 
 bool isDust(interfaces::Node &node, const QString &address, const Amount amount,
             const CChainParams &chainParams) {
     CTxDestination dest = DecodeDestination(address.toStdString(), chainParams);
     CScript script = GetScriptForDestination(dest);
     CTxOut txOut(amount, script);
     return IsDust(txOut, node.getDustRelayFee());
 }
 
 QString HtmlEscape(const QString &str, bool fMultiLine) {
     QString escaped = str.toHtmlEscaped();
     if (fMultiLine) {
         escaped = escaped.replace("\n", "<br>\n");
     }
     return escaped;
 }
 
 QString HtmlEscape(const std::string &str, bool fMultiLine) {
     return HtmlEscape(QString::fromStdString(str), fMultiLine);
 }
 
 void copyEntryData(QAbstractItemView *view, int column, int role) {
     if (!view || !view->selectionModel()) {
         return;
     }
     QModelIndexList selection = view->selectionModel()->selectedRows(column);
 
     if (!selection.isEmpty()) {
         // Copy first item
         setClipboard(selection.at(0).data(role).toString());
     }
 }
 
 QList<QModelIndex> getEntryData(QAbstractItemView *view, int column) {
     if (!view || !view->selectionModel()) {
         return QList<QModelIndex>();
     }
     return view->selectionModel()->selectedRows(column);
 }
 
 QString getSaveFileName(QWidget *parent, const QString &caption,
                         const QString &dir, const QString &filter,
                         QString *selectedSuffixOut) {
     QString selectedFilter;
     QString myDir;
     // Default to user documents location
     if (dir.isEmpty()) {
         myDir =
             QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
     } else {
         myDir = dir;
     }
     /* Directly convert path to native OS path separators */
     QString result = QDir::toNativeSeparators(QFileDialog::getSaveFileName(
         parent, caption, myDir, filter, &selectedFilter));
 
     /* Extract first suffix from filter pattern "Description (*.foo)" or
      * "Description (*.foo *.bar ...) */
     QRegExp filter_re(".* \\(\\*\\.(.*)[ \\)]");
     QString selectedSuffix;
     if (filter_re.exactMatch(selectedFilter)) {
         selectedSuffix = filter_re.cap(1);
     }
 
     /* Add suffix if needed */
     QFileInfo info(result);
     if (!result.isEmpty()) {
         if (info.suffix().isEmpty() && !selectedSuffix.isEmpty()) {
             /* No suffix specified, add selected suffix */
             if (!result.endsWith(".")) {
                 result.append(".");
             }
             result.append(selectedSuffix);
         }
     }
 
     /* Return selected suffix if asked to */
     if (selectedSuffixOut) {
         *selectedSuffixOut = selectedSuffix;
     }
     return result;
 }
 
 QString getOpenFileName(QWidget *parent, const QString &caption,
                         const QString &dir, const QString &filter,
                         QString *selectedSuffixOut) {
     QString selectedFilter;
     QString myDir;
     // Default to user documents location
     if (dir.isEmpty()) {
         myDir =
             QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
     } else {
         myDir = dir;
     }
     /* Directly convert path to native OS path separators */
     QString result = QDir::toNativeSeparators(QFileDialog::getOpenFileName(
         parent, caption, myDir, filter, &selectedFilter));
 
     if (selectedSuffixOut) {
         /* Extract first suffix from filter pattern "Description (*.foo)" or
          * "Description (*.foo *.bar ...) */
         QRegExp filter_re(".* \\(\\*\\.(.*)[ \\)]");
         QString selectedSuffix;
         if (filter_re.exactMatch(selectedFilter)) {
             selectedSuffix = filter_re.cap(1);
         }
         *selectedSuffixOut = selectedSuffix;
     }
     return result;
 }
 
 Qt::ConnectionType blockingGUIThreadConnection() {
     if (QThread::currentThread() != qApp->thread()) {
         return Qt::BlockingQueuedConnection;
     } else {
         return Qt::DirectConnection;
     }
 }
 
 bool checkPoint(const QPoint &p, const QWidget *w) {
     QWidget *atW = QApplication::widgetAt(w->mapToGlobal(p));
     if (!atW) {
         return false;
     }
     return atW->topLevelWidget() == w;
 }
 
 bool isObscured(QWidget *w) {
     return !(checkPoint(QPoint(0, 0), w) &&
              checkPoint(QPoint(w->width() - 1, 0), w) &&
              checkPoint(QPoint(0, w->height() - 1), w) &&
              checkPoint(QPoint(w->width() - 1, w->height() - 1), w) &&
              checkPoint(QPoint(w->width() / 2, w->height() / 2), w));
 }
 
 void bringToFront(QWidget *w) {
 #ifdef Q_OS_MAC
     ForceActivation();
 #endif
 
     if (w) {
         // activateWindow() (sometimes) helps with keyboard focus on Windows
         if (w->isMinimized()) {
             w->showNormal();
         } else {
             w->show();
         }
         w->activateWindow();
         w->raise();
     }
 }
 
 void openDebugLogfile() {
     fs::path pathDebug = GetDataDir() / "debug.log";
 
     /* Open debug.log with the associated application */
     if (fs::exists(pathDebug)) {
         QDesktopServices::openUrl(
             QUrl::fromLocalFile(boostPathToQString(pathDebug)));
     }
 }
 
 bool openBitcoinConf() {
     fs::path pathConfig =
         GetConfigFile(gArgs.GetArg("-conf", BITCOIN_CONF_FILENAME));
 
     /* Create the file */
     fsbridge::ofstream configFile(pathConfig, std::ios_base::app);
 
     if (!configFile.good()) {
         return false;
     }
 
     configFile.close();
 
     /* Open bitcoin.conf with the associated application */
     return QDesktopServices::openUrl(
         QUrl::fromLocalFile(boostPathToQString(pathConfig)));
 }
 
 ToolTipToRichTextFilter::ToolTipToRichTextFilter(int _size_threshold,
                                                  QObject *parent)
     : QObject(parent), size_threshold(_size_threshold) {}
 
 bool ToolTipToRichTextFilter::eventFilter(QObject *obj, QEvent *evt) {
     if (evt->type() == QEvent::ToolTipChange) {
         QWidget *widget = static_cast<QWidget *>(obj);
         QString tooltip = widget->toolTip();
         if (tooltip.size() > size_threshold && !tooltip.startsWith("<qt") &&
             !Qt::mightBeRichText(tooltip)) {
             // Envelop with <qt></qt> to make sure Qt detects this as rich text
             // Escape the current message as HTML and replace \n by <br>
             tooltip = "<qt>" + HtmlEscape(tooltip, true) + "</qt>";
             widget->setToolTip(tooltip);
             return true;
         }
     }
     return QObject::eventFilter(obj, evt);
 }
 
 void TableViewLastColumnResizingFixer::connectViewHeadersSignals() {
     connect(tableView->horizontalHeader(), &QHeaderView::sectionResized, this,
             &TableViewLastColumnResizingFixer::on_sectionResized);
     connect(tableView->horizontalHeader(), &QHeaderView::geometriesChanged,
             this, &TableViewLastColumnResizingFixer::on_geometriesChanged);
 }
 
 // We need to disconnect these while handling the resize events, otherwise we
 // can enter infinite loops.
 void TableViewLastColumnResizingFixer::disconnectViewHeadersSignals() {
     disconnect(tableView->horizontalHeader(), &QHeaderView::sectionResized,
                this, &TableViewLastColumnResizingFixer::on_sectionResized);
     disconnect(tableView->horizontalHeader(), &QHeaderView::geometriesChanged,
                this, &TableViewLastColumnResizingFixer::on_geometriesChanged);
 } // namespace GUIUtil
 
 // Setup the resize mode, handles compatibility for Qt5 and below as the method
 // signatures changed.
 // Refactored here for readability.
 void TableViewLastColumnResizingFixer::setViewHeaderResizeMode(
     int logicalIndex, QHeaderView::ResizeMode resizeMode) {
     tableView->horizontalHeader()->setSectionResizeMode(logicalIndex,
                                                         resizeMode);
 }
 
 void TableViewLastColumnResizingFixer::resizeColumn(int nColumnIndex,
                                                     int width) {
     tableView->setColumnWidth(nColumnIndex, width);
     tableView->horizontalHeader()->resizeSection(nColumnIndex, width);
 }
 
 int TableViewLastColumnResizingFixer::getColumnsWidth() {
     int nColumnsWidthSum = 0;
     for (int i = 0; i < columnCount; i++) {
         nColumnsWidthSum += tableView->horizontalHeader()->sectionSize(i);
     }
     return nColumnsWidthSum;
 }
 
 int TableViewLastColumnResizingFixer::getAvailableWidthForColumn(int column) {
     int nResult = lastColumnMinimumWidth;
     int nTableWidth = tableView->horizontalHeader()->width();
 
     if (nTableWidth > 0) {
         int nOtherColsWidth =
             getColumnsWidth() -
             tableView->horizontalHeader()->sectionSize(column);
         nResult = std::max(nResult, nTableWidth - nOtherColsWidth);
     }
 
     return nResult;
 }
 
 // Make sure we don't make the columns wider than the table's viewport width.
 void TableViewLastColumnResizingFixer::adjustTableColumnsWidth() {
     disconnectViewHeadersSignals();
     resizeColumn(lastColumnIndex, getAvailableWidthForColumn(lastColumnIndex));
     connectViewHeadersSignals();
 
     int nTableWidth = tableView->horizontalHeader()->width();
     int nColsWidth = getColumnsWidth();
     if (nColsWidth > nTableWidth) {
         resizeColumn(secondToLastColumnIndex,
                      getAvailableWidthForColumn(secondToLastColumnIndex));
     }
 }
 
 // Make column use all the space available, useful during window resizing.
 void TableViewLastColumnResizingFixer::stretchColumnWidth(int column) {
     disconnectViewHeadersSignals();
     resizeColumn(column, getAvailableWidthForColumn(column));
     connectViewHeadersSignals();
 }
 
 // When a section is resized this is a slot-proxy for ajustAmountColumnWidth().
 void TableViewLastColumnResizingFixer::on_sectionResized(int logicalIndex,
                                                          int oldSize,
                                                          int newSize) {
     adjustTableColumnsWidth();
     int remainingWidth = getAvailableWidthForColumn(logicalIndex);
     if (newSize > remainingWidth) {
         resizeColumn(logicalIndex, remainingWidth);
     }
 }
 
 // When the table's geometry is ready, we manually perform the stretch of the
 // "Message" column,
 // as the "Stretch" resize mode does not allow for interactive resizing.
 void TableViewLastColumnResizingFixer::on_geometriesChanged() {
     if ((getColumnsWidth() - this->tableView->horizontalHeader()->width()) !=
         0) {
         disconnectViewHeadersSignals();
         resizeColumn(secondToLastColumnIndex,
                      getAvailableWidthForColumn(secondToLastColumnIndex));
         connectViewHeadersSignals();
     }
 }
 
 /**
  * Initializes all internal variables and prepares the
  * the resize modes of the last 2 columns of the table and
  */
 TableViewLastColumnResizingFixer::TableViewLastColumnResizingFixer(
     QTableView *table, int lastColMinimumWidth, int allColsMinimumWidth,
     QObject *parent)
     : QObject(parent), tableView(table),
       lastColumnMinimumWidth(lastColMinimumWidth),
       allColumnsMinimumWidth(allColsMinimumWidth) {
     columnCount = tableView->horizontalHeader()->count();
     lastColumnIndex = columnCount - 1;
     secondToLastColumnIndex = columnCount - 2;
     tableView->horizontalHeader()->setMinimumSectionSize(
         allColumnsMinimumWidth);
     setViewHeaderResizeMode(secondToLastColumnIndex, QHeaderView::Interactive);
     setViewHeaderResizeMode(lastColumnIndex, QHeaderView::Interactive);
 }
 
 #ifdef WIN32
 static fs::path StartupShortcutPath() {
     std::string chain = gArgs.GetChainName();
     if (chain == CBaseChainParams::MAIN) {
         return GetSpecialFolderPath(CSIDL_STARTUP) / "Bitcoin.lnk";
     }
     // Remove this special case when CBaseChainParams::TESTNET = "testnet4"
     if (chain == CBaseChainParams::TESTNET) {
         return GetSpecialFolderPath(CSIDL_STARTUP) / "Bitcoin (testnet).lnk";
     }
     return GetSpecialFolderPath(CSIDL_STARTUP) /
            strprintf("Bitcoin (%s).lnk", chain);
 }
 
 bool GetStartOnSystemStartup() {
     // check for Bitcoin*.lnk
     return fs::exists(StartupShortcutPath());
 }
 
 bool SetStartOnSystemStartup(bool fAutoStart) {
     // If the shortcut exists already, remove it for updating
     fs::remove(StartupShortcutPath());
 
     if (fAutoStart) {
         CoInitialize(nullptr);
 
         // Get a pointer to the IShellLink interface.
         IShellLinkW *psl = nullptr;
         HRESULT hres =
             CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_INPROC_SERVER,
                              IID_IShellLinkW, reinterpret_cast<void **>(&psl));
 
         if (SUCCEEDED(hres)) {
             // Get the current executable path
             WCHAR pszExePath[MAX_PATH];
             GetModuleFileNameW(nullptr, pszExePath, ARRAYSIZE(pszExePath));
 
             // Start client minimized
             QString strArgs = "-min";
             // Set -testnet /-regtest options
             strArgs += QString::fromStdString(
                 strprintf(" -chain=%s", gArgs.GetChainName()));
 
             // Set the path to the shortcut target
             psl->SetPath(pszExePath);
             PathRemoveFileSpecW(pszExePath);
             psl->SetWorkingDirectory(pszExePath);
             psl->SetShowCmd(SW_SHOWMINNOACTIVE);
             psl->SetArguments(strArgs.toStdWString().c_str());
 
             // Query IShellLink for the IPersistFile interface for
             // saving the shortcut in persistent storage.
             IPersistFile *ppf = nullptr;
             hres = psl->QueryInterface(IID_IPersistFile,
                                        reinterpret_cast<void **>(&ppf));
             if (SUCCEEDED(hres)) {
                 // Save the link by calling IPersistFile::Save.
                 hres = ppf->Save(StartupShortcutPath().wstring().c_str(), TRUE);
                 ppf->Release();
                 psl->Release();
                 CoUninitialize();
                 return true;
             }
             psl->Release();
         }
         CoUninitialize();
         return false;
     }
     return true;
 }
 #elif defined(Q_OS_LINUX)
 
 // Follow the Desktop Application Autostart Spec:
 // http://standards.freedesktop.org/autostart-spec/autostart-spec-latest.html
 
 static fs::path GetAutostartDir() {
     char *pszConfigHome = getenv("XDG_CONFIG_HOME");
     if (pszConfigHome) {
         return fs::path(pszConfigHome) / "autostart";
     }
     char *pszHome = getenv("HOME");
     if (pszHome) {
         return fs::path(pszHome) / ".config" / "autostart";
     }
     return fs::path();
 }
 
 static fs::path GetAutostartFilePath() {
     std::string chain = gArgs.GetChainName();
     if (chain == CBaseChainParams::MAIN) {
         return GetAutostartDir() / "bitcoin.desktop";
     }
     return GetAutostartDir() / strprintf("bitcoin-%s.lnk", chain);
 }
 
 bool GetStartOnSystemStartup() {
     fsbridge::ifstream optionFile(GetAutostartFilePath());
     if (!optionFile.good()) {
         return false;
     }
     // Scan through file for "Hidden=true":
     std::string line;
     while (!optionFile.eof()) {
         getline(optionFile, line);
         if (line.find("Hidden") != std::string::npos &&
             line.find("true") != std::string::npos) {
             return false;
         }
     }
     optionFile.close();
 
     return true;
 }
 
 bool SetStartOnSystemStartup(bool fAutoStart) {
     if (!fAutoStart) {
         fs::remove(GetAutostartFilePath());
     } else {
         char pszExePath[MAX_PATH + 1];
         ssize_t r =
             readlink("/proc/self/exe", pszExePath, sizeof(pszExePath) - 1);
         if (r == -1) {
             return false;
         }
         pszExePath[r] = '\0';
 
         fs::create_directories(GetAutostartDir());
 
         fsbridge::ofstream optionFile(
             GetAutostartFilePath(), std::ios_base::out | std::ios_base::trunc);
         if (!optionFile.good()) {
             return false;
         }
         std::string chain = gArgs.GetChainName();
         // Write a bitcoin.desktop file to the autostart directory:
         optionFile << "[Desktop Entry]\n";
         optionFile << "Type=Application\n";
         if (chain == CBaseChainParams::MAIN) {
             optionFile << "Name=Bitcoin\n";
         } else {
             optionFile << strprintf("Name=Bitcoin (%s)\n", chain);
         }
         optionFile << "Exec=" << pszExePath
                    << strprintf(" -min -chain=%s\n", chain);
         optionFile << "Terminal=false\n";
         optionFile << "Hidden=false\n";
         optionFile.close();
     }
     return true;
 }
 
 #elif defined(Q_OS_MAC)
 // based on:
 // https://github.com/Mozketo/LaunchAtLoginController/blob/master/LaunchAtLoginController.m
 
 // NB: caller must release returned ref if it's not NULL
 LSSharedFileListItemRef findStartupItemInList(LSSharedFileListRef list,
                                               CFURLRef findUrl);
 LSSharedFileListItemRef findStartupItemInList(LSSharedFileListRef list,
                                               CFURLRef findUrl) {
     LSSharedFileListItemRef foundItem = nullptr;
     // loop through the list of startup items and try to find the bitcoin app
     CFArrayRef listSnapshot = LSSharedFileListCopySnapshot(list, nullptr);
     for (int i = 0; !foundItem && i < CFArrayGetCount(listSnapshot); ++i) {
         LSSharedFileListItemRef item =
             (LSSharedFileListItemRef)CFArrayGetValueAtIndex(listSnapshot, i);
         UInt32 resolutionFlags = kLSSharedFileListNoUserInteraction |
                                  kLSSharedFileListDoNotMountVolumes;
         CFURLRef currentItemURL = nullptr;
 
 #if defined(MAC_OS_X_VERSION_MAX_ALLOWED) &&                                   \
     MAC_OS_X_VERSION_MAX_ALLOWED >= 10100
         if (&LSSharedFileListItemCopyResolvedURL) {
             currentItemURL = LSSharedFileListItemCopyResolvedURL(
                 item, resolutionFlags, nullptr);
         }
 #if defined(MAC_OS_X_VERSION_MIN_REQUIRED) &&                                  \
     MAC_OS_X_VERSION_MIN_REQUIRED < 10100
         else {
             LSSharedFileListItemResolve(item, resolutionFlags, &currentItemURL,
                                         nullptr);
         }
 #endif
 #else
         LSSharedFileListItemResolve(item, resolutionFlags, &currentItemURL,
                                     nullptr);
 #endif
 
         if (currentItemURL && CFEqual(currentItemURL, findUrl)) {
             // found
             CFRetain(foundItem = item);
         }
         if (currentItemURL) {
             CFRelease(currentItemURL);
         }
     }
     CFRelease(listSnapshot);
     return foundItem;
 }
 
 bool GetStartOnSystemStartup() {
     CFURLRef bitcoinAppUrl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
     LSSharedFileListRef loginItems = LSSharedFileListCreate(
         nullptr, kLSSharedFileListSessionLoginItems, nullptr);
     LSSharedFileListItemRef foundItem =
         findStartupItemInList(loginItems, bitcoinAppUrl);
     // findStartupItemInList retains the item it returned, need to release
     if (foundItem) {
         CFRelease(foundItem);
     }
     CFRelease(loginItems);
     CFRelease(bitcoinAppUrl);
     return foundItem;
 }
 
 bool SetStartOnSystemStartup(bool fAutoStart) {
     CFURLRef bitcoinAppUrl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
     LSSharedFileListRef loginItems = LSSharedFileListCreate(
         nullptr, kLSSharedFileListSessionLoginItems, nullptr);
     LSSharedFileListItemRef foundItem =
         findStartupItemInList(loginItems, bitcoinAppUrl);
 
     if (fAutoStart && !foundItem) {
         // add bitcoin app to startup item list
         LSSharedFileListInsertItemURL(loginItems,
                                       kLSSharedFileListItemBeforeFirst, nullptr,
                                       nullptr, bitcoinAppUrl, nullptr, nullptr);
     } else if (!fAutoStart && foundItem) {
         // remove item
         LSSharedFileListItemRemove(loginItems, foundItem);
     }
     // findStartupItemInList retains the item it returned, need to release
     if (foundItem) {
         CFRelease(foundItem);
     }
     CFRelease(loginItems);
     CFRelease(bitcoinAppUrl);
     return true;
 }
 #pragma GCC diagnostic pop
 #else
 
 bool GetStartOnSystemStartup() {
     return false;
 }
 bool SetStartOnSystemStartup(bool fAutoStart) {
     return false;
 }
 
 #endif
 
 void setClipboard(const QString &str) {
     QApplication::clipboard()->setText(str, QClipboard::Clipboard);
     QApplication::clipboard()->setText(str, QClipboard::Selection);
 }
 
 fs::path qstringToBoostPath(const QString &path) {
     return fs::path(path.toStdString());
 }
 
 QString boostPathToQString(const fs::path &path) {
     return QString::fromStdString(path.string());
 }
 
 QString formatDurationStr(int secs) {
     QStringList strList;
     int days = secs / 86400;
     int hours = (secs % 86400) / 3600;
     int mins = (secs % 3600) / 60;
     int seconds = secs % 60;
 
     if (days) {
         strList.append(QString(QObject::tr("%1 d")).arg(days));
     }
     if (hours) {
         strList.append(QString(QObject::tr("%1 h")).arg(hours));
     }
     if (mins) {
         strList.append(QString(QObject::tr("%1 m")).arg(mins));
     }
     if (seconds || (!days && !hours && !mins)) {
         strList.append(QString(QObject::tr("%1 s")).arg(seconds));
     }
 
     return strList.join(" ");
 }
 
 QString formatServicesStr(quint64 mask) {
     QStringList strList;
 
     // Don't display experimental service bits
     for (uint64_t check = 1; check <= NODE_LAST_NON_EXPERIMENTAL_SERVICE_BIT;
          check <<= 1) {
         if (mask & check) {
             switch (check) {
                 case NODE_NETWORK:
                     strList.append("NETWORK");
                     break;
                 case NODE_GETUTXO:
                     strList.append("GETUTXO");
                     break;
                 case NODE_BLOOM:
                     strList.append("BLOOM");
                     break;
                 case NODE_XTHIN:
                     strList.append("XTHIN");
                     break;
                 case NODE_BITCOIN_CASH:
                     strList.append("CASH");
                     break;
                 case NODE_NETWORK_LIMITED:
                     strList.append("LIMITED");
                     break;
                 default:
                     strList.append(QString("%1[%2]").arg("UNKNOWN").arg(check));
             }
         }
     }
 
     if (strList.size()) {
         return strList.join(" & ");
     } else {
         return QObject::tr("None");
     }
 }
 
 QString formatPingTime(int64_t ping_usec) {
     return (ping_usec == std::numeric_limits<int64_t>::max() || ping_usec == 0)
                ? QObject::tr("N/A")
                : QString(QObject::tr("%1 ms"))
                      .arg(QString::number(int(ping_usec / 1000), 10));
 }
 
 QString formatTimeOffset(int64_t nTimeOffset) {
     return QString(QObject::tr("%1 s"))
         .arg(QString::number((int)nTimeOffset, 10));
 }
 
 QString formatNiceTimeOffset(qint64 secs) {
     // Represent time from last generated block in human readable text
     QString timeBehindText;
     const int HOUR_IN_SECONDS = 60 * 60;
     const int DAY_IN_SECONDS = 24 * 60 * 60;
     const int WEEK_IN_SECONDS = 7 * 24 * 60 * 60;
     // Average length of year in Gregorian calendar
     const int YEAR_IN_SECONDS = 31556952;
     if (secs < 60) {
         timeBehindText = QObject::tr("%n second(s)", "", secs);
     } else if (secs < 2 * HOUR_IN_SECONDS) {
         timeBehindText = QObject::tr("%n minute(s)", "", secs / 60);
     } else if (secs < 2 * DAY_IN_SECONDS) {
         timeBehindText = QObject::tr("%n hour(s)", "", secs / HOUR_IN_SECONDS);
     } else if (secs < 2 * WEEK_IN_SECONDS) {
         timeBehindText = QObject::tr("%n day(s)", "", secs / DAY_IN_SECONDS);
     } else if (secs < YEAR_IN_SECONDS) {
         timeBehindText = QObject::tr("%n week(s)", "", secs / WEEK_IN_SECONDS);
     } else {
         qint64 years = secs / YEAR_IN_SECONDS;
         qint64 remainder = secs % YEAR_IN_SECONDS;
         timeBehindText = QObject::tr("%1 and %2")
                              .arg(QObject::tr("%n year(s)", "", years))
                              .arg(QObject::tr("%n week(s)", "",
                                               remainder / WEEK_IN_SECONDS));
     }
     return timeBehindText;
 }
 
 QString formatBytes(uint64_t bytes) {
     if (bytes < 1024) {
         return QString(QObject::tr("%1 B")).arg(bytes);
     }
     if (bytes < 1024 * 1024) {
         return QString(QObject::tr("%1 KB")).arg(bytes / 1024);
     }
     if (bytes < 1024 * 1024 * 1024) {
         return QString(QObject::tr("%1 MB")).arg(bytes / 1024 / 1024);
     }
 
     return QString(QObject::tr("%1 GB")).arg(bytes / 1024 / 1024 / 1024);
 }
 
 void ClickableLabel::mouseReleaseEvent(QMouseEvent *event) {
     Q_EMIT clicked(event->pos());
 }
 
 void ClickableProgressBar::mouseReleaseEvent(QMouseEvent *event) {
     Q_EMIT clicked(event->pos());
 }
 
 bool ItemDelegate::eventFilter(QObject *object, QEvent *event) {
     if (event->type() == QEvent::KeyPress) {
         if (static_cast<QKeyEvent *>(event)->key() == Qt::Key_Escape) {
             Q_EMIT keyEscapePressed();
         }
     }
     return QItemDelegate::eventFilter(object, event);
 }
 
 int TextWidth(const QFontMetrics &fm, const QString &text) {
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 11, 0))
     return fm.horizontalAdvance(text);
 #else
     return fm.width(text);
 #endif
 }
 
 } // namespace GUIUtil
diff --git a/src/qt/signverifymessagedialog.cpp b/src/qt/signverifymessagedialog.cpp
index 41b635447..4234108e7 100644
--- a/src/qt/signverifymessagedialog.cpp
+++ b/src/qt/signverifymessagedialog.cpp
@@ -1,282 +1,282 @@
 // 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.
 
 #include <qt/forms/ui_signverifymessagedialog.h>
 #include <qt/signverifymessagedialog.h>
 
 #include <key_io.h>
 #include <qt/addressbookpage.h>
 #include <qt/guiutil.h>
 #include <qt/platformstyle.h>
 #include <qt/walletmodel.h>
 #include <util/validation.h> // For strMessageMagic
 #include <wallet/wallet.h>
 
 #include <QClipboard>
 
 #include <string>
 #include <vector>
 
 SignVerifyMessageDialog::SignVerifyMessageDialog(
     const PlatformStyle *_platformStyle, QWidget *parent)
     : QDialog(parent), ui(new Ui::SignVerifyMessageDialog), model(nullptr),
       platformStyle(_platformStyle) {
     ui->setupUi(this);
 
     ui->addressBookButton_SM->setIcon(
         platformStyle->SingleColorIcon(":/icons/address-book"));
     ui->pasteButton_SM->setIcon(
         platformStyle->SingleColorIcon(":/icons/editpaste"));
     ui->copySignatureButton_SM->setIcon(
         platformStyle->SingleColorIcon(":/icons/editcopy"));
     ui->signMessageButton_SM->setIcon(
         platformStyle->SingleColorIcon(":/icons/edit"));
     ui->clearButton_SM->setIcon(
         platformStyle->SingleColorIcon(":/icons/remove"));
     ui->addressBookButton_VM->setIcon(
         platformStyle->SingleColorIcon(":/icons/address-book"));
     ui->verifyMessageButton_VM->setIcon(
         platformStyle->SingleColorIcon(":/icons/transaction_0"));
     ui->clearButton_VM->setIcon(
         platformStyle->SingleColorIcon(":/icons/remove"));
 
     ui->signatureOut_SM->setPlaceholderText(
         tr("Click \"Sign Message\" to generate signature"));
 
     GUIUtil::setupAddressWidget(ui->addressIn_SM, this);
     GUIUtil::setupAddressWidget(ui->addressIn_VM, this);
 
     ui->addressIn_SM->installEventFilter(this);
     ui->messageIn_SM->installEventFilter(this);
     ui->signatureOut_SM->installEventFilter(this);
     ui->addressIn_VM->installEventFilter(this);
     ui->messageIn_VM->installEventFilter(this);
     ui->signatureIn_VM->installEventFilter(this);
 
     ui->signatureOut_SM->setFont(GUIUtil::fixedPitchFont());
     ui->signatureIn_VM->setFont(GUIUtil::fixedPitchFont());
 }
 
 SignVerifyMessageDialog::~SignVerifyMessageDialog() {
     delete ui;
 }
 
 void SignVerifyMessageDialog::setModel(WalletModel *_model) {
     this->model = _model;
 }
 
 void SignVerifyMessageDialog::setAddress_SM(const QString &address) {
     ui->addressIn_SM->setText(address);
     ui->messageIn_SM->setFocus();
 }
 
 void SignVerifyMessageDialog::setAddress_VM(const QString &address) {
     ui->addressIn_VM->setText(address);
     ui->messageIn_VM->setFocus();
 }
 
 void SignVerifyMessageDialog::showTab_SM(bool fShow) {
     ui->tabWidget->setCurrentIndex(0);
     if (fShow) {
         this->show();
     }
 }
 
 void SignVerifyMessageDialog::showTab_VM(bool fShow) {
     ui->tabWidget->setCurrentIndex(1);
     if (fShow) {
         this->show();
     }
 }
 
 void SignVerifyMessageDialog::on_addressBookButton_SM_clicked() {
     if (model && model->getAddressTableModel()) {
         AddressBookPage dlg(platformStyle, AddressBookPage::ForSelection,
                             AddressBookPage::ReceivingTab, this);
         dlg.setModel(model->getAddressTableModel());
         if (dlg.exec()) {
             setAddress_SM(dlg.getReturnValue());
         }
     }
 }
 
 void SignVerifyMessageDialog::on_pasteButton_SM_clicked() {
     setAddress_SM(QApplication::clipboard()->text());
 }
 
 void SignVerifyMessageDialog::on_signMessageButton_SM_clicked() {
     if (!model) {
         return;
     }
 
     /* Clear old signature to ensure users don't get confused on error with an
      * old signature displayed */
     ui->signatureOut_SM->clear();
 
     CTxDestination destination = DecodeDestination(
         ui->addressIn_SM->text().toStdString(), model->getChainParams());
     if (!IsValidDestination(destination)) {
         ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_SM->setText(
             tr("The entered address is invalid.") + QString(" ") +
             tr("Please check the address and try again."));
         return;
     }
-    const CKeyID *keyID = boost::get<CKeyID>(&destination);
-    if (!keyID) {
+    const PKHash *pkhash = boost::get<PKHash>(&destination);
+    if (!pkhash) {
         ui->addressIn_SM->setValid(false);
         ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_SM->setText(
             tr("The entered address does not refer to a key.") + QString(" ") +
             tr("Please check the address and try again."));
         return;
     }
 
     WalletModel::UnlockContext ctx(model->requestUnlock());
     if (!ctx.isValid()) {
         ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_SM->setText(tr("Wallet unlock was cancelled."));
         return;
     }
 
     CKey key;
-    if (!model->wallet().getPrivKey(*keyID, key)) {
+    if (!model->wallet().getPrivKey(CKeyID(*pkhash), key)) {
         ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_SM->setText(
             tr("Private key for the entered address is not available."));
         return;
     }
 
     CHashWriter ss(SER_GETHASH, 0);
     ss << strMessageMagic;
     ss << ui->messageIn_SM->document()->toPlainText().toStdString();
 
     std::vector<uint8_t> vchSig;
     if (!key.SignCompact(ss.GetHash(), vchSig)) {
         ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_SM->setText(QString("<nobr>") +
                                     tr("Message signing failed.") +
                                     QString("</nobr>"));
         return;
     }
 
     ui->statusLabel_SM->setStyleSheet("QLabel { color: green; }");
     ui->statusLabel_SM->setText(QString("<nobr>") + tr("Message signed.") +
                                 QString("</nobr>"));
 
     ui->signatureOut_SM->setText(
         QString::fromStdString(EncodeBase64(vchSig.data(), vchSig.size())));
 }
 
 void SignVerifyMessageDialog::on_copySignatureButton_SM_clicked() {
     GUIUtil::setClipboard(ui->signatureOut_SM->text());
 }
 
 void SignVerifyMessageDialog::on_clearButton_SM_clicked() {
     ui->addressIn_SM->clear();
     ui->messageIn_SM->clear();
     ui->signatureOut_SM->clear();
     ui->statusLabel_SM->clear();
 
     ui->addressIn_SM->setFocus();
 }
 
 void SignVerifyMessageDialog::on_addressBookButton_VM_clicked() {
     if (model && model->getAddressTableModel()) {
         AddressBookPage dlg(platformStyle, AddressBookPage::ForSelection,
                             AddressBookPage::SendingTab, this);
         dlg.setModel(model->getAddressTableModel());
         if (dlg.exec()) {
             setAddress_VM(dlg.getReturnValue());
         }
     }
 }
 
 void SignVerifyMessageDialog::on_verifyMessageButton_VM_clicked() {
     CTxDestination destination = DecodeDestination(
         ui->addressIn_VM->text().toStdString(), model->getChainParams());
     if (!IsValidDestination(destination)) {
         ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_VM->setText(
             tr("The entered address is invalid.") + QString(" ") +
             tr("Please check the address and try again."));
         return;
     }
-    if (!boost::get<CKeyID>(&destination)) {
+    if (!boost::get<PKHash>(&destination)) {
         ui->addressIn_VM->setValid(false);
         ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_VM->setText(
             tr("The entered address does not refer to a key.") + QString(" ") +
             tr("Please check the address and try again."));
         return;
     }
 
     bool fInvalid = false;
     std::vector<uint8_t> vchSig = DecodeBase64(
         ui->signatureIn_VM->text().toStdString().c_str(), &fInvalid);
 
     if (fInvalid) {
         ui->signatureIn_VM->setValid(false);
         ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_VM->setText(
             tr("The signature could not be decoded.") + QString(" ") +
             tr("Please check the signature and try again."));
         return;
     }
 
     CHashWriter ss(SER_GETHASH, 0);
     ss << strMessageMagic;
     ss << ui->messageIn_VM->document()->toPlainText().toStdString();
 
     CPubKey pubkey;
     if (!pubkey.RecoverCompact(ss.GetHash(), vchSig)) {
         ui->signatureIn_VM->setValid(false);
         ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_VM->setText(
             tr("The signature did not match the message digest.") +
             QString(" ") + tr("Please check the signature and try again."));
         return;
     }
 
-    if (!(CTxDestination(pubkey.GetID()) == destination)) {
+    if (!(CTxDestination(PKHash(pubkey)) == destination)) {
         ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_VM->setText(QString("<nobr>") +
                                     tr("Message verification failed.") +
                                     QString("</nobr>"));
         return;
     }
 
     ui->statusLabel_VM->setStyleSheet("QLabel { color: green; }");
     ui->statusLabel_VM->setText(QString("<nobr>") + tr("Message verified.") +
                                 QString("</nobr>"));
 }
 
 void SignVerifyMessageDialog::on_clearButton_VM_clicked() {
     ui->addressIn_VM->clear();
     ui->signatureIn_VM->clear();
     ui->messageIn_VM->clear();
     ui->statusLabel_VM->clear();
 
     ui->addressIn_VM->setFocus();
 }
 
 bool SignVerifyMessageDialog::eventFilter(QObject *object, QEvent *event) {
     if (event->type() == QEvent::MouseButtonPress ||
         event->type() == QEvent::FocusIn) {
         if (ui->tabWidget->currentIndex() == 0) {
             /* Clear status message on focus change */
             ui->statusLabel_SM->clear();
 
             /* Select generated signature */
             if (object == ui->signatureOut_SM) {
                 ui->signatureOut_SM->selectAll();
                 return true;
             }
         } else if (ui->tabWidget->currentIndex() == 1) {
             /* Clear status message on focus change */
             ui->statusLabel_VM->clear();
         }
     }
     return QDialog::eventFilter(object, event);
 }
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
index f0ffed784..9ee61ff12 100644
--- a/src/qt/test/wallettests.cpp
+++ b/src/qt/test/wallettests.cpp
@@ -1,262 +1,262 @@
 #include <qt/test/util.h>
 #include <qt/test/wallettests.h>
 
 #include <cashaddrenc.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <interfaces/chain.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <qt/bitcoinamountfield.h>
 #include <qt/optionsmodel.h>
 #include <qt/overviewpage.h>
 #include <qt/platformstyle.h>
 #include <qt/qvalidatedlineedit.h>
 #include <qt/receivecoinsdialog.h>
 #include <qt/receiverequestdialog.h>
 #include <qt/recentrequeststablemodel.h>
 #include <qt/sendcoinsdialog.h>
 #include <qt/sendcoinsentry.h>
 #include <qt/transactiontablemodel.h>
 #include <qt/walletmodel.h>
 #include <validation.h>
 #include <wallet/wallet.h>
 
 #include <test/util/setup_common.h>
 
 #include <QAbstractButton>
 #include <QApplication>
 #include <QDialogButtonBox>
 #include <QListView>
 #include <QPushButton>
 #include <QTextEdit>
 #include <QTimer>
 #include <QVBoxLayout>
 
 #include <memory>
 
 namespace {
 //! Press "Yes" or "Cancel" buttons in modal send confirmation dialog.
 void ConfirmSend(QString *text = nullptr, bool cancel = false) {
     QTimer::singleShot(0, Qt::PreciseTimer, [text, cancel]() {
         for (QWidget *widget : QApplication::topLevelWidgets()) {
             if (widget->inherits("SendConfirmationDialog")) {
                 SendConfirmationDialog *dialog =
                     qobject_cast<SendConfirmationDialog *>(widget);
                 if (text) {
                     *text = dialog->text();
                 }
                 QAbstractButton *button = dialog->button(
                     cancel ? QMessageBox::Cancel : QMessageBox::Yes);
                 button->setEnabled(true);
                 button->click();
             }
         }
     });
 }
 
 //! Send coins to address and return txid.
 TxId SendCoins(CWallet &wallet, SendCoinsDialog &sendCoinsDialog,
                const CTxDestination &address, Amount amount) {
     QVBoxLayout *entries = sendCoinsDialog.findChild<QVBoxLayout *>("entries");
     SendCoinsEntry *entry =
         qobject_cast<SendCoinsEntry *>(entries->itemAt(0)->widget());
     entry->findChild<QValidatedLineEdit *>("payTo")->setText(
         QString::fromStdString(EncodeCashAddr(address, Params())));
     entry->findChild<BitcoinAmountField *>("payAmount")->setValue(amount);
     TxId txid;
     boost::signals2::scoped_connection c =
         wallet.NotifyTransactionChanged.connect(
             [&txid](CWallet *, const TxId &hash, ChangeType status) {
                 if (status == CT_NEW) {
                     txid = hash;
                 }
             });
     ConfirmSend();
     bool invoked =
         QMetaObject::invokeMethod(&sendCoinsDialog, "on_sendButton_clicked");
     assert(invoked);
     return txid;
 }
 
 //! Find index of txid in transaction list.
 QModelIndex FindTx(const QAbstractItemModel &model, const uint256 &txid) {
     QString hash = QString::fromStdString(txid.ToString());
     int rows = model.rowCount({});
     for (int row = 0; row < rows; ++row) {
         QModelIndex index = model.index(row, 0, {});
         if (model.data(index, TransactionTableModel::TxHashRole) == hash) {
             return index;
         }
     }
     return {};
 }
 
 //! Simple qt wallet tests.
 //
 // Test widgets can be debugged interactively calling show() on them and
 // manually running the event loop, e.g.:
 //
 //     sendCoinsDialog.show();
 //     QEventLoop().exec();
 //
 // This also requires overriding the default minimal Qt platform:
 //
 //     src/qt/test/test_bitcoin-qt -platform xcb      # Linux
 //     src/qt/test/test_bitcoin-qt -platform windows  # Windows
 //     src/qt/test/test_bitcoin-qt -platform cocoa    # macOS
 void TestGUI() {
     // Set up wallet and chain with 105 blocks (5 mature blocks for spending).
     TestChain100Setup test;
     for (int i = 0; i < 5; ++i) {
         test.CreateAndProcessBlock(
             {}, GetScriptForRawPubKey(test.coinbaseKey.GetPubKey()));
     }
 
     auto chain = interfaces::MakeChain();
     std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(
         Params(), chain.get(), WalletLocation(), WalletDatabase::CreateMock());
 
     bool firstRun;
     wallet->LoadWallet(firstRun);
     {
         LOCK(wallet->cs_wallet);
         wallet->SetAddressBook(
             GetDestinationForKey(test.coinbaseKey.GetPubKey(),
                                  wallet->m_default_address_type),
             "", "receive");
         wallet->AddKeyPubKey(test.coinbaseKey, test.coinbaseKey.GetPubKey());
     }
     {
         auto locked_chain = wallet->chain().lock();
         LockAssertion lock(::cs_main);
 
         WalletRescanReserver reserver(wallet.get());
         reserver.reserve();
         CWallet::ScanResult result = wallet->ScanForWalletTransactions(
             locked_chain->getBlockHash(0), BlockHash(), reserver,
             true /* fUpdate */);
         QCOMPARE(result.status, CWallet::ScanResult::SUCCESS);
         QCOMPARE(result.last_scanned_block,
                  ::ChainActive().Tip()->GetBlockHash());
         QVERIFY(result.last_failed_block.IsNull());
     }
     wallet->SetBroadcastTransactions(true);
 
     // Create widgets for sending coins and listing transactions.
     std::unique_ptr<const PlatformStyle> platformStyle(
         PlatformStyle::instantiate("other"));
     auto node = interfaces::MakeNode();
     OptionsModel optionsModel(*node);
     AddWallet(wallet);
     WalletModel walletModel(std::move(node->getWallets().back()), *node,
                             platformStyle.get(), &optionsModel);
     RemoveWallet(wallet);
 
     // Send two transactions, and verify they are added to transaction list.
     SendCoinsDialog sendCoinsDialog(platformStyle.get(), &walletModel);
     TransactionTableModel *transactionTableModel =
         walletModel.getTransactionTableModel();
     QCOMPARE(transactionTableModel->rowCount({}), 105);
     TxId txid1 = SendCoins(*wallet.get(), sendCoinsDialog,
-                           CTxDestination(CKeyID()), 5 * COIN);
+                           CTxDestination(PKHash()), 5 * COIN);
     TxId txid2 = SendCoins(*wallet.get(), sendCoinsDialog,
-                           CTxDestination(CKeyID()), 10 * COIN);
+                           CTxDestination(PKHash()), 10 * COIN);
     QCOMPARE(transactionTableModel->rowCount({}), 107);
     QVERIFY(FindTx(*transactionTableModel, txid1).isValid());
     QVERIFY(FindTx(*transactionTableModel, txid2).isValid());
 
     // Check current balance on OverviewPage
     OverviewPage overviewPage(platformStyle.get());
     overviewPage.setWalletModel(&walletModel);
     QLabel *balanceLabel = overviewPage.findChild<QLabel *>("labelBalance");
     QString balanceText = balanceLabel->text();
     int unit = walletModel.getOptionsModel()->getDisplayUnit();
     Amount balance = walletModel.wallet().getBalance();
     QString balanceComparison = BitcoinUnits::formatWithUnit(
         unit, balance, false, BitcoinUnits::separatorAlways);
     QCOMPARE(balanceText, balanceComparison);
 
     // Check Request Payment button
     ReceiveCoinsDialog receiveCoinsDialog(platformStyle.get());
     receiveCoinsDialog.setModel(&walletModel);
     RecentRequestsTableModel *requestTableModel =
         walletModel.getRecentRequestsTableModel();
 
     // Label input
     QLineEdit *labelInput =
         receiveCoinsDialog.findChild<QLineEdit *>("reqLabel");
     labelInput->setText("TEST_LABEL_1");
 
     // Amount input
     BitcoinAmountField *amountInput =
         receiveCoinsDialog.findChild<BitcoinAmountField *>("reqAmount");
     amountInput->setValue(1 * SATOSHI);
 
     // Message input
     QLineEdit *messageInput =
         receiveCoinsDialog.findChild<QLineEdit *>("reqMessage");
     messageInput->setText("TEST_MESSAGE_1");
     int initialRowCount = requestTableModel->rowCount({});
     QPushButton *requestPaymentButton =
         receiveCoinsDialog.findChild<QPushButton *>("receiveButton");
     requestPaymentButton->click();
     for (QWidget *widget : QApplication::topLevelWidgets()) {
         if (widget->inherits("ReceiveRequestDialog")) {
             ReceiveRequestDialog *receiveRequestDialog =
                 qobject_cast<ReceiveRequestDialog *>(widget);
             QTextEdit *rlist =
                 receiveRequestDialog->QObject::findChild<QTextEdit *>("outUri");
             QString paymentText = rlist->toPlainText();
             QStringList paymentTextList = paymentText.split('\n');
             QCOMPARE(paymentTextList.at(0), QString("Payment information"));
             QVERIFY(paymentTextList.at(1).indexOf(QString("URI: bchreg:")) !=
                     -1);
             QVERIFY(paymentTextList.at(2).indexOf(QString("Address:")) != -1);
             QCOMPARE(paymentTextList.at(3),
                      QString("Amount: 0.00000001 ") +
                          QString::fromStdString(CURRENCY_UNIT));
             QCOMPARE(paymentTextList.at(4), QString("Label: TEST_LABEL_1"));
             QCOMPARE(paymentTextList.at(5), QString("Message: TEST_MESSAGE_1"));
         }
     }
 
     // Clear button
     QPushButton *clearButton =
         receiveCoinsDialog.findChild<QPushButton *>("clearButton");
     clearButton->click();
     QCOMPARE(labelInput->text(), QString(""));
     QCOMPARE(amountInput->value(), Amount::zero());
     QCOMPARE(messageInput->text(), QString(""));
 
     // Check addition to history
     int currentRowCount = requestTableModel->rowCount({});
     QCOMPARE(currentRowCount, initialRowCount + 1);
 
     // Check Remove button
     QTableView *table =
         receiveCoinsDialog.findChild<QTableView *>("recentRequestsView");
     table->selectRow(currentRowCount - 1);
     QPushButton *removeRequestButton =
         receiveCoinsDialog.findChild<QPushButton *>("removeRequestButton");
     removeRequestButton->click();
     QCOMPARE(requestTableModel->rowCount({}), currentRowCount - 1);
 }
 
 } // namespace
 
 void WalletTests::walletTests() {
 #ifdef Q_OS_MAC
     if (QApplication::platformName() == "minimal") {
         // Disable for mac on "minimal" platform to avoid crashes inside the Qt
         // framework when it tries to look up unimplemented cocoa functions,
         // and fails to handle returned nulls
         // (https://bugreports.qt.io/browse/QTBUG-49686).
         QWARN("Skipping WalletTests on mac build with 'minimal' platform set "
               "due to Qt bugs. To run AppTests, invoke with 'test_bitcoin-qt "
               "-platform cocoa' on mac, or else use a linux or windows build.");
         return;
     }
 #endif
     TestGUI();
 }
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 9341847d3..66b20addb 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -1,700 +1,700 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
 #include <config.h>
 #include <httpserver.h>
 #include <key_io.h>
 #include <logging.h>
 #include <outputtype.h>
 #include <rpc/blockchain.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <util/check.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <util/validation.h>
 
 #include <univalue.h>
 
 #include <cstdint>
 #ifdef HAVE_MALLOC_INFO
 #include <malloc.h>
 #endif
 
 static UniValue validateaddress(const Config &config,
                                 const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "validateaddress",
             "\nReturn information about the given bitcoin address.\n",
             {
                 {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The bitcoin address to validate"},
             },
             RPCResult{
                 "{\n"
                 "  \"isvalid\" : true|false,       (boolean) If the address is "
                 "valid or not. If not, this is the only property returned.\n"
                 "  \"address\" : \"address\",        (string) The bitcoin "
                 "address validated\n"
                 "  \"scriptPubKey\" : \"hex\",       (string) The hex-encoded "
                 "scriptPubKey generated by the address\n"
                 "  \"isscript\" : true|false,      (boolean) If the key is a "
                 "script\n"
                 "}\n"},
             RPCExamples{
                 HelpExampleCli("validateaddress",
                                "\"1PSSGeFHDnKNxiEyFrD1wcEaHr9hrQDDWc\"") +
                 HelpExampleRpc("validateaddress",
                                "\"1PSSGeFHDnKNxiEyFrD1wcEaHr9hrQDDWc\"")},
         }
                                      .ToString());
     }
 
     CTxDestination dest =
         DecodeDestination(request.params[0].get_str(), config.GetChainParams());
     bool isValid = IsValidDestination(dest);
 
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("isvalid", isValid);
 
     if (isValid) {
         if (ret["address"].isNull()) {
             std::string currentAddress = EncodeDestination(dest, config);
             ret.pushKV("address", currentAddress);
 
             CScript scriptPubKey = GetScriptForDestination(dest);
             ret.pushKV("scriptPubKey",
                        HexStr(scriptPubKey.begin(), scriptPubKey.end()));
 
             UniValue detail = DescribeAddress(dest);
             ret.pushKVs(detail);
         }
     }
     return ret;
 }
 
 static UniValue createmultisig(const Config &config,
                                const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 2) {
         std::string msg =
             RPCHelpMan{
                 "createmultisig",
                 "\nCreates a multi-signature address with n signature of m "
                 "keys required.\n"
                 "It returns a json object with the address and redeemScript.\n",
                 {
                     {"nrequired", RPCArg::Type::NUM, RPCArg::Optional::NO,
                      "The number of required signatures out of the n keys."},
                     {"keys",
                      RPCArg::Type::ARR,
                      RPCArg::Optional::NO,
                      "A json array of hex-encoded public keys.",
                      {
                          {"key", RPCArg::Type::STR_HEX,
                           RPCArg::Optional::OMITTED,
                           "The hex-encoded public key"},
                      }},
                 },
                 RPCResult{"{\n"
                           "  \"address\":\"multisigaddress\",  (string) The "
                           "value of the new multisig address.\n"
                           "  \"redeemScript\":\"script\"       (string) The "
                           "string value of the hex-encoded redemption script.\n"
                           "}\n"},
                 RPCExamples{
                     "\nCreate a multisig address from 2 public keys\n" +
                     HelpExampleCli(
                         "createmultisig",
                         "2 "
                         "\"["
                         "\\\"03789ed0bb717d88f7d321a368d905e7430207ebbd82bd3"
                         "42cf11ae157a7ace5fd\\\","
                         "\\\"03dbc6764b8884a92e871274b87583e6d5c2a58819473e1"
                         "7e107ef3f6aa5a61626\\\"]\"") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc(
                         "createmultisig",
                         "2, "
                         "\"["
                         "\\\"03789ed0bb717d88f7d321a368d905e7430207ebbd82bd3"
                         "42cf11ae157a7ace5fd\\\","
                         "\\\"03dbc6764b8884a92e871274b87583e6d5c2a58819473e1"
                         "7e107ef3f6aa5a61626\\\"]\"")},
             }
                 .ToString();
         throw std::runtime_error(msg);
     }
 
     int required = request.params[0].get_int();
 
     // Get the public keys
     const UniValue &keys = request.params[1].get_array();
     std::vector<CPubKey> pubkeys;
     for (size_t i = 0; i < keys.size(); ++i) {
         if ((keys[i].get_str().length() ==
                  2 * CPubKey::COMPRESSED_PUBLIC_KEY_SIZE ||
              keys[i].get_str().length() == 2 * CPubKey::PUBLIC_KEY_SIZE) &&
             IsHex(keys[i].get_str())) {
             pubkeys.push_back(HexToPubKey(keys[i].get_str()));
         } else {
             throw JSONRPCError(
                 RPC_INVALID_ADDRESS_OR_KEY,
                 strprintf("Invalid public key: %s\n", keys[i].get_str()));
         }
     }
 
     // Get the output type
     OutputType output_type = OutputType::LEGACY;
 
     // Construct using pay-to-script-hash:
     const CScript inner = CreateMultisigRedeemscript(required, pubkeys);
     CBasicKeyStore keystore;
     const CTxDestination dest =
         AddAndGetDestinationForScript(keystore, inner, output_type);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("address", EncodeDestination(dest, config));
     result.pushKV("redeemScript", HexStr(inner.begin(), inner.end()));
 
     return result;
 }
 
 UniValue deriveaddresses(const Config &config, const JSONRPCRequest &request) {
     if (request.fHelp || request.params.empty() || request.params.size() > 3) {
         throw std::runtime_error(RPCHelpMan{
             "deriveaddresses",
             {"\nDerives one or more addresses corresponding to an output "
              "descriptor.\n"
              "Examples of output descriptors are:\n"
              "    pkh(<pubkey>)                        P2PKH outputs for the "
              "given pubkey\n"
              "    sh(multi(<n>,<pubkey>,<pubkey>,...)) P2SH-multisig outputs "
              "for the given threshold and pubkeys\n"
              "    raw(<hex script>)                    Outputs whose "
              "scriptPubKey equals the specified hex scripts\n"
              "\nIn the above, <pubkey> either refers to a fixed public key in "
              "hexadecimal notation, or to an xpub/xprv optionally followed by "
              "one\n"
              "or more path elements separated by \"/\", where \"h\" represents "
              "a hardened child key.\n"
              "For more information on output descriptors, see the "
              "documentation in the doc/descriptors.md file.\n"},
             {
                 {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The descriptor."},
                 {"begin", RPCArg::Type::NUM,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "If a ranged descriptor is used, this specifies the beginning "
                  "of the range to import."},
                 {"end", RPCArg::Type::NUM, RPCArg::Optional::OMITTED_NAMED_ARG,
                  "If a ranged descriptor is used, this specifies the end of "
                  "the range to import."},
             },
             RPCResult{"[ address ] (array) the derived addresses\n"},
             RPCExamples{
                 "First three native segwit receive addresses\n" +
                 HelpExampleCli(
                     "deriveaddresses",
                     "\"pkh([d34db33f/84h/0h/"
                     "0h]"
                     "xpub6DJ2dNUysrn5Vt36jH2KLBT2i1auw1tTSSomg8PhqNiUtx8QX2SvC9"
                     "nrHu81fT41fvDUnhMjEzQgXnQjKEu3oaqMSzhSrHMxyyoEAmUHQbY/0/"
                     "*)\" 0 2")}}.ToString());
     }
 
     RPCTypeCheck(request.params,
                  {UniValue::VSTR, UniValue::VNUM, UniValue::VNUM});
     const std::string desc_str = request.params[0].get_str();
 
     int range_begin = 0;
     int range_end = 0;
 
     if (request.params.size() >= 2) {
         if (request.params.size() == 2) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Missing range end parameter");
         }
         range_begin = request.params[1].get_int();
         range_end = request.params[2].get_int();
         if (range_begin < 0) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Range should be greater or equal than 0");
         }
         if (range_begin > range_end) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Range end should be equal to or greater than begin");
         }
     }
 
     FlatSigningProvider provider;
     auto desc = Parse(desc_str, provider);
     if (!desc) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            strprintf("Invalid descriptor"));
     }
 
     if (!desc->IsRange() && request.params.size() > 1) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "Range should not be specified for an un-ranged descriptor");
     }
 
     if (desc->IsRange() && request.params.size() == 1) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Range must be specified for a ranged descriptor");
     }
 
     UniValue addresses(UniValue::VARR);
 
     for (int i = range_begin; i <= range_end; ++i) {
         std::vector<CScript> scripts;
         if (!desc->Expand(i, provider, scripts, provider)) {
             throw JSONRPCError(
                 RPC_INVALID_ADDRESS_OR_KEY,
                 strprintf("Cannot derive script without private keys"));
         }
 
         for (const CScript &script : scripts) {
             CTxDestination dest;
             if (!ExtractDestination(script, dest)) {
                 throw JSONRPCError(
                     RPC_INVALID_ADDRESS_OR_KEY,
                     strprintf(
                         "Descriptor does not have a corresponding address"));
             }
 
             addresses.push_back(EncodeDestination(dest, config));
         }
     }
 
     // This should not be possible, but an assert seems overkill:
     if (addresses.empty()) {
         throw JSONRPCError(RPC_MISC_ERROR, "Unexpected empty result");
     }
 
     return addresses;
 }
 
 static UniValue verifymessage(const Config &config,
                               const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 3) {
         throw std::runtime_error(RPCHelpMan{
             "verifymessage",
             "\nVerify a signed message\n",
             {
                 {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The bitcoin address to use for the signature."},
                 {"signature", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The signature provided by the signer in base 64 encoding "
                  "(see signmessage)."},
                 {"message", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The message that was signed."},
             },
             RPCResult{"true|false   (boolean) If the signature is verified or "
                       "not.\n"},
             RPCExamples{
                 "\nUnlock the wallet for 30 seconds\n" +
                 HelpExampleCli("walletpassphrase", "\"mypassphrase\" 30") +
                 "\nCreate the signature\n" +
                 HelpExampleCli(
                     "signmessage",
                     "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"my message\"") +
                 "\nVerify the signature\n" +
                 HelpExampleCli("verifymessage",
                                "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4"
                                "XX\" \"signature\" \"my "
                                "message\"") +
                 "\nAs a JSON-RPC call\n" +
                 HelpExampleRpc("verifymessage",
                                "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4"
                                "XX\", \"signature\", \"my "
                                "message\"")},
         }
                                      .ToString());
     }
 
     LOCK(cs_main);
 
     std::string strAddress = request.params[0].get_str();
     std::string strSign = request.params[1].get_str();
     std::string strMessage = request.params[2].get_str();
 
     CTxDestination destination =
         DecodeDestination(strAddress, config.GetChainParams());
     if (!IsValidDestination(destination)) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");
     }
 
-    const CKeyID *keyID = boost::get<CKeyID>(&destination);
-    if (!keyID) {
+    const PKHash *pkhash = boost::get<PKHash>(&destination);
+    if (!pkhash) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");
     }
 
     bool fInvalid = false;
     std::vector<uint8_t> vchSig = DecodeBase64(strSign.c_str(), &fInvalid);
 
     if (fInvalid) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Malformed base64 encoding");
     }
 
     CHashWriter ss(SER_GETHASH, 0);
     ss << strMessageMagic;
     ss << strMessage;
 
     CPubKey pubkey;
     if (!pubkey.RecoverCompact(ss.GetHash(), vchSig)) {
         return false;
     }
 
-    return (pubkey.GetID() == *keyID);
+    return (pubkey.GetID() == *pkhash);
 }
 
 static UniValue signmessagewithprivkey(const Config &config,
                                        const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 2) {
         throw std::runtime_error(RPCHelpMan{
             "signmessagewithprivkey",
             "\nSign a message with the private key of an address\n",
             {
                 {"privkey", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The private key to sign the message with."},
                 {"message", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The message to create a signature of."},
             },
             RPCResult{"\"signature\"          (string) The signature of the "
                       "message encoded in base 64\n"},
             RPCExamples{"\nCreate the signature\n" +
                         HelpExampleCli("signmessagewithprivkey",
                                        "\"privkey\" \"my message\"") +
                         "\nVerify the signature\n" +
                         HelpExampleCli("verifymessage",
                                        "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4"
                                        "XX\" \"signature\" \"my "
                                        "message\"") +
                         "\nAs a JSON-RPC call\n" +
                         HelpExampleRpc("signmessagewithprivkey",
                                        "\"privkey\", \"my message\"")},
         }
                                      .ToString());
     }
 
     std::string strPrivkey = request.params[0].get_str();
     std::string strMessage = request.params[1].get_str();
 
     CKey key = DecodeSecret(strPrivkey);
     if (!key.IsValid()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key");
     }
 
     CHashWriter ss(SER_GETHASH, 0);
     ss << strMessageMagic;
     ss << strMessage;
 
     std::vector<uint8_t> vchSig;
     if (!key.SignCompact(ss.GetHash(), vchSig)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Sign failed");
     }
 
     return EncodeBase64(vchSig.data(), vchSig.size());
 }
 
 static UniValue setmocktime(const Config &config,
                             const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "setmocktime",
             "\nSet the local time to given timestamp (-regtest only)\n",
             {
                 {"timestamp", RPCArg::Type::NUM, RPCArg::Optional::NO,
                  "Unix seconds-since-epoch timestamp\n"
                  "   Pass 0 to go back to using the system time."},
             },
             RPCResults{},
             RPCExamples{""},
         }
                                      .ToString());
     }
 
     if (!config.GetChainParams().MineBlocksOnDemand()) {
         throw std::runtime_error(
             "setmocktime for regression testing (-regtest mode) only");
     }
 
     // For now, don't change mocktime if we're in the middle of validation, as
     // this could have an effect on mempool time-based eviction, as well as
     // IsInitialBlockDownload().
     // TODO: figure out the right way to synchronize around mocktime, and
     // ensure all call sites of GetTime() are accessing this safely.
     LOCK(cs_main);
 
     RPCTypeCheck(request.params, {UniValue::VNUM});
     int64_t mockTime = request.params[0].get_int64();
     if (mockTime < 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Timestamp must be 0 or greater");
     }
     SetMockTime(mockTime);
 
     return NullUniValue;
 }
 
 static UniValue RPCLockedMemoryInfo() {
     LockedPool::Stats stats = LockedPoolManager::Instance().stats();
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("used", uint64_t(stats.used));
     obj.pushKV("free", uint64_t(stats.free));
     obj.pushKV("total", uint64_t(stats.total));
     obj.pushKV("locked", uint64_t(stats.locked));
     obj.pushKV("chunks_used", uint64_t(stats.chunks_used));
     obj.pushKV("chunks_free", uint64_t(stats.chunks_free));
     return obj;
 }
 
 #ifdef HAVE_MALLOC_INFO
 static std::string RPCMallocInfo() {
     char *ptr = nullptr;
     size_t size = 0;
     FILE *f = open_memstream(&ptr, &size);
     if (f) {
         malloc_info(0, f);
         fclose(f);
         if (ptr) {
             std::string rv(ptr, size);
             free(ptr);
             return rv;
         }
     }
     return "";
 }
 #endif
 
 static UniValue getmemoryinfo(const Config &config,
                               const JSONRPCRequest &request) {
     /* Please, avoid using the word "pool" here in the RPC interface or help,
      * as users will undoubtedly confuse it with the other "memory pool"
      */
     if (request.fHelp || request.params.size() > 1) {
         throw std::runtime_error(RPCHelpMan{
             "getmemoryinfo",
             "Returns an object containing information about memory usage.\n",
             {
                 {"mode", RPCArg::Type::STR, /* default */ "\"stats\"",
                  "determines what kind of information is returned.\n"
                  "  - \"stats\" returns general statistics about memory usage "
                  "in the daemon.\n"
                  "  - \"mallocinfo\" returns an XML string describing "
                  "low-level heap state (only available if compiled with glibc "
                  "2.10+)."},
             },
             {
                 RPCResult{"mode \"stats\"",
                           "{\n"
                           "  \"locked\": {               (json object) "
                           "Information about locked memory manager\n"
                           "    \"used\": xxxxx,          (numeric) Number of "
                           "bytes used\n"
                           "    \"free\": xxxxx,          (numeric) Number of "
                           "bytes available in current arenas\n"
                           "    \"total\": xxxxxxx,       (numeric) Total "
                           "number of bytes managed\n"
                           "    \"locked\": xxxxxx,       (numeric) Amount of "
                           "bytes that succeeded locking. If this number is "
                           "smaller than total, locking pages failed at some "
                           "point and key data could be swapped to disk.\n"
                           "    \"chunks_used\": xxxxx,   (numeric) Number "
                           "allocated chunks\n"
                           "    \"chunks_free\": xxxxx,   (numeric) Number "
                           "unused chunks\n"
                           "  }\n"
                           "}\n"},
                 RPCResult{"mode \"mallocinfo\"",
                           "\"<malloc version=\"1\">...\"\n"},
             },
             RPCExamples{HelpExampleCli("getmemoryinfo", "") +
                         HelpExampleRpc("getmemoryinfo", "")},
         }
                                      .ToString());
     }
 
     std::string mode =
         request.params[0].isNull() ? "stats" : request.params[0].get_str();
     if (mode == "stats") {
         UniValue obj(UniValue::VOBJ);
         obj.pushKV("locked", RPCLockedMemoryInfo());
         return obj;
     } else if (mode == "mallocinfo") {
 #ifdef HAVE_MALLOC_INFO
         return RPCMallocInfo();
 #else
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "mallocinfo is only available when compiled with glibc 2.10+");
 #endif
     } else {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "unknown mode " + mode);
     }
 }
 
 static void EnableOrDisableLogCategories(UniValue cats, bool enable) {
     cats = cats.get_array();
     for (size_t i = 0; i < cats.size(); ++i) {
         std::string cat = cats[i].get_str();
 
         bool success;
         if (enable) {
             success = LogInstance().EnableCategory(cat);
         } else {
             success = LogInstance().DisableCategory(cat);
         }
 
         if (!success) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "unknown logging category " + cat);
         }
     }
 }
 
 static UniValue logging(const Config &config, const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "logging",
             "Gets and sets the logging configuration.\n"
             "When called without an argument, returns the list of categories "
             "with status that are currently being debug logged or not.\n"
             "When called with arguments, adds or removes categories from debug "
             "logging and return the lists above.\n"
             "The arguments are evaluated in order \"include\", \"exclude\".\n"
             "If an item is both included and excluded, it will thus end up "
             "being excluded.\n"
             "The valid logging categories are: " +
                 ListLogCategories() +
                 "\n"
                 "In addition, the following are available as category names "
                 "with special meanings:\n"
                 "  - \"all\",  \"1\" : represent all logging categories.\n"
                 "  - \"none\", \"0\" : even if other logging categories are "
                 "specified, ignore all of them.\n",
             {
                 {"include",
                  RPCArg::Type::ARR,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "A json array of categories to add debug logging",
                  {
                      {"include_category", RPCArg::Type::STR,
                       RPCArg::Optional::OMITTED, "the valid logging category"},
                  }},
                 {"exclude",
                  RPCArg::Type::ARR,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "A json array of categories to remove debug logging",
                  {
                      {"exclude_category", RPCArg::Type::STR,
                       RPCArg::Optional::OMITTED, "the valid logging category"},
                  }},
             },
             RPCResult{"{                   (json object where keys are the "
                       "logging categories, and values indicates its status\n"
                       "  \"category\": 0|1,  (numeric) if being debug logged "
                       "or not. 0:inactive, 1:active\n"
                       "  ...\n"
                       "}\n"},
             RPCExamples{HelpExampleCli("logging",
                                        "\"[\\\"all\\\"]\" \"[\\\"http\\\"]\"") +
                         HelpExampleRpc("logging", "[\"all\"], \"[libevent]\"")},
         }
                                      .ToString());
     }
 
     uint32_t original_log_categories = LogInstance().GetCategoryMask();
     if (request.params[0].isArray()) {
         EnableOrDisableLogCategories(request.params[0], true);
     }
 
     if (request.params[1].isArray()) {
         EnableOrDisableLogCategories(request.params[1], false);
     }
 
     uint32_t updated_log_categories = LogInstance().GetCategoryMask();
     uint32_t changed_log_categories =
         original_log_categories ^ updated_log_categories;
 
     /**
      * Update libevent logging if BCLog::LIBEVENT has changed.
      * If the library version doesn't allow it, UpdateHTTPServerLogging()
      * returns false, in which case we should clear the BCLog::LIBEVENT flag.
      * Throw an error if the user has explicitly asked to change only the
      * libevent flag and it failed.
      */
     if (changed_log_categories & BCLog::LIBEVENT) {
         if (!UpdateHTTPServerLogging(
                 LogInstance().WillLogCategory(BCLog::LIBEVENT))) {
             LogInstance().DisableCategory(BCLog::LIBEVENT);
             if (changed_log_categories == BCLog::LIBEVENT) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "libevent logging cannot be updated when "
                                    "using libevent before v2.1.1.");
             }
         }
     }
 
     UniValue result(UniValue::VOBJ);
     std::vector<CLogCategoryActive> vLogCatActive = ListActiveLogCategories();
     for (const auto &logCatActive : vLogCatActive) {
         result.pushKV(logCatActive.category, logCatActive.active);
     }
 
     return result;
 }
 
 static UniValue echo(const Config &config, const JSONRPCRequest &request) {
     if (request.fHelp) {
         throw std::runtime_error(RPCHelpMan{
             "echo|echojson ...",
             "\nSimply echo back the input arguments. This command is for "
             "testing.\n"
             "\nThe difference between echo and echojson is that echojson has "
             "argument conversion enabled in the client-side table in "
             "bitcoin-cli and the GUI. There is no server-side difference.",
             {},
             RPCResults{},
             RPCExamples{""},
         }
                                      .ToString());
     }
 
     CHECK_NONFATAL(request.params.size() != 100);
 
     return request.params;
 }
 
 // clang-format off
 static const CRPCCommand commands[] = {
     //  category            name                      actor (function)        argNames
     //  ------------------- ------------------------  ----------------------  ----------
     { "control",            "getmemoryinfo",          getmemoryinfo,          {"mode"} },
     { "control",            "logging",                logging,                {"include", "exclude"} },
     { "util",               "validateaddress",        validateaddress,        {"address"} },
     { "util",               "createmultisig",         createmultisig,         {"nrequired","keys"} },
     { "util",               "deriveaddresses",        deriveaddresses,        {"descriptor", "begin", "end"} },
     { "util",               "verifymessage",          verifymessage,          {"address","signature","message"} },
     { "util",               "signmessagewithprivkey", signmessagewithprivkey, {"privkey","message"} },
     /* Not shown in help */
     { "hidden",             "setmocktime",            setmocktime,            {"timestamp"}},
     { "hidden",             "echo",                   echo,                   {"arg0","arg1","arg2","arg3","arg4","arg5","arg6","arg7","arg8","arg9"}},
     { "hidden",             "echojson",               echo,                   {"arg0","arg1","arg2","arg3","arg4","arg5","arg6","arg7","arg8","arg9"}},
 };
 // clang-format on
 
 void RegisterMiscRPCCommands(CRPCTable &t) {
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 1f56f6252..87e92634e 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -1,1998 +1,1998 @@
 // 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 <chain.h>
 #include <chainparams.h>
 #include <coins.h>
 #include <compat/byteswap.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <index/txindex.h>
 #include <key_io.h>
 #include <keystore.h>
 #include <merkleblock.h>
 #include <node/coin.h>
 #include <node/psbt.h>
 #include <node/transaction.h>
 #include <primitives/transaction.h>
 #include <psbt.h>
 #include <rpc/rawtransaction_util.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/script.h>
 #include <script/script_error.h>
 #include <script/sign.h>
 #include <script/standard.h>
 #include <txmempool.h>
 #include <uint256.h>
 #include <util/error.h>
 #include <util/moneystr.h>
 #include <util/strencodings.h>
 #include <validation.h>
 #include <validationinterface.h>
 
 #include <cstdint>
 
 #include <univalue.h>
 
 /**
  * High fee for sendrawtransaction and testmempoolaccept.
  * By default, transaction with a fee higher than this will be rejected by the
  * RPCs. This can be overridden with the maxfeerate argument.
  */
 constexpr static Amount DEFAULT_MAX_RAW_TX_FEE{COIN / 10};
 
 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) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 3) {
         throw std::runtime_error(RPCHelpMan{
             "getrawtransaction",
             "\nBy 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",
                           "\"data\"      (string) The serialized, hex-encoded "
                           "data for 'txid'\n"},
                 RPCResult{
                     "if verbose is set to true",
                     "{\n"
                     "  \"in_active_chain\": b, (bool) Whether specified block "
                     "is in the active chain or not (only present with explicit "
                     "\"blockhash\" argument)\n"
                     "  \"hex\" : \"data\",       (string) The serialized, "
                     "hex-encoded data for 'txid'\n"
                     "  \"txid\" : \"id\",        (string) The transaction id "
                     "(same as provided)\n"
                     "  \"hash\" : \"id\",        (string) The transaction hash "
                     "(differs from txid for witness transactions)\n"
                     "  \"size\" : n,             (numeric) The serialized "
                     "transaction size\n"
                     "  \"version\" : n,          (numeric) The version\n"
                     "  \"locktime\" : ttt,       (numeric) The lock time\n"
                     "  \"vin\" : [               (array of json objects)\n"
                     "     {\n"
                     "       \"txid\": \"id\",    (string) The transaction id\n"
                     "       \"vout\": n,         (numeric) \n"
                     "       \"scriptSig\": {     (json object) The script\n"
                     "         \"asm\": \"asm\",  (string) asm\n"
                     "         \"hex\": \"hex\"   (string) hex\n"
                     "       },\n"
                     "       \"sequence\": n      (numeric) The script sequence "
                     "number\n"
                     "     }\n"
                     "     ,...\n"
                     "  ],\n"
                     "  \"vout\" : [              (array of json objects)\n"
                     "     {\n"
                     "       \"value\" : x.xxx,            (numeric) The value "
                     "in " +
                         CURRENCY_UNIT +
                         "\n"
                         "       \"n\" : n,                    (numeric) index\n"
                         "       \"scriptPubKey\" : {          (json object)\n"
                         "         \"asm\" : \"asm\",          (string) the "
                         "asm\n"
                         "         \"hex\" : \"hex\",          (string) the "
                         "hex\n"
                         "         \"reqSigs\" : n,            (numeric) The "
                         "required sigs\n"
                         "         \"type\" : \"pubkeyhash\",  (string) The "
                         "type, eg 'pubkeyhash'\n"
                         "         \"addresses\" : [           (json array of "
                         "string)\n"
                         "           \"address\"        (string) bitcoin "
                         "address\n"
                         "           ,...\n"
                         "         ]\n"
                         "       }\n"
                         "     }\n"
                         "     ,...\n"
                         "  ],\n"
                         "  \"blockhash\" : \"hash\",   (string) the block "
                         "hash\n"
                         "  \"confirmations\" : n,      (numeric) The "
                         "confirmations\n"
                         "  \"time\" : ttt,             (numeric) The "
                         "transaction time in seconds since epoch (Jan 1 1970 "
                         "GMT)\n"
                         "  \"blocktime\" : ttt         (numeric) The block "
                         "time in seconds since epoch (Jan 1 1970 GMT)\n"
                         "}\n"},
             },
             RPCExamples{
                 HelpExampleCli("getrawtransaction", "\"mytxid\"") +
                 HelpExampleCli("getrawtransaction", "\"mytxid\" true") +
                 HelpExampleRpc("getrawtransaction", "\"mytxid\", true") +
                 HelpExampleCli("getrawtransaction",
                                "\"mytxid\" false \"myblockhash\"") +
                 HelpExampleCli("getrawtransaction",
                                "\"mytxid\" true \"myblockhash\"")},
         }
                                      .ToString());
     }
 
     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 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) {
     if (request.fHelp ||
         (request.params.size() != 1 && request.params.size() != 2)) {
         throw std::runtime_error(RPCHelpMan{
             "gettxoutproof",
             "\nReturns 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,
                     "A json array of 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{"\"data\"           (string) A string that is a "
                       "serialized, hex-encoded data for the proof.\n"},
             RPCExamples{""},
         }
                                      .ToString());
     }
 
     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(*pcoinsTip, 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) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "verifytxoutproof",
             "\nVerifies 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{"[\"txid\"]      (array, strings) The txid(s) which the "
                       "proof commits to, or empty array if the proof can not "
                       "be validated.\n"},
             RPCExamples{""},
         }
                                      .ToString());
     }
 
     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) {
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 3) {
         throw std::runtime_error(RPCHelpMan{
             "createrawtransaction",
             "\nCreate 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,
                     "A json array of 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,
                     "a json array with outputs (key-value pairs).\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{"\"transaction\"              (string) hex string of the "
                       "transaction\n"},
             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\\\"}]\"")},
         }
                                      .ToString());
     }
 
     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) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "decoderawtransaction",
             "\nReturn a JSON object representing the serialized, "
             "hex-encoded transaction.\n",
             {
                 {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "The transaction hex string"},
             },
             RPCResult{
                 "{\n"
                 "  \"txid\" : \"id\",        (string) The transaction id\n"
                 "  \"hash\" : \"id\",        (string) The transaction hash "
                 "(differs from txid for witness transactions)\n"
                 "  \"size\" : n,             (numeric) The transaction size\n"
                 "  \"version\" : n,          (numeric) The version\n"
                 "  \"locktime\" : ttt,       (numeric) The lock time\n"
                 "  \"vin\" : [               (array of json objects)\n"
                 "     {\n"
                 "       \"txid\": \"id\",    (string) The transaction id\n"
                 "       \"vout\": n,         (numeric) The output number\n"
                 "       \"scriptSig\": {     (json object) The script\n"
                 "         \"asm\": \"asm\",  (string) asm\n"
                 "         \"hex\": \"hex\"   (string) hex\n"
                 "       },\n"
                 "       \"sequence\": n     (numeric) The script sequence "
                 "number\n"
                 "     }\n"
                 "     ,...\n"
                 "  ],\n"
                 "  \"vout\" : [             (array of json objects)\n"
                 "     {\n"
                 "       \"value\" : x.xxx,            (numeric) The value in " +
                 CURRENCY_UNIT +
                 "\n"
                 "       \"n\" : n,                    (numeric) index\n"
                 "       \"scriptPubKey\" : {          (json object)\n"
                 "         \"asm\" : \"asm\",          (string) the asm\n"
                 "         \"hex\" : \"hex\",          (string) the hex\n"
                 "         \"reqSigs\" : n,            (numeric) The required "
                 "sigs\n"
                 "         \"type\" : \"pubkeyhash\",  (string) The type, eg "
                 "'pubkeyhash'\n"
                 "         \"addresses\" : [           (json array of string)\n"
                 "           \"12tvKAXCxZjSmdNbao16dKXC8tRWfcF5oc\"   (string) "
                 "bitcoin address\n"
                 "           ,...\n"
                 "         ]\n"
                 "       }\n"
                 "     }\n"
                 "     ,...\n"
                 "  ],\n"
                 "}\n"},
             RPCExamples{
                 HelpExampleCli("decoderawtransaction", "\"hexstring\"") +
                 HelpExampleRpc("decoderawtransaction", "\"hexstring\"")},
         }
                                      .ToString());
     }
 
     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 UniValue decodescript(const Config &config,
                              const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "decodescript",
             "\nDecode a hex-encoded script.\n",
             {
                 {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "the hex-encoded script"},
             },
             RPCResult{"{\n"
                       "  \"asm\":\"asm\",   (string) Script public key\n"
                       "  \"hex\":\"hex\",   (string) hex-encoded public key\n"
                       "  \"type\":\"type\", (string) The output type\n"
                       "  \"reqSigs\": n,    (numeric) The required signatures\n"
                       "  \"addresses\": [   (json array of string)\n"
                       "     \"address\"     (string) bitcoin address\n"
                       "     ,...\n"
                       "  ],\n"
                       "  \"p2sh\",\"address\" (string) address of P2SH script "
                       "wrapping this redeem script (not returned if the script "
                       "is already a P2SH).\n"
                       "}\n"},
             RPCExamples{HelpExampleCli("decodescript", "\"hexstring\"") +
                         HelpExampleRpc("decodescript", "\"hexstring\"")},
         }
                                      .ToString());
     }
 
     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, 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(CScriptID(script), config));
+        r.pushKV("p2sh", EncodeDestination(ScriptHash(script), config));
     }
 
     return r;
 }
 
 static UniValue combinerawtransaction(const Config &config,
                                       const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "combinerawtransaction",
             "\nCombine 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,
                     "A json array of hex strings of partially signed "
                     "transactions",
                     {
                         {"hexstring", RPCArg::Type::STR_HEX,
                          RPCArg::Optional::OMITTED, "A transaction hash"},
                     },
                 },
             },
             RPCResult{"\"hex\"            (string) The hex-encoded raw "
                       "transaction with signature(s)\n"},
             RPCExamples{HelpExampleCli("combinerawtransaction",
                                        "[\"myhex1\", \"myhex2\", \"myhex3\"]")},
         }
                                      .ToString());
     }
 
     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);
     {
         LOCK(cs_main);
         LOCK(g_mempool.cs);
         CCoinsViewCache &viewChain = *pcoinsTip;
         CCoinsViewMemPool viewMempool(&viewChain, g_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) {
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 4) {
         throw std::runtime_error(RPCHelpMan{
             "signrawtransactionwithkey",
             "\nSign 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,
                     "A json array of 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,
                     "A json array of 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{"{\n"
                       "  \"hex\" : \"value\",                  (string) The "
                       "hex-encoded raw transaction with signature(s)\n"
                       "  \"complete\" : true|false,          (boolean) If the "
                       "transaction has a complete set of signatures\n"
                       "  \"errors\" : [                      (json array of "
                       "objects) Script verification errors (if there are any)\n"
                       "    {\n"
                       "      \"txid\" : \"hash\",              (string) The "
                       "hash of the referenced, previous transaction\n"
                       "      \"vout\" : n,                   (numeric) The "
                       "index of the output to spent and used as input\n"
                       "      \"scriptSig\" : \"hex\",          (string) The "
                       "hex-encoded signature script\n"
                       "      \"sequence\" : n,               (numeric) Script "
                       "sequence number\n"
                       "      \"error\" : \"text\"              (string) "
                       "Verification or signing error related to the input\n"
                       "    }\n"
                       "    ,...\n"
                       "  ]\n"
                       "}\n"},
             RPCExamples{
                 HelpExampleCli("signrawtransactionwithkey", "\"myhex\"") +
                 HelpExampleRpc("signrawtransactionwithkey", "\"myhex\"")},
         }
                                      .ToString());
     }
 
     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");
     }
 
     CBasicKeyStore 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];
     }
     FindCoins(coins);
 
     return SignTransaction(mtx, request.params[2], &keystore, coins, true,
                            request.params[3]);
 }
 
 static UniValue sendrawtransaction(const Config &config,
                                    const JSONRPCRequest &request) {
     const RPCHelpMan help{
         "sendrawtransaction",
         "\nSubmits 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),
              "Reject transactions whose fee rate is higher than the specified "
              "value, expressed in " +
                  CURRENCY_UNIT + "/kB\n"},
         },
         RPCResult{"\"hex\"             (string) The transaction hash in hex\n"},
         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\"")},
     };
 
     if (request.fHelp || !help.IsValidNumArgs(request.params.size())) {
         throw std::runtime_error(help.ToString());
     }
 
     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)));
 
     Amount max_raw_tx_fee = DEFAULT_MAX_RAW_TX_FEE;
     // 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].isNum()) {
         size_t sz = tx->GetTotalSize();
         CFeeRate fr(AmountFromValue(request.params[1]));
         max_raw_tx_fee = fr.GetFee(sz);
     } else if (!request.params[1].isNull()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "second argument (maxfeerate) must be numeric");
     }
     std::string err_string;
     AssertLockNotHeld(cs_main);
     const TransactionError err = BroadcastTransaction(
         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) {
     const RPCHelpMan help{
         "testmempoolaccept",
         "\nReturns 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),
              "Reject transactions whose fee rate is higher than the specified "
              "value, expressed in " +
                  CURRENCY_UNIT + "/kB\n"},
         },
         RPCResult{
             "[                   (array) The result of the mempool acceptance "
             "test for each raw transaction in the input array.\n"
             "                            Length is exactly one for now.\n"
             " {\n"
             "  \"txid\"           (string) The transaction hash in hex\n"
             "  \"allowed\"        (boolean) If the mempool allows this tx to "
             "be inserted\n"
             "  \"reject-reason\"  (string) Rejection string (only present when "
             "'allowed' is false)\n"
             " }\n"
             "]\n"},
         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\"]")},
     };
 
     if (request.fHelp || !help.IsValidNumArgs(request.params.size())) {
         throw std::runtime_error(help.ToString());
     }
 
     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();
 
     Amount max_raw_tx_fee = DEFAULT_MAX_RAW_TX_FEE;
     // TODO: temporary migration code for old clients. Remove in v0.20
     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].isNum()) {
         size_t sz = tx->GetTotalSize();
         CFeeRate fr(AmountFromValue(request.params[1]));
         max_raw_tx_fee = fr.GetFee(sz);
     } else if (!request.params[1].isNull()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "second argument (maxfeerate) must be numeric");
     }
 
     UniValue result(UniValue::VARR);
     UniValue result_0(UniValue::VOBJ);
     result_0.pushKV("txid", txid.GetHex());
 
     CValidationState state;
     bool missing_inputs;
     bool test_accept_res;
     {
         LOCK(cs_main);
         test_accept_res = AcceptToMemoryPool(
             config, g_mempool, state, std::move(tx), &missing_inputs,
             false /* bypass_limits */, max_raw_tx_fee, true /* test_accept */);
     }
     result_0.pushKV("allowed", test_accept_res);
     if (!test_accept_res) {
         if (state.IsInvalid()) {
             result_0.pushKV("reject-reason",
                             strprintf("%i: %s", state.GetRejectCode(),
                                       state.GetRejectReason()));
         } else if (missing_inputs) {
             result_0.pushKV("reject-reason", "missing-inputs");
         } 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);
         if (hardened) {
             keypath_str += "'";
         }
     }
     return keypath_str;
 }
 
 static UniValue decodepsbt(const Config &config,
                            const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "decodepsbt",
             "\nReturn 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{
                 "{\n"
                 "  \"tx\" : {                   (json object) The decoded "
                 "network-serialized unsigned transaction.\n"
                 "    ...                                      The layout is "
                 "the same as the output of decoderawtransaction.\n"
                 "  },\n"
                 "  \"unknown\" : {                (json object) The unknown "
                 "global fields\n"
                 "    \"key\" : \"value\"            (key-value pair) An "
                 "unknown key-value pair\n"
                 "     ...\n"
                 "  },\n"
                 "  \"inputs\" : [                 (array of json objects)\n"
                 "    {\n"
                 "      \"utxo\" : {            (json object, optional) "
                 "Transaction output for UTXOs\n"
                 "        \"amount\" : x.xxx,           (numeric) The value "
                 "in " +
                 CURRENCY_UNIT +
                 "\n"
                 "        \"scriptPubKey\" : {          (json object)\n"
                 "          \"asm\" : \"asm\",            (string) The asm\n"
                 "          \"hex\" : \"hex\",            (string) The hex\n"
                 "          \"type\" : \"pubkeyhash\",    (string) The type, eg "
                 "'pubkeyhash'\n"
                 "          \"address\" : \"address\"     (string) Bitcoin "
                 "address if there is one\n"
                 "        }\n"
                 "      },\n"
                 "      \"partial_signatures\" : {             (json object, "
                 "optional)\n"
                 "        \"pubkey\" : \"signature\",           (string) The "
                 "public key and signature that corresponds to it.\n"
                 "        ,...\n"
                 "      }\n"
                 "      \"sighash\" : \"type\",                  (string, "
                 "optional) The sighash type to be used\n"
                 "      \"redeem_script\" : {       (json object, optional)\n"
                 "          \"asm\" : \"asm\",            (string) The asm\n"
                 "          \"hex\" : \"hex\",            (string) The hex\n"
                 "          \"type\" : \"pubkeyhash\",    (string) The type, eg "
                 "'pubkeyhash'\n"
                 "        }\n"
                 "      \"bip32_derivs\" : {          (json object, optional)\n"
                 "        \"pubkey\" : {                     (json object, "
                 "optional) The public key with the derivation path as the "
                 "value.\n"
                 "          \"master_fingerprint\" : \"fingerprint\"     "
                 "(string) The fingerprint of the master key\n"
                 "          \"path\" : \"path\",                         "
                 "(string) The path\n"
                 "        }\n"
                 "        ,...\n"
                 "      }\n"
                 "      \"final_scriptsig\" : {       (json object, optional)\n"
                 "          \"asm\" : \"asm\",            (string) The asm\n"
                 "          \"hex\" : \"hex\",            (string) The hex\n"
                 "        }\n"
                 "      \"unknown\" : {                (json object) The "
                 "unknown global fields\n"
                 "        \"key\" : \"value\"            (key-value pair) An "
                 "unknown key-value pair\n"
                 "         ...\n"
                 "      },\n"
                 "    }\n"
                 "    ,...\n"
                 "  ]\n"
                 "  \"outputs\" : [                 (array of json objects)\n"
                 "    {\n"
                 "      \"redeem_script\" : {       (json object, optional)\n"
                 "          \"asm\" : \"asm\",            (string) The asm\n"
                 "          \"hex\" : \"hex\",            (string) The hex\n"
                 "          \"type\" : \"pubkeyhash\",    (string) The type, eg "
                 "'pubkeyhash'\n"
                 "        }\n"
                 "      \"bip32_derivs\" : [          (array of json objects, "
                 "optional)\n"
                 "        {\n"
                 "          \"pubkey\" : \"pubkey\",                     "
                 "(string) The public key this path corresponds to\n"
                 "          \"master_fingerprint\" : \"fingerprint\"     "
                 "(string) The fingerprint of the master key\n"
                 "          \"path\" : \"path\",                         "
                 "(string) The path\n"
                 "          }\n"
                 "        }\n"
                 "        ,...\n"
                 "      ],\n"
                 "      \"unknown\" : {                (json object) The "
                 "unknown global fields\n"
                 "        \"key\" : \"value\"            (key-value pair) An "
                 "unknown key-value pair\n"
                 "         ...\n"
                 "      },\n"
                 "    }\n"
                 "    ,...\n"
                 "  ]\n"
                 "  \"fee\" : fee                      (numeric, optional) The "
                 "transaction fee paid if all UTXOs slots in the PSBT have been "
                 "filled.\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("decodepsbt", "\"psbt\"")},
         }
                                      .ToString());
     }
 
     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));
             total_in += txout.nValue;
 
             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
         output_value += psbtx.tx->vout[i].nValue;
     }
     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) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "combinepsbt",
             "\nCombine multiple partially signed Bitcoin transactions into "
             "one transaction.\n"
             "Implements the Combiner role.\n",
             {
                 {
                     "txs",
                     RPCArg::Type::ARR,
                     RPCArg::Optional::NO,
                     "A json array of base64 strings of partially signed "
                     "transactions",
                     {
                         {"psbt", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                          "A base64 string of a PSBT"},
                     },
                 },
             },
             RPCResult{"  \"psbt\"          (string) The base64-encoded "
                       "partially signed transaction\n"},
             RPCExamples{HelpExampleCli(
                 "combinepsbt",
                 "[\"mybase64_1\", \"mybase64_2\", \"mybase64_3\"]")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VARR}, true);
 
     // Unserialize the transactions
     std::vector<PartiallySignedTransaction> psbtxs;
     UniValue txs = request.params[0].get_array();
     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);
     }
 
     UniValue result(UniValue::VOBJ);
     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) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(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{
                 "{\n"
                 "  \"psbt\" : \"value\",          (string) The base64-encoded "
                 "partially signed transaction if not extracted\n"
                 "  \"hex\" : \"value\",           (string) The hex-encoded "
                 "network transaction if extracted\n"
                 "  \"complete\" : true|false,   (boolean) If the transaction "
                 "has a complete set of signatures\n"
                 "  ]\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("finalizepsbt", "\"psbt\"")},
         }
                                      .ToString());
     }
 
     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) {
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 3) {
         throw std::runtime_error(RPCHelpMan{
             "createpsbt",
             "\nCreates a transaction in the Partially Signed Transaction "
             "format.\n"
             "Implements the Creator role.\n",
             {
                 {
                     "inputs",
                     RPCArg::Type::ARR,
                     RPCArg::Optional::NO,
                     "A json array of 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,
                     "a json array with outputs (key-value pairs).\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{"  \"psbt\"        (string)  The resulting raw "
                       "transaction (base64-encoded string)\n"},
             RPCExamples{HelpExampleCli(
                 "createpsbt", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                               "\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"")},
         }
                                      .ToString());
     }
 
     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) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "converttopsbt",
             "\nConverts 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{"  \"psbt\"        (string)  The resulting raw "
                       "transaction (base64-encoded string)\n"},
             RPCExamples{
                 "\nCreate a transaction\n" +
                 HelpExampleCli("createrawtransaction",
                                "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                                "\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"") +
                 "\nConvert the transaction to a PSBT\n" +
                 HelpExampleCli("converttopsbt", "\"rawtransaction\"")},
         }
                                      .ToString());
     }
 
     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) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "utxoupdatepsbt",
             "\nUpdates a PSBT with witness UTXOs retrieved from the UTXO set "
             "or the mempool.\n",
             {{"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
               "A base64 string of a PSBT"}},
             RPCResult{"  \"psbt\"          (string) The base64-encoded "
                       "partially signed transaction with inputs updated\n"},
             RPCExamples{HelpExampleCli("utxoupdatepsbt", "\"psbt\"")}}
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR}, 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));
     }
 
     // Fetch previous transactions (inputs):
     CCoinsView viewDummy;
     CCoinsViewCache view(&viewDummy);
     {
         LOCK2(cs_main, g_mempool.cs);
         CCoinsViewCache &viewChain = *pcoinsTip;
         CCoinsViewMemPool viewMempool(&viewChain, g_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;
         }
 
         input.utxo = view.AccessCoin(psbtx.tx->vin[i].prevout).GetTxOut();
     }
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 UniValue joinpsbts(const Config &config, const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "joinpsbts",
             "\nJoins 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,
               "A json array of base64 strings of partially signed transactions",
               {{"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
                 "A base64 string of a PSBT"}}}},
             RPCResult{"  \"psbt\"          (string) The base64-encoded "
                       "partially signed transaction\n"},
             RPCExamples{HelpExampleCli("joinpsbts", "\"psbt\"")}}
                                      .ToString());
     }
 
     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());
     }
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << merged_psbt;
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 UniValue analyzepsbt(const Config &config, const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "analyzepsbt",
             "\nAnalyzes 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{
                 "{\n"
                 "  \"inputs\" : [                      (array of json "
                 "objects)\n"
                 "    {\n"
                 "      \"has_utxo\" : true|false     (boolean) Whether a UTXO "
                 "is provided\n"
                 "      \"is_final\" : true|false     (boolean) Whether the "
                 "input is finalized\n"
                 "      \"missing\" : {               (json object, optional) "
                 "Things that are missing that are required to complete this "
                 "input\n"
                 "        \"pubkeys\" : [             (array)\n"
                 "          \"keyid\"                 (string) Public key ID, "
                 "hash160 of the public key, of a public key whose BIP 32 "
                 "derivation path is missing\n"
                 "        ]\n"
                 "        \"signatures\" : [          (array)\n"
                 "          \"keyid\"                 (string) Public key ID, "
                 "hash160 of the public key, of a public key whose signature is "
                 "missing\n"
                 "        ]\n"
                 "        \"redeemscript\" : \"hash\"   (string) Hash160 of the "
                 "redeemScript that is missing\n"
                 "      }\n"
                 "      \"next\" : \"role\"           (string) Role of the next "
                 "person that this input needs to go to\n"
                 "    }\n"
                 "    ,...\n"
                 "  ]\n"
                 "  \"estimated_vsize\" : vsize       (numeric) Estimated vsize "
                 "of the final signed transaction\n"
                 "  \"estimated_feerate\" : feerate   (numeric, optional) "
                 "Estimated feerate of the final signed transaction. Shown only "
                 "if all UTXO slots in the PSBT have been filled.\n"
                 "  \"fee\" : fee                     (numeric, optional) The "
                 "transaction fee paid. Shown only if all UTXO slots in the "
                 "PSBT have been filled.\n"
                 "  \"next\" : \"role\"                 (string) Role of the "
                 "next person that this psbt needs to go to\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("analyzepsbt", "\"psbt\"")}}
                                      .ToString());
     }
 
     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);
     }
     result.pushKV("inputs", inputs_result);
 
     if (psbta.estimated_vsize != nullopt) {
         result.pushKV("estimated_vsize", (int)*psbta.estimated_vsize);
     }
     if (psbta.estimated_feerate != nullopt) {
         result.pushKV("estimated_feerate",
                       ValueFromAmount(psbta.estimated_feerate->GetFeePerK()));
     }
     if (psbta.fee != nullopt) {
         result.pushKV("fee", ValueFromAmount(*psbta.fee));
     }
     result.pushKV("next", PSBTRoleName(psbta.next));
 
     return result;
 }
 
 // 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"} },
     { "rawtransactions",    "joinpsbts",                 joinpsbts,                 {"txs"} },
     { "rawtransactions",    "analyzepsbt",               analyzepsbt,               {"psbt"} },
     { "blockchain",         "gettxoutproof",             gettxoutproof,             {"txids", "blockhash"} },
     { "blockchain",         "verifytxoutproof",          verifytxoutproof,          {"proof"} },
 };
 // clang-format on
 
 void RegisterRawTransactionRPCCommands(CRPCTable &t) {
     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 22fa1b816..ecc329333 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -1,670 +1,670 @@
 // 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 <key_io.h>
 #include <keystore.h>
 #include <pubkey.h>
 #include <rpc/util.h>
 #include <tinyformat.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 
 #include <univalue.h>
 
 #include <boost/variant/static_visitor.hpp>
 
 NodeContext *g_rpc_node = nullptr;
 
 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 CKeyStore
 CPubKey AddrToPubKey(const CChainParams &chainparams, CKeyStore *const 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 redeemscript from a given list of public keys and number
 // required.
 CScript CreateMultisigRedeemscript(const int required,
                                    const std::vector<CPubKey> &pubkeys) {
     // 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");
     }
 
     CScript result = GetScriptForMultisig(required, pubkeys);
 
     if (result.size() > MAX_SCRIPT_ELEMENT_SIZE) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             (strprintf("redeemScript exceeds size limit: %d > %d",
                        result.size(), MAX_SCRIPT_ELEMENT_SIZE)));
     }
 
     return result;
 }
 
 class DescribeAddressVisitor : public boost::static_visitor<UniValue> {
 public:
     explicit DescribeAddressVisitor() {}
 
     UniValue operator()(const CNoDestination &dest) const {
         return UniValue(UniValue::VOBJ);
     }
 
-    UniValue operator()(const CKeyID &keyID) const {
+    UniValue operator()(const PKHash &keyID) const {
         UniValue obj(UniValue::VOBJ);
         obj.pushKV("isscript", false);
         return obj;
     }
 
-    UniValue operator()(const CScriptID &scriptID) const {
+    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));
     }
 }
 
 /**
  * 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);
     }
 
     /**
      * Serializing RPCArgs depends on the outer type. Only arrays and
      * dictionaries can be nested in json. The top-level outer type is "named
      * arguments", a mix between a dictionary and arrays.
      */
     enum class OuterType {
         ARR,
         OBJ,
         // Only set on first recursion
         NAMED_ARG,
     };
 
     /**
      * Recursive helper to translate an RPCArg into sections
      */
     void Push(const RPCArg &arg, const size_t current_indent = 5,
               const OuterType outer_type = OuterType::NAMED_ARG) {
         const auto indent = std::string(current_indent, ' ');
         const auto indent_next = std::string(current_indent + 2, ' ');
         // 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::BOOL: {
                 // Nothing more to do for non-recursive types on first recursion
                 if (outer_type == OuterType::NAMED_ARG) {
                     return;
                 }
                 auto left = indent;
                 if (arg.m_type_str.size() != 0 && push_name) {
                     left += "\"" + arg.m_name + "\": " + 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::NAMED_ARG
                                        ? ""
                                        : arg.ToDescriptionString();
                 PushSection({indent +
                                  (push_name ? "\"" + arg.m_name + "\": " : "") +
                                  "{",
                              right});
                 for (const auto &arg_inner : arg.m_inner) {
                     Push(arg_inner, current_indent + 2, OuterType::OBJ);
                 }
                 if (arg.m_type != RPCArg::Type::OBJ) {
                     PushSection({indent_next + "...", ""});
                 }
                 PushSection(
                     {indent + "}" +
                          (outer_type != OuterType::NAMED_ARG ? "," : ""),
                      ""});
                 break;
             }
             case RPCArg::Type::ARR: {
                 auto left = indent;
                 left += push_name ? "\"" + arg.m_name + "\": " : "";
                 left += "[";
                 const auto right = outer_type == OuterType::NAMED_ARG
                                        ? ""
                                        : arg.ToDescriptionString();
                 PushSection({left, right});
                 for (const auto &arg_inner : arg.m_inner) {
                     Push(arg_inner, current_indent + 2, OuterType::ARR);
                 }
                 PushSection({indent_next + "...", ""});
                 PushSection(
                     {indent + "]" +
                          (outer_type != OuterType::NAMED_ARG ? "," : ""),
                      ""});
                 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) {
         // Should have unique named arguments
         CHECK_NONFATAL(named_args.insert(arg.m_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";
         }
         result += r.m_result;
     }
     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";
 
     // 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) + ". " +
                                              arg.m_name,
                                          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;
 }
 
 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::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;
 }
 
 std::string RPCArg::ToStringObj(const bool oneline) const {
     std::string res;
     res += "\"";
     res += m_name;
     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::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
             assert(false);
 
             // no default case, so the compiler can warn about missing cases
     }
     assert(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 "\"" + m_name + "\"";
         }
         case Type::NUM:
         case Type::AMOUNT:
         case Type::BOOL: {
             return m_name;
         }
         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
     }
     assert(false);
 }
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index 2b5e270ed..399c18ebb 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -1,930 +1,930 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <script/descriptor.h>
 
 #include <chainparams.h> // For Params()
 #include <config.h>
 #include <key_io.h>
 #include <pubkey.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <span.h>
 #include <util/bip32.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace {
 
 ////////////////////////////////////////////////////////////////////////////
 // Internal representation                                                //
 ////////////////////////////////////////////////////////////////////////////
 
 typedef std::vector<uint32_t> KeyPath;
 
 /** Interface for public key objects in descriptors. */
 struct PubkeyProvider {
     virtual ~PubkeyProvider() = default;
 
     /** Derive a public key. If key==nullptr, only info is desired. */
     virtual bool GetPubKey(int pos, const SigningProvider &arg, CPubKey *key,
                            KeyOriginInfo &info) const = 0;
 
     /** Whether this represent multiple public keys at different positions. */
     virtual bool IsRange() const = 0;
 
     /** Get the size of the generated public key(s) in bytes (33 or 65). */
     virtual size_t GetSize() const = 0;
 
     /** Get the descriptor string form. */
     virtual std::string ToString() const = 0;
 
     /**
      * Get the descriptor string form including private data (if available in
      * arg).
      */
     virtual bool ToPrivateString(const SigningProvider &arg,
                                  std::string &out) const = 0;
 };
 
 class OriginPubkeyProvider final : public PubkeyProvider {
     KeyOriginInfo m_origin;
     std::unique_ptr<PubkeyProvider> m_provider;
 
     std::string OriginString() const {
         return HexStr(std::begin(m_origin.fingerprint),
                       std::end(m_origin.fingerprint)) +
                FormatHDKeypath(m_origin.path);
     }
 
 public:
     OriginPubkeyProvider(KeyOriginInfo info,
                          std::unique_ptr<PubkeyProvider> provider)
         : m_origin(std::move(info)), m_provider(std::move(provider)) {}
     bool GetPubKey(int pos, const SigningProvider &arg, CPubKey *key,
                    KeyOriginInfo &info) const override {
         if (!m_provider->GetPubKey(pos, arg, key, info)) {
             return false;
         }
         std::copy(std::begin(m_origin.fingerprint),
                   std::end(m_origin.fingerprint), info.fingerprint);
         info.path.insert(info.path.begin(), m_origin.path.begin(),
                          m_origin.path.end());
         return true;
     }
     bool IsRange() const override { return m_provider->IsRange(); }
     size_t GetSize() const override { return m_provider->GetSize(); }
     std::string ToString() const override {
         return "[" + OriginString() + "]" + m_provider->ToString();
     }
     bool ToPrivateString(const SigningProvider &arg,
                          std::string &ret) const override {
         std::string sub;
         if (!m_provider->ToPrivateString(arg, sub)) {
             return false;
         }
         ret = "[" + OriginString() + "]" + std::move(sub);
         return true;
     }
 };
 
 /** An object representing a parsed constant public key in a descriptor. */
 class ConstPubkeyProvider final : public PubkeyProvider {
     CPubKey m_pubkey;
 
 public:
     ConstPubkeyProvider(const CPubKey &pubkey) : m_pubkey(pubkey) {}
     bool GetPubKey(int pos, const SigningProvider &arg, CPubKey *key,
                    KeyOriginInfo &info) const override {
         if (key) {
             *key = m_pubkey;
         }
         info.path.clear();
         CKeyID keyid = m_pubkey.GetID();
         std::copy(keyid.begin(), keyid.begin() + sizeof(info.fingerprint),
                   info.fingerprint);
         return true;
     }
     bool IsRange() const override { return false; }
     size_t GetSize() const override { return m_pubkey.size(); }
     std::string ToString() const override {
         return HexStr(m_pubkey.begin(), m_pubkey.end());
     }
     bool ToPrivateString(const SigningProvider &arg,
                          std::string &ret) const override {
         CKey key;
         if (!arg.GetKey(m_pubkey.GetID(), key)) {
             return false;
         }
         ret = EncodeSecret(key);
         return true;
     }
 };
 
 enum class DeriveType {
     NO,
     UNHARDENED,
     HARDENED,
 };
 
 /** An object representing a parsed extended public key in a descriptor. */
 class BIP32PubkeyProvider final : public PubkeyProvider {
     CExtPubKey m_extkey;
     KeyPath m_path;
     DeriveType m_derive;
 
     bool GetExtKey(const SigningProvider &arg, CExtKey &ret) const {
         CKey key;
         if (!arg.GetKey(m_extkey.pubkey.GetID(), key)) {
             return false;
         }
         ret.nDepth = m_extkey.nDepth;
         std::copy(m_extkey.vchFingerprint,
                   m_extkey.vchFingerprint + sizeof(ret.vchFingerprint),
                   ret.vchFingerprint);
         ret.nChild = m_extkey.nChild;
         ret.chaincode = m_extkey.chaincode;
         ret.key = key;
         return true;
     }
 
     bool IsHardened() const {
         if (m_derive == DeriveType::HARDENED) {
             return true;
         }
         for (auto entry : m_path) {
             if (entry >> 31) {
                 return true;
             }
         }
         return false;
     }
 
 public:
     BIP32PubkeyProvider(const CExtPubKey &extkey, KeyPath path,
                         DeriveType derive)
         : m_extkey(extkey), m_path(std::move(path)), m_derive(derive) {}
     bool IsRange() const override { return m_derive != DeriveType::NO; }
     size_t GetSize() const override { return 33; }
     bool GetPubKey(int pos, const SigningProvider &arg, CPubKey *key,
                    KeyOriginInfo &info) const override {
         if (key) {
             if (IsHardened()) {
                 CExtKey extkey;
                 if (!GetExtKey(arg, extkey)) {
                     return false;
                 }
                 for (auto entry : m_path) {
                     extkey.Derive(extkey, entry);
                 }
                 if (m_derive == DeriveType::UNHARDENED) {
                     extkey.Derive(extkey, pos);
                 }
                 if (m_derive == DeriveType::HARDENED) {
                     extkey.Derive(extkey, pos | 0x80000000UL);
                 }
                 *key = extkey.Neuter().pubkey;
             } else {
                 // TODO: optimize by caching
                 CExtPubKey extkey = m_extkey;
                 for (auto entry : m_path) {
                     extkey.Derive(extkey, entry);
                 }
                 if (m_derive == DeriveType::UNHARDENED) {
                     extkey.Derive(extkey, pos);
                 }
                 assert(m_derive != DeriveType::HARDENED);
                 *key = extkey.pubkey;
             }
         }
         CKeyID keyid = m_extkey.pubkey.GetID();
         std::copy(keyid.begin(), keyid.begin() + sizeof(info.fingerprint),
                   info.fingerprint);
         info.path = m_path;
         if (m_derive == DeriveType::UNHARDENED) {
             info.path.push_back(uint32_t(pos));
         }
         if (m_derive == DeriveType::HARDENED) {
             info.path.push_back(uint32_t(pos) | 0x80000000L);
         }
         return true;
     }
     std::string ToString() const override {
         std::string ret = EncodeExtPubKey(m_extkey) + FormatHDKeypath(m_path);
         if (IsRange()) {
             ret += "/*";
             if (m_derive == DeriveType::HARDENED) {
                 ret += '\'';
             }
         }
         return ret;
     }
     bool ToPrivateString(const SigningProvider &arg,
                          std::string &out) const override {
         CExtKey key;
         if (!GetExtKey(arg, key)) {
             return false;
         }
         out = EncodeExtKey(key) + FormatHDKeypath(m_path);
         if (IsRange()) {
             out += "/*";
             if (m_derive == DeriveType::HARDENED) {
                 out += '\'';
             }
         }
         return true;
     }
 };
 
 /** Base class for all Descriptor implementations. */
 class DescriptorImpl : public Descriptor {
     //! Public key arguments for this descriptor (size 1 for PK, PKH; any size
     //! of Multisig).
     const std::vector<std::unique_ptr<PubkeyProvider>> m_pubkey_args;
     //! The sub-descriptor argument (nullptr for everything but SH).
     const std::unique_ptr<DescriptorImpl> m_script_arg;
     //! The string name of the descriptor function.
     const std::string m_name;
 
 protected:
     //! Return a serialization of anything except pubkey and script arguments,
     //! to be prepended to those.
     virtual std::string ToStringExtra() const { return ""; }
 
     /**
      * A helper function to construct the scripts for this descriptor.
      *
      *  This function is invoked once for every CScript produced by evaluating
      *  m_script_arg, or just once in case m_script_arg is nullptr.
 
      *  @param pubkeys The evaluations of the m_pubkey_args field.
      *  @param script The evaluation of m_script_arg (or nullptr when
      m_script_arg is nullptr).
      *  @param out A FlatSigningProvider to put scripts or public keys in that
      are necessary to the solver.
      *             The script arguments to this function are automatically
      added, as is the origin info of the provided pubkeys.
      *  @return A vector with scriptPubKeys for this descriptor.
      */
     virtual std::vector<CScript>
     MakeScripts(const std::vector<CPubKey> &pubkeys, const CScript *script,
                 FlatSigningProvider &out) const = 0;
 
 public:
     DescriptorImpl(std::vector<std::unique_ptr<PubkeyProvider>> pubkeys,
                    std::unique_ptr<DescriptorImpl> script,
                    const std::string &name)
         : m_pubkey_args(std::move(pubkeys)), m_script_arg(std::move(script)),
           m_name(name) {}
 
     bool IsSolvable() const override {
         if (m_script_arg) {
             if (!m_script_arg->IsSolvable()) {
                 return false;
             }
         }
         return true;
     }
 
     bool IsRange() const final {
         for (const auto &pubkey : m_pubkey_args) {
             if (pubkey->IsRange()) {
                 return true;
             }
         }
         if (m_script_arg) {
             if (m_script_arg->IsRange()) {
                 return true;
             }
         }
         return false;
     }
 
     bool ToStringHelper(const SigningProvider *arg, std::string &out,
                         bool priv) const {
         std::string extra = ToStringExtra();
         size_t pos = extra.size() > 0 ? 1 : 0;
         std::string ret = m_name + "(" + extra;
         for (const auto &pubkey : m_pubkey_args) {
             if (pos++) {
                 ret += ",";
             }
             std::string tmp;
             if (priv) {
                 if (!pubkey->ToPrivateString(*arg, tmp)) {
                     return false;
                 }
             } else {
                 tmp = pubkey->ToString();
             }
             ret += std::move(tmp);
         }
         if (m_script_arg) {
             if (pos++) {
                 ret += ",";
             }
             std::string tmp;
             if (!m_script_arg->ToStringHelper(arg, tmp, priv)) {
                 return false;
             }
             ret += std::move(tmp);
         }
         out = std::move(ret) + ")";
         return true;
     }
 
     std::string ToString() const final {
         std::string ret;
         ToStringHelper(nullptr, ret, false);
         return ret;
     }
 
     bool ToPrivateString(const SigningProvider &arg,
                          std::string &out) const override final {
         return ToStringHelper(&arg, out, true);
     }
 
     bool ExpandHelper(int pos, const SigningProvider &arg,
                       Span<const uint8_t> *cache_read,
                       std::vector<CScript> &output_scripts,
                       FlatSigningProvider &out,
                       std::vector<uint8_t> *cache_write) const {
         std::vector<std::pair<CPubKey, KeyOriginInfo>> entries;
         entries.reserve(m_pubkey_args.size());
 
         // Construct temporary data in `entries` and `subscripts`, to avoid
         // producing output in case of failure.
         for (const auto &p : m_pubkey_args) {
             entries.emplace_back();
             if (!p->GetPubKey(pos, arg,
                               cache_read ? nullptr : &entries.back().first,
                               entries.back().second)) {
                 return false;
             }
             if (cache_read) {
                 // Cached expanded public key exists, use it.
                 if (cache_read->size() == 0) {
                     return false;
                 }
                 bool compressed =
                     ((*cache_read)[0] == 0x02 || (*cache_read)[0] == 0x03) &&
                     cache_read->size() >= 33;
                 bool uncompressed =
                     ((*cache_read)[0] == 0x04) && cache_read->size() >= 65;
                 if (!(compressed || uncompressed)) {
                     return false;
                 }
                 CPubKey pubkey(cache_read->begin(),
                                cache_read->begin() + (compressed ? 33 : 65));
                 entries.back().first = pubkey;
                 *cache_read = cache_read->subspan(compressed ? 33 : 65);
             }
             if (cache_write) {
                 cache_write->insert(cache_write->end(),
                                     entries.back().first.begin(),
                                     entries.back().first.end());
             }
         }
         std::vector<CScript> subscripts;
         if (m_script_arg) {
             FlatSigningProvider subprovider;
             if (!m_script_arg->ExpandHelper(pos, arg, cache_read, subscripts,
                                             subprovider, cache_write)) {
                 return false;
             }
             out = Merge(out, subprovider);
         }
 
         std::vector<CPubKey> pubkeys;
         pubkeys.reserve(entries.size());
         for (auto &entry : entries) {
             pubkeys.push_back(entry.first);
             out.origins.emplace(
                 entry.first.GetID(),
                 std::make_pair<CPubKey, KeyOriginInfo>(
                     CPubKey(entry.first), std::move(entry.second)));
         }
         if (m_script_arg) {
             for (const auto &subscript : subscripts) {
                 out.scripts.emplace(CScriptID(subscript), subscript);
                 std::vector<CScript> addscripts =
                     MakeScripts(pubkeys, &subscript, out);
                 for (auto &addscript : addscripts) {
                     output_scripts.push_back(std::move(addscript));
                 }
             }
         } else {
             output_scripts = MakeScripts(pubkeys, nullptr, out);
         }
         return true;
     }
 
     bool Expand(int pos, const SigningProvider &provider,
                 std::vector<CScript> &output_scripts, FlatSigningProvider &out,
                 std::vector<uint8_t> *cache = nullptr) const final {
         return ExpandHelper(pos, provider, nullptr, output_scripts, out, cache);
     }
 
     bool ExpandFromCache(int pos, const std::vector<uint8_t> &cache,
                          std::vector<CScript> &output_scripts,
                          FlatSigningProvider &out) const final {
         Span<const uint8_t> span = MakeSpan(cache);
         return ExpandHelper(pos, DUMMY_SIGNING_PROVIDER, &span, output_scripts,
                             out, nullptr) &&
                span.size() == 0;
     }
 };
 
 /** Construct a vector with one element, which is moved into it. */
 template <typename T> std::vector<T> Singleton(T elem) {
     std::vector<T> ret;
     ret.emplace_back(std::move(elem));
     return ret;
 }
 
 /** A parsed addr(A) descriptor. */
 class AddressDescriptor final : public DescriptorImpl {
     const CTxDestination m_destination;
 
 protected:
     std::string ToStringExtra() const override {
         return EncodeDestination(m_destination, GetConfig());
     }
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &,
                                      const CScript *,
                                      FlatSigningProvider &) const override {
         return Singleton(GetScriptForDestination(m_destination));
     }
 
 public:
     AddressDescriptor(CTxDestination destination)
         : DescriptorImpl({}, {}, "addr"),
           m_destination(std::move(destination)) {}
     bool IsSolvable() const final { return false; }
 };
 
 /** A parsed raw(H) descriptor. */
 class RawDescriptor final : public DescriptorImpl {
     const CScript m_script;
 
 protected:
     std::string ToStringExtra() const override {
         return HexStr(m_script.begin(), m_script.end());
     }
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &,
                                      const CScript *,
                                      FlatSigningProvider &) const override {
         return Singleton(m_script);
     }
 
 public:
     RawDescriptor(CScript script)
         : DescriptorImpl({}, {}, "raw"), m_script(std::move(script)) {}
     bool IsSolvable() const final { return false; }
 };
 
 /** A parsed pk(P) descriptor. */
 class PKDescriptor final : public DescriptorImpl {
 protected:
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
                                      const CScript *,
                                      FlatSigningProvider &) const override {
         return Singleton(GetScriptForRawPubKey(keys[0]));
     }
 
 public:
     PKDescriptor(std::unique_ptr<PubkeyProvider> prov)
         : DescriptorImpl(Singleton(std::move(prov)), {}, "pk") {}
 };
 
 /** A parsed pkh(P) descriptor. */
 class PKHDescriptor final : public DescriptorImpl {
 protected:
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
                                      const CScript *,
                                      FlatSigningProvider &out) const override {
         CKeyID id = keys[0].GetID();
         out.pubkeys.emplace(id, keys[0]);
-        return Singleton(GetScriptForDestination(id));
+        return Singleton(GetScriptForDestination(PKHash(id)));
     }
 
 public:
     PKHDescriptor(std::unique_ptr<PubkeyProvider> prov)
         : DescriptorImpl(Singleton(std::move(prov)), {}, "pkh") {}
 };
 
 /** A parsed combo(P) descriptor. */
 class ComboDescriptor final : public DescriptorImpl {
 protected:
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
                                      const CScript *,
                                      FlatSigningProvider &out) const override {
         std::vector<CScript> ret;
         CKeyID id = keys[0].GetID();
         out.pubkeys.emplace(id, keys[0]);
         // P2PK
         ret.emplace_back(GetScriptForRawPubKey(keys[0]));
         // P2PKH
-        ret.emplace_back(GetScriptForDestination(id));
+        ret.emplace_back(GetScriptForDestination(PKHash(id)));
         return ret;
     }
 
 public:
     ComboDescriptor(std::unique_ptr<PubkeyProvider> prov)
         : DescriptorImpl(Singleton(std::move(prov)), {}, "combo") {}
 };
 
 /** A parsed multi(...) descriptor. */
 class MultisigDescriptor final : public DescriptorImpl {
     const int m_threshold;
 
 protected:
     std::string ToStringExtra() const override {
         return strprintf("%i", m_threshold);
     }
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
                                      const CScript *,
                                      FlatSigningProvider &) const override {
         return Singleton(GetScriptForMultisig(m_threshold, keys));
     }
 
 public:
     MultisigDescriptor(int threshold,
                        std::vector<std::unique_ptr<PubkeyProvider>> providers)
         : DescriptorImpl(std::move(providers), {}, "multi"),
           m_threshold(threshold) {}
 };
 
 /** A parsed sh(...) descriptor. */
 class SHDescriptor final : public DescriptorImpl {
 protected:
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &,
                                      const CScript *script,
                                      FlatSigningProvider &) const override {
-        return Singleton(GetScriptForDestination(CScriptID(*script)));
+        return Singleton(GetScriptForDestination(ScriptHash(*script)));
     }
 
 public:
     SHDescriptor(std::unique_ptr<DescriptorImpl> desc)
         : DescriptorImpl({}, std::move(desc), "sh") {}
 };
 
 ////////////////////////////////////////////////////////////////////////////
 // Parser                                                                 //
 ////////////////////////////////////////////////////////////////////////////
 
 enum class ParseScriptContext {
     TOP,
     P2SH,
 };
 
 /**
  * Parse a constant. If successful, sp is updated to skip the constant and
  * return true.
  */
 bool Const(const std::string &str, Span<const char> &sp) {
     if ((size_t)sp.size() >= str.size() &&
         std::equal(str.begin(), str.end(), sp.begin())) {
         sp = sp.subspan(str.size());
         return true;
     }
     return false;
 }
 
 /**
  * Parse a function call. If successful, sp is updated to be the function's
  * argument(s).
  */
 bool Func(const std::string &str, Span<const char> &sp) {
     if ((size_t)sp.size() >= str.size() + 2 && sp[str.size()] == '(' &&
         sp[sp.size() - 1] == ')' &&
         std::equal(str.begin(), str.end(), sp.begin())) {
         sp = sp.subspan(str.size() + 1, sp.size() - str.size() - 2);
         return true;
     }
     return false;
 }
 
 /** Return the expression that sp begins with, and update sp to skip it. */
 Span<const char> Expr(Span<const char> &sp) {
     int level = 0;
     auto it = sp.begin();
     while (it != sp.end()) {
         if (*it == '(') {
             ++level;
         } else if (level && *it == ')') {
             --level;
         } else if (level == 0 && (*it == ')' || *it == ',')) {
             break;
         }
         ++it;
     }
     Span<const char> ret = sp.first(it - sp.begin());
     sp = sp.subspan(it - sp.begin());
     return ret;
 }
 
 /** Split a string on every instance of sep, returning a vector. */
 std::vector<Span<const char>> Split(const Span<const char> &sp, char sep) {
     std::vector<Span<const char>> ret;
     auto it = sp.begin();
     auto start = it;
     while (it != sp.end()) {
         if (*it == sep) {
             ret.emplace_back(start, it);
             start = it + 1;
         }
         ++it;
     }
     ret.emplace_back(start, it);
     return ret;
 }
 
 /**
  * Parse a key path, being passed a split list of elements (the first element is
  * ignored).
  */
 NODISCARD bool ParseKeyPath(const std::vector<Span<const char>> &split,
                             KeyPath &out) {
     for (size_t i = 1; i < split.size(); ++i) {
         Span<const char> elem = split[i];
         bool hardened = false;
         if (elem.size() > 0 &&
             (elem[elem.size() - 1] == '\'' || elem[elem.size() - 1] == 'h')) {
             elem = elem.first(elem.size() - 1);
             hardened = true;
         }
         uint32_t p;
         if (!ParseUInt32(std::string(elem.begin(), elem.end()), &p) ||
             p > 0x7FFFFFFFUL) {
             return false;
         }
         out.push_back(p | (uint32_t(hardened) << 31));
     }
     return true;
 }
 
 /** Parse a public key that excludes origin information. */
 std::unique_ptr<PubkeyProvider> ParsePubkeyInner(const Span<const char> &sp,
                                                  FlatSigningProvider &out) {
     auto split = Split(sp, '/');
     std::string str(split[0].begin(), split[0].end());
     if (split.size() == 1) {
         if (IsHex(str)) {
             std::vector<uint8_t> data = ParseHex(str);
             CPubKey pubkey(data);
             if (pubkey.IsFullyValid()) {
                 return std::make_unique<ConstPubkeyProvider>(pubkey);
             }
         }
         CKey key = DecodeSecret(str);
         if (key.IsValid()) {
             CPubKey pubkey = key.GetPubKey();
             out.keys.emplace(pubkey.GetID(), key);
             return std::make_unique<ConstPubkeyProvider>(pubkey);
         }
     }
     CExtKey extkey = DecodeExtKey(str);
     CExtPubKey extpubkey = DecodeExtPubKey(str);
     if (!extkey.key.IsValid() && !extpubkey.pubkey.IsValid()) {
         return nullptr;
     }
     KeyPath path;
     DeriveType type = DeriveType::NO;
     if (split.back() == MakeSpan("*").first(1)) {
         split.pop_back();
         type = DeriveType::UNHARDENED;
     } else if (split.back() == MakeSpan("*'").first(2) ||
                split.back() == MakeSpan("*h").first(2)) {
         split.pop_back();
         type = DeriveType::HARDENED;
     }
     if (!ParseKeyPath(split, path)) {
         return nullptr;
     }
     if (extkey.key.IsValid()) {
         extpubkey = extkey.Neuter();
         out.keys.emplace(extpubkey.pubkey.GetID(), extkey.key);
     }
     return std::make_unique<BIP32PubkeyProvider>(extpubkey, std::move(path),
                                                  type);
 }
 
 /** Parse a public key including origin information (if enabled). */
 std::unique_ptr<PubkeyProvider> ParsePubkey(const Span<const char> &sp,
                                             FlatSigningProvider &out) {
     auto origin_split = Split(sp, ']');
     if (origin_split.size() > 2) {
         return nullptr;
     }
     if (origin_split.size() == 1) {
         return ParsePubkeyInner(origin_split[0], out);
     }
     if (origin_split[0].size() < 1 || origin_split[0][0] != '[') {
         return nullptr;
     }
     auto slash_split = Split(origin_split[0].subspan(1), '/');
     if (slash_split[0].size() != 8) {
         return nullptr;
     }
     std::string fpr_hex =
         std::string(slash_split[0].begin(), slash_split[0].end());
     if (!IsHex(fpr_hex)) {
         return nullptr;
     }
     auto fpr_bytes = ParseHex(fpr_hex);
     KeyOriginInfo info;
     static_assert(sizeof(info.fingerprint) == 4, "Fingerprint must be 4 bytes");
     assert(fpr_bytes.size() == 4);
     std::copy(fpr_bytes.begin(), fpr_bytes.end(), info.fingerprint);
     if (!ParseKeyPath(slash_split, info.path)) {
         return nullptr;
     }
     auto provider = ParsePubkeyInner(origin_split[1], out);
     if (!provider) {
         return nullptr;
     }
     return std::make_unique<OriginPubkeyProvider>(std::move(info),
                                                   std::move(provider));
 }
 
 /** Parse a script in a particular context. */
 std::unique_ptr<DescriptorImpl> ParseScript(Span<const char> &sp,
                                             ParseScriptContext ctx,
                                             FlatSigningProvider &out) {
     auto expr = Expr(sp);
     if (Func("pk", expr)) {
         auto pubkey = ParsePubkey(expr, out);
         if (!pubkey) {
             return nullptr;
         }
         return std::make_unique<PKDescriptor>(std::move(pubkey));
     }
     if (Func("pkh", expr)) {
         auto pubkey = ParsePubkey(expr, out);
         if (!pubkey) {
             return nullptr;
         }
         return std::make_unique<PKHDescriptor>(std::move(pubkey));
     }
     if (ctx == ParseScriptContext::TOP && Func("combo", expr)) {
         auto pubkey = ParsePubkey(expr, out);
         if (!pubkey) {
             return nullptr;
         }
         return std::make_unique<ComboDescriptor>(std::move(pubkey));
     }
     if (Func("multi", expr)) {
         auto threshold = Expr(expr);
         uint32_t thres;
         std::vector<std::unique_ptr<PubkeyProvider>> providers;
         if (!ParseUInt32(std::string(threshold.begin(), threshold.end()),
                          &thres)) {
             return nullptr;
         }
         size_t script_size = 0;
         while (expr.size()) {
             if (!Const(",", expr)) {
                 return nullptr;
             }
             auto arg = Expr(expr);
             auto pk = ParsePubkey(arg, out);
             if (!pk) {
                 return nullptr;
             }
             script_size += pk->GetSize() + 1;
             providers.emplace_back(std::move(pk));
         }
         if (providers.size() < 1 || providers.size() > 16 || thres < 1 ||
             thres > providers.size()) {
             return nullptr;
         }
         if (ctx == ParseScriptContext::TOP) {
             if (providers.size() > 3) {
                 // Not more than 3 pubkeys for raw multisig
                 return nullptr;
             }
         }
         if (ctx == ParseScriptContext::P2SH) {
             if (script_size + 3 > 520) {
                 // Enforce P2SH script size limit
                 return nullptr;
             }
         }
         return std::make_unique<MultisigDescriptor>(thres,
                                                     std::move(providers));
     }
     if (ctx == ParseScriptContext::TOP && Func("sh", expr)) {
         auto desc = ParseScript(expr, ParseScriptContext::P2SH, out);
         if (!desc || expr.size()) {
             return nullptr;
         }
         return std::make_unique<SHDescriptor>(std::move(desc));
     }
     if (ctx == ParseScriptContext::TOP && Func("addr", expr)) {
         CTxDestination dest =
             DecodeDestination(std::string(expr.begin(), expr.end()), Params());
         if (!IsValidDestination(dest)) {
             return nullptr;
         }
         return std::make_unique<AddressDescriptor>(std::move(dest));
     }
     if (ctx == ParseScriptContext::TOP && Func("raw", expr)) {
         std::string str(expr.begin(), expr.end());
         if (!IsHex(str)) {
             return nullptr;
         }
         auto bytes = ParseHex(str);
         return std::make_unique<RawDescriptor>(
             CScript(bytes.begin(), bytes.end()));
     }
     return nullptr;
 }
 
 static std::unique_ptr<PubkeyProvider>
 InferPubkey(const CPubKey &pubkey, ParseScriptContext,
             const SigningProvider &provider) {
     auto key_provider = std::make_unique<ConstPubkeyProvider>(pubkey);
     KeyOriginInfo info;
     if (provider.GetKeyOrigin(pubkey.GetID(), info)) {
         return std::make_unique<OriginPubkeyProvider>(std::move(info),
                                                       std::move(key_provider));
     }
     return key_provider;
 }
 
 std::unique_ptr<DescriptorImpl> InferScript(const CScript &script,
                                             ParseScriptContext ctx,
                                             const SigningProvider &provider) {
     std::vector<std::vector<uint8_t>> data;
     txnouttype txntype = Solver(script, data);
 
     if (txntype == TX_PUBKEY) {
         CPubKey pubkey(data[0].begin(), data[0].end());
         if (pubkey.IsValid()) {
             return std::make_unique<PKDescriptor>(
                 InferPubkey(pubkey, ctx, provider));
         }
     }
     if (txntype == TX_PUBKEYHASH) {
         uint160 hash(data[0]);
         CKeyID keyid(hash);
         CPubKey pubkey;
         if (provider.GetPubKey(keyid, pubkey)) {
             return std::make_unique<PKHDescriptor>(
                 InferPubkey(pubkey, ctx, provider));
         }
     }
     if (txntype == TX_MULTISIG) {
         std::vector<std::unique_ptr<PubkeyProvider>> providers;
         for (size_t i = 1; i + 1 < data.size(); ++i) {
             CPubKey pubkey(data[i].begin(), data[i].end());
             providers.push_back(InferPubkey(pubkey, ctx, provider));
         }
         return std::make_unique<MultisigDescriptor>((int)data[0][0],
                                                     std::move(providers));
     }
     if (txntype == TX_SCRIPTHASH && ctx == ParseScriptContext::TOP) {
         uint160 hash(data[0]);
         CScriptID scriptid(hash);
         CScript subscript;
         if (provider.GetCScript(scriptid, subscript)) {
             auto sub =
                 InferScript(subscript, ParseScriptContext::P2SH, provider);
             if (sub) {
                 return std::make_unique<SHDescriptor>(std::move(sub));
             }
         }
     }
 
     CTxDestination dest;
     if (ExtractDestination(script, dest)) {
         if (GetScriptForDestination(dest) == script) {
             return std::make_unique<AddressDescriptor>(std::move(dest));
         }
     }
 
     return std::make_unique<RawDescriptor>(script);
 }
 
 } // namespace
 
 std::unique_ptr<Descriptor> Parse(const std::string &descriptor,
                                   FlatSigningProvider &out) {
     Span<const char> sp(descriptor.data(), descriptor.size());
     auto ret = ParseScript(sp, ParseScriptContext::TOP, out);
     if (sp.size() == 0 && ret) {
         return std::unique_ptr<Descriptor>(std::move(ret));
     }
     return nullptr;
 }
 
 std::unique_ptr<Descriptor> InferDescriptor(const CScript &script,
                                             const SigningProvider &provider) {
     return InferScript(script, ParseScriptContext::TOP, provider);
 }
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index f4305bc37..8812115bd 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -1,269 +1,274 @@
 // Copyright (c) 2009-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 <script/standard.h>
 
 #include <crypto/sha256.h>
 #include <pubkey.h>
 #include <script/script.h>
 
 typedef std::vector<uint8_t> valtype;
 
 bool fAcceptDatacarrier = DEFAULT_ACCEPT_DATACARRIER;
 
 CScriptID::CScriptID(const CScript &in)
     : uint160(Hash160(in.begin(), in.end())) {}
 
+ScriptHash::ScriptHash(const CScript &in)
+    : uint160(Hash160(in.begin(), in.end())) {}
+
+PKHash::PKHash(const CPubKey &pubkey) : uint160(pubkey.GetID()) {}
+
 const char *GetTxnOutputType(txnouttype t) {
     switch (t) {
         case TX_NONSTANDARD:
             return "nonstandard";
         case TX_PUBKEY:
             return "pubkey";
         case TX_PUBKEYHASH:
             return "pubkeyhash";
         case TX_SCRIPTHASH:
             return "scripthash";
         case TX_MULTISIG:
             return "multisig";
         case TX_NULL_DATA:
             return "nulldata";
     }
     return nullptr;
 }
 
 static bool MatchPayToPubkey(const CScript &script, valtype &pubkey) {
     if (script.size() == CPubKey::PUBLIC_KEY_SIZE + 2 &&
         script[0] == CPubKey::PUBLIC_KEY_SIZE && script.back() == OP_CHECKSIG) {
         pubkey = valtype(script.begin() + 1,
                          script.begin() + CPubKey::PUBLIC_KEY_SIZE + 1);
         return CPubKey::ValidSize(pubkey);
     }
     if (script.size() == CPubKey::COMPRESSED_PUBLIC_KEY_SIZE + 2 &&
         script[0] == CPubKey::COMPRESSED_PUBLIC_KEY_SIZE &&
         script.back() == OP_CHECKSIG) {
         pubkey =
             valtype(script.begin() + 1,
                     script.begin() + CPubKey::COMPRESSED_PUBLIC_KEY_SIZE + 1);
         return CPubKey::ValidSize(pubkey);
     }
     return false;
 }
 
 static bool MatchPayToPubkeyHash(const CScript &script, valtype &pubkeyhash) {
     if (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_HASH160 &&
         script[2] == 20 && script[23] == OP_EQUALVERIFY &&
         script[24] == OP_CHECKSIG) {
         pubkeyhash = valtype(script.begin() + 3, script.begin() + 23);
         return true;
     }
     return false;
 }
 
 /** Test for "small positive integer" script opcodes - OP_1 through OP_16. */
 static constexpr bool IsSmallInteger(opcodetype opcode) {
     return opcode >= OP_1 && opcode <= OP_16;
 }
 
 static bool MatchMultisig(const CScript &script, unsigned int &required,
                           std::vector<valtype> &pubkeys) {
     opcodetype opcode;
     valtype data;
     CScript::const_iterator it = script.begin();
     if (script.size() < 1 || script.back() != OP_CHECKMULTISIG) {
         return false;
     }
 
     if (!script.GetOp(it, opcode, data) || !IsSmallInteger(opcode)) {
         return false;
     }
     required = CScript::DecodeOP_N(opcode);
     while (script.GetOp(it, opcode, data) && CPubKey::ValidSize(data)) {
         if (opcode < 0 || opcode > OP_PUSHDATA4 ||
             !CheckMinimalPush(data, opcode)) {
             return false;
         }
         pubkeys.emplace_back(std::move(data));
     }
     if (!IsSmallInteger(opcode)) {
         return false;
     }
     unsigned int keys = CScript::DecodeOP_N(opcode);
     if (pubkeys.size() != keys || keys < required) {
         return false;
     }
     return (it + 1 == script.end());
 }
 
 txnouttype Solver(const CScript &scriptPubKey,
                   std::vector<std::vector<uint8_t>> &vSolutionsRet) {
     vSolutionsRet.clear();
 
     // Shortcut for pay-to-script-hash, which are more constrained than the
     // other types:
     // it is always OP_HASH160 20 [20 byte hash] OP_EQUAL
     if (scriptPubKey.IsPayToScriptHash()) {
         std::vector<uint8_t> hashBytes(scriptPubKey.begin() + 2,
                                        scriptPubKey.begin() + 22);
         vSolutionsRet.push_back(hashBytes);
         return TX_SCRIPTHASH;
     }
 
     // Provably prunable, data-carrying output
     //
     // So long as script passes the IsUnspendable() test and all but the first
     // byte passes the IsPushOnly() test we don't care what exactly is in the
     // script.
     if (scriptPubKey.size() >= 1 && scriptPubKey[0] == OP_RETURN &&
         scriptPubKey.IsPushOnly(scriptPubKey.begin() + 1)) {
         return TX_NULL_DATA;
     }
 
     std::vector<uint8_t> data;
     if (MatchPayToPubkey(scriptPubKey, data)) {
         vSolutionsRet.push_back(std::move(data));
         return TX_PUBKEY;
     }
 
     if (MatchPayToPubkeyHash(scriptPubKey, data)) {
         vSolutionsRet.push_back(std::move(data));
         return TX_PUBKEYHASH;
     }
 
     unsigned int required;
     std::vector<std::vector<uint8_t>> keys;
     if (MatchMultisig(scriptPubKey, required, keys)) {
         // safe as required is in range 1..16
         vSolutionsRet.push_back({static_cast<uint8_t>(required)});
         vSolutionsRet.insert(vSolutionsRet.end(), keys.begin(), keys.end());
         // safe as size is in range 1..16
         vSolutionsRet.push_back({static_cast<uint8_t>(keys.size())});
         return TX_MULTISIG;
     }
 
     vSolutionsRet.clear();
     return TX_NONSTANDARD;
 }
 
 bool ExtractDestination(const CScript &scriptPubKey,
                         CTxDestination &addressRet) {
     std::vector<valtype> vSolutions;
     txnouttype whichType = Solver(scriptPubKey, vSolutions);
 
     if (whichType == TX_PUBKEY) {
         CPubKey pubKey(vSolutions[0]);
         if (!pubKey.IsValid()) {
             return false;
         }
 
-        addressRet = pubKey.GetID();
+        addressRet = PKHash(pubKey);
         return true;
     }
     if (whichType == TX_PUBKEYHASH) {
-        addressRet = CKeyID(uint160(vSolutions[0]));
+        addressRet = PKHash(uint160(vSolutions[0]));
         return true;
     }
     if (whichType == TX_SCRIPTHASH) {
-        addressRet = CScriptID(uint160(vSolutions[0]));
+        addressRet = ScriptHash(uint160(vSolutions[0]));
         return true;
     }
     // Multisig txns have more than one address...
     return false;
 }
 
 bool ExtractDestinations(const CScript &scriptPubKey, txnouttype &typeRet,
                          std::vector<CTxDestination> &addressRet,
                          int &nRequiredRet) {
     addressRet.clear();
     std::vector<valtype> vSolutions;
     typeRet = Solver(scriptPubKey, vSolutions);
     if (typeRet == TX_NONSTANDARD) {
         return false;
     } else if (typeRet == TX_NULL_DATA) {
         // This is data, not addresses
         return false;
     }
 
     if (typeRet == TX_MULTISIG) {
         nRequiredRet = vSolutions.front()[0];
         for (size_t i = 1; i < vSolutions.size() - 1; i++) {
             CPubKey pubKey(vSolutions[i]);
             if (!pubKey.IsValid()) {
                 continue;
             }
 
-            CTxDestination address = pubKey.GetID();
+            CTxDestination address = PKHash(pubKey);
             addressRet.push_back(address);
         }
 
         if (addressRet.empty()) {
             return false;
         }
     } else {
         nRequiredRet = 1;
         CTxDestination address;
         if (!ExtractDestination(scriptPubKey, address)) {
             return false;
         }
         addressRet.push_back(address);
     }
 
     return true;
 }
 
 namespace {
 class CScriptVisitor : public boost::static_visitor<bool> {
 private:
     CScript *script;
 
 public:
     explicit CScriptVisitor(CScript *scriptin) { script = scriptin; }
 
     bool operator()(const CNoDestination &dest) const {
         script->clear();
         return false;
     }
 
-    bool operator()(const CKeyID &keyID) const {
+    bool operator()(const PKHash &keyID) const {
         script->clear();
         *script << OP_DUP << OP_HASH160 << ToByteVector(keyID) << OP_EQUALVERIFY
                 << OP_CHECKSIG;
         return true;
     }
 
-    bool operator()(const CScriptID &scriptID) const {
+    bool operator()(const ScriptHash &scriptID) const {
         script->clear();
         *script << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
         return true;
     }
 };
 } // namespace
 
 CScript GetScriptForDestination(const CTxDestination &dest) {
     CScript script;
 
     boost::apply_visitor(CScriptVisitor(&script), dest);
     return script;
 }
 
 CScript GetScriptForRawPubKey(const CPubKey &pubKey) {
     return CScript() << std::vector<uint8_t>(pubKey.begin(), pubKey.end())
                      << OP_CHECKSIG;
 }
 
 CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey> &keys) {
     CScript script;
 
     script << CScript::EncodeOP_N(nRequired);
     for (const CPubKey &key : keys) {
         script << ToByteVector(key);
     }
     script << CScript::EncodeOP_N(keys.size()) << OP_CHECKMULTISIG;
     return script;
 }
 
 bool IsValidDestination(const CTxDestination &dest) {
     return dest.which() != 0;
 }
diff --git a/src/script/standard.h b/src/script/standard.h
index 66bc0a69d..95a70e4e2 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -1,131 +1,145 @@
 // Copyright (c) 2009-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.
 
 #ifndef BITCOIN_SCRIPT_STANDARD_H
 #define BITCOIN_SCRIPT_STANDARD_H
 
 #include <amount.h>
 #include <pubkey.h>
 #include <script/script_flags.h>
 #include <uint256.h>
 
 #include <boost/variant.hpp>
 
 #include <cstdint>
 
 static const bool DEFAULT_ACCEPT_DATACARRIER = true;
 
 class CKeyID;
 class CScript;
 
 /** A reference to a CScript: the Hash160 of its serialization (see script.h) */
 class CScriptID : public uint160 {
 public:
     CScriptID() : uint160() {}
     explicit CScriptID(const CScript &in);
     CScriptID(const uint160 &in) : uint160(in) {}
 };
 
 /**
  * Default setting for nMaxDatacarrierBytes. 220 bytes of data, +1 for
  * OP_RETURN, +2 for the pushdata opcodes.
  */
 static const unsigned int MAX_OP_RETURN_RELAY = 223;
 
 /**
  * A data carrying output is an unspendable output containing data. The script
  * type is designated as TX_NULL_DATA.
  */
 extern bool fAcceptDatacarrier;
 
 enum txnouttype {
     TX_NONSTANDARD,
     // 'standard' transaction types:
     TX_PUBKEY,
     TX_PUBKEYHASH,
     TX_SCRIPTHASH,
     TX_MULTISIG,
     // unspendable OP_RETURN script that carries data
     TX_NULL_DATA,
 };
 
 class CNoDestination {
 public:
     friend bool operator==(const CNoDestination &a, const CNoDestination &b) {
         return true;
     }
     friend bool operator<(const CNoDestination &a, const CNoDestination &b) {
         return true;
     }
 };
 
+struct PKHash : public uint160 {
+    PKHash() : uint160() {}
+    explicit PKHash(const uint160 &hash) : uint160(hash) {}
+    explicit PKHash(const CPubKey &pubkey);
+    using uint160::uint160;
+};
+
+struct ScriptHash : public uint160 {
+    ScriptHash() : uint160() {}
+    explicit ScriptHash(const uint160 &hash) : uint160(hash) {}
+    explicit ScriptHash(const CScript &script);
+    using uint160::uint160;
+};
+
 /**
  * A txout script template with a specific destination. It is either:
  *  * CNoDestination: no destination set
- *  * CKeyID: TX_PUBKEYHASH destination
- *  * CScriptID: TX_SCRIPTHASH destination
+ *  * PKHash: TX_PUBKEYHASH destination (P2PKH)
+ *  * ScriptHash: TX_SCRIPTHASH destination (P2SH)
  *  A CTxDestination is the internal data type encoded in a bitcoin address
  */
-typedef boost::variant<CNoDestination, CKeyID, CScriptID> CTxDestination;
+typedef boost::variant<CNoDestination, PKHash, ScriptHash> CTxDestination;
 
 /** Check whether a CTxDestination is a CNoDestination. */
 bool IsValidDestination(const CTxDestination &dest);
 
 /** Get the name of a txnouttype as a C string, or nullptr if unknown. */
 const char *GetTxnOutputType(txnouttype t);
 
 /**
  * Parse a scriptPubKey and identify script type for standard scripts. If
  * successful, returns script type and parsed pubkeys or hashes, depending on
  * the type. For example, for a P2SH script, vSolutionsRet will contain the
  * script hash, for P2PKH it will contain the key hash, etc.
  *
  * @param[in]   scriptPubKey   Script to parse
  * @param[out]  vSolutionsRet  Vector of parsed pubkeys and hashes
  * @return                     The script type. TX_NONSTANDARD represents a
  * failed solve.
  */
 txnouttype Solver(const CScript &scriptPubKey,
                   std::vector<std::vector<uint8_t>> &vSolutionsRet);
 
 /**
  * Parse a standard scriptPubKey for the destination address. Assigns result to
  * the addressRet parameter and returns true if successful. For multisig
  * scripts, instead use ExtractDestinations. Currently only works for P2PK,
  * P2PKH, and P2SH scripts.
  */
 bool ExtractDestination(const CScript &scriptPubKey,
                         CTxDestination &addressRet);
 
 /**
  * Parse a standard scriptPubKey with one or more destination addresses. For
  * multisig scripts, this populates the addressRet vector with the pubkey IDs
  * and nRequiredRet with the n required to spend. For other destinations,
  * addressRet is populated with a single value and nRequiredRet is set to 1.
  * Returns true if successful. Currently does not extract address from
  * pay-to-witness scripts.
  *
  * Note: this function confuses destinations (a subset of CScripts that are
  * encodable as an address) with key identifiers (of keys involved in a
  * CScript), and its use should be phased out.
  */
 bool ExtractDestinations(const CScript &scriptPubKey, txnouttype &typeRet,
                          std::vector<CTxDestination> &addressRet,
                          int &nRequiredRet);
 
 /**
  * Generate a Bitcoin scriptPubKey for the given CTxDestination. Returns a P2PKH
  * script for a CKeyID destination, a P2SH script for a CScriptID, and an empty
  * script for CNoDestination.
  */
 CScript GetScriptForDestination(const CTxDestination &dest);
 
 /** Generate a P2PK script for the given pubkey. */
 CScript GetScriptForRawPubKey(const CPubKey &pubkey);
 
 /** Generate a multisig script. */
 CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey> &keys);
 
 #endif // BITCOIN_SCRIPT_STANDARD_H
diff --git a/src/test/blockfilter_index_tests.cpp b/src/test/blockfilter_index_tests.cpp
index 217d61395..ecbbe79ab 100644
--- a/src/test/blockfilter_index_tests.cpp
+++ b/src/test/blockfilter_index_tests.cpp
@@ -1,304 +1,304 @@
 // Copyright (c) 2017-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 <blockfilter.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <index/blockfilterindex.h>
 #include <miner.h>
 #include <pow.h>
 #include <script/standard.h>
 #include <test/util/blockfilter.h>
 #include <test/util/setup_common.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_AUTO_TEST_SUITE(blockfilter_index_tests)
 
 static bool CheckFilterLookups(BlockFilterIndex &filter_index,
                                const CBlockIndex *block_index,
                                uint256 &last_header) {
     BlockFilter expected_filter;
     if (!ComputeFilter(filter_index.GetFilterType(), block_index,
                        expected_filter)) {
         BOOST_ERROR("ComputeFilter failed on block " << block_index->nHeight);
         return false;
     }
 
     BlockFilter filter;
     uint256 filter_header;
     std::vector<BlockFilter> filters;
     std::vector<uint256> filter_hashes;
 
     BOOST_CHECK(filter_index.LookupFilter(block_index, filter));
     BOOST_CHECK(filter_index.LookupFilterHeader(block_index, filter_header));
     BOOST_CHECK(filter_index.LookupFilterRange(block_index->nHeight,
                                                block_index, filters));
     BOOST_CHECK(filter_index.LookupFilterHashRange(block_index->nHeight,
                                                    block_index, filter_hashes));
 
     BOOST_CHECK_EQUAL(filters.size(), 1);
     BOOST_CHECK_EQUAL(filter_hashes.size(), 1);
 
     BOOST_CHECK_EQUAL(filter.GetHash(), expected_filter.GetHash());
     BOOST_CHECK_EQUAL(filter_header,
                       expected_filter.ComputeHeader(last_header));
     BOOST_CHECK_EQUAL(filters[0].GetHash(), expected_filter.GetHash());
     BOOST_CHECK_EQUAL(filter_hashes[0], expected_filter.GetHash());
 
     filters.clear();
     filter_hashes.clear();
     last_header = filter_header;
     return true;
 }
 
 static CBlock CreateBlock(const CBlockIndex *prev,
                           const std::vector<CMutableTransaction> &txns,
                           const CScript &scriptPubKey) {
     const Config &config = GetConfig();
     std::unique_ptr<CBlockTemplate> pblocktemplate =
         BlockAssembler(config, g_mempool).CreateNewBlock(scriptPubKey);
     CBlock &block = pblocktemplate->block;
     block.hashPrevBlock = prev->GetBlockHash();
     block.nTime = prev->nTime + 1;
 
     // Replace mempool-selected txns with just coinbase plus passed-in txns:
     block.vtx.resize(1);
     for (const CMutableTransaction &tx : txns) {
         block.vtx.push_back(MakeTransactionRef(tx));
     }
     // IncrementExtraNonce creates a valid coinbase and merkleRoot
     unsigned int extraNonce = 0;
     IncrementExtraNonce(&block, prev, config.GetMaxBlockSize(), extraNonce);
 
     while (!CheckProofOfWork(block.GetHash(), block.nBits,
                              config.GetChainParams().GetConsensus())) {
         ++block.nNonce;
     }
 
     return block;
 }
 
 static bool BuildChain(const CBlockIndex *pindex,
                        const CScript &coinbase_script_pub_key, size_t length,
                        std::vector<std::shared_ptr<CBlock>> &chain) {
     std::vector<CMutableTransaction> no_txns;
 
     chain.resize(length);
     for (auto &block : chain) {
         block = std::make_shared<CBlock>(
             CreateBlock(pindex, no_txns, coinbase_script_pub_key));
         CBlockHeader header = block->GetBlockHeader();
 
         CValidationState state;
         if (!ProcessNewBlockHeaders(GetConfig(), {header}, state, &pindex,
                                     nullptr)) {
             return false;
         }
     }
 
     return true;
 }
 
 BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync, TestChain100Setup) {
     BlockFilterIndex filter_index(BlockFilterType::BASIC, 1 << 20, true);
 
     uint256 last_header;
 
     // Filter should not be found in the index before it is started.
     {
         LOCK(cs_main);
 
         BlockFilter filter;
         uint256 filter_header;
         std::vector<BlockFilter> filters;
         std::vector<uint256> filter_hashes;
 
         for (const CBlockIndex *block_index = ::ChainActive().Genesis();
              block_index != nullptr;
              block_index = ::ChainActive().Next(block_index)) {
             BOOST_CHECK(!filter_index.LookupFilter(block_index, filter));
             BOOST_CHECK(
                 !filter_index.LookupFilterHeader(block_index, filter_header));
             BOOST_CHECK(!filter_index.LookupFilterRange(block_index->nHeight,
                                                         block_index, filters));
             BOOST_CHECK(!filter_index.LookupFilterHashRange(
                 block_index->nHeight, block_index, filter_hashes));
         }
     }
 
     // BlockUntilSyncedToCurrentChain should return false before index is
     // started.
     BOOST_CHECK(!filter_index.BlockUntilSyncedToCurrentChain());
 
     filter_index.Start();
 
     // Allow filter index to catch up with the block index.
     constexpr int64_t timeout_ms = 10 * 1000;
     int64_t time_start = GetTimeMillis();
     while (!filter_index.BlockUntilSyncedToCurrentChain()) {
         BOOST_REQUIRE(time_start + timeout_ms > GetTimeMillis());
         MilliSleep(100);
     }
 
     // Check that filter index has all blocks that were in the chain before it
     // started.
     {
         LOCK(cs_main);
         const CBlockIndex *block_index;
         for (block_index = ::ChainActive().Genesis(); block_index != nullptr;
              block_index = ::ChainActive().Next(block_index)) {
             CheckFilterLookups(filter_index, block_index, last_header);
         }
     }
 
     // Create two forks.
     const CBlockIndex *tip;
     {
         LOCK(cs_main);
         tip = ::ChainActive().Tip();
     }
     CScript coinbase_script_pub_key =
-        GetScriptForDestination(coinbaseKey.GetPubKey().GetID());
+        GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()));
     std::vector<std::shared_ptr<CBlock>> chainA, chainB;
     BOOST_REQUIRE(BuildChain(tip, coinbase_script_pub_key, 10, chainA));
     BOOST_REQUIRE(BuildChain(tip, coinbase_script_pub_key, 10, chainB));
 
     // Check that new blocks on chain A get indexed.
     uint256 chainA_last_header = last_header;
     for (size_t i = 0; i < 2; i++) {
         const auto &block = chainA[i];
         BOOST_REQUIRE(ProcessNewBlock(GetConfig(), block, true, nullptr));
 
         const CBlockIndex *block_index;
         {
             LOCK(cs_main);
             block_index = LookupBlockIndex(block->GetHash());
         }
 
         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
         CheckFilterLookups(filter_index, block_index, chainA_last_header);
     }
 
     // Reorg to chain B.
     uint256 chainB_last_header = last_header;
     for (size_t i = 0; i < 3; i++) {
         const auto &block = chainB[i];
         BOOST_REQUIRE(ProcessNewBlock(GetConfig(), block, true, nullptr));
 
         const CBlockIndex *block_index;
         {
             LOCK(cs_main);
             block_index = LookupBlockIndex(block->GetHash());
         }
 
         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
         CheckFilterLookups(filter_index, block_index, chainB_last_header);
     }
 
     // Check that filters for stale blocks on A can be retrieved.
     chainA_last_header = last_header;
     for (size_t i = 0; i < 2; i++) {
         const auto &block = chainA[i];
         const CBlockIndex *block_index;
         {
             LOCK(cs_main);
             block_index = LookupBlockIndex(block->GetHash());
         }
 
         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
         CheckFilterLookups(filter_index, block_index, chainA_last_header);
     }
 
     // Reorg back to chain A.
     for (size_t i = 2; i < 4; i++) {
         const auto &block = chainA[i];
         BOOST_REQUIRE(ProcessNewBlock(GetConfig(), block, true, nullptr));
     }
 
     // Check that chain A and B blocks can be retrieved.
     chainA_last_header = last_header;
     chainB_last_header = last_header;
     for (size_t i = 0; i < 3; i++) {
         const CBlockIndex *block_index;
 
         {
             LOCK(cs_main);
             block_index = LookupBlockIndex(chainA[i]->GetHash());
         }
         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
         CheckFilterLookups(filter_index, block_index, chainA_last_header);
 
         {
             LOCK(cs_main);
             block_index = LookupBlockIndex(chainB[i]->GetHash());
         }
         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
         CheckFilterLookups(filter_index, block_index, chainB_last_header);
     }
 
     // Test lookups for a range of filters/hashes.
     std::vector<BlockFilter> filters;
     std::vector<uint256> filter_hashes;
 
     {
         LOCK(cs_main);
         tip = ::ChainActive().Tip();
     }
     BOOST_CHECK(filter_index.LookupFilterRange(0, tip, filters));
     BOOST_CHECK(filter_index.LookupFilterHashRange(0, tip, filter_hashes));
 
     BOOST_CHECK_EQUAL(filters.size(), tip->nHeight + 1);
     BOOST_CHECK_EQUAL(filter_hashes.size(), tip->nHeight + 1);
 
     filters.clear();
     filter_hashes.clear();
 
     filter_index.Interrupt();
     filter_index.Stop();
 }
 
 BOOST_FIXTURE_TEST_CASE(blockfilter_index_init_destroy, BasicTestingSetup) {
     BlockFilterIndex *filter_index;
 
     filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
     BOOST_CHECK(filter_index == nullptr);
 
     BOOST_CHECK(
         InitBlockFilterIndex(BlockFilterType::BASIC, 1 << 20, true, false));
 
     filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
     BOOST_CHECK(filter_index != nullptr);
     BOOST_CHECK(filter_index->GetFilterType() == BlockFilterType::BASIC);
 
     // Initialize returns false if index already exists.
     BOOST_CHECK(
         !InitBlockFilterIndex(BlockFilterType::BASIC, 1 << 20, true, false));
 
     int iter_count = 0;
     ForEachBlockFilterIndex(
         [&iter_count](BlockFilterIndex &_index) { iter_count++; });
     BOOST_CHECK_EQUAL(iter_count, 1);
 
     BOOST_CHECK(DestroyBlockFilterIndex(BlockFilterType::BASIC));
 
     // Destroy returns false because index was already destroyed.
     BOOST_CHECK(!DestroyBlockFilterIndex(BlockFilterType::BASIC));
 
     filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
     BOOST_CHECK(filter_index == nullptr);
 
     // Reinitialize index.
     BOOST_CHECK(
         InitBlockFilterIndex(BlockFilterType::BASIC, 1 << 20, true, false));
 
     DestroyAllBlockFilterIndexes();
 
     filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
     BOOST_CHECK(filter_index == nullptr);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/cashaddrenc_tests.cpp b/src/test/cashaddrenc_tests.cpp
index 97aca660f..0087bdd1c 100644
--- a/src/test/cashaddrenc_tests.cpp
+++ b/src/test/cashaddrenc_tests.cpp
@@ -1,463 +1,465 @@
 // 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 <cashaddrenc.h>
 
 #include <cashaddr.h>
 #include <chainparams.h>
 #include <random.h>
 #include <uint256.h>
 #include <util/strencodings.h>
 
+#include <key_io.h>
+
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 namespace {
 
 std::vector<std::string> GetNetworks() {
     return {CBaseChainParams::MAIN, CBaseChainParams::TESTNET,
             CBaseChainParams::REGTEST};
 }
 
 uint160 insecure_GetRandUInt160(FastRandomContext &rand) {
     uint160 n;
     for (uint8_t *c = n.begin(); c != n.end(); ++c) {
         *c = static_cast<uint8_t>(rand.rand32());
     }
     return n;
 }
 
 std::vector<uint8_t> insecure_GetRandomByteArray(FastRandomContext &rand,
                                                  size_t n) {
     std::vector<uint8_t> out;
     out.reserve(n);
 
     for (size_t i = 0; i < n; i++) {
         out.push_back(uint8_t(rand.randbits(8)));
     }
     return out;
 }
 
 class DstTypeChecker : public boost::static_visitor<void> {
 public:
-    void operator()(const CKeyID &id) { isKey = true; }
-    void operator()(const CScriptID &id) { isScript = true; }
+    void operator()(const PKHash &id) { isKey = true; }
+    void operator()(const ScriptHash &id) { isScript = true; }
     void operator()(const CNoDestination &) {}
 
     static bool IsScriptDst(const CTxDestination &d) {
         DstTypeChecker checker;
         boost::apply_visitor(checker, d);
         return checker.isScript;
     }
 
     static bool IsKeyDst(const CTxDestination &d) {
         DstTypeChecker checker;
         boost::apply_visitor(checker, d);
         return checker.isKey;
     }
 
 private:
     DstTypeChecker() : isKey(false), isScript(false) {}
     bool isKey;
     bool isScript;
 };
 
 // Map all possible size bits in the version to the expected size of the
 // hash in bytes.
 const std::array<std::pair<uint8_t, uint32_t>, 8> valid_sizes = {
     {{0, 20}, {1, 24}, {2, 28}, {3, 32}, {4, 40}, {5, 48}, {6, 56}, {7, 64}}};
 
 } // namespace
 
 BOOST_FIXTURE_TEST_SUITE(cashaddrenc_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(encode_decode_all_sizes) {
     FastRandomContext rand(true);
     const std::string prefix = "bitcoincash";
 
     for (auto ps : valid_sizes) {
         std::vector<uint8_t> data =
             insecure_GetRandomByteArray(rand, ps.second);
         CashAddrContent content = {PUBKEY_TYPE, data};
         std::vector<uint8_t> packed_data = PackCashAddrContent(content);
 
         // Check that the packed size is correct
         BOOST_CHECK_EQUAL(packed_data[1] >> 2, ps.first);
         std::string address = cashaddr::Encode(prefix, packed_data);
 
         // Check that the address decodes properly
         CashAddrContent decoded = DecodeCashAddrContent(address, prefix);
         BOOST_CHECK_EQUAL_COLLECTIONS(
             std::begin(content.hash), std::end(content.hash),
             std::begin(decoded.hash), std::end(decoded.hash));
     }
 }
 
 BOOST_AUTO_TEST_CASE(check_packaddr_throws) {
     FastRandomContext rand(true);
 
     for (auto ps : valid_sizes) {
         std::vector<uint8_t> data =
             insecure_GetRandomByteArray(rand, ps.second - 1);
         CashAddrContent content = {PUBKEY_TYPE, data};
         BOOST_CHECK_THROW(PackCashAddrContent(content), std::runtime_error);
     }
 }
 
 BOOST_AUTO_TEST_CASE(encode_decode) {
     std::vector<CTxDestination> toTest = {CNoDestination{},
-                                          CKeyID(uint160S("badf00d")),
-                                          CScriptID(uint160S("f00dbad"))};
+                                          PKHash(uint160S("badf00d")),
+                                          ScriptHash(uint160S("f00dbad"))};
 
     for (auto dst : toTest) {
         for (auto net : GetNetworks()) {
             const auto netParams = CreateChainParams(net);
             std::string encoded = EncodeCashAddr(dst, *netParams);
             CTxDestination decoded = DecodeCashAddr(encoded, *netParams);
             BOOST_CHECK(dst == decoded);
         }
     }
 }
 
 // Check that an encoded cash address is not valid on another network.
 BOOST_AUTO_TEST_CASE(invalid_on_wrong_network) {
-    const CTxDestination dst = CKeyID(uint160S("c0ffee"));
+    const CTxDestination dst = PKHash(uint160S("c0ffee"));
     const CTxDestination invalidDst = CNoDestination{};
 
     for (auto net : GetNetworks()) {
         for (auto otherNet : GetNetworks()) {
             if (net == otherNet) {
                 continue;
             }
 
             const auto netParams = CreateChainParams(net);
             std::string encoded = EncodeCashAddr(dst, *netParams);
 
             const auto otherNetParams = CreateChainParams(otherNet);
             CTxDestination decoded = DecodeCashAddr(encoded, *otherNetParams);
             BOOST_CHECK(decoded != dst);
             BOOST_CHECK(decoded == invalidDst);
         }
     }
 }
 
 BOOST_AUTO_TEST_CASE(random_dst) {
     FastRandomContext rand(true);
 
     const size_t NUM_TESTS = 5000;
     const auto params = CreateChainParams(CBaseChainParams::MAIN);
 
     for (size_t i = 0; i < NUM_TESTS; ++i) {
         uint160 hash = insecure_GetRandUInt160(rand);
-        const CTxDestination dst_key = CKeyID(hash);
-        const CTxDestination dst_scr = CScriptID(hash);
+        const CTxDestination dst_key = PKHash(hash);
+        const CTxDestination dst_scr = ScriptHash(hash);
 
         const std::string encoded_key = EncodeCashAddr(dst_key, *params);
         const CTxDestination decoded_key = DecodeCashAddr(encoded_key, *params);
 
         const std::string encoded_scr = EncodeCashAddr(dst_scr, *params);
         const CTxDestination decoded_scr = DecodeCashAddr(encoded_scr, *params);
 
         std::string err("cashaddr failed for hash: ");
         err += hash.ToString();
 
         BOOST_CHECK_MESSAGE(dst_key == decoded_key, err);
         BOOST_CHECK_MESSAGE(dst_scr == decoded_scr, err);
 
         BOOST_CHECK_MESSAGE(DstTypeChecker::IsKeyDst(decoded_key), err);
         BOOST_CHECK_MESSAGE(DstTypeChecker::IsScriptDst(decoded_scr), err);
     }
 }
 
 /**
  * Cashaddr payload made of 5-bit nibbles. The last one is padded. When
  * converting back to bytes, this extra padding is truncated. In order to ensure
  * cashaddr are cannonicals, we check that the data we truncate is zeroed.
  */
 BOOST_AUTO_TEST_CASE(check_padding) {
     uint8_t version = 0;
     std::vector<uint8_t> data = {version};
     for (size_t i = 0; i < 33; ++i) {
         data.push_back(1);
     }
 
     BOOST_CHECK_EQUAL(data.size(), 34UL);
 
     const CTxDestination nodst = CNoDestination{};
     const auto params = CreateChainParams(CBaseChainParams::MAIN);
 
     for (uint8_t i = 0; i < 32; i++) {
         data[data.size() - 1] = i;
         std::string fake = cashaddr::Encode(params->CashAddrPrefix(), data);
         CTxDestination dst = DecodeCashAddr(fake, *params);
 
         // We have 168 bits of payload encoded as 170 bits in 5 bits nimbles. As
         // a result, we must have 2 zeros.
         if (i & 0x03) {
             BOOST_CHECK(dst == nodst);
         } else {
             BOOST_CHECK(dst != nodst);
         }
     }
 }
 
 /**
  * We ensure type is extracted properly from the version.
  */
 BOOST_AUTO_TEST_CASE(check_type) {
     std::vector<uint8_t> data;
     data.resize(34);
 
     const std::string prefix = "bitcoincash";
 
     for (uint8_t v = 0; v < 16; v++) {
         std::fill(begin(data), end(data), 0);
         data[0] = v;
         auto content =
             DecodeCashAddrContent(cashaddr::Encode(prefix, data), prefix);
         BOOST_CHECK_EQUAL(content.type, v);
         BOOST_CHECK_EQUAL(content.hash.size(), 20UL);
 
         // Check that using the reserved bit result in a failure.
         data[0] |= 0x10;
         content = DecodeCashAddrContent(cashaddr::Encode(prefix, data), prefix);
         BOOST_CHECK_EQUAL(content.type, 0);
         BOOST_CHECK_EQUAL(content.hash.size(), 0UL);
     }
 }
 
 /**
  * We ensure size is extracted and checked properly.
  */
 BOOST_AUTO_TEST_CASE(check_size) {
     const CTxDestination nodst = CNoDestination{};
     const std::string prefix = "bitcoincash";
 
     std::vector<uint8_t> data;
 
     for (auto ps : valid_sizes) {
         // Number of bytes required for a 5-bit packed version of a hash, with
         // version byte.  Add half a byte(4) so integer math provides the next
         // multiple-of-5 that would fit all the data.
         size_t expectedSize = (8 * (1 + ps.second) + 4) / 5;
         data.resize(expectedSize);
         std::fill(begin(data), end(data), 0);
         // After conversion from 8 bit packing to 5 bit packing, the size will
         // be in the second 5-bit group, shifted left twice.
         data[1] = ps.first << 2;
 
         auto content =
             DecodeCashAddrContent(cashaddr::Encode(prefix, data), prefix);
 
         BOOST_CHECK_EQUAL(content.type, 0);
         BOOST_CHECK_EQUAL(content.hash.size(), ps.second);
 
         data.push_back(0);
         content = DecodeCashAddrContent(cashaddr::Encode(prefix, data), prefix);
 
         BOOST_CHECK_EQUAL(content.type, 0);
         BOOST_CHECK_EQUAL(content.hash.size(), 0UL);
 
         data.pop_back();
         data.pop_back();
         content = DecodeCashAddrContent(cashaddr::Encode(prefix, data), prefix);
 
         BOOST_CHECK_EQUAL(content.type, 0);
         BOOST_CHECK_EQUAL(content.hash.size(), 0UL);
     }
 }
 
 BOOST_AUTO_TEST_CASE(test_encode_address) {
     const auto params = CreateChainParams(CBaseChainParams::MAIN);
 
     std::vector<std::vector<uint8_t>> hash{
         {118, 160, 64,  83, 189, 160, 168, 139, 218, 81,
          119, 184, 106, 21, 195, 178, 159, 85,  152, 115},
         {203, 72, 18, 50, 41,  156, 213, 116, 49,  81,
          172, 75, 45, 99, 174, 25,  142, 123, 176, 169},
         {1,   31, 40,  228, 115, 201, 95, 64,  19,  215,
          213, 62, 197, 251, 195, 180, 45, 248, 237, 16}};
 
     std::vector<std::string> pubkey = {
         "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a",
         "bitcoincash:qr95sy3j9xwd2ap32xkykttr4cvcu7as4y0qverfuy",
         "bitcoincash:qqq3728yw0y47sqn6l2na30mcw6zm78dzqre909m2r"};
     std::vector<std::string> script = {
         "bitcoincash:ppm2qsznhks23z7629mms6s4cwef74vcwvn0h829pq",
         "bitcoincash:pr95sy3j9xwd2ap32xkykttr4cvcu7as4yc93ky28e",
         "bitcoincash:pqq3728yw0y47sqn6l2na30mcw6zm78dzq5ucqzc37"};
 
     for (size_t i = 0; i < hash.size(); ++i) {
-        const CTxDestination dstKey = CKeyID(uint160(hash[i]));
+        const CTxDestination dstKey = PKHash(uint160(hash[i]));
         BOOST_CHECK_EQUAL(pubkey[i], EncodeCashAddr(dstKey, *params));
 
         CashAddrContent keyContent{PUBKEY_TYPE, hash[i]};
         BOOST_CHECK_EQUAL(pubkey[i], EncodeCashAddr("bitcoincash", keyContent));
 
-        const CTxDestination dstScript = CScriptID(uint160(hash[i]));
+        const CTxDestination dstScript = ScriptHash(uint160(hash[i]));
         BOOST_CHECK_EQUAL(script[i], EncodeCashAddr(dstScript, *params));
 
         CashAddrContent scriptContent{SCRIPT_TYPE, hash[i]};
         BOOST_CHECK_EQUAL(script[i],
                           EncodeCashAddr("bitcoincash", scriptContent));
     }
 }
 
 struct CashAddrTestVector {
     std::string prefix;
     CashAddrType type;
     std::vector<uint8_t> hash;
     std::string addr;
 };
 
 BOOST_AUTO_TEST_CASE(test_vectors) {
     std::vector<CashAddrTestVector> cases = {
         // 20 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("F5BF48B397DAE70BE82B3CCA4793F8EB2B6CDAC9"),
          "bitcoincash:qr6m7j9njldwwzlg9v7v53unlr4jkmx6eylep8ekg2"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("F5BF48B397DAE70BE82B3CCA4793F8EB2B6CDAC9"),
          "bchtest:pr6m7j9njldwwzlg9v7v53unlr4jkmx6eyvwc0uz5t"},
         {"prefix", CashAddrType(15),
          ParseHex("F5BF48B397DAE70BE82B3CCA4793F8EB2B6CDAC9"),
          "prefix:0r6m7j9njldwwzlg9v7v53unlr4jkmx6ey3qnjwsrf"},
         {"bchreg", PUBKEY_TYPE,
          ParseHex("d85c2b71d0060b09c9886aeb815e50991dda124d"),
          "bchreg:qrv9c2m36qrqkzwf3p4whq272zv3mksjf5ln6v9le5"},
         {"bchreg", PUBKEY_TYPE,
          ParseHex("00aea9a2e5f0f876a588df5546e8742d1d87008f"),
          "bchreg:qqq2a2dzuhc0sa493r0423hgwsk3mpcq3upac4z3wr"},
         // 24 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("7ADBF6C17084BC86C1706827B41A56F5CA32865925E946EA"),
          "bitcoincash:q9adhakpwzztepkpwp5z0dq62m6u5v5xtyj7j3h2ws4mr9g0"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("7ADBF6C17084BC86C1706827B41A56F5CA32865925E946EA"),
          "bchtest:p9adhakpwzztepkpwp5z0dq62m6u5v5xtyj7j3h2u94tsynr"},
         {"prefix", CashAddrType(15),
          ParseHex("7ADBF6C17084BC86C1706827B41A56F5CA32865925E946EA"),
          "prefix:09adhakpwzztepkpwp5z0dq62m6u5v5xtyj7j3h2p29kc2lp"},
         // 28 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("3A84F9CF51AAE98A3BB3A78BF16A6183790B18719126325BFC0C075B"),
          "bitcoincash:qgagf7w02x4wnz3mkwnchut2vxphjzccwxgjvvjmlsxqwkcw59jxxuz"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("3A84F9CF51AAE98A3BB3A78BF16A6183790B18719126325BFC0C075B"),
          "bchtest:pgagf7w02x4wnz3mkwnchut2vxphjzccwxgjvvjmlsxqwkcvs7md7wt"},
         {"prefix", CashAddrType(15),
          ParseHex("3A84F9CF51AAE98A3BB3A78BF16A6183790B18719126325BFC0C075B"),
          "prefix:0gagf7w02x4wnz3mkwnchut2vxphjzccwxgjvvjmlsxqwkc5djw8s9g"},
         // 32 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("3173EF6623C6B48FFD1A3DCC0CC6489B0A07BB47A37F47CFEF4FE69DE825"
                   "C060"),
          "bitcoincash:"
          "qvch8mmxy0rtfrlarg7ucrxxfzds5pamg73h7370aa87d80gyhqxq5nlegake"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("3173EF6623C6B48FFD1A3DCC0CC6489B0A07BB47A37F47CFEF4FE69DE825"
                   "C060"),
          "bchtest:"
          "pvch8mmxy0rtfrlarg7ucrxxfzds5pamg73h7370aa87d80gyhqxq7fqng6m6"},
         {"prefix", CashAddrType(15),
          ParseHex("3173EF6623C6B48FFD1A3DCC0CC6489B0A07BB47A37F47CFEF4FE69DE825"
                   "C060"),
          "prefix:"
          "0vch8mmxy0rtfrlarg7ucrxxfzds5pamg73h7370aa87d80gyhqxqsh6jgp6w"},
         // 40 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("C07138323E00FA4FC122D3B85B9628EA810B3F381706385E289B0B256311"
                   "97D194B5C238BEB136FB"),
          "bitcoincash:"
          "qnq8zwpj8cq05n7pytfmskuk9r4gzzel8qtsvwz79zdskftrzxtar994cgutavfklv39g"
          "r3uvz"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("C07138323E00FA4FC122D3B85B9628EA810B3F381706385E289B0B256311"
                   "97D194B5C238BEB136FB"),
          "bchtest:"
          "pnq8zwpj8cq05n7pytfmskuk9r4gzzel8qtsvwz79zdskftrzxtar994cgutavfklvmgm"
          "6ynej"},
         {"prefix", CashAddrType(15),
          ParseHex("C07138323E00FA4FC122D3B85B9628EA810B3F381706385E289B0B256311"
                   "97D194B5C238BEB136FB"),
          "prefix:"
          "0nq8zwpj8cq05n7pytfmskuk9r4gzzel8qtsvwz79zdskftrzxtar994cgutavfklvwsv"
          "ctzqy"},
         // 48 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("E361CA9A7F99107C17A622E047E3745D3E19CF804ED63C5C40C6BA763696"
                   "B98241223D8CE62AD48D863F4CB18C930E4C"),
          "bitcoincash:"
          "qh3krj5607v3qlqh5c3wq3lrw3wnuxw0sp8dv0zugrrt5a3kj6ucysfz8kxwv2k53krr7"
          "n933jfsunqex2w82sl"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("E361CA9A7F99107C17A622E047E3745D3E19CF804ED63C5C40C6BA763696"
                   "B98241223D8CE62AD48D863F4CB18C930E4C"),
          "bchtest:"
          "ph3krj5607v3qlqh5c3wq3lrw3wnuxw0sp8dv0zugrrt5a3kj6ucysfz8kxwv2k53krr7"
          "n933jfsunqnzf7mt6x"},
         {"prefix", CashAddrType(15),
          ParseHex("E361CA9A7F99107C17A622E047E3745D3E19CF804ED63C5C40C6BA763696"
                   "B98241223D8CE62AD48D863F4CB18C930E4C"),
          "prefix:"
          "0h3krj5607v3qlqh5c3wq3lrw3wnuxw0sp8dv0zugrrt5a3kj6ucysfz8kxwv2k53krr7"
          "n933jfsunqakcssnmn"},
         // 56 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("D9FA7C4C6EF56DC4FF423BAAE6D495DBFF663D034A72D1DC7D52CBFE7D1E"
                   "6858F9D523AC0A7A5C34077638E4DD1A701BD017842789982041"),
          "bitcoincash:"
          "qmvl5lzvdm6km38lgga64ek5jhdl7e3aqd9895wu04fvhlnare5937w4ywkq57juxsrhv"
          "w8ym5d8qx7sz7zz0zvcypqscw8jd03f"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("D9FA7C4C6EF56DC4FF423BAAE6D495DBFF663D034A72D1DC7D52CBFE7D1E"
                   "6858F9D523AC0A7A5C34077638E4DD1A701BD017842789982041"),
          "bchtest:"
          "pmvl5lzvdm6km38lgga64ek5jhdl7e3aqd9895wu04fvhlnare5937w4ywkq57juxsrhv"
          "w8ym5d8qx7sz7zz0zvcypqs6kgdsg2g"},
         {"prefix", CashAddrType(15),
          ParseHex("D9FA7C4C6EF56DC4FF423BAAE6D495DBFF663D034A72D1DC7D52CBFE7D1E"
                   "6858F9D523AC0A7A5C34077638E4DD1A701BD017842789982041"),
          "prefix:"
          "0mvl5lzvdm6km38lgga64ek5jhdl7e3aqd9895wu04fvhlnare5937w4ywkq57juxsrhv"
          "w8ym5d8qx7sz7zz0zvcypqsgjrqpnw8"},
         // 64 bytes
         {"bitcoincash", PUBKEY_TYPE,
          ParseHex("D0F346310D5513D9E01E299978624BA883E6BDA8F4C60883C10F28C2967E"
                   "67EC77ECC7EEEAEAFC6DA89FAD72D11AC961E164678B868AEEEC5F2C1DA0"
                   "8884175B"),
          "bitcoincash:"
          "qlg0x333p4238k0qrc5ej7rzfw5g8e4a4r6vvzyrcy8j3s5k0en7calvclhw46hudk5fl"
          "ttj6ydvjc0pv3nchp52amk97tqa5zygg96mtky5sv5w"},
         {"bchtest", SCRIPT_TYPE,
          ParseHex("D0F346310D5513D9E01E299978624BA883E6BDA8F4C60883C10F28C2967E"
                   "67EC77ECC7EEEAEAFC6DA89FAD72D11AC961E164678B868AEEEC5F2C1DA0"
                   "8884175B"),
          "bchtest:"
          "plg0x333p4238k0qrc5ej7rzfw5g8e4a4r6vvzyrcy8j3s5k0en7calvclhw46hudk5fl"
          "ttj6ydvjc0pv3nchp52amk97tqa5zygg96mc773cwez"},
         {"prefix", CashAddrType(15),
          ParseHex("D0F346310D5513D9E01E299978624BA883E6BDA8F4C60883C10F28C2967E"
                   "67EC77ECC7EEEAEAFC6DA89FAD72D11AC961E164678B868AEEEC5F2C1DA0"
                   "8884175B"),
          "prefix:"
          "0lg0x333p4238k0qrc5ej7rzfw5g8e4a4r6vvzyrcy8j3s5k0en7calvclhw46hudk5fl"
          "ttj6ydvjc0pv3nchp52amk97tqa5zygg96ms92w6845"},
     };
 
     for (const auto &t : cases) {
         CashAddrContent content{t.type, t.hash};
         BOOST_CHECK_EQUAL(t.addr, EncodeCashAddr(t.prefix, content));
 
         std::string err("hash mistmatch for address: ");
         err += t.addr;
 
         content = DecodeCashAddrContent(t.addr, t.prefix);
         BOOST_CHECK_EQUAL(t.type, content.type);
         BOOST_CHECK_MESSAGE(t.hash == content.hash, err);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/coins_tests.cpp b/src/test/coins_tests.cpp
index 6a2e79c10..c1cfc67cb 100644
--- a/src/test/coins_tests.cpp
+++ b/src/test/coins_tests.cpp
@@ -1,913 +1,913 @@
 // Copyright (c) 2014-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 <coins.h>
 
 #include <clientversion.h>
 #include <script/standard.h>
 #include <streams.h>
 #include <undo.h>
 #include <util/strencodings.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <map>
 #include <vector>
 
 void UpdateCoins(CCoinsViewCache &inputs, const CTransaction &tx,
                  CTxUndo &txundo, int nHeight);
 
 namespace {
 
 //! equality test
 bool operator==(const Coin &a, const Coin &b) {
     // Empty Coin objects are always equal.
     if (a.IsSpent() && b.IsSpent()) {
         return true;
     }
 
     return a.IsCoinBase() == b.IsCoinBase() && a.GetHeight() == b.GetHeight() &&
            a.GetTxOut() == b.GetTxOut();
 }
 
 class CCoinsViewTest : public CCoinsView {
     BlockHash hashBestBlock_;
     std::map<COutPoint, Coin> map_;
 
 public:
     bool GetCoin(const COutPoint &outpoint, Coin &coin) const override {
         std::map<COutPoint, Coin>::const_iterator it = map_.find(outpoint);
         if (it == map_.end()) {
             return false;
         }
         coin = it->second;
         if (coin.IsSpent() && InsecureRandBool() == 0) {
             // Randomly return false in case of an empty entry.
             return false;
         }
         return true;
     }
 
     BlockHash GetBestBlock() const override { return hashBestBlock_; }
 
     bool BatchWrite(CCoinsMap &mapCoins, const BlockHash &hashBlock) override {
         for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) {
             if (it->second.flags & CCoinsCacheEntry::DIRTY) {
                 // Same optimization used in CCoinsViewDB is to only write dirty
                 // entries.
                 map_[it->first] = it->second.coin;
                 if (it->second.coin.IsSpent() && InsecureRandRange(3) == 0) {
                     // Randomly delete empty entries on write.
                     map_.erase(it->first);
                 }
             }
             mapCoins.erase(it++);
         }
         if (!hashBlock.IsNull()) {
             hashBestBlock_ = hashBlock;
         }
         return true;
     }
 };
 
 class CCoinsViewCacheTest : public CCoinsViewCache {
 public:
     explicit CCoinsViewCacheTest(CCoinsView *_base) : CCoinsViewCache(_base) {}
 
     void SelfTest() const {
         // Manually recompute the dynamic usage of the whole data, and compare
         // it.
         size_t ret = memusage::DynamicUsage(cacheCoins);
         size_t count = 0;
         for (const auto &entry : cacheCoins) {
             ret += entry.second.coin.DynamicMemoryUsage();
             count++;
         }
         BOOST_CHECK_EQUAL(GetCacheSize(), count);
         BOOST_CHECK_EQUAL(DynamicMemoryUsage(), ret);
     }
 
     CCoinsMap &map() const { return cacheCoins; }
     size_t &usage() const { return cachedCoinsUsage; }
 };
 } // namespace
 
 BOOST_FIXTURE_TEST_SUITE(coins_tests, BasicTestingSetup)
 
 static const unsigned int NUM_SIMULATION_ITERATIONS = 40000;
 
 // This is a large randomized insert/remove simulation test on a variable-size
 // stack of caches on top of CCoinsViewTest.
 //
 // It will randomly create/update/delete Coin entries to a tip of caches, with
 // txids picked from a limited list of random 256-bit hashes. Occasionally, a
 // new tip is added to the stack of caches, or the tip is flushed and removed.
 //
 // During the process, booleans are kept to make sure that the randomized
 // operation hits all branches.
 BOOST_AUTO_TEST_CASE(coins_cache_simulation_test) {
     // Various coverage trackers.
     bool removed_all_caches = false;
     bool reached_4_caches = false;
     bool added_an_entry = false;
     bool added_an_unspendable_entry = false;
     bool removed_an_entry = false;
     bool updated_an_entry = false;
     bool found_an_entry = false;
     bool missed_an_entry = false;
     bool uncached_an_entry = false;
 
     // A simple map to track what we expect the cache stack to represent.
     std::map<COutPoint, Coin> result;
 
     // The cache stack.
     // A CCoinsViewTest at the bottom.
     CCoinsViewTest base;
     // A stack of CCoinsViewCaches on top.
     std::vector<CCoinsViewCacheTest *> stack;
     // Start with one cache.
     stack.push_back(new CCoinsViewCacheTest(&base));
 
     // Use a limited set of random transaction ids, so we do test overwriting
     // entries.
     std::vector<TxId> txids;
     txids.resize(NUM_SIMULATION_ITERATIONS / 8);
     for (size_t i = 0; i < txids.size(); i++) {
         txids[i] = TxId(InsecureRand256());
     }
 
     for (unsigned int i = 0; i < NUM_SIMULATION_ITERATIONS; i++) {
         // Do a random modification.
         {
             // txid we're going to modify in this iteration.
             const TxId txid = txids[InsecureRandRange(txids.size())];
             Coin &coin = result[COutPoint(txid, 0)];
             // Determine whether to test HaveCoin before or after Access* (or
             // both). As these functions can influence each other's behaviour by
             // pulling things into the cache, all combinations are tested.
             bool test_havecoin_before = InsecureRandBits(2) == 0;
             bool test_havecoin_after = InsecureRandBits(2) == 0;
 
             bool result_havecoin =
                 test_havecoin_before
                     ? stack.back()->HaveCoin(COutPoint(txid, 0))
                     : false;
             const Coin &entry =
                 (InsecureRandRange(500) == 0)
                     ? AccessByTxid(*stack.back(), txid)
                     : stack.back()->AccessCoin(COutPoint(txid, 0));
             BOOST_CHECK(coin == entry);
             BOOST_CHECK(!test_havecoin_before ||
                         result_havecoin == !entry.IsSpent());
 
             if (test_havecoin_after) {
                 bool ret = stack.back()->HaveCoin(COutPoint(txid, 0));
                 BOOST_CHECK(ret == !entry.IsSpent());
             }
 
             if (InsecureRandRange(5) == 0 || coin.IsSpent()) {
                 CTxOut txout;
                 txout.nValue = int64_t(InsecureRand32()) * SATOSHI;
                 if (InsecureRandRange(16) == 0 && coin.IsSpent()) {
                     txout.scriptPubKey.assign(1 + InsecureRandBits(6),
                                               OP_RETURN);
                     BOOST_CHECK(txout.scriptPubKey.IsUnspendable());
                     added_an_unspendable_entry = true;
                 } else {
                     // Random sizes so we can test memory usage accounting
                     txout.scriptPubKey.assign(InsecureRandBits(6), 0);
                     (coin.IsSpent() ? added_an_entry : updated_an_entry) = true;
                     coin = Coin(txout, 1, false);
                 }
 
                 Coin newcoin(txout, 1, false);
                 stack.back()->AddCoin(COutPoint(txid, 0), newcoin,
                                       !coin.IsSpent() || InsecureRand32() & 1);
             } else {
                 removed_an_entry = true;
                 coin.Clear();
                 stack.back()->SpendCoin(COutPoint(txid, 0));
             }
         }
 
         // One every 10 iterations, remove a random entry from the cache
         if (InsecureRandRange(10) == 0) {
             COutPoint out(txids[InsecureRand32() % txids.size()], 0);
             int cacheid = InsecureRand32() % stack.size();
             stack[cacheid]->Uncache(out);
             uncached_an_entry |= !stack[cacheid]->HaveCoinInCache(out);
         }
 
         // Once every 1000 iterations and at the end, verify the full cache.
         if (InsecureRandRange(1000) == 1 ||
             i == NUM_SIMULATION_ITERATIONS - 1) {
             for (const auto &entry : result) {
                 bool have = stack.back()->HaveCoin(entry.first);
                 const Coin &coin = stack.back()->AccessCoin(entry.first);
                 BOOST_CHECK(have == !coin.IsSpent());
                 BOOST_CHECK(coin == entry.second);
                 if (coin.IsSpent()) {
                     missed_an_entry = true;
                 } else {
                     BOOST_CHECK(stack.back()->HaveCoinInCache(entry.first));
                     found_an_entry = true;
                 }
             }
             for (const CCoinsViewCacheTest *test : stack) {
                 test->SelfTest();
             }
         }
 
         // Every 100 iterations, flush an intermediate cache
         if (InsecureRandRange(100) == 0) {
             if (stack.size() > 1 && InsecureRandBool() == 0) {
                 unsigned int flushIndex = InsecureRandRange(stack.size() - 1);
                 stack[flushIndex]->Flush();
             }
         }
         if (InsecureRandRange(100) == 0) {
             // Every 100 iterations, change the cache stack.
             if (stack.size() > 0 && InsecureRandBool() == 0) {
                 // Remove the top cache
                 stack.back()->Flush();
                 delete stack.back();
                 stack.pop_back();
             }
             if (stack.size() == 0 || (stack.size() < 4 && InsecureRandBool())) {
                 // Add a new cache
                 CCoinsView *tip = &base;
                 if (stack.size() > 0) {
                     tip = stack.back();
                 } else {
                     removed_all_caches = true;
                 }
                 stack.push_back(new CCoinsViewCacheTest(tip));
                 if (stack.size() == 4) {
                     reached_4_caches = true;
                 }
             }
         }
     }
 
     // Clean up the stack.
     while (stack.size() > 0) {
         delete stack.back();
         stack.pop_back();
     }
 
     // Verify coverage.
     BOOST_CHECK(removed_all_caches);
     BOOST_CHECK(reached_4_caches);
     BOOST_CHECK(added_an_entry);
     BOOST_CHECK(added_an_unspendable_entry);
     BOOST_CHECK(removed_an_entry);
     BOOST_CHECK(updated_an_entry);
     BOOST_CHECK(found_an_entry);
     BOOST_CHECK(missed_an_entry);
     BOOST_CHECK(uncached_an_entry);
 }
 
 // Store of all necessary tx and undo data for next test
 typedef std::map<COutPoint, std::tuple<CTransaction, CTxUndo, Coin>> UtxoData;
 UtxoData utxoData;
 
 UtxoData::iterator FindRandomFrom(const std::set<COutPoint> &utxoSet) {
     assert(utxoSet.size());
     auto utxoSetIt = utxoSet.lower_bound(COutPoint(TxId(InsecureRand256()), 0));
     if (utxoSetIt == utxoSet.end()) {
         utxoSetIt = utxoSet.begin();
     }
     auto utxoDataIt = utxoData.find(*utxoSetIt);
     assert(utxoDataIt != utxoData.end());
     return utxoDataIt;
 }
 
 // This test is similar to the previous test except the emphasis is on testing
 // the functionality of UpdateCoins random txs are created and UpdateCoins is
 // used to update the cache stack. In particular it is tested that spending a
 // duplicate coinbase tx has the expected effect (the other duplicate is
 // overwritten at all cache levels)
 BOOST_AUTO_TEST_CASE(updatecoins_simulation_test) {
     bool spent_a_duplicate_coinbase = false;
     // A simple map to track what we expect the cache stack to represent.
     std::map<COutPoint, Coin> result;
 
     // The cache stack.
     // A CCoinsViewTest at the bottom.
     CCoinsViewTest base;
     // A stack of CCoinsViewCaches on top.
     std::vector<CCoinsViewCacheTest *> stack;
     // Start with one cache.
     stack.push_back(new CCoinsViewCacheTest(&base));
 
     // Track the txids we've used in various sets
     std::set<COutPoint> coinbase_coins;
     std::set<COutPoint> disconnected_coins;
     std::set<COutPoint> duplicate_coins;
     std::set<COutPoint> utxoset;
 
     for (int64_t i = 0; i < NUM_SIMULATION_ITERATIONS; i++) {
         uint32_t randiter = InsecureRand32();
 
         // 19/20 txs add a new transaction
         if (randiter % 20 < 19) {
             CMutableTransaction tx;
             tx.vin.resize(1);
             tx.vout.resize(1);
             // Keep txs unique unless intended to duplicate.
             tx.vout[0].nValue = i * SATOSHI;
             // Random sizes so we can test memory usage accounting
             tx.vout[0].scriptPubKey.assign(InsecureRand32() & 0x3F, 0);
             unsigned int height = InsecureRand32();
             Coin old_coin;
 
             // 2/20 times create a new coinbase
             if (randiter % 20 < 2 || coinbase_coins.size() < 10) {
                 // 1/10 of those times create a duplicate coinbase
                 if (InsecureRandRange(10) == 0 && coinbase_coins.size()) {
                     auto utxod = FindRandomFrom(coinbase_coins);
                     // Reuse the exact same coinbase
                     tx = CMutableTransaction{std::get<0>(utxod->second)};
                     // shouldn't be available for reconnection if it's been
                     // duplicated
                     disconnected_coins.erase(utxod->first);
 
                     duplicate_coins.insert(utxod->first);
                 } else {
                     coinbase_coins.insert(COutPoint(tx.GetId(), 0));
                 }
                 assert(CTransaction(tx).IsCoinBase());
             }
 
             // 17/20 times reconnect previous or add a regular tx
             else {
                 COutPoint prevout;
                 // 1/20 times reconnect a previously disconnected tx
                 if (randiter % 20 == 2 && disconnected_coins.size()) {
                     auto utxod = FindRandomFrom(disconnected_coins);
                     tx = CMutableTransaction{std::get<0>(utxod->second)};
                     prevout = tx.vin[0].prevout;
                     if (!CTransaction(tx).IsCoinBase() &&
                         !utxoset.count(prevout)) {
                         disconnected_coins.erase(utxod->first);
                         continue;
                     }
 
                     // If this tx is already IN the UTXO, then it must be a
                     // coinbase, and it must be a duplicate
                     if (utxoset.count(utxod->first)) {
                         assert(CTransaction(tx).IsCoinBase());
                         assert(duplicate_coins.count(utxod->first));
                     }
                     disconnected_coins.erase(utxod->first);
                 }
 
                 // 16/20 times create a regular tx
                 else {
                     auto utxod = FindRandomFrom(utxoset);
                     prevout = utxod->first;
 
                     // Construct the tx to spend the coins of prevouthash
                     tx.vin[0].prevout = COutPoint(prevout.GetTxId(), 0);
                     assert(!CTransaction(tx).IsCoinBase());
                 }
 
                 // In this simple test coins only have two states, spent or
                 // unspent, save the unspent state to restore
                 old_coin = result[prevout];
                 // Update the expected result of prevouthash to know these coins
                 // are spent
                 result[prevout].Clear();
 
                 utxoset.erase(prevout);
 
                 // The test is designed to ensure spending a duplicate coinbase
                 // will work properly if that ever happens and not resurrect the
                 // previously overwritten coinbase
                 if (duplicate_coins.count(prevout)) {
                     spent_a_duplicate_coinbase = true;
                 }
             }
             // Update the expected result to know about the new output coins
             assert(tx.vout.size() == 1);
             const COutPoint outpoint(tx.GetId(), 0);
             result[outpoint] =
                 Coin(tx.vout[0], height, CTransaction(tx).IsCoinBase());
 
             // Call UpdateCoins on the top cache
             CTxUndo undo;
             UpdateCoins(*(stack.back()), CTransaction(tx), undo, height);
 
             // Update the utxo set for future spends
             utxoset.insert(outpoint);
 
             // Track this tx and undo info to use later
             utxoData.emplace(outpoint,
                              std::make_tuple(CTransaction(tx), undo, old_coin));
         }
 
         // 1/20 times undo a previous transaction
         else if (utxoset.size()) {
             auto utxod = FindRandomFrom(utxoset);
 
             CTransaction &tx = std::get<0>(utxod->second);
             CTxUndo &undo = std::get<1>(utxod->second);
             Coin &orig_coin = std::get<2>(utxod->second);
 
             // Update the expected result
             // Remove new outputs
             result[utxod->first].Clear();
             // If not coinbase restore prevout
             if (!tx.IsCoinBase()) {
                 result[tx.vin[0].prevout] = orig_coin;
             }
 
             // Disconnect the tx from the current UTXO
             // See code in DisconnectBlock
             // remove outputs
             stack.back()->SpendCoin(utxod->first);
 
             // restore inputs
             if (!tx.IsCoinBase()) {
                 const COutPoint &out = tx.vin[0].prevout;
                 UndoCoinSpend(undo.vprevout[0], *(stack.back()), out);
             }
 
             // Store as a candidate for reconnection
             disconnected_coins.insert(utxod->first);
 
             // Update the utxoset
             utxoset.erase(utxod->first);
             if (!tx.IsCoinBase()) {
                 utxoset.insert(tx.vin[0].prevout);
             }
         }
 
         // Once every 1000 iterations and at the end, verify the full cache.
         if (InsecureRandRange(1000) == 1 ||
             i == NUM_SIMULATION_ITERATIONS - 1) {
             for (const auto &entry : result) {
                 bool have = stack.back()->HaveCoin(entry.first);
                 const Coin &coin = stack.back()->AccessCoin(entry.first);
                 BOOST_CHECK(have == !coin.IsSpent());
                 BOOST_CHECK(coin == entry.second);
             }
         }
 
         // One every 10 iterations, remove a random entry from the cache
         if (utxoset.size() > 1 && InsecureRandRange(30) == 0) {
             stack[InsecureRand32() % stack.size()]->Uncache(
                 FindRandomFrom(utxoset)->first);
         }
         if (disconnected_coins.size() > 1 && InsecureRandRange(30) == 0) {
             stack[InsecureRand32() % stack.size()]->Uncache(
                 FindRandomFrom(disconnected_coins)->first);
         }
         if (duplicate_coins.size() > 1 && InsecureRandRange(30) == 0) {
             stack[InsecureRand32() % stack.size()]->Uncache(
                 FindRandomFrom(duplicate_coins)->first);
         }
 
         if (InsecureRandRange(100) == 0) {
             // Every 100 iterations, flush an intermediate cache
             if (stack.size() > 1 && InsecureRandBool() == 0) {
                 unsigned int flushIndex = InsecureRandRange(stack.size() - 1);
                 stack[flushIndex]->Flush();
             }
         }
         if (InsecureRandRange(100) == 0) {
             // Every 100 iterations, change the cache stack.
             if (stack.size() > 0 && InsecureRandBool() == 0) {
                 stack.back()->Flush();
                 delete stack.back();
                 stack.pop_back();
             }
             if (stack.size() == 0 || (stack.size() < 4 && InsecureRandBool())) {
                 CCoinsView *tip = &base;
                 if (stack.size() > 0) {
                     tip = stack.back();
                 }
                 stack.push_back(new CCoinsViewCacheTest(tip));
             }
         }
     }
 
     // Clean up the stack.
     while (stack.size() > 0) {
         delete stack.back();
         stack.pop_back();
     }
 
     // Verify coverage.
     BOOST_CHECK(spent_a_duplicate_coinbase);
 }
 
 BOOST_AUTO_TEST_CASE(coin_serialization) {
     // Good example
     CDataStream ss1(
         ParseHex("97f23c835800816115944e077fe7c803cfa57f29b36bf87c1d35"),
         SER_DISK, CLIENT_VERSION);
     Coin c1;
     ss1 >> c1;
     BOOST_CHECK_EQUAL(c1.IsCoinBase(), false);
     BOOST_CHECK_EQUAL(c1.GetHeight(), 203998U);
     BOOST_CHECK_EQUAL(c1.GetTxOut().nValue, int64_t(60000000000) * SATOSHI);
     BOOST_CHECK_EQUAL(HexStr(c1.GetTxOut().scriptPubKey),
-                      HexStr(GetScriptForDestination(CKeyID(uint160(ParseHex(
+                      HexStr(GetScriptForDestination(PKHash(uint160(ParseHex(
                           "816115944e077fe7c803cfa57f29b36bf87c1d35"))))));
 
     // Good example
     CDataStream ss2(
         ParseHex("8ddf77bbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa4"),
         SER_DISK, CLIENT_VERSION);
     Coin c2;
     ss2 >> c2;
     BOOST_CHECK_EQUAL(c2.IsCoinBase(), true);
     BOOST_CHECK_EQUAL(c2.GetHeight(), 120891U);
     BOOST_CHECK_EQUAL(c2.GetTxOut().nValue, 110397 * SATOSHI);
     BOOST_CHECK_EQUAL(HexStr(c2.GetTxOut().scriptPubKey),
-                      HexStr(GetScriptForDestination(CKeyID(uint160(ParseHex(
+                      HexStr(GetScriptForDestination(PKHash(uint160(ParseHex(
                           "8c988f1a4a4de2161e0f50aac7f17e7f9555caa4"))))));
 
     // Smallest possible example
     CDataStream ss3(ParseHex("000006"), SER_DISK, CLIENT_VERSION);
     Coin c3;
     ss3 >> c3;
     BOOST_CHECK_EQUAL(c3.IsCoinBase(), false);
     BOOST_CHECK_EQUAL(c3.GetHeight(), 0U);
     BOOST_CHECK_EQUAL(c3.GetTxOut().nValue, Amount::zero());
     BOOST_CHECK_EQUAL(c3.GetTxOut().scriptPubKey.size(), 0U);
 
     // scriptPubKey that ends beyond the end of the stream
     CDataStream ss4(ParseHex("000007"), SER_DISK, CLIENT_VERSION);
     try {
         Coin c4;
         ss4 >> c4;
         BOOST_CHECK_MESSAGE(false, "We should have thrown");
     } catch (const std::ios_base::failure &) {
     }
 
     // Very large scriptPubKey (3*10^9 bytes) past the end of the stream
     CDataStream tmp(SER_DISK, CLIENT_VERSION);
     uint64_t x = 3000000000ULL;
     tmp << VARINT(x);
     BOOST_CHECK_EQUAL(HexStr(tmp.begin(), tmp.end()), "8a95c0bb00");
     CDataStream ss5(ParseHex("00008a95c0bb00"), SER_DISK, CLIENT_VERSION);
     try {
         Coin c5;
         ss5 >> c5;
         BOOST_CHECK_MESSAGE(false, "We should have thrown");
     } catch (const std::ios_base::failure &) {
     }
 }
 
 static const COutPoint OUTPOINT;
 static const Amount PRUNED(-1 * SATOSHI);
 static const Amount ABSENT(-2 * SATOSHI);
 static const Amount FAIL(-3 * SATOSHI);
 static const Amount VALUE1(100 * SATOSHI);
 static const Amount VALUE2(200 * SATOSHI);
 static const Amount VALUE3(300 * SATOSHI);
 static const char DIRTY = CCoinsCacheEntry::DIRTY;
 static const char FRESH = CCoinsCacheEntry::FRESH;
 static const char NO_ENTRY = -1;
 
 static const auto FLAGS = {char(0), FRESH, DIRTY, char(DIRTY | FRESH)};
 static const auto CLEAN_FLAGS = {char(0), FRESH};
 static const auto ABSENT_FLAGS = {NO_ENTRY};
 
 static void SetCoinValue(const Amount value, Coin &coin) {
     assert(value != ABSENT);
     coin.Clear();
     assert(coin.IsSpent());
     if (value != PRUNED) {
         CTxOut out;
         out.nValue = value;
         coin = Coin(std::move(out), 1, false);
         assert(!coin.IsSpent());
     }
 }
 
 static size_t InsertCoinMapEntry(CCoinsMap &map, const Amount value,
                                  char flags) {
     if (value == ABSENT) {
         assert(flags == NO_ENTRY);
         return 0;
     }
     assert(flags != NO_ENTRY);
     CCoinsCacheEntry entry;
     entry.flags = flags;
     SetCoinValue(value, entry.coin);
     auto inserted = map.emplace(OUTPOINT, std::move(entry));
     assert(inserted.second);
     return inserted.first->second.coin.DynamicMemoryUsage();
 }
 
 void GetCoinMapEntry(const CCoinsMap &map, Amount &value, char &flags) {
     auto it = map.find(OUTPOINT);
     if (it == map.end()) {
         value = ABSENT;
         flags = NO_ENTRY;
     } else {
         if (it->second.coin.IsSpent()) {
             value = PRUNED;
         } else {
             value = it->second.coin.GetTxOut().nValue;
         }
         flags = it->second.flags;
         assert(flags != NO_ENTRY);
     }
 }
 
 void WriteCoinViewEntry(CCoinsView &view, const Amount value, char flags) {
     CCoinsMap map;
     InsertCoinMapEntry(map, value, flags);
     view.BatchWrite(map, BlockHash());
 }
 
 class SingleEntryCacheTest {
 public:
     SingleEntryCacheTest(const Amount base_value, const Amount cache_value,
                          char cache_flags) {
         WriteCoinViewEntry(base, base_value,
                            base_value == ABSENT ? NO_ENTRY : DIRTY);
         cache.usage() +=
             InsertCoinMapEntry(cache.map(), cache_value, cache_flags);
     }
 
     CCoinsView root;
     CCoinsViewCacheTest base{&root};
     CCoinsViewCacheTest cache{&base};
 };
 
 static void CheckAccessCoin(const Amount base_value, const Amount cache_value,
                             const Amount expected_value, char cache_flags,
                             char expected_flags) {
     SingleEntryCacheTest test(base_value, cache_value, cache_flags);
     test.cache.AccessCoin(OUTPOINT);
     test.cache.SelfTest();
 
     Amount result_value;
     char result_flags;
     GetCoinMapEntry(test.cache.map(), result_value, result_flags);
     BOOST_CHECK_EQUAL(result_value, expected_value);
     BOOST_CHECK_EQUAL(result_flags, expected_flags);
 }
 
 BOOST_AUTO_TEST_CASE(coin_access) {
     /* Check AccessCoin behavior, requesting a coin from a cache view layered on
      * top of a base view, and checking the resulting entry in the cache after
      * the access.
      *
      *               Base    Cache   Result  Cache        Result
      *               Value   Value   Value   Flags        Flags
      */
     CheckAccessCoin(ABSENT, ABSENT, ABSENT, NO_ENTRY, NO_ENTRY);
     CheckAccessCoin(ABSENT, PRUNED, PRUNED, 0, 0);
     CheckAccessCoin(ABSENT, PRUNED, PRUNED, FRESH, FRESH);
     CheckAccessCoin(ABSENT, PRUNED, PRUNED, DIRTY, DIRTY);
     CheckAccessCoin(ABSENT, PRUNED, PRUNED, DIRTY | FRESH, DIRTY | FRESH);
     CheckAccessCoin(ABSENT, VALUE2, VALUE2, 0, 0);
     CheckAccessCoin(ABSENT, VALUE2, VALUE2, FRESH, FRESH);
     CheckAccessCoin(ABSENT, VALUE2, VALUE2, DIRTY, DIRTY);
     CheckAccessCoin(ABSENT, VALUE2, VALUE2, DIRTY | FRESH, DIRTY | FRESH);
     CheckAccessCoin(PRUNED, ABSENT, ABSENT, NO_ENTRY, NO_ENTRY);
     CheckAccessCoin(PRUNED, PRUNED, PRUNED, 0, 0);
     CheckAccessCoin(PRUNED, PRUNED, PRUNED, FRESH, FRESH);
     CheckAccessCoin(PRUNED, PRUNED, PRUNED, DIRTY, DIRTY);
     CheckAccessCoin(PRUNED, PRUNED, PRUNED, DIRTY | FRESH, DIRTY | FRESH);
     CheckAccessCoin(PRUNED, VALUE2, VALUE2, 0, 0);
     CheckAccessCoin(PRUNED, VALUE2, VALUE2, FRESH, FRESH);
     CheckAccessCoin(PRUNED, VALUE2, VALUE2, DIRTY, DIRTY);
     CheckAccessCoin(PRUNED, VALUE2, VALUE2, DIRTY | FRESH, DIRTY | FRESH);
     CheckAccessCoin(VALUE1, ABSENT, VALUE1, NO_ENTRY, 0);
     CheckAccessCoin(VALUE1, PRUNED, PRUNED, 0, 0);
     CheckAccessCoin(VALUE1, PRUNED, PRUNED, FRESH, FRESH);
     CheckAccessCoin(VALUE1, PRUNED, PRUNED, DIRTY, DIRTY);
     CheckAccessCoin(VALUE1, PRUNED, PRUNED, DIRTY | FRESH, DIRTY | FRESH);
     CheckAccessCoin(VALUE1, VALUE2, VALUE2, 0, 0);
     CheckAccessCoin(VALUE1, VALUE2, VALUE2, FRESH, FRESH);
     CheckAccessCoin(VALUE1, VALUE2, VALUE2, DIRTY, DIRTY);
     CheckAccessCoin(VALUE1, VALUE2, VALUE2, DIRTY | FRESH, DIRTY | FRESH);
 }
 
 static void CheckSpendCoin(Amount base_value, Amount cache_value,
                            Amount expected_value, char cache_flags,
                            char expected_flags) {
     SingleEntryCacheTest test(base_value, cache_value, cache_flags);
     test.cache.SpendCoin(OUTPOINT);
     test.cache.SelfTest();
 
     Amount result_value;
     char result_flags;
     GetCoinMapEntry(test.cache.map(), result_value, result_flags);
     BOOST_CHECK_EQUAL(result_value, expected_value);
     BOOST_CHECK_EQUAL(result_flags, expected_flags);
 };
 
 BOOST_AUTO_TEST_CASE(coin_spend) {
     /**
      * Check SpendCoin behavior, requesting a coin from a cache view layered on
      * top of a base view, spending, and then checking the resulting entry in
      * the cache after the modification.
      *
      *              Base    Cache   Result  Cache        Result
      *              Value   Value   Value   Flags        Flags
      */
     CheckSpendCoin(ABSENT, ABSENT, ABSENT, NO_ENTRY, NO_ENTRY);
     CheckSpendCoin(ABSENT, PRUNED, PRUNED, 0, DIRTY);
     CheckSpendCoin(ABSENT, PRUNED, ABSENT, FRESH, NO_ENTRY);
     CheckSpendCoin(ABSENT, PRUNED, PRUNED, DIRTY, DIRTY);
     CheckSpendCoin(ABSENT, PRUNED, ABSENT, DIRTY | FRESH, NO_ENTRY);
     CheckSpendCoin(ABSENT, VALUE2, PRUNED, 0, DIRTY);
     CheckSpendCoin(ABSENT, VALUE2, ABSENT, FRESH, NO_ENTRY);
     CheckSpendCoin(ABSENT, VALUE2, PRUNED, DIRTY, DIRTY);
     CheckSpendCoin(ABSENT, VALUE2, ABSENT, DIRTY | FRESH, NO_ENTRY);
     CheckSpendCoin(PRUNED, ABSENT, ABSENT, NO_ENTRY, NO_ENTRY);
     CheckSpendCoin(PRUNED, PRUNED, PRUNED, 0, DIRTY);
     CheckSpendCoin(PRUNED, PRUNED, ABSENT, FRESH, NO_ENTRY);
     CheckSpendCoin(PRUNED, PRUNED, PRUNED, DIRTY, DIRTY);
     CheckSpendCoin(PRUNED, PRUNED, ABSENT, DIRTY | FRESH, NO_ENTRY);
     CheckSpendCoin(PRUNED, VALUE2, PRUNED, 0, DIRTY);
     CheckSpendCoin(PRUNED, VALUE2, ABSENT, FRESH, NO_ENTRY);
     CheckSpendCoin(PRUNED, VALUE2, PRUNED, DIRTY, DIRTY);
     CheckSpendCoin(PRUNED, VALUE2, ABSENT, DIRTY | FRESH, NO_ENTRY);
     CheckSpendCoin(VALUE1, ABSENT, PRUNED, NO_ENTRY, DIRTY);
     CheckSpendCoin(VALUE1, PRUNED, PRUNED, 0, DIRTY);
     CheckSpendCoin(VALUE1, PRUNED, ABSENT, FRESH, NO_ENTRY);
     CheckSpendCoin(VALUE1, PRUNED, PRUNED, DIRTY, DIRTY);
     CheckSpendCoin(VALUE1, PRUNED, ABSENT, DIRTY | FRESH, NO_ENTRY);
     CheckSpendCoin(VALUE1, VALUE2, PRUNED, 0, DIRTY);
     CheckSpendCoin(VALUE1, VALUE2, ABSENT, FRESH, NO_ENTRY);
     CheckSpendCoin(VALUE1, VALUE2, PRUNED, DIRTY, DIRTY);
     CheckSpendCoin(VALUE1, VALUE2, ABSENT, DIRTY | FRESH, NO_ENTRY);
 }
 
 static void CheckAddCoinBase(Amount base_value, Amount cache_value,
                              Amount modify_value, Amount expected_value,
                              char cache_flags, char expected_flags,
                              bool coinbase) {
     SingleEntryCacheTest test(base_value, cache_value, cache_flags);
 
     Amount result_value;
     char result_flags;
     try {
         CTxOut output;
         output.nValue = modify_value;
         test.cache.AddCoin(OUTPOINT, Coin(std::move(output), 1, coinbase),
                            coinbase);
         test.cache.SelfTest();
         GetCoinMapEntry(test.cache.map(), result_value, result_flags);
     } catch (std::logic_error &) {
         result_value = FAIL;
         result_flags = NO_ENTRY;
     }
 
     BOOST_CHECK_EQUAL(result_value, expected_value);
     BOOST_CHECK_EQUAL(result_flags, expected_flags);
 }
 
 // Simple wrapper for CheckAddCoinBase function above that loops through
 // different possible base_values, making sure each one gives the same results.
 // This wrapper lets the coin_add test below be shorter and less repetitive,
 // while still verifying that the CoinsViewCache::AddCoin implementation ignores
 // base values.
 template <typename... Args> static void CheckAddCoin(Args &&... args) {
     for (const Amount &base_value : {ABSENT, PRUNED, VALUE1}) {
         CheckAddCoinBase(base_value, std::forward<Args>(args)...);
     }
 }
 
 BOOST_AUTO_TEST_CASE(coin_add) {
     /**
      * Check AddCoin behavior, requesting a new coin from a cache view, writing
      * a modification to the coin, and then checking the resulting entry in the
      * cache after the modification. Verify behavior with the with the AddCoin
      * potential_overwrite argument set to false, and to true.
      *
      * Cache   Write   Result  Cache        Result       potential_overwrite
      * Value   Value   Value   Flags        Flags
      */
     CheckAddCoin(ABSENT, VALUE3, VALUE3, NO_ENTRY, DIRTY | FRESH, false);
     CheckAddCoin(ABSENT, VALUE3, VALUE3, NO_ENTRY, DIRTY, true);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, 0, DIRTY | FRESH, false);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, 0, DIRTY, true);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, FRESH, DIRTY | FRESH, false);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, FRESH, DIRTY | FRESH, true);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, DIRTY, DIRTY, false);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, DIRTY, DIRTY, true);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, DIRTY | FRESH, DIRTY | FRESH, false);
     CheckAddCoin(PRUNED, VALUE3, VALUE3, DIRTY | FRESH, DIRTY | FRESH, true);
     CheckAddCoin(VALUE2, VALUE3, FAIL, 0, NO_ENTRY, false);
     CheckAddCoin(VALUE2, VALUE3, VALUE3, 0, DIRTY, true);
     CheckAddCoin(VALUE2, VALUE3, FAIL, FRESH, NO_ENTRY, false);
     CheckAddCoin(VALUE2, VALUE3, VALUE3, FRESH, DIRTY | FRESH, true);
     CheckAddCoin(VALUE2, VALUE3, FAIL, DIRTY, NO_ENTRY, false);
     CheckAddCoin(VALUE2, VALUE3, VALUE3, DIRTY, DIRTY, true);
     CheckAddCoin(VALUE2, VALUE3, FAIL, DIRTY | FRESH, NO_ENTRY, false);
     CheckAddCoin(VALUE2, VALUE3, VALUE3, DIRTY | FRESH, DIRTY | FRESH, true);
 }
 
 void CheckWriteCoin(Amount parent_value, Amount child_value,
                     Amount expected_value, char parent_flags, char child_flags,
                     char expected_flags) {
     SingleEntryCacheTest test(ABSENT, parent_value, parent_flags);
 
     Amount result_value;
     char result_flags;
     try {
         WriteCoinViewEntry(test.cache, child_value, child_flags);
         test.cache.SelfTest();
         GetCoinMapEntry(test.cache.map(), result_value, result_flags);
     } catch (std::logic_error &) {
         result_value = FAIL;
         result_flags = NO_ENTRY;
     }
 
     BOOST_CHECK_EQUAL(result_value, expected_value);
     BOOST_CHECK_EQUAL(result_flags, expected_flags);
 }
 
 BOOST_AUTO_TEST_CASE(coin_write) {
     /* Check BatchWrite behavior, flushing one entry from a child cache to a
      * parent cache, and checking the resulting entry in the parent cache
      * after the write.
      *
      *              Parent  Child   Result  Parent       Child        Result
      *              Value   Value   Value   Flags        Flags        Flags
      */
     CheckWriteCoin(ABSENT, ABSENT, ABSENT, NO_ENTRY, NO_ENTRY, NO_ENTRY);
     CheckWriteCoin(ABSENT, PRUNED, PRUNED, NO_ENTRY, DIRTY, DIRTY);
     CheckWriteCoin(ABSENT, PRUNED, ABSENT, NO_ENTRY, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(ABSENT, VALUE2, VALUE2, NO_ENTRY, DIRTY, DIRTY);
     CheckWriteCoin(ABSENT, VALUE2, VALUE2, NO_ENTRY, DIRTY | FRESH,
                    DIRTY | FRESH);
     CheckWriteCoin(PRUNED, ABSENT, PRUNED, 0, NO_ENTRY, 0);
     CheckWriteCoin(PRUNED, ABSENT, PRUNED, FRESH, NO_ENTRY, FRESH);
     CheckWriteCoin(PRUNED, ABSENT, PRUNED, DIRTY, NO_ENTRY, DIRTY);
     CheckWriteCoin(PRUNED, ABSENT, PRUNED, DIRTY | FRESH, NO_ENTRY,
                    DIRTY | FRESH);
     CheckWriteCoin(PRUNED, PRUNED, PRUNED, 0, DIRTY, DIRTY);
     CheckWriteCoin(PRUNED, PRUNED, PRUNED, 0, DIRTY | FRESH, DIRTY);
     CheckWriteCoin(PRUNED, PRUNED, ABSENT, FRESH, DIRTY, NO_ENTRY);
     CheckWriteCoin(PRUNED, PRUNED, ABSENT, FRESH, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(PRUNED, PRUNED, PRUNED, DIRTY, DIRTY, DIRTY);
     CheckWriteCoin(PRUNED, PRUNED, PRUNED, DIRTY, DIRTY | FRESH, DIRTY);
     CheckWriteCoin(PRUNED, PRUNED, ABSENT, DIRTY | FRESH, DIRTY, NO_ENTRY);
     CheckWriteCoin(PRUNED, PRUNED, ABSENT, DIRTY | FRESH, DIRTY | FRESH,
                    NO_ENTRY);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, 0, DIRTY, DIRTY);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, 0, DIRTY | FRESH, DIRTY);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, FRESH, DIRTY, DIRTY | FRESH);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, FRESH, DIRTY | FRESH, DIRTY | FRESH);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, DIRTY, DIRTY, DIRTY);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, DIRTY, DIRTY | FRESH, DIRTY);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, DIRTY | FRESH, DIRTY, DIRTY | FRESH);
     CheckWriteCoin(PRUNED, VALUE2, VALUE2, DIRTY | FRESH, DIRTY | FRESH,
                    DIRTY | FRESH);
     CheckWriteCoin(VALUE1, ABSENT, VALUE1, 0, NO_ENTRY, 0);
     CheckWriteCoin(VALUE1, ABSENT, VALUE1, FRESH, NO_ENTRY, FRESH);
     CheckWriteCoin(VALUE1, ABSENT, VALUE1, DIRTY, NO_ENTRY, DIRTY);
     CheckWriteCoin(VALUE1, ABSENT, VALUE1, DIRTY | FRESH, NO_ENTRY,
                    DIRTY | FRESH);
     CheckWriteCoin(VALUE1, PRUNED, PRUNED, 0, DIRTY, DIRTY);
     CheckWriteCoin(VALUE1, PRUNED, FAIL, 0, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(VALUE1, PRUNED, ABSENT, FRESH, DIRTY, NO_ENTRY);
     CheckWriteCoin(VALUE1, PRUNED, FAIL, FRESH, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(VALUE1, PRUNED, PRUNED, DIRTY, DIRTY, DIRTY);
     CheckWriteCoin(VALUE1, PRUNED, FAIL, DIRTY, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(VALUE1, PRUNED, ABSENT, DIRTY | FRESH, DIRTY, NO_ENTRY);
     CheckWriteCoin(VALUE1, PRUNED, FAIL, DIRTY | FRESH, DIRTY | FRESH,
                    NO_ENTRY);
     CheckWriteCoin(VALUE1, VALUE2, VALUE2, 0, DIRTY, DIRTY);
     CheckWriteCoin(VALUE1, VALUE2, FAIL, 0, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(VALUE1, VALUE2, VALUE2, FRESH, DIRTY, DIRTY | FRESH);
     CheckWriteCoin(VALUE1, VALUE2, FAIL, FRESH, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(VALUE1, VALUE2, VALUE2, DIRTY, DIRTY, DIRTY);
     CheckWriteCoin(VALUE1, VALUE2, FAIL, DIRTY, DIRTY | FRESH, NO_ENTRY);
     CheckWriteCoin(VALUE1, VALUE2, VALUE2, DIRTY | FRESH, DIRTY, DIRTY | FRESH);
     CheckWriteCoin(VALUE1, VALUE2, FAIL, DIRTY | FRESH, DIRTY | FRESH,
                    NO_ENTRY);
 
     // The checks above omit cases where the child flags are not DIRTY, since
     // they would be too repetitive (the parent cache is never updated in these
     // cases). The loop below covers these cases and makes sure the parent cache
     // is always left unchanged.
     for (const Amount &parent_value : {ABSENT, PRUNED, VALUE1}) {
         for (const Amount &child_value : {ABSENT, PRUNED, VALUE2}) {
             for (const char parent_flags :
                  parent_value == ABSENT ? ABSENT_FLAGS : FLAGS) {
                 for (const char child_flags :
                      child_value == ABSENT ? ABSENT_FLAGS : CLEAN_FLAGS) {
                     CheckWriteCoin(parent_value, child_value, parent_value,
                                    parent_flags, child_flags, parent_flags);
                 }
             }
         }
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/denialofservice_tests.cpp b/src/test/denialofservice_tests.cpp
index 4184207e8..1290164e2 100644
--- a/src/test/denialofservice_tests.cpp
+++ b/src/test/denialofservice_tests.cpp
@@ -1,481 +1,481 @@
 // 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.
 
 // Unit tests for denial-of-service detection/prevention code
 
 #include <banman.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <keystore.h>
 #include <net.h>
 #include <net_processing.h>
 #include <script/sign.h>
 #include <serialize.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 <cstdint>
 
 struct CConnmanTest : public CConnman {
     using CConnman::CConnman;
     void AddNode(CNode &node) {
         LOCK(cs_vNodes);
         vNodes.push_back(&node);
     }
     void ClearNodes() {
         LOCK(cs_vNodes);
         for (CNode *node : vNodes) {
             delete node;
         }
         vNodes.clear();
     }
 };
 
 // Tests these internal-to-net_processing.cpp methods:
 extern bool AddOrphanTx(const CTransactionRef &tx, NodeId peer);
 extern void EraseOrphansFor(NodeId peer);
 extern unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans);
 
 struct COrphanTx {
     CTransactionRef tx;
     NodeId fromPeer;
     int64_t nTimeExpire;
 };
 extern RecursiveMutex g_cs_orphans;
 extern std::map<uint256, COrphanTx>
     mapOrphanTransactions GUARDED_BY(g_cs_orphans);
 
 static CService ip(uint32_t i) {
     struct in_addr s;
     s.s_addr = i;
     return CService(CNetAddr(s), Params().GetDefaultPort());
 }
 
 static NodeId id = 0;
 
 void UpdateLastBlockAnnounceTime(NodeId node, int64_t time_in_seconds);
 
 BOOST_FIXTURE_TEST_SUITE(denialofservice_tests, TestingSetup)
 
 // Test eviction of an outbound peer whose chain never advances
 // Mock a node connection, and use mocktime to simulate a peer which never sends
 // any headers messages. PeerLogic should decide to evict that outbound peer,
 // after the appropriate timeouts.
 // Note that we protect 4 outbound nodes from being subject to this logic; this
 // test takes advantage of that protection only being applied to nodes which
 // send headers with sufficient work.
 BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction) {
     const Config &config = GetConfig();
     std::atomic<bool> interruptDummy(false);
 
     auto connman = std::make_unique<CConnman>(config, 0x1337, 0x1337);
     auto peerLogic = std::make_unique<PeerLogicValidation>(
         connman.get(), nullptr, scheduler, false);
 
     // Mock an outbound peer
     CAddress addr1(ip(0xa0b0c001), NODE_NONE);
     CNode dummyNode1(id++, ServiceFlags(NODE_NETWORK), 0, INVALID_SOCKET, addr1,
                      0, 0, CAddress(), "",
                      /*fInboundIn=*/false);
     dummyNode1.SetSendVersion(PROTOCOL_VERSION);
 
     peerLogic->InitializeNode(config, &dummyNode1);
     dummyNode1.nVersion = 1;
     dummyNode1.fSuccessfullyConnected = true;
 
     // This test requires that we have a chain with non-zero work.
     {
         LOCK(cs_main);
         BOOST_CHECK(::ChainActive().Tip() != nullptr);
         BOOST_CHECK(::ChainActive().Tip()->nChainWork > 0);
     }
 
     // Test starts here
     {
         LOCK2(cs_main, dummyNode1.cs_sendProcessing);
         // should result in getheaders
         peerLogic->SendMessages(config, &dummyNode1, interruptDummy);
     }
     {
         LOCK2(cs_main, dummyNode1.cs_vSend);
         BOOST_CHECK(dummyNode1.vSendMsg.size() > 0);
         dummyNode1.vSendMsg.clear();
     }
 
     int64_t nStartTime = GetTime();
     // Wait 21 minutes
     SetMockTime(nStartTime + 21 * 60);
     {
         LOCK2(cs_main, dummyNode1.cs_sendProcessing);
         // should result in getheaders
         peerLogic->SendMessages(config, &dummyNode1, interruptDummy);
     }
     {
         LOCK2(cs_main, dummyNode1.cs_vSend);
         BOOST_CHECK(dummyNode1.vSendMsg.size() > 0);
     }
     // Wait 3 more minutes
     SetMockTime(nStartTime + 24 * 60);
     {
         LOCK2(cs_main, dummyNode1.cs_sendProcessing);
         // should result in disconnect
         peerLogic->SendMessages(config, &dummyNode1, interruptDummy);
     }
     BOOST_CHECK(dummyNode1.fDisconnect == true);
     SetMockTime(0);
 
     bool dummy;
     peerLogic->FinalizeNode(config, dummyNode1.GetId(), dummy);
 }
 
 static void AddRandomOutboundPeer(const Config &config,
                                   std::vector<CNode *> &vNodes,
                                   PeerLogicValidation &peerLogic,
                                   CConnmanTest *connman) {
     CAddress addr(ip(g_insecure_rand_ctx.randbits(32)), NODE_NONE);
     vNodes.emplace_back(new CNode(id++, ServiceFlags(NODE_NETWORK), 0,
                                   INVALID_SOCKET, addr, 0, 0, CAddress(), "",
                                   /*fInboundIn=*/false));
     CNode &node = *vNodes.back();
     node.SetSendVersion(PROTOCOL_VERSION);
 
     peerLogic.InitializeNode(config, &node);
     node.nVersion = 1;
     node.fSuccessfullyConnected = true;
 
     connman->AddNode(node);
 }
 
 BOOST_AUTO_TEST_CASE(stale_tip_peer_management) {
     const Config &config = GetConfig();
 
     auto connman = std::make_unique<CConnmanTest>(config, 0x1337, 0x1337);
     auto peerLogic = std::make_unique<PeerLogicValidation>(
         connman.get(), nullptr, scheduler, false);
 
     const Consensus::Params &consensusParams =
         config.GetChainParams().GetConsensus();
     constexpr int nMaxOutbound = 8;
     CConnman::Options options;
     options.nMaxConnections = 125;
     options.nMaxOutbound = nMaxOutbound;
     options.nMaxFeeler = 1;
 
     connman->Init(options);
     std::vector<CNode *> vNodes;
 
     // Mock some outbound peers
     for (int i = 0; i < nMaxOutbound; ++i) {
         AddRandomOutboundPeer(config, vNodes, *peerLogic, connman.get());
     }
 
     peerLogic->CheckForStaleTipAndEvictPeers(consensusParams);
 
     // No nodes should be marked for disconnection while we have no extra peers
     for (const CNode *node : vNodes) {
         BOOST_CHECK(node->fDisconnect == false);
     }
 
     SetMockTime(GetTime() + 3 * consensusParams.nPowTargetSpacing + 1);
 
     // Now tip should definitely be stale, and we should look for an extra
     // outbound peer
     peerLogic->CheckForStaleTipAndEvictPeers(consensusParams);
     BOOST_CHECK(connman->GetTryNewOutboundPeer());
 
     // Still no peers should be marked for disconnection
     for (const CNode *node : vNodes) {
         BOOST_CHECK(node->fDisconnect == false);
     }
 
     // If we add one more peer, something should get marked for eviction
     // on the next check (since we're mocking the time to be in the future, the
     // required time connected check should be satisfied).
     AddRandomOutboundPeer(config, vNodes, *peerLogic, connman.get());
 
     peerLogic->CheckForStaleTipAndEvictPeers(consensusParams);
     for (int i = 0; i < nMaxOutbound; ++i) {
         BOOST_CHECK(vNodes[i]->fDisconnect == false);
     }
     // Last added node should get marked for eviction
     BOOST_CHECK(vNodes.back()->fDisconnect == true);
 
     vNodes.back()->fDisconnect = false;
 
     // Update the last announced block time for the last
     // peer, and check that the next newest node gets evicted.
     UpdateLastBlockAnnounceTime(vNodes.back()->GetId(), GetTime());
 
     peerLogic->CheckForStaleTipAndEvictPeers(consensusParams);
     for (int i = 0; i < nMaxOutbound - 1; ++i) {
         BOOST_CHECK(vNodes[i]->fDisconnect == false);
     }
     BOOST_CHECK(vNodes[nMaxOutbound - 1]->fDisconnect == true);
     BOOST_CHECK(vNodes.back()->fDisconnect == false);
 
     bool dummy;
     for (const CNode *node : vNodes) {
         peerLogic->FinalizeNode(config, node->GetId(), dummy);
     }
 
     connman->ClearNodes();
 }
 
 BOOST_AUTO_TEST_CASE(DoS_banning) {
     const Config &config = GetConfig();
     std::atomic<bool> interruptDummy(false);
 
     auto banman = std::make_unique<BanMan>(GetDataDir() / "banlist.dat",
                                            config.GetChainParams(), nullptr,
                                            DEFAULT_MISBEHAVING_BANTIME);
     auto connman = std::make_unique<CConnman>(config, 0x1337, 0x1337);
     auto peerLogic = std::make_unique<PeerLogicValidation>(
         connman.get(), banman.get(), scheduler, false);
 
     banman->ClearBanned();
     CAddress addr1(ip(0xa0b0c001), NODE_NONE);
     CNode dummyNode1(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr1, 0, 0,
                      CAddress(), "", true);
     dummyNode1.SetSendVersion(PROTOCOL_VERSION);
     peerLogic->InitializeNode(config, &dummyNode1);
     dummyNode1.nVersion = 1;
     dummyNode1.fSuccessfullyConnected = true;
     {
         LOCK(cs_main);
         // Should get banned.
         Misbehaving(dummyNode1.GetId(), 100, "");
     }
     {
         LOCK2(cs_main, dummyNode1.cs_sendProcessing);
         peerLogic->SendMessages(config, &dummyNode1, interruptDummy);
     }
     BOOST_CHECK(banman->IsBanned(addr1));
     // Different IP, not banned.
     BOOST_CHECK(!banman->IsBanned(ip(0xa0b0c001 | 0x0000ff00)));
 
     CAddress addr2(ip(0xa0b0c002), NODE_NONE);
     CNode dummyNode2(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr2, 1, 1,
                      CAddress(), "", true);
     dummyNode2.SetSendVersion(PROTOCOL_VERSION);
     peerLogic->InitializeNode(config, &dummyNode2);
     dummyNode2.nVersion = 1;
     dummyNode2.fSuccessfullyConnected = true;
     {
         LOCK(cs_main);
         Misbehaving(dummyNode2.GetId(), 50, "");
     }
     {
         LOCK2(cs_main, dummyNode2.cs_sendProcessing);
         peerLogic->SendMessages(config, &dummyNode2, interruptDummy);
     }
     // 2 not banned yet...
     BOOST_CHECK(!banman->IsBanned(addr2));
     // ... but 1 still should be.
     BOOST_CHECK(banman->IsBanned(addr1));
     {
         LOCK(cs_main);
         Misbehaving(dummyNode2.GetId(), 50, "");
     }
     {
         LOCK2(cs_main, dummyNode2.cs_sendProcessing);
         peerLogic->SendMessages(config, &dummyNode2, interruptDummy);
     }
     BOOST_CHECK(banman->IsBanned(addr2));
 
     bool dummy;
     peerLogic->FinalizeNode(config, dummyNode1.GetId(), dummy);
     peerLogic->FinalizeNode(config, dummyNode2.GetId(), dummy);
 }
 
 BOOST_AUTO_TEST_CASE(DoS_banscore) {
     const Config &config = GetConfig();
     std::atomic<bool> interruptDummy(false);
 
     auto banman = std::make_unique<BanMan>(GetDataDir() / "banlist.dat",
                                            config.GetChainParams(), nullptr,
                                            DEFAULT_MISBEHAVING_BANTIME);
     auto connman = std::make_unique<CConnman>(config, 0x1337, 0x1337);
     auto peerLogic = std::make_unique<PeerLogicValidation>(
         connman.get(), banman.get(), scheduler, false);
 
     banman->ClearBanned();
     // because 11 is my favorite number.
     gArgs.ForceSetArg("-banscore", "111");
     CAddress addr1(ip(0xa0b0c001), NODE_NONE);
     CNode dummyNode1(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr1, 3, 1,
                      CAddress(), "", true);
     dummyNode1.SetSendVersion(PROTOCOL_VERSION);
     peerLogic->InitializeNode(config, &dummyNode1);
     dummyNode1.nVersion = 1;
     dummyNode1.fSuccessfullyConnected = true;
     {
         LOCK(cs_main);
         Misbehaving(dummyNode1.GetId(), 100, "");
     }
     {
         LOCK2(cs_main, dummyNode1.cs_sendProcessing);
         peerLogic->SendMessages(config, &dummyNode1, interruptDummy);
     }
     BOOST_CHECK(!banman->IsBanned(addr1));
     {
         LOCK(cs_main);
         Misbehaving(dummyNode1.GetId(), 10, "");
     }
     {
         LOCK2(cs_main, dummyNode1.cs_sendProcessing);
         peerLogic->SendMessages(config, &dummyNode1, interruptDummy);
     }
     BOOST_CHECK(!banman->IsBanned(addr1));
     {
         LOCK(cs_main);
         Misbehaving(dummyNode1.GetId(), 1, "");
     }
     {
         LOCK2(cs_main, dummyNode1.cs_sendProcessing);
         peerLogic->SendMessages(config, &dummyNode1, interruptDummy);
     }
     BOOST_CHECK(banman->IsBanned(addr1));
     gArgs.ForceSetArg("-banscore", std::to_string(DEFAULT_BANSCORE_THRESHOLD));
 
     bool dummy;
     peerLogic->FinalizeNode(config, dummyNode1.GetId(), dummy);
 }
 
 BOOST_AUTO_TEST_CASE(DoS_bantime) {
     const Config &config = GetConfig();
     std::atomic<bool> interruptDummy(false);
 
     auto banman = std::make_unique<BanMan>(GetDataDir() / "banlist.dat",
                                            config.GetChainParams(), nullptr,
                                            DEFAULT_MISBEHAVING_BANTIME);
     auto connman = std::make_unique<CConnman>(config, 0x1337, 0x1337);
     auto peerLogic = std::make_unique<PeerLogicValidation>(
         connman.get(), banman.get(), scheduler, false);
 
     banman->ClearBanned();
     int64_t nStartTime = GetTime();
     // Overrides future calls to GetTime()
     SetMockTime(nStartTime);
 
     CAddress addr(ip(0xa0b0c001), NODE_NONE);
     CNode dummyNode(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr, 4, 4,
                     CAddress(), "", true);
     dummyNode.SetSendVersion(PROTOCOL_VERSION);
     peerLogic->InitializeNode(config, &dummyNode);
     dummyNode.nVersion = 1;
     dummyNode.fSuccessfullyConnected = true;
 
     {
         LOCK(cs_main);
         Misbehaving(dummyNode.GetId(), 100, "");
     }
     {
         LOCK2(cs_main, dummyNode.cs_sendProcessing);
         peerLogic->SendMessages(config, &dummyNode, interruptDummy);
     }
     BOOST_CHECK(banman->IsBanned(addr));
 
     SetMockTime(nStartTime + 60 * 60);
     BOOST_CHECK(banman->IsBanned(addr));
 
     SetMockTime(nStartTime + 60 * 60 * 24 + 1);
     BOOST_CHECK(!banman->IsBanned(addr));
 
     bool dummy;
     peerLogic->FinalizeNode(config, dummyNode.GetId(), dummy);
 }
 
 static CTransactionRef RandomOrphan() {
     std::map<uint256, COrphanTx>::iterator it;
     LOCK2(cs_main, g_cs_orphans);
     it = mapOrphanTransactions.lower_bound(InsecureRand256());
     if (it == mapOrphanTransactions.end()) {
         it = mapOrphanTransactions.begin();
     }
     return it->second.tx;
 }
 
 BOOST_AUTO_TEST_CASE(DoS_mapOrphans) {
     CKey key;
     key.MakeNewKey(true);
     CBasicKeyStore keystore;
     keystore.AddKey(key);
 
     // 50 orphan transactions:
     for (int i = 0; i < 50; i++) {
         CMutableTransaction tx;
         tx.vin.resize(1);
         tx.vin[0].prevout = COutPoint(TxId(InsecureRand256()), 0);
         tx.vin[0].scriptSig << OP_1;
         tx.vout.resize(1);
         tx.vout[0].nValue = 1 * CENT;
         tx.vout[0].scriptPubKey =
-            GetScriptForDestination(key.GetPubKey().GetID());
+            GetScriptForDestination(PKHash(key.GetPubKey()));
 
         AddOrphanTx(MakeTransactionRef(tx), i);
     }
 
     // ... and 50 that depend on other orphans:
     for (int i = 0; i < 50; i++) {
         CTransactionRef txPrev = RandomOrphan();
 
         CMutableTransaction tx;
         tx.vin.resize(1);
         tx.vin[0].prevout = COutPoint(txPrev->GetId(), 0);
         tx.vout.resize(1);
         tx.vout[0].nValue = 1 * CENT;
         tx.vout[0].scriptPubKey =
-            GetScriptForDestination(key.GetPubKey().GetID());
+            GetScriptForDestination(PKHash(key.GetPubKey()));
         SignSignature(keystore, *txPrev, tx, 0, SigHashType());
 
         AddOrphanTx(MakeTransactionRef(tx), i);
     }
 
     // This really-big orphan should be ignored:
     for (int i = 0; i < 10; i++) {
         CTransactionRef txPrev = RandomOrphan();
 
         CMutableTransaction tx;
         tx.vout.resize(1);
         tx.vout[0].nValue = 1 * CENT;
         tx.vout[0].scriptPubKey =
-            GetScriptForDestination(key.GetPubKey().GetID());
+            GetScriptForDestination(PKHash(key.GetPubKey()));
         tx.vin.resize(2777);
         for (size_t j = 0; j < tx.vin.size(); j++) {
             tx.vin[j].prevout = COutPoint(txPrev->GetId(), j);
         }
         SignSignature(keystore, *txPrev, tx, 0, SigHashType());
         // Re-use same signature for other inputs
         // (they don't have to be valid for this test)
         for (unsigned int j = 1; j < tx.vin.size(); j++) {
             tx.vin[j].scriptSig = tx.vin[0].scriptSig;
         }
 
         BOOST_CHECK(!AddOrphanTx(MakeTransactionRef(tx), i));
     }
 
     LOCK2(cs_main, g_cs_orphans);
     // Test EraseOrphansFor:
     for (NodeId i = 0; i < 3; i++) {
         size_t sizeBefore = mapOrphanTransactions.size();
         EraseOrphansFor(i);
         BOOST_CHECK(mapOrphanTransactions.size() < sizeBefore);
     }
 
     // Test LimitOrphanTxSize() function:
     LimitOrphanTxSize(40);
     BOOST_CHECK(mapOrphanTransactions.size() <= 40);
     LimitOrphanTxSize(10);
     BOOST_CHECK(mapOrphanTransactions.size() <= 10);
     LimitOrphanTxSize(0);
     BOOST_CHECK(mapOrphanTransactions.empty());
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/dstencode_tests.cpp b/src/test/dstencode_tests.cpp
index 2f6b64c24..be024d86b 100644
--- a/src/test/dstencode_tests.cpp
+++ b/src/test/dstencode_tests.cpp
@@ -1,71 +1,71 @@
 // 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 <key_io.h>
 
 #include <chainparams.h>
 #include <config.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 namespace {
 
 class DummyCashAddrConfig : public DummyConfig {
 public:
     DummyCashAddrConfig()
         : DummyConfig(CBaseChainParams::MAIN), useCashAddr(false) {}
     void SetCashAddrEncoding(bool b) override { useCashAddr = b; }
     bool UseCashAddrEncoding() const override { return useCashAddr; }
 
 private:
     bool useCashAddr;
 };
 
 } // namespace
 
 BOOST_FIXTURE_TEST_SUITE(dstencode_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(test_addresses) {
     std::vector<uint8_t> hash = {118, 160, 64,  83,  189, 160, 168,
                                  139, 218, 81,  119, 184, 106, 21,
                                  195, 178, 159, 85,  152, 115};
 
-    const CTxDestination dstKey = CKeyID(uint160(hash));
-    const CTxDestination dstScript = CScriptID(uint160(hash));
+    const CTxDestination dstKey = PKHash(uint160(hash));
+    const CTxDestination dstScript = ScriptHash(uint160(hash));
 
     std::string cashaddr_pubkey =
         "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a";
     std::string cashaddr_script =
         "bitcoincash:ppm2qsznhks23z7629mms6s4cwef74vcwvn0h829pq";
     std::string base58_pubkey = "1BpEi6DfDAUFd7GtittLSdBeYJvcoaVggu";
     std::string base58_script = "3CWFddi6m4ndiGyKqzYvsFYagqDLPVMTzC";
 
     DummyCashAddrConfig config;
 
     // Check encoding
     config.SetCashAddrEncoding(true);
     BOOST_CHECK_EQUAL(cashaddr_pubkey, EncodeDestination(dstKey, config));
     BOOST_CHECK_EQUAL(cashaddr_script, EncodeDestination(dstScript, config));
     config.SetCashAddrEncoding(false);
     BOOST_CHECK_EQUAL(base58_pubkey, EncodeDestination(dstKey, config));
     BOOST_CHECK_EQUAL(base58_script, EncodeDestination(dstScript, config));
 
     // Check decoding
     const CChainParams &params = config.GetChainParams();
     BOOST_CHECK(dstKey == DecodeDestination(cashaddr_pubkey, params));
     BOOST_CHECK(dstScript == DecodeDestination(cashaddr_script, params));
     BOOST_CHECK(dstKey == DecodeDestination(base58_pubkey, params));
     BOOST_CHECK(dstScript == DecodeDestination(base58_script, params));
 
     // Validation
     BOOST_CHECK(IsValidDestinationString(cashaddr_pubkey, params));
     BOOST_CHECK(IsValidDestinationString(cashaddr_script, params));
     BOOST_CHECK(IsValidDestinationString(base58_pubkey, params));
     BOOST_CHECK(IsValidDestinationString(base58_script, params));
     BOOST_CHECK(!IsValidDestinationString("notvalid", params));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/key_tests.cpp b/src/test/key_tests.cpp
index 44968dd31..9f3c18f19 100644
--- a/src/test/key_tests.cpp
+++ b/src/test/key_tests.cpp
@@ -1,332 +1,332 @@
 // 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/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 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(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(pubkey1.GetID()));
+                CTxDestination(PKHash(pubkey1)));
     BOOST_CHECK(DecodeDestination(addr2, chainParams) ==
-                CTxDestination(pubkey2.GetID()));
+                CTxDestination(PKHash(pubkey2)));
     BOOST_CHECK(DecodeDestination(addr1C, chainParams) ==
-                CTxDestination(pubkey1C.GetID()));
+                CTxDestination(PKHash(pubkey1C)));
     BOOST_CHECK(DecodeDestination(addr2C, chainParams) ==
-                CTxDestination(pubkey2C.GetID()));
+                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();
         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_hash = Hash(msg.begin(), msg.end());
         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_SUITE_END()
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index e1dc69265..1c48b495e 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -1,738 +1,738 @@
 // 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/system.h>
 #include <util/time.h>
 #include <validation.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <memory>
 
 BOOST_FIXTURE_TEST_SUITE(miner_tests, TestingSetup)
 
 // 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);
 
 static BlockAssembler AssemblerForTest(const CChainParams &params,
                                        const CTxMemPool &mempool) {
     BlockAssembler::Options options;
     options.blockMinFeeRate = blockMinFeeRate;
     return BlockAssembler(params, mempool, options);
 }
 
 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;
 }
 
 static bool TestSequenceLocks(const CTransaction &tx, int flags)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     LOCK(::g_mempool.cs);
     return CheckSequenceLocks(::g_mempool, tx, flags);
 }
 
 // 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.
 static void TestPackageSelection(const CChainParams &chainparams,
                                  const CScript &scriptPubKey,
                                  const std::vector<CTransactionRef> &txFirst)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main, ::g_mempool.cs) {
     // 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();
     g_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();
     g_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();
     g_mempool.addUnchecked(entry.Fee(50000 * SATOSHI)
                                .Time(GetTime())
                                .SpendsCoinbase(false)
                                .FromTx(tx));
 
     std::unique_ptr<CBlockTemplate> pblocktemplate =
         AssemblerForTest(chainparams, g_mempool).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();
     g_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();
     g_mempool.addUnchecked(entry.Fee(feeToUse).FromTx(tx));
     pblocktemplate =
         AssemblerForTest(chainparams, g_mempool).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
     g_mempool.removeRecursive(CTransaction(tx));
     // Now we should be just over the min relay fee.
     tx.vout[0].nValue -= 2 * SATOSHI;
     lowFeeTxId = tx.GetId();
     g_mempool.addUnchecked(entry.Fee(feeToUse + 2 * SATOSHI).FromTx(tx));
     pblocktemplate =
         AssemblerForTest(chainparams, g_mempool).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();
     g_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();
     g_mempool.addUnchecked(
         entry.Fee(feeToUse).SpendsCoinbase(false).FromTx(tx));
     pblocktemplate =
         AssemblerForTest(chainparams, g_mempool).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;
     g_mempool.addUnchecked(entry.Fee(10000 * SATOSHI).FromTx(tx));
     pblocktemplate =
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey);
     BOOST_CHECK(pblocktemplate->block.vtx[8]->GetId() == lowFeeTxId2);
 }
 
 void TestCoinbaseMessageEB(uint64_t eb, std::string cbmsg) {
     GlobalConfig config;
     config.SetMaxBlockSize(eb);
 
     CScript scriptPubKey =
         CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112"
                               "de5c384df7ba0b8d578a4c702b6bf11d5f")
                   << OP_CHECKSIG;
 
     std::unique_ptr<CBlockTemplate> pblocktemplate =
         BlockAssembler(config, g_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_FLAGS));
 }
 
 // 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/");
     TestCoinbaseMessageEB(2000000, "/EB2.0/");
     TestCoinbaseMessageEB(8000000, "/EB8.0/");
     TestCoinbaseMessageEB(8320000, "/EB8.3/");
 }
 
 // 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, g_mempool)
                                      .CreateNewBlock(scriptPubKey));
 
     // We can't make transactions until we have inputs.
     // Therefore, load 100 blocks :)
     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(ProcessNewBlock(config, shared_pblock, true, nullptr));
         pblock->hashPrevBlock = pblock->GetHash();
     }
 
     LOCK(cs_main);
     LOCK(::g_mempool.cs);
 
     // Just to make sure we can still make simple blocks.
     BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams, g_mempool)
                                      .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;
         g_mempool.addUnchecked(entry.Fee(LOWFEE)
                                    .Time(GetTime())
                                    .SpendsCoinbase(spendsCoinbase)
                                    .FromTx(tx));
         tx.vin[0].prevout = COutPoint(txid, 0);
     }
 
     BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams, g_mempool)
                                      .CreateNewBlock(scriptPubKey));
     g_mempool.clear();
 
     // Orphan in mempool, template creation fails.
     g_mempool.addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).FromTx(tx));
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
     g_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();
     g_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();
     g_mempool.addUnchecked(
         entry.Fee(HIGHERFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams, g_mempool)
                                      .CreateNewBlock(scriptPubKey));
     g_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.
     g_mempool.addUnchecked(
         entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
     // Should throw bad-tx-coinbase
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("bad-tx-coinbase"));
     g_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();
     g_mempool.addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     tx.vout[0].scriptPubKey = CScript() << OP_2;
     txid = tx.GetId();
     g_mempool.addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
     g_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());
         pcoinsTip->SetBestBlock(next->GetBlockHash());
         next->pprev = prev;
         next->nHeight = prev->nHeight + 1;
         next->BuildSkip();
         ::ChainActive().SetTip(next);
     }
     BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams, g_mempool)
                                      .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());
         pcoinsTip->SetBestBlock(next->GetBlockHash());
         next->pprev = prev;
         next->nHeight = prev->nHeight + 1;
         next->BuildSkip();
         ::ChainActive().SetTip(next);
     }
 
     BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams, g_mempool)
                                      .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(CScriptID(script));
+    tx.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(script));
     txid = tx.GetId();
     g_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();
     g_mempool.addUnchecked(
         entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
     // Should throw blk-bad-inputs
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("blk-bad-inputs"));
     g_mempool.clear();
 
     // Delete the dummy blocks again.
     while (::ChainActive().Tip()->nHeight > nHeight) {
         CBlockIndex *del = ::ChainActive().Tip();
         ::ChainActive().SetTip(del->pprev);
         pcoinsTip->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();
     g_mempool.addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
 
     const Consensus::Params &params = chainparams.GetConsensus();
 
     {
         // Locktime passes.
         CValidationState 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();
     g_mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx));
 
     {
         // Locktime passes.
         CValidationState 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();
     g_mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx));
 
     {
         // Locktime fails.
         CValidationState 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.
         CValidationState 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();
     g_mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx));
 
     {
         // Locktime fails.
         CValidationState 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.
         CValidationState 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.
         CValidationState 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, g_mempool).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, g_mempool)
                                      .CreateNewBlock(scriptPubKey));
     BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 5UL);
 
     ::ChainActive().Tip()->nHeight--;
     SetMockTime(0);
     g_mempool.clear();
 
     TestPackageSelection(chainparams, scriptPubKey, txFirst);
 
     fCheckpointsEnabled = true;
 }
 
 void CheckBlockMaxSize(const Config &config, uint64_t size, uint64_t expected) {
     gArgs.ForceSetArg("-blockmaxsize", std::to_string(size));
 
     BlockAssembler ba(config, g_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, 0, 1000);
     CheckBlockMaxSize(config, 1000, 1000);
     CheckBlockMaxSize(config, 1001, 1001);
     CheckBlockMaxSize(config, 12345, 12345);
 
     CheckBlockMaxSize(config, ONE_MEGABYTE - 1001, ONE_MEGABYTE - 1001);
     CheckBlockMaxSize(config, ONE_MEGABYTE - 1000, ONE_MEGABYTE - 1000);
     CheckBlockMaxSize(config, ONE_MEGABYTE - 999, ONE_MEGABYTE - 999);
     CheckBlockMaxSize(config, 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, DEFAULT_MAX_BLOCK_SIZE - 1001,
                       DEFAULT_MAX_BLOCK_SIZE - 1001);
     CheckBlockMaxSize(config, DEFAULT_MAX_BLOCK_SIZE - 1000,
                       DEFAULT_MAX_BLOCK_SIZE - 1000);
     CheckBlockMaxSize(config, DEFAULT_MAX_BLOCK_SIZE - 999,
                       DEFAULT_MAX_BLOCK_SIZE - 1000);
     CheckBlockMaxSize(config, 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, g_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/script_p2sh_tests.cpp b/src/test/script_p2sh_tests.cpp
index ca68ac74b..f709946f6 100644
--- a/src/test/script_p2sh_tests.cpp
+++ b/src/test/script_p2sh_tests.cpp
@@ -1,385 +1,387 @@
 // 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 <consensus/tx_verify.h>
 #include <key.h>
 #include <keystore.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <script/ismine.h>
 #include <script/script.h>
 #include <script/script_error.h>
 #include <script/sign.h>
 #include <tinyformat.h>
 #include <validation.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <vector>
 
 // Helpers:
 static std::vector<uint8_t> Serialize(const CScript &s) {
     std::vector<uint8_t> sSerialized(s.begin(), s.end());
     return sSerialized;
 }
 
 static bool Verify(const CScript &scriptSig, const CScript &scriptPubKey,
                    bool fStrict, ScriptError &err) {
     // Create dummy to/from transactions:
     CMutableTransaction txFrom;
     txFrom.vout.resize(1);
     txFrom.vout[0].scriptPubKey = scriptPubKey;
 
     CMutableTransaction txTo;
     txTo.vin.resize(1);
     txTo.vout.resize(1);
     txTo.vin[0].prevout = COutPoint(txFrom.GetId(), 0);
     txTo.vin[0].scriptSig = scriptSig;
     txTo.vout[0].nValue = SATOSHI;
 
     return VerifyScript(
         scriptSig, scriptPubKey,
         (fStrict ? SCRIPT_VERIFY_P2SH : SCRIPT_VERIFY_NONE) |
             SCRIPT_ENABLE_SIGHASH_FORKID,
         MutableTransactionSignatureChecker(&txTo, 0, txFrom.vout[0].nValue),
         &err);
 }
 
 BOOST_FIXTURE_TEST_SUITE(script_p2sh_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(sign) {
     LOCK(cs_main);
     // Pay-to-script-hash looks like this:
     // scriptSig:    <sig> <sig...> <serialized_script>
     // scriptPubKey: HASH160 <hash> EQUAL
 
     // Test SignSignature() (and therefore the version of Solver() that signs
     // transactions)
     CBasicKeyStore keystore;
     CKey key[4];
     for (int i = 0; i < 4; i++) {
         key[i].MakeNewKey(true);
         keystore.AddKey(key[i]);
     }
 
     // 8 Scripts: checking all combinations of
     // different keys, straight/P2SH, pubkey/pubkeyhash
     CScript standardScripts[4];
     standardScripts[0] << ToByteVector(key[0].GetPubKey()) << OP_CHECKSIG;
-    standardScripts[1] = GetScriptForDestination(key[1].GetPubKey().GetID());
+    standardScripts[1] = GetScriptForDestination(PKHash(key[1].GetPubKey()));
     standardScripts[2] << ToByteVector(key[1].GetPubKey()) << OP_CHECKSIG;
-    standardScripts[3] = GetScriptForDestination(key[2].GetPubKey().GetID());
+    standardScripts[3] = GetScriptForDestination(PKHash(key[2].GetPubKey()));
     CScript evalScripts[4];
     for (int i = 0; i < 4; i++) {
         keystore.AddCScript(standardScripts[i]);
-        evalScripts[i] = GetScriptForDestination(CScriptID(standardScripts[i]));
+        evalScripts[i] =
+            GetScriptForDestination(ScriptHash(standardScripts[i]));
     }
 
     // Funding transaction:
     CMutableTransaction txFrom;
     std::string reason;
     txFrom.vout.resize(8);
     for (int i = 0; i < 4; i++) {
         txFrom.vout[i].scriptPubKey = evalScripts[i];
         txFrom.vout[i].nValue = COIN;
         txFrom.vout[i + 4].scriptPubKey = standardScripts[i];
         txFrom.vout[i + 4].nValue = COIN;
     }
     BOOST_CHECK(IsStandardTx(CTransaction(txFrom), reason));
 
     // Spending transactions
     CMutableTransaction txTo[8];
     for (int i = 0; i < 8; i++) {
         txTo[i].vin.resize(1);
         txTo[i].vout.resize(1);
         txTo[i].vin[0].prevout = COutPoint(txFrom.GetId(), i);
         txTo[i].vout[0].nValue = SATOSHI;
         BOOST_CHECK_MESSAGE(IsMine(keystore, txFrom.vout[i].scriptPubKey),
                             strprintf("IsMine %d", i));
     }
 
     for (int i = 0; i < 8; i++) {
         BOOST_CHECK_MESSAGE(SignSignature(keystore, CTransaction(txFrom),
                                           txTo[i], 0,
                                           SigHashType().withForkId()),
                             strprintf("SignSignature %d", i));
     }
 
     // All of the above should be OK, and the txTos have valid signatures
     // Check to make sure signature verification fails if we use the wrong
     // ScriptSig:
     for (int i = 0; i < 8; i++) {
         CTransaction tx(txTo[i]);
         PrecomputedTransactionData txdata(tx);
         for (int j = 0; j < 8; j++) {
             CScript sigSave = txTo[i].vin[0].scriptSig;
             txTo[i].vin[0].scriptSig = txTo[j].vin[0].scriptSig;
             const CTxOut &output = txFrom.vout[txTo[i].vin[0].prevout.GetN()];
             bool sigOK = CScriptCheck(
                 output.scriptPubKey, output.nValue, CTransaction(txTo[i]), 0,
                 SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC |
                     SCRIPT_ENABLE_SIGHASH_FORKID,
                 false, txdata)();
             if (i == j) {
                 BOOST_CHECK_MESSAGE(sigOK,
                                     strprintf("VerifySignature %d %d", i, j));
             } else {
                 BOOST_CHECK_MESSAGE(!sigOK,
                                     strprintf("VerifySignature %d %d", i, j));
             }
             txTo[i].vin[0].scriptSig = sigSave;
         }
     }
 }
 
 BOOST_AUTO_TEST_CASE(norecurse) {
     ScriptError err;
     // Make sure only the outer pay-to-script-hash does the
     // extra-validation thing:
     CScript invalidAsScript;
     invalidAsScript << OP_INVALIDOPCODE << OP_INVALIDOPCODE;
 
-    CScript p2sh = GetScriptForDestination(CScriptID(invalidAsScript));
+    CScript p2sh = GetScriptForDestination(ScriptHash(invalidAsScript));
 
     CScript scriptSig;
     scriptSig << Serialize(invalidAsScript);
 
     // Should not verify, because it will try to execute OP_INVALIDOPCODE
     BOOST_CHECK(!Verify(scriptSig, p2sh, true, err));
     BOOST_CHECK_MESSAGE(err == ScriptError::BAD_OPCODE, ScriptErrorString(err));
 
     // Try to recur, and verification should succeed because
     // the inner HASH160 <> EQUAL should only check the hash:
-    CScript p2sh2 = GetScriptForDestination(CScriptID(p2sh));
+    CScript p2sh2 = GetScriptForDestination(ScriptHash(p2sh));
     CScript scriptSig2;
     scriptSig2 << Serialize(invalidAsScript) << Serialize(p2sh);
 
     BOOST_CHECK(Verify(scriptSig2, p2sh2, true, err));
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 }
 
 BOOST_AUTO_TEST_CASE(set) {
     LOCK(cs_main);
     // Test the CScript::Set* methods
     CBasicKeyStore keystore;
     CKey key[4];
     std::vector<CPubKey> keys;
     for (int i = 0; i < 4; i++) {
         key[i].MakeNewKey(true);
         keystore.AddKey(key[i]);
         keys.push_back(key[i].GetPubKey());
     }
 
     CScript inner[4];
-    inner[0] = GetScriptForDestination(key[0].GetPubKey().GetID());
+    inner[0] = GetScriptForDestination(PKHash(key[0].GetPubKey()));
     inner[1] = GetScriptForMultisig(
         2, std::vector<CPubKey>(keys.begin(), keys.begin() + 2));
     inner[2] = GetScriptForMultisig(
         1, std::vector<CPubKey>(keys.begin(), keys.begin() + 2));
     inner[3] = GetScriptForMultisig(
         2, std::vector<CPubKey>(keys.begin(), keys.begin() + 3));
 
     CScript outer[4];
     for (int i = 0; i < 4; i++) {
-        outer[i] = GetScriptForDestination(CScriptID(inner[i]));
+        outer[i] = GetScriptForDestination(ScriptHash(inner[i]));
         keystore.AddCScript(inner[i]);
     }
 
     // Funding transaction:
     CMutableTransaction txFrom;
     std::string reason;
     txFrom.vout.resize(4);
     for (int i = 0; i < 4; i++) {
         txFrom.vout[i].scriptPubKey = outer[i];
         txFrom.vout[i].nValue = CENT;
     }
     BOOST_CHECK(IsStandardTx(CTransaction(txFrom), reason));
 
     // Spending transactions
     CMutableTransaction txTo[4];
     for (int i = 0; i < 4; i++) {
         txTo[i].vin.resize(1);
         txTo[i].vout.resize(1);
         txTo[i].vin[0].prevout = COutPoint(txFrom.GetId(), i);
         txTo[i].vout[0].nValue = 1 * CENT;
         txTo[i].vout[0].scriptPubKey = inner[i];
         BOOST_CHECK_MESSAGE(IsMine(keystore, txFrom.vout[i].scriptPubKey),
                             strprintf("IsMine %d", i));
     }
     for (int i = 0; i < 4; i++) {
         BOOST_CHECK_MESSAGE(SignSignature(keystore, CTransaction(txFrom),
                                           txTo[i], 0,
                                           SigHashType().withForkId()),
                             strprintf("SignSignature %d", i));
         BOOST_CHECK_MESSAGE(IsStandardTx(CTransaction(txTo[i]), reason),
                             strprintf("txTo[%d].IsStandard", i));
     }
 }
 
 BOOST_AUTO_TEST_CASE(is) {
     // Test CScript::IsPayToScriptHash()
     uint160 dummy;
     CScript p2sh;
     p2sh << OP_HASH160 << ToByteVector(dummy) << OP_EQUAL;
     BOOST_CHECK(p2sh.IsPayToScriptHash());
 
     // Not considered pay-to-script-hash if using one of the OP_PUSHDATA
     // opcodes:
     static const uint8_t direct[] = {OP_HASH160, 20, 0, 0, 0, 0, 0,       0,
                                      0,          0,  0, 0, 0, 0, 0,       0,
                                      0,          0,  0, 0, 0, 0, OP_EQUAL};
     BOOST_CHECK(CScript(direct, direct + sizeof(direct)).IsPayToScriptHash());
     static const uint8_t pushdata1[] = {OP_HASH160, OP_PUSHDATA1,
                                         20,         0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          OP_EQUAL};
     BOOST_CHECK(
         !CScript(pushdata1, pushdata1 + sizeof(pushdata1)).IsPayToScriptHash());
     static const uint8_t pushdata2[] = {OP_HASH160, OP_PUSHDATA2,
                                         20,         0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         OP_EQUAL};
     BOOST_CHECK(
         !CScript(pushdata2, pushdata2 + sizeof(pushdata2)).IsPayToScriptHash());
     static const uint8_t pushdata4[] = {OP_HASH160, OP_PUSHDATA4,
                                         20,         0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         0,          0,
                                         OP_EQUAL};
     BOOST_CHECK(
         !CScript(pushdata4, pushdata4 + sizeof(pushdata4)).IsPayToScriptHash());
 
     CScript not_p2sh;
     BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
 
     not_p2sh.clear();
     not_p2sh << OP_HASH160 << ToByteVector(dummy) << ToByteVector(dummy)
              << OP_EQUAL;
     BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
 
     not_p2sh.clear();
     not_p2sh << OP_NOP << ToByteVector(dummy) << OP_EQUAL;
     BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
 
     not_p2sh.clear();
     not_p2sh << OP_HASH160 << ToByteVector(dummy) << OP_CHECKSIG;
     BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
 }
 
 BOOST_AUTO_TEST_CASE(switchover) {
     // Test switch over code
     CScript notValid;
     ScriptError err;
     notValid << OP_11 << OP_12 << OP_EQUALVERIFY;
     CScript scriptSig;
     scriptSig << Serialize(notValid);
 
-    CScript fund = GetScriptForDestination(CScriptID(notValid));
+    CScript fund = GetScriptForDestination(ScriptHash(notValid));
 
     // Validation should succeed under old rules (hash is correct):
     BOOST_CHECK(Verify(scriptSig, fund, false, err));
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
     // Fail under new:
     BOOST_CHECK(!Verify(scriptSig, fund, true, err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EQUALVERIFY,
                         ScriptErrorString(err));
 }
 
 BOOST_AUTO_TEST_CASE(AreInputsStandard) {
     LOCK(cs_main);
     CCoinsView coinsDummy;
     CCoinsViewCache coins(&coinsDummy);
     CBasicKeyStore keystore;
     CKey key[6];
     std::vector<CPubKey> keys;
     for (int i = 0; i < 6; i++) {
         key[i].MakeNewKey(true);
         keystore.AddKey(key[i]);
     }
     for (int i = 0; i < 3; i++) {
         keys.push_back(key[i].GetPubKey());
     }
 
     CMutableTransaction txFrom;
     txFrom.vout.resize(4);
 
     // First three are standard:
-    CScript pay1 = GetScriptForDestination(key[0].GetPubKey().GetID());
+    CScript pay1 = GetScriptForDestination(PKHash(key[0].GetPubKey()));
     keystore.AddCScript(pay1);
     CScript pay1of3 = GetScriptForMultisig(1, keys);
 
     // P2SH (OP_CHECKSIG)
-    txFrom.vout[0].scriptPubKey = GetScriptForDestination(CScriptID(pay1));
+    txFrom.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(pay1));
     txFrom.vout[0].nValue = 1000 * SATOSHI;
     // ordinary OP_CHECKSIG
     txFrom.vout[1].scriptPubKey = pay1;
     txFrom.vout[1].nValue = 2000 * SATOSHI;
     // ordinary OP_CHECKMULTISIG
     txFrom.vout[2].scriptPubKey = pay1of3;
     txFrom.vout[2].nValue = 3000 * SATOSHI;
 
     // vout[3] is complicated 1-of-3 AND 2-of-3
     // ... that is OK if wrapped in P2SH:
     CScript oneAndTwo;
     oneAndTwo << OP_1 << ToByteVector(key[0].GetPubKey())
               << ToByteVector(key[1].GetPubKey())
               << ToByteVector(key[2].GetPubKey());
     oneAndTwo << OP_3 << OP_CHECKMULTISIGVERIFY;
     oneAndTwo << OP_2 << ToByteVector(key[3].GetPubKey())
               << ToByteVector(key[4].GetPubKey())
               << ToByteVector(key[5].GetPubKey());
     oneAndTwo << OP_3 << OP_CHECKMULTISIG;
     keystore.AddCScript(oneAndTwo);
-    txFrom.vout[3].scriptPubKey = GetScriptForDestination(CScriptID(oneAndTwo));
+    txFrom.vout[3].scriptPubKey =
+        GetScriptForDestination(ScriptHash(oneAndTwo));
     txFrom.vout[3].nValue = 4000 * SATOSHI;
 
     AddCoins(coins, CTransaction(txFrom), 0);
 
     CMutableTransaction txTo;
     txTo.vout.resize(1);
     txTo.vout[0].scriptPubKey =
-        GetScriptForDestination(key[1].GetPubKey().GetID());
+        GetScriptForDestination(PKHash(key[1].GetPubKey()));
 
     txTo.vin.resize(5);
     for (int i = 0; i < 5; i++) {
         txTo.vin[i].prevout = COutPoint(txFrom.GetId(), i);
     }
 
     BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0,
                               SigHashType().withForkId()));
     BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 1,
                               SigHashType().withForkId()));
     BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 2,
                               SigHashType().withForkId()));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/script_standard_tests.cpp b/src/test/script_standard_tests.cpp
index 5efc91691..105373cd2 100644
--- a/src/test/script_standard_tests.cpp
+++ b/src/test/script_standard_tests.cpp
@@ -1,624 +1,624 @@
 // 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 <key.h>
 #include <keystore.h>
 #include <script/ismine.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 // Append given push onto a script, using specific opcode (not necessarily
 // the minimal one, but must be able to contain the given data.)
 void AppendPush(CScript &script, opcodetype opcode,
                 const std::vector<uint8_t> &b) {
     assert(opcode <= OP_PUSHDATA4);
     script.push_back(opcode);
     if (opcode < OP_PUSHDATA1) {
         assert(b.size() == opcode);
     } else if (opcode == OP_PUSHDATA1) {
         assert(b.size() <= 0xff);
         script.push_back(uint8_t(b.size()));
     } else if (opcode == OP_PUSHDATA2) {
         assert(b.size() <= 0xffff);
         uint8_t _data[2];
         WriteLE16(_data, b.size());
         script.insert(script.end(), _data, _data + sizeof(_data));
     } else if (opcode == OP_PUSHDATA4) {
         uint8_t _data[4];
         WriteLE32(_data, b.size());
         script.insert(script.end(), _data, _data + sizeof(_data));
     }
     script.insert(script.end(), b.begin(), b.end());
 }
 
 BOOST_FIXTURE_TEST_SUITE(script_standard_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(script_standard_Solver_success) {
     CKey keys[3];
     CPubKey pubkeys[3];
     for (int i = 0; i < 3; i++) {
         keys[i].MakeNewKey(true);
         pubkeys[i] = keys[i].GetPubKey();
     }
 
     CScript s;
     std::vector<std::vector<uint8_t>> solutions;
 
     // TX_PUBKEY
     s.clear();
     s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_PUBKEY);
     BOOST_CHECK_EQUAL(solutions.size(), 1U);
     BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0]));
 
     // TX_PUBKEYHASH
     s.clear();
     s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
       << OP_EQUALVERIFY << OP_CHECKSIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_PUBKEYHASH);
     BOOST_CHECK_EQUAL(solutions.size(), 1U);
     BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
 
     // TX_SCRIPTHASH
     CScript redeemScript(s); // initialize with leftover P2PKH script
     s.clear();
     s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_SCRIPTHASH);
     BOOST_CHECK_EQUAL(solutions.size(), 1U);
     BOOST_CHECK(solutions[0] == ToByteVector(CScriptID(redeemScript)));
 
     // TX_MULTISIG
     s.clear();
     s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2
       << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_MULTISIG);
     BOOST_CHECK_EQUAL(solutions.size(), 4U);
     BOOST_CHECK(solutions[0] == std::vector<uint8_t>({1}));
     BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
     BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
     BOOST_CHECK(solutions[3] == std::vector<uint8_t>({2}));
 
     s.clear();
     s << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1])
       << ToByteVector(pubkeys[2]) << OP_3 << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_MULTISIG);
     BOOST_CHECK_EQUAL(solutions.size(), 5U);
     BOOST_CHECK(solutions[0] == std::vector<uint8_t>({2}));
     BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
     BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
     BOOST_CHECK(solutions[3] == ToByteVector(pubkeys[2]));
     BOOST_CHECK(solutions[4] == std::vector<uint8_t>({3}));
 
     // TX_NULL_DATA
     s.clear();
     s << OP_RETURN << std::vector<uint8_t>({0}) << std::vector<uint8_t>({75})
       << std::vector<uint8_t>({255});
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NULL_DATA);
     BOOST_CHECK_EQUAL(solutions.size(), 0U);
 
     // TX_WITNESS_V0_KEYHASH
     s.clear();
     s << OP_0 << ToByteVector(pubkeys[0].GetID());
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0U);
 
     // TX_WITNESS_V0_SCRIPTHASH
     uint256 scriptHash;
     CSHA256()
         .Write(&redeemScript[0], redeemScript.size())
         .Finalize(scriptHash.begin());
 
     s.clear();
     s << OP_0 << ToByteVector(scriptHash);
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0U);
 
     // TX_NONSTANDARD
     s.clear();
     s << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0);
 
     // Try some non-minimal PUSHDATA pushes in various standard scripts
     for (auto pushdataop : {OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4}) {
         // mutated TX_PUBKEY
         s.clear();
         AppendPush(s, pushdataop, ToByteVector(pubkeys[0]));
         s << OP_CHECKSIG;
         BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_PUBKEYHASH
         s.clear();
         s << OP_DUP << OP_HASH160;
         AppendPush(s, pushdataop, ToByteVector(pubkeys[0].GetID()));
         s << OP_EQUALVERIFY << OP_CHECKSIG;
         BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_SCRIPTHASH
         s.clear();
         s << OP_HASH160;
         AppendPush(s, pushdataop, ToByteVector(CScriptID(redeemScript)));
         s << OP_EQUAL;
         BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_MULTISIG -- pubkey
         s.clear();
         s << OP_1;
         AppendPush(s, pushdataop, ToByteVector(pubkeys[0]));
         s << ToByteVector(pubkeys[1]) << OP_2 << OP_CHECKMULTISIG;
         BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_MULTISIG -- num_signatures
         s.clear();
         AppendPush(s, pushdataop, {1});
         s << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2
           << OP_CHECKMULTISIG;
         BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_MULTISIG -- num_pubkeys
         s.clear();
         s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]);
         AppendPush(s, pushdataop, {2});
         s << OP_CHECKMULTISIG;
         BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
     }
 
     // also try pushing the num_signatures and num_pubkeys using PUSH_N opcode
     // instead of OP_N opcode:
     s.clear();
     s << std::vector<uint8_t>{1} << ToByteVector(pubkeys[0])
       << ToByteVector(pubkeys[1]) << OP_2 << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0);
     s.clear();
     s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1])
       << std::vector<uint8_t>{2} << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0);
 
     // Non-minimal pushes in OP_RETURN scripts are standard (some OP_RETURN
     // protocols like SLP rely on this). Also it turns out OP_RESERVED gets past
     // IsPushOnly and thus is standard here.
     std::vector<uint8_t> op_return_nonminimal{
         OP_RETURN,    OP_RESERVED, OP_PUSHDATA1, 0x00, 0x01, 0x01,
         OP_PUSHDATA4, 0x01,        0x00,         0x00, 0x00, 0xaa};
     s.assign(op_return_nonminimal.begin(), op_return_nonminimal.end());
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NULL_DATA);
     BOOST_CHECK_EQUAL(solutions.size(), 0);
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_Solver_failure) {
     CKey key;
     CPubKey pubkey;
     key.MakeNewKey(true);
     pubkey = key.GetPubKey();
 
     CScript s;
     std::vector<std::vector<uint8_t>> solutions;
 
     // TX_PUBKEY with incorrectly sized pubkey
     s.clear();
     s << std::vector<uint8_t>(30, 0x01) << OP_CHECKSIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_PUBKEYHASH with incorrectly sized key hash
     s.clear();
     s << OP_DUP << OP_HASH160 << ToByteVector(pubkey) << OP_EQUALVERIFY
       << OP_CHECKSIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_SCRIPTHASH with incorrectly sized script hash
     s.clear();
     s << OP_HASH160 << std::vector<uint8_t>(21, 0x01) << OP_EQUAL;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_MULTISIG 0/2
     s.clear();
     s << OP_0 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_MULTISIG 2/1
     s.clear();
     s << OP_2 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_MULTISIG n = 2 with 1 pubkey
     s.clear();
     s << OP_1 << ToByteVector(pubkey) << OP_2 << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_MULTISIG n = 1 with 0 pubkeys
     s.clear();
     s << OP_1 << OP_1 << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_NULL_DATA with other opcodes
     s.clear();
     s << OP_RETURN << std::vector<uint8_t>({75}) << OP_ADD;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_WITNESS with unknown version
     s.clear();
     s << OP_1 << ToByteVector(pubkey);
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_WITNESS with incorrect program size
     s.clear();
     s << OP_0 << std::vector<uint8_t>(19, 0x01);
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination) {
     CKey key;
     CPubKey pubkey;
     key.MakeNewKey(true);
     pubkey = key.GetPubKey();
 
     CScript s;
     CTxDestination address;
 
     // TX_PUBKEY
     s.clear();
     s << ToByteVector(pubkey) << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestination(s, address));
-    BOOST_CHECK(boost::get<CKeyID>(&address) &&
-                *boost::get<CKeyID>(&address) == pubkey.GetID());
+    BOOST_CHECK(boost::get<PKHash>(&address) &&
+                *boost::get<PKHash>(&address) == PKHash(pubkey));
 
     // TX_PUBKEYHASH
     s.clear();
     s << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY
       << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestination(s, address));
-    BOOST_CHECK(boost::get<CKeyID>(&address) &&
-                *boost::get<CKeyID>(&address) == pubkey.GetID());
+    BOOST_CHECK(boost::get<PKHash>(&address) &&
+                *boost::get<PKHash>(&address) == PKHash(pubkey));
 
     // TX_SCRIPTHASH
     CScript redeemScript(s); // initialize with leftover P2PKH script
     s.clear();
     s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     BOOST_CHECK(ExtractDestination(s, address));
-    BOOST_CHECK(boost::get<CScriptID>(&address) &&
-                *boost::get<CScriptID>(&address) == CScriptID(redeemScript));
+    BOOST_CHECK(boost::get<ScriptHash>(&address) &&
+                *boost::get<ScriptHash>(&address) == ScriptHash(redeemScript));
 
     // TX_MULTISIG
     s.clear();
     s << OP_1 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
     BOOST_CHECK(!ExtractDestination(s, address));
 
     // TX_NULL_DATA
     s.clear();
     s << OP_RETURN << std::vector<uint8_t>({75});
     BOOST_CHECK(!ExtractDestination(s, address));
 
     // TX_WITNESS_V0_KEYHASH
     s.clear();
     s << OP_0 << ToByteVector(pubkey);
     BOOST_CHECK(!ExtractDestination(s, address));
 
     // TX_WITNESS_V0_SCRIPTHASH
     s.clear();
     s << OP_0 << ToByteVector(CScriptID(redeemScript));
     BOOST_CHECK(!ExtractDestination(s, address));
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations) {
     CKey keys[3];
     CPubKey pubkeys[3];
     for (int i = 0; i < 3; i++) {
         keys[i].MakeNewKey(true);
         pubkeys[i] = keys[i].GetPubKey();
     }
 
     CScript s;
     txnouttype whichType;
     std::vector<CTxDestination> addresses;
     int nRequired;
 
     // TX_PUBKEY
     s.clear();
     s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
     BOOST_CHECK_EQUAL(whichType, TX_PUBKEY);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
-    BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
-                *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
+    BOOST_CHECK(boost::get<PKHash>(&addresses[0]) &&
+                *boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
 
     // TX_PUBKEYHASH
     s.clear();
     s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
       << OP_EQUALVERIFY << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
     BOOST_CHECK_EQUAL(whichType, TX_PUBKEYHASH);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
-    BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
-                *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
+    BOOST_CHECK(boost::get<PKHash>(&addresses[0]) &&
+                *boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
 
     // TX_SCRIPTHASH
     // initialize with leftover P2PKH script
     CScript redeemScript(s);
     s.clear();
     s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
     BOOST_CHECK_EQUAL(whichType, TX_SCRIPTHASH);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
-    BOOST_CHECK(boost::get<CScriptID>(&addresses[0]) &&
-                *boost::get<CScriptID>(&addresses[0]) ==
-                    CScriptID(redeemScript));
+    BOOST_CHECK(boost::get<ScriptHash>(&addresses[0]) &&
+                *boost::get<ScriptHash>(&addresses[0]) ==
+                    ScriptHash(redeemScript));
 
     // TX_MULTISIG
     s.clear();
     s << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2
       << OP_CHECKMULTISIG;
     BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
     BOOST_CHECK_EQUAL(whichType, TX_MULTISIG);
     BOOST_CHECK_EQUAL(addresses.size(), 2U);
     BOOST_CHECK_EQUAL(nRequired, 2);
-    BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
-                *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
-    BOOST_CHECK(boost::get<CKeyID>(&addresses[1]) &&
-                *boost::get<CKeyID>(&addresses[1]) == pubkeys[1].GetID());
+    BOOST_CHECK(boost::get<PKHash>(&addresses[0]) &&
+                *boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
+    BOOST_CHECK(boost::get<PKHash>(&addresses[1]) &&
+                *boost::get<PKHash>(&addresses[1]) == PKHash(pubkeys[1]));
 
     // TX_NULL_DATA
     s.clear();
     s << OP_RETURN << std::vector<uint8_t>({75});
     BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
 
     // TX_WITNESS_V0_KEYHASH
     s.clear();
     s << OP_0 << ToByteVector(pubkeys[0].GetID());
     BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
 
     // TX_WITNESS_V0_SCRIPTHASH
     s.clear();
     s << OP_0 << ToByteVector(CScriptID(redeemScript));
     BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_GetScriptFor_) {
     CKey keys[3];
     CPubKey pubkeys[3];
     for (int i = 0; i < 3; i++) {
         keys[i].MakeNewKey(true);
         pubkeys[i] = keys[i].GetPubKey();
     }
 
     CScript expected, result;
 
-    // CKeyID
+    // PKHash
     expected.clear();
     expected << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
              << OP_EQUALVERIFY << OP_CHECKSIG;
-    result = GetScriptForDestination(pubkeys[0].GetID());
+    result = GetScriptForDestination(PKHash(pubkeys[0]));
     BOOST_CHECK(result == expected);
 
     // CScriptID
     CScript redeemScript(result);
     expected.clear();
     expected << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
-    result = GetScriptForDestination(CScriptID(redeemScript));
+    result = GetScriptForDestination(ScriptHash(redeemScript));
     BOOST_CHECK(result == expected);
 
     // CNoDestination
     expected.clear();
     result = GetScriptForDestination(CNoDestination());
     BOOST_CHECK(result == expected);
 
     // GetScriptForRawPubKey
     expected.clear();
     expected << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
     result = GetScriptForRawPubKey(pubkeys[0]);
     BOOST_CHECK(result == expected);
 
     // GetScriptForMultisig
     expected.clear();
     expected << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1])
              << ToByteVector(pubkeys[2]) << OP_3 << OP_CHECKMULTISIG;
     result =
         GetScriptForMultisig(2, std::vector<CPubKey>(pubkeys, pubkeys + 3));
     BOOST_CHECK(result == expected);
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_IsMine) {
     CKey keys[2];
     CPubKey pubkeys[2];
     for (int i = 0; i < 2; i++) {
         keys[i].MakeNewKey(true);
         pubkeys[i] = keys[i].GetPubKey();
     }
 
     CKey uncompressedKey;
     uncompressedKey.MakeNewKey(false);
     CPubKey uncompressedPubkey = uncompressedKey.GetPubKey();
 
     CScript scriptPubKey;
     isminetype result;
 
     // P2PK compressed
     {
         CBasicKeyStore keystore;
         scriptPubKey = GetScriptForRawPubKey(pubkeys[0]);
 
         // Keystore does not have key
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has key
         keystore.AddKey(keys[0]);
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // P2PK uncompressed
     {
         CBasicKeyStore keystore;
         scriptPubKey = GetScriptForRawPubKey(uncompressedPubkey);
 
         // Keystore does not have key
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has key
         keystore.AddKey(uncompressedKey);
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // P2PKH compressed
     {
         CBasicKeyStore keystore;
-        scriptPubKey = GetScriptForDestination(pubkeys[0].GetID());
+        scriptPubKey = GetScriptForDestination(PKHash(pubkeys[0]));
 
         // Keystore does not have key
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has key
         keystore.AddKey(keys[0]);
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // P2PKH uncompressed
     {
         CBasicKeyStore keystore;
-        scriptPubKey = GetScriptForDestination(uncompressedPubkey.GetID());
+        scriptPubKey = GetScriptForDestination(PKHash(uncompressedPubkey));
 
         // Keystore does not have key
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has key
         keystore.AddKey(uncompressedKey);
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // P2SH
     {
         CBasicKeyStore keystore;
 
-        CScript redeemScript = GetScriptForDestination(pubkeys[0].GetID());
-        scriptPubKey = GetScriptForDestination(CScriptID(redeemScript));
+        CScript redeemScript = GetScriptForDestination(PKHash(pubkeys[0]));
+        scriptPubKey = GetScriptForDestination(ScriptHash(redeemScript));
 
         // Keystore does not have redeemScript or key
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has redeemScript but no key
         keystore.AddCScript(redeemScript);
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has redeemScript and key
         keystore.AddKey(keys[0]);
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // (P2PKH inside) P2SH inside P2SH (invalid)
     {
         CBasicKeyStore keystore;
 
         CScript redeemscript_inner =
-            GetScriptForDestination(pubkeys[0].GetID());
+            GetScriptForDestination(PKHash(pubkeys[0]));
         CScript redeemscript =
-            GetScriptForDestination(CScriptID(redeemscript_inner));
-        scriptPubKey = GetScriptForDestination(CScriptID(redeemscript));
+            GetScriptForDestination(ScriptHash(redeemscript_inner));
+        scriptPubKey = GetScriptForDestination(ScriptHash(redeemscript));
 
         keystore.AddCScript(redeemscript);
         keystore.AddCScript(redeemscript_inner);
         keystore.AddCScript(scriptPubKey);
         keystore.AddKey(keys[0]);
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
     }
 
     // scriptPubKey multisig
     {
         CBasicKeyStore keystore;
 
         scriptPubKey =
             GetScriptForMultisig(2, {uncompressedPubkey, pubkeys[1]});
 
         // Keystore does not have any keys
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has 1/2 keys
         keystore.AddKey(uncompressedKey);
 
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has 2/2 keys
         keystore.AddKey(keys[1]);
 
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has 2/2 keys and the script
         keystore.AddCScript(scriptPubKey);
 
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
     }
 
     // P2SH multisig
     {
         CBasicKeyStore keystore;
         keystore.AddKey(uncompressedKey);
         keystore.AddKey(keys[1]);
 
         CScript redeemScript =
             GetScriptForMultisig(2, {uncompressedPubkey, pubkeys[1]});
-        scriptPubKey = GetScriptForDestination(CScriptID(redeemScript));
+        scriptPubKey = GetScriptForDestination(ScriptHash(redeemScript));
 
         // Keystore has no redeemScript
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has redeemScript
         keystore.AddCScript(redeemScript);
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // OP_RETURN
     {
         CBasicKeyStore keystore;
         keystore.AddKey(keys[0]);
 
         scriptPubKey.clear();
         scriptPubKey << OP_RETURN << ToByteVector(pubkeys[0]);
 
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
     }
 
     // Nonstandard
     {
         CBasicKeyStore keystore;
         keystore.AddKey(keys[0]);
 
         scriptPubKey.clear();
         scriptPubKey << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
 
         result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index 89a7dca15..c6f242cb3 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -1,3230 +1,3230 @@
 // 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 <script/script.h>
 #include <script/script_error.h>
 #include <script/sighashtype.h>
 #include <script/sign.h>
 
 #include <core_io.h>
 #include <key.h>
 #include <keystore.h>
 #include <rpc/util.h>
 #include <streams.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 
 #if defined(HAVE_CONSENSUS_LIB)
 #include <script/bitcoinconsensus.h>
 #endif
 
 #include <test/data/script_tests.json.h>
 #include <test/jsonutil.h>
 #include <test/scriptflags.h>
 #include <test/sigutil.h>
 #include <test/util/setup_common.h>
 #include <test/util/transaction_utils.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <univalue.h>
 
 #include <cstdint>
 #include <string>
 #include <vector>
 
 // Uncomment if you want to output updated JSON tests.
 // #define UPDATE_JSON_TESTS
 
 static const uint32_t gFlags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
 
 struct ScriptErrorDesc {
     ScriptError err;
     const char *name;
 };
 
 static ScriptErrorDesc script_errors[] = {
     {ScriptError::OK, "OK"},
     {ScriptError::UNKNOWN, "UNKNOWN_ERROR"},
     {ScriptError::EVAL_FALSE, "EVAL_FALSE"},
     {ScriptError::OP_RETURN, "OP_RETURN"},
     {ScriptError::SCRIPT_SIZE, "SCRIPT_SIZE"},
     {ScriptError::PUSH_SIZE, "PUSH_SIZE"},
     {ScriptError::OP_COUNT, "OP_COUNT"},
     {ScriptError::STACK_SIZE, "STACK_SIZE"},
     {ScriptError::SIG_COUNT, "SIG_COUNT"},
     {ScriptError::PUBKEY_COUNT, "PUBKEY_COUNT"},
     {ScriptError::INPUT_SIGCHECKS, "INPUT_SIGCHECKS"},
     {ScriptError::INVALID_OPERAND_SIZE, "OPERAND_SIZE"},
     {ScriptError::INVALID_NUMBER_RANGE, "INVALID_NUMBER_RANGE"},
     {ScriptError::IMPOSSIBLE_ENCODING, "IMPOSSIBLE_ENCODING"},
     {ScriptError::INVALID_SPLIT_RANGE, "SPLIT_RANGE"},
     {ScriptError::INVALID_BIT_COUNT, "INVALID_BIT_COUNT"},
     {ScriptError::VERIFY, "VERIFY"},
     {ScriptError::EQUALVERIFY, "EQUALVERIFY"},
     {ScriptError::CHECKMULTISIGVERIFY, "CHECKMULTISIGVERIFY"},
     {ScriptError::CHECKSIGVERIFY, "CHECKSIGVERIFY"},
     {ScriptError::CHECKDATASIGVERIFY, "CHECKDATASIGVERIFY"},
     {ScriptError::NUMEQUALVERIFY, "NUMEQUALVERIFY"},
     {ScriptError::BAD_OPCODE, "BAD_OPCODE"},
     {ScriptError::DISABLED_OPCODE, "DISABLED_OPCODE"},
     {ScriptError::INVALID_STACK_OPERATION, "INVALID_STACK_OPERATION"},
     {ScriptError::INVALID_ALTSTACK_OPERATION, "INVALID_ALTSTACK_OPERATION"},
     {ScriptError::UNBALANCED_CONDITIONAL, "UNBALANCED_CONDITIONAL"},
     {ScriptError::NEGATIVE_LOCKTIME, "NEGATIVE_LOCKTIME"},
     {ScriptError::UNSATISFIED_LOCKTIME, "UNSATISFIED_LOCKTIME"},
     {ScriptError::SIG_HASHTYPE, "SIG_HASHTYPE"},
     {ScriptError::SIG_DER, "SIG_DER"},
     {ScriptError::MINIMALDATA, "MINIMALDATA"},
     {ScriptError::SIG_PUSHONLY, "SIG_PUSHONLY"},
     {ScriptError::SIG_HIGH_S, "SIG_HIGH_S"},
     {ScriptError::PUBKEYTYPE, "PUBKEYTYPE"},
     {ScriptError::CLEANSTACK, "CLEANSTACK"},
     {ScriptError::MINIMALIF, "MINIMALIF"},
     {ScriptError::SIG_NULLFAIL, "NULLFAIL"},
     {ScriptError::SIG_BADLENGTH, "SIG_BADLENGTH"},
     {ScriptError::SIG_NONSCHNORR, "SIG_NONSCHNORR"},
     {ScriptError::DISCOURAGE_UPGRADABLE_NOPS, "DISCOURAGE_UPGRADABLE_NOPS"},
     {ScriptError::ILLEGAL_FORKID, "ILLEGAL_FORKID"},
     {ScriptError::MUST_USE_FORKID, "MISSING_FORKID"},
     {ScriptError::DIV_BY_ZERO, "DIV_BY_ZERO"},
     {ScriptError::MOD_BY_ZERO, "MOD_BY_ZERO"},
     {ScriptError::INVALID_BITFIELD_SIZE, "BITFIELD_SIZE"},
     {ScriptError::INVALID_BIT_RANGE, "BIT_RANGE"},
 };
 
 static const char *FormatScriptError(ScriptError err) {
     for (size_t i = 0; i < ARRAYLEN(script_errors); ++i) {
         if (script_errors[i].err == err) {
             return script_errors[i].name;
         }
     }
 
     BOOST_ERROR("Unknown scripterror enumeration value, update script_errors "
                 "in script_tests.cpp.");
     return "";
 }
 
 static ScriptError ParseScriptError(const std::string &name) {
     for (size_t i = 0; i < ARRAYLEN(script_errors); ++i) {
         if (script_errors[i].name == name) {
             return script_errors[i].err;
         }
     }
 
     BOOST_ERROR("Unknown scripterror \"" << name << "\" in test description");
     return ScriptError::UNKNOWN;
 }
 
 BOOST_FIXTURE_TEST_SUITE(script_tests, BasicTestingSetup)
 
 static void DoTest(const CScript &scriptPubKey, const CScript &scriptSig,
                    uint32_t flags, const std::string &message,
                    ScriptError scriptError, const Amount nValue) {
     bool expect = (scriptError == ScriptError::OK);
     if (flags & SCRIPT_VERIFY_CLEANSTACK) {
         flags |= SCRIPT_VERIFY_P2SH;
     }
 
     ScriptError err;
     const CTransaction txCredit{
         BuildCreditingTransaction(scriptPubKey, nValue)};
     CMutableTransaction tx = BuildSpendingTransaction(scriptSig, txCredit);
     CMutableTransaction tx2 = tx;
     BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, flags,
                                      MutableTransactionSignatureChecker(
                                          &tx, 0, txCredit.vout[0].nValue),
                                      &err) == expect,
                         message);
     BOOST_CHECK_MESSAGE(err == scriptError,
                         std::string(FormatScriptError(err)) + " where " +
                             std::string(FormatScriptError(scriptError)) +
                             " expected: " + message);
 
     // Verify that removing flags from a passing test or adding flags to a
     // failing test does not change the result, except for some special flags.
     for (int i = 0; i < 16; ++i) {
         uint32_t extra_flags = InsecureRandBits(32);
         // Some flags are not purely-restrictive and thus we can't assume
         // anything about what happens when they are flipped. Keep them as-is.
         extra_flags &=
             ~(SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_ENABLE_REPLAY_PROTECTION |
               SCRIPT_ENABLE_SCHNORR_MULTISIG);
         uint32_t combined_flags =
             expect ? (flags & ~extra_flags) : (flags | extra_flags);
         // Weed out invalid flag combinations.
         if (combined_flags & SCRIPT_VERIFY_CLEANSTACK) {
             combined_flags |= SCRIPT_VERIFY_P2SH;
         }
 
         BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey,
                                          combined_flags,
                                          MutableTransactionSignatureChecker(
                                              &tx, 0, txCredit.vout[0].nValue),
                                          &err) == expect,
                             message + strprintf(" (with %s flags %08x)",
                                                 expect ? "removed" : "added",
                                                 combined_flags ^ flags));
     }
 
 #if defined(HAVE_CONSENSUS_LIB)
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << tx2;
     uint32_t libconsensus_flags =
         flags & bitcoinconsensus_SCRIPT_FLAGS_VERIFY_ALL;
     if (libconsensus_flags == flags) {
         if (flags & bitcoinconsensus_SCRIPT_ENABLE_SIGHASH_FORKID) {
             BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(
                                     scriptPubKey.data(), scriptPubKey.size(),
                                     txCredit.vout[0].nValue / SATOSHI,
                                     (const uint8_t *)&stream[0], stream.size(),
                                     0, libconsensus_flags, nullptr) == expect,
                                 message);
         } else {
             BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(
                                     scriptPubKey.data(), scriptPubKey.size(), 0,
                                     (const uint8_t *)&stream[0], stream.size(),
                                     0, libconsensus_flags, nullptr) == expect,
                                 message);
             BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script(
                                     scriptPubKey.data(), scriptPubKey.size(),
                                     (const uint8_t *)&stream[0], stream.size(),
                                     0, libconsensus_flags, nullptr) == expect,
                                 message);
         }
     }
 #endif
 }
 
 namespace {
 const uint8_t vchKey0[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                              0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
 const uint8_t vchKey1[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                              0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0};
 const uint8_t vchKey2[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                              0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0};
 
 struct KeyData {
     CKey key0, key0C, key1, key1C, key2, key2C;
     CPubKey pubkey0, pubkey0C, pubkey0H;
     CPubKey pubkey1, pubkey1C;
     CPubKey pubkey2, pubkey2C;
 
     KeyData() {
         key0.Set(vchKey0, vchKey0 + 32, false);
         key0C.Set(vchKey0, vchKey0 + 32, true);
         pubkey0 = key0.GetPubKey();
         pubkey0H = key0.GetPubKey();
         pubkey0C = key0C.GetPubKey();
         *const_cast<uint8_t *>(&pubkey0H[0]) = 0x06 | (pubkey0H[64] & 1);
 
         key1.Set(vchKey1, vchKey1 + 32, false);
         key1C.Set(vchKey1, vchKey1 + 32, true);
         pubkey1 = key1.GetPubKey();
         pubkey1C = key1C.GetPubKey();
 
         key2.Set(vchKey2, vchKey2 + 32, false);
         key2C.Set(vchKey2, vchKey2 + 32, true);
         pubkey2 = key2.GetPubKey();
         pubkey2C = key2C.GetPubKey();
     }
 };
 
 class TestBuilder {
 private:
     //! Actually executed script
     CScript script;
     //! The P2SH redeemscript
     CScript redeemscript;
     CTransactionRef creditTx;
     CMutableTransaction spendTx;
     bool havePush;
     std::vector<uint8_t> push;
     std::string comment;
     uint32_t flags;
     ScriptError scriptError;
     Amount nValue;
 
     void DoPush() {
         if (havePush) {
             spendTx.vin[0].scriptSig << push;
             havePush = false;
         }
     }
 
     void DoPush(const std::vector<uint8_t> &data) {
         DoPush();
         push = data;
         havePush = true;
     }
 
     std::vector<uint8_t> DoSignECDSA(const CKey &key, const uint256 &hash,
                                      unsigned int lenR = 32,
                                      unsigned int lenS = 32) const {
         std::vector<uint8_t> vchSig, r, s;
         uint32_t iter = 0;
         do {
             key.SignECDSA(hash, vchSig, false, iter++);
             if ((lenS == 33) != (vchSig[5 + vchSig[3]] == 33)) {
                 NegateSignatureS(vchSig);
             }
 
             r = std::vector<uint8_t>(vchSig.begin() + 4,
                                      vchSig.begin() + 4 + vchSig[3]);
             s = std::vector<uint8_t>(vchSig.begin() + 6 + vchSig[3],
                                      vchSig.begin() + 6 + vchSig[3] +
                                          vchSig[5 + vchSig[3]]);
         } while (lenR != r.size() || lenS != s.size());
 
         return vchSig;
     }
 
     std::vector<uint8_t> DoSignSchnorr(const CKey &key,
                                        const uint256 &hash) const {
         std::vector<uint8_t> vchSig;
 
         // no need to iterate for size; schnorrs are always same size.
         key.SignSchnorr(hash, vchSig);
 
         return vchSig;
     }
 
 public:
     TestBuilder(const CScript &script_, const std::string &comment_,
                 uint32_t flags_, bool P2SH = false,
                 Amount nValue_ = Amount::zero())
         : script(script_), havePush(false), comment(comment_), flags(flags_),
           scriptError(ScriptError::OK), nValue(nValue_) {
         CScript scriptPubKey = script;
         if (P2SH) {
             redeemscript = scriptPubKey;
             scriptPubKey = CScript()
                            << OP_HASH160
                            << ToByteVector(CScriptID(redeemscript)) << OP_EQUAL;
         }
         creditTx =
             MakeTransactionRef(BuildCreditingTransaction(scriptPubKey, nValue));
         spendTx = BuildSpendingTransaction(CScript(), *creditTx);
     }
 
     TestBuilder &SetScriptError(ScriptError err) {
         scriptError = err;
         return *this;
     }
 
     TestBuilder &Add(const CScript &_script) {
         DoPush();
         spendTx.vin[0].scriptSig += _script;
         return *this;
     }
 
     TestBuilder &Num(int num) {
         DoPush();
         spendTx.vin[0].scriptSig << num;
         return *this;
     }
 
     TestBuilder &Push(const std::string &hex) {
         DoPush(ParseHex(hex));
         return *this;
     }
 
     TestBuilder &Push(const uint256 &hash) {
         DoPush(ToByteVector(hash));
         return *this;
     }
 
     TestBuilder &Push(const CScript &_script) {
         DoPush(std::vector<uint8_t>(_script.begin(), _script.end()));
         return *this;
     }
 
     TestBuilder &
     PushSigECDSA(const CKey &key, SigHashType sigHashType = SigHashType(),
                  unsigned int lenR = 32, unsigned int lenS = 32,
                  Amount amount = Amount::zero(),
                  uint32_t sigFlags = SCRIPT_ENABLE_SIGHASH_FORKID) {
         uint256 hash = SignatureHash(script, CTransaction(spendTx), 0,
                                      sigHashType, amount, nullptr, sigFlags);
         std::vector<uint8_t> vchSig = DoSignECDSA(key, hash, lenR, lenS);
         vchSig.push_back(static_cast<uint8_t>(sigHashType.getRawSigHashType()));
         DoPush(vchSig);
         return *this;
     }
 
     TestBuilder &
     PushSigSchnorr(const CKey &key, SigHashType sigHashType = SigHashType(),
                    Amount amount = Amount::zero(),
                    uint32_t sigFlags = SCRIPT_ENABLE_SIGHASH_FORKID) {
         uint256 hash = SignatureHash(script, CTransaction(spendTx), 0,
                                      sigHashType, amount, nullptr, sigFlags);
         std::vector<uint8_t> vchSig = DoSignSchnorr(key, hash);
         vchSig.push_back(static_cast<uint8_t>(sigHashType.getRawSigHashType()));
         DoPush(vchSig);
         return *this;
     }
 
     TestBuilder &PushDataSigECDSA(const CKey &key,
                                   const std::vector<uint8_t> &data,
                                   unsigned int lenR = 32,
                                   unsigned int lenS = 32) {
         std::vector<uint8_t> vchHash(32);
         CSHA256().Write(data.data(), data.size()).Finalize(vchHash.data());
 
         DoPush(DoSignECDSA(key, uint256(vchHash), lenR, lenS));
         return *this;
     }
 
     TestBuilder &PushDataSigSchnorr(const CKey &key,
                                     const std::vector<uint8_t> &data) {
         std::vector<uint8_t> vchHash(32);
         CSHA256().Write(data.data(), data.size()).Finalize(vchHash.data());
 
         DoPush(DoSignSchnorr(key, uint256(vchHash)));
         return *this;
     }
 
     TestBuilder &PushECDSARecoveredPubKey(
         const std::vector<uint8_t> &rdata, const std::vector<uint8_t> &sdata,
         SigHashType sigHashType = SigHashType(), Amount amount = Amount::zero(),
         uint32_t sigFlags = SCRIPT_ENABLE_SIGHASH_FORKID) {
         // This calculates a pubkey to verify with a given ECDSA transaction
         // signature.
         uint256 hash = SignatureHash(script, CTransaction(spendTx), 0,
                                      sigHashType, amount, nullptr, sigFlags);
 
         assert(rdata.size() <= 32);
         assert(sdata.size() <= 32);
 
         // Our strategy: make a 'key recovery' signature, and just try all the
         // recovery IDs. If none of them work then this means the 'r' value
         // doesn't have any corresponding point, and the caller should pick a
         // different r.
         std::vector<uint8_t> vchSig(65, 0);
         std::copy(rdata.begin(), rdata.end(),
                   vchSig.begin() + (33 - rdata.size()));
         std::copy(sdata.begin(), sdata.end(),
                   vchSig.begin() + (65 - sdata.size()));
 
         CPubKey key;
         for (uint8_t recid : {0, 1, 2, 3}) {
             vchSig[0] = 31 + recid;
             if (key.RecoverCompact(hash, vchSig)) {
                 // found a match
                 break;
             }
         }
         if (!key.IsValid()) {
             throw std::runtime_error(
                 std::string("Could not generate pubkey for ") + HexStr(rdata));
         }
         std::vector<uint8_t> vchKey(key.begin(), key.end());
 
         DoPush(vchKey);
         return *this;
     }
 
     TestBuilder &
     PushECDSASigFromParts(const std::vector<uint8_t> &rdata,
                           const std::vector<uint8_t> &sdata,
                           SigHashType sigHashType = SigHashType()) {
         // Constructs a DER signature out of variable-length r and s arrays &
         // adds hashtype byte.
         assert(rdata.size() <= 32);
         assert(sdata.size() <= 32);
         assert(rdata.size() > 0);
         assert(sdata.size() > 0);
         assert(rdata[0] != 0);
         assert(sdata[0] != 0);
         std::vector<uint8_t> vchSig{0x30, 0x00, 0x02};
         if (rdata[0] & 0x80) {
             vchSig.push_back(rdata.size() + 1);
             vchSig.push_back(0);
             vchSig.insert(vchSig.end(), rdata.begin(), rdata.end());
         } else {
             vchSig.push_back(rdata.size());
             vchSig.insert(vchSig.end(), rdata.begin(), rdata.end());
         }
         vchSig.push_back(0x02);
         if (sdata[0] & 0x80) {
             vchSig.push_back(sdata.size() + 1);
             vchSig.push_back(0);
             vchSig.insert(vchSig.end(), sdata.begin(), sdata.end());
         } else {
             vchSig.push_back(sdata.size());
             vchSig.insert(vchSig.end(), sdata.begin(), sdata.end());
         }
         vchSig[1] = vchSig.size() - 2;
         vchSig.push_back(static_cast<uint8_t>(sigHashType.getRawSigHashType()));
         DoPush(vchSig);
         return *this;
     }
 
     TestBuilder &Push(const CPubKey &pubkey) {
         DoPush(std::vector<uint8_t>(pubkey.begin(), pubkey.end()));
         return *this;
     }
 
     TestBuilder &PushRedeem() {
         DoPush(std::vector<uint8_t>(redeemscript.begin(), redeemscript.end()));
         return *this;
     }
 
     TestBuilder &EditPush(unsigned int pos, const std::string &hexin,
                           const std::string &hexout) {
         assert(havePush);
         std::vector<uint8_t> datain = ParseHex(hexin);
         std::vector<uint8_t> dataout = ParseHex(hexout);
         assert(pos + datain.size() <= push.size());
         BOOST_CHECK_MESSAGE(
             std::vector<uint8_t>(push.begin() + pos,
                                  push.begin() + pos + datain.size()) == datain,
             comment);
         push.erase(push.begin() + pos, push.begin() + pos + datain.size());
         push.insert(push.begin() + pos, dataout.begin(), dataout.end());
         return *this;
     }
 
     TestBuilder &DamagePush(unsigned int pos) {
         assert(havePush);
         assert(pos < push.size());
         push[pos] ^= 1;
         return *this;
     }
 
     TestBuilder &Test() {
         // Make a copy so we can rollback the push.
         TestBuilder copy = *this;
         DoPush();
         DoTest(creditTx->vout[0].scriptPubKey, spendTx.vin[0].scriptSig, flags,
                comment, scriptError, nValue);
         *this = copy;
         return *this;
     }
 
     UniValue GetJSON() {
         DoPush();
         UniValue array(UniValue::VARR);
         if (nValue != Amount::zero()) {
             UniValue amount(UniValue::VARR);
             amount.push_back(ValueFromAmount(nValue));
             array.push_back(amount);
         }
 
         array.push_back(FormatScript(spendTx.vin[0].scriptSig));
         array.push_back(FormatScript(creditTx->vout[0].scriptPubKey));
         array.push_back(FormatScriptFlags(flags));
         array.push_back(FormatScriptError(scriptError));
         array.push_back(comment);
         return array;
     }
 
     std::string GetComment() const { return comment; }
 };
 
 std::string JSONPrettyPrint(const UniValue &univalue) {
     std::string ret = univalue.write(4);
     // Workaround for libunivalue pretty printer, which puts a space between
     // commas and newlines
     size_t pos = 0;
     while ((pos = ret.find(" \n", pos)) != std::string::npos) {
         ret.replace(pos, 2, "\n");
         pos++;
     }
 
     return ret;
 }
 } // namespace
 
 BOOST_AUTO_TEST_CASE(script_build) {
     const KeyData keys;
 
     std::vector<TestBuilder> tests;
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK", 0)
             .PushSigECDSA(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK, bad sig", 0)
             .PushSigECDSA(keys.key0)
             .DamagePush(10)
             .SetScriptError(ScriptError::EVAL_FALSE));
 
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey1C.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "P2PKH", 0)
                         .PushSigECDSA(keys.key1)
                         .Push(keys.pubkey1C));
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey2C.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "P2PKH, bad pubkey", 0)
                         .PushSigECDSA(keys.key2)
                         .Push(keys.pubkey2C)
                         .DamagePush(5)
                         .SetScriptError(ScriptError::EQUALVERIFY));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "P2PK anyonecanpay", 0)
             .PushSigECDSA(keys.key1, SigHashType().withAnyoneCanPay()));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "P2PK anyonecanpay marked with normal hashtype", 0)
             .PushSigECDSA(keys.key1, SigHashType().withAnyoneCanPay())
             .EditPush(70, "81", "01")
             .SetScriptError(ScriptError::EVAL_FALSE));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
                     "P2SH(P2PK)", SCRIPT_VERIFY_P2SH, true)
             .PushSigECDSA(keys.key0)
             .PushRedeem());
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
                     "P2SH(P2PK), bad redeemscript", SCRIPT_VERIFY_P2SH, true)
             .PushSigECDSA(keys.key0)
             .PushRedeem()
             .DamagePush(10)
             .SetScriptError(ScriptError::EVAL_FALSE));
 
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey0.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "P2SH(P2PKH)", SCRIPT_VERIFY_P2SH, true)
                         .PushSigECDSA(keys.key0)
                         .Push(keys.pubkey0)
                         .PushRedeem());
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey1.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "P2SH(P2PKH), bad sig but no VERIFY_P2SH", 0,
                                 true)
                         .PushSigECDSA(keys.key0)
                         .DamagePush(10)
                         .PushRedeem());
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey1.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "P2SH(P2PKH), bad sig", SCRIPT_VERIFY_P2SH,
                                 true)
                         .PushSigECDSA(keys.key0)
                         .DamagePush(10)
                         .PushRedeem()
                         .SetScriptError(ScriptError::EQUALVERIFY));
 
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "3-of-3", 0)
                         .Num(0)
                         .PushSigECDSA(keys.key0)
                         .PushSigECDSA(keys.key1)
                         .PushSigECDSA(keys.key2));
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "3-of-3, 2 sigs", 0)
                         .Num(0)
                         .PushSigECDSA(keys.key0)
                         .PushSigECDSA(keys.key1)
                         .Num(0)
                         .SetScriptError(ScriptError::EVAL_FALSE));
 
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "P2SH(2-of-3)", SCRIPT_VERIFY_P2SH, true)
                         .Num(0)
                         .PushSigECDSA(keys.key1)
                         .PushSigECDSA(keys.key2)
                         .PushRedeem());
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "P2SH(2-of-3), 1 sig", SCRIPT_VERIFY_P2SH, true)
                         .Num(0)
                         .PushSigECDSA(keys.key1)
                         .Num(0)
                         .PushRedeem()
                         .SetScriptError(ScriptError::EVAL_FALSE));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "P2PK with too much R padding but no DERSIG", 0)
             .PushSigECDSA(keys.key1, SigHashType(), 31, 32)
             .EditPush(1, "43021F", "44022000"));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "P2PK with too much R padding", SCRIPT_VERIFY_DERSIG)
             .PushSigECDSA(keys.key1, SigHashType(), 31, 32)
             .EditPush(1, "43021F", "44022000")
             .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "P2PK with too much S padding but no DERSIG", 0)
             .PushSigECDSA(keys.key1)
             .EditPush(1, "44", "45")
             .EditPush(37, "20", "2100"));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "P2PK with too much S padding", SCRIPT_VERIFY_DERSIG)
             .PushSigECDSA(keys.key1)
             .EditPush(1, "44", "45")
             .EditPush(37, "20", "2100")
             .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "P2PK with too little R padding but no DERSIG", 0)
             .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
             .EditPush(1, "45022100", "440220"));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "P2PK with too little R padding", SCRIPT_VERIFY_DERSIG)
             .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
             .EditPush(1, "45022100", "440220")
             .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(
         TestBuilder(
             CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
             "P2PK NOT with bad sig with too much R padding but no DERSIG", 0)
             .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
             .EditPush(1, "43021F", "44022000")
             .DamagePush(10));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "P2PK NOT with bad sig with too much R padding",
                                 SCRIPT_VERIFY_DERSIG)
                         .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
                         .EditPush(1, "43021F", "44022000")
                         .DamagePush(10)
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(
         TestBuilder(CScript()
                         << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
                     "P2PK NOT with too much R padding but no DERSIG", 0)
             .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
             .EditPush(1, "43021F", "44022000")
             .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "P2PK NOT with too much R padding",
                                 SCRIPT_VERIFY_DERSIG)
                         .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
                         .EditPush(1, "43021F", "44022000")
                         .SetScriptError(ScriptError::SIG_DER));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "BIP66 example 1, without DERSIG", 0)
             .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
             .EditPush(1, "45022100", "440220"));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "BIP66 example 1, with DERSIG", SCRIPT_VERIFY_DERSIG)
             .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
             .EditPush(1, "45022100", "440220")
             .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 2, without DERSIG", 0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 2, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "BIP66 example 3, without DERSIG", 0)
             .Num(0)
             .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "BIP66 example 3, with DERSIG", SCRIPT_VERIFY_DERSIG)
             .Num(0)
             .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 4, without DERSIG", 0)
                         .Num(0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 4, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(0));
     tests.push_back(
         TestBuilder(
             CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
             "BIP66 example 4, with DERSIG, non-null DER-compliant signature",
             SCRIPT_VERIFY_DERSIG)
             .Push("300602010102010101"));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 4, with DERSIG and NULLFAIL",
                                 SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_NULLFAIL)
                         .Num(0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 4, with DERSIG and NULLFAIL, "
                                 "non-null DER-compliant signature",
                                 SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_NULLFAIL)
                         .Push("300602010102010101")
                         .SetScriptError(ScriptError::SIG_NULLFAIL));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "BIP66 example 5, without DERSIG", 0)
             .Num(1)
             .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "BIP66 example 5, with DERSIG", SCRIPT_VERIFY_DERSIG)
             .Num(1)
             .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 6, without DERSIG", 0)
                         .Num(1));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 6, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(1)
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "BIP66 example 7, without DERSIG", 0)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .PushSigECDSA(keys.key2));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "BIP66 example 7, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .PushSigECDSA(keys.key2)
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "BIP66 example 8, without DERSIG", 0)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .PushSigECDSA(keys.key2)
                         .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "BIP66 example 8, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .PushSigECDSA(keys.key2)
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "BIP66 example 9, without DERSIG", 0)
                         .Num(0)
                         .Num(0)
                         .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "BIP66 example 9, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(0)
                         .Num(0)
                         .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "BIP66 example 10, without DERSIG", 0)
                         .Num(0)
                         .Num(0)
                         .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220"));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "BIP66 example 10, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(0)
                         .Num(0)
                         .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "BIP66 example 11, without DERSIG", 0)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .Num(0)
                         .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "BIP66 example 11, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .Num(0)
                         .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "BIP66 example 12, without DERSIG", 0)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .Num(0));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "BIP66 example 12, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .Num(0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                     "P2PK with multi-byte hashtype, without DERSIG", 0)
             .PushSigECDSA(keys.key2)
             .EditPush(70, "01", "0101"));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                     "P2PK with multi-byte hashtype, with DERSIG",
                     SCRIPT_VERIFY_DERSIG)
             .PushSigECDSA(keys.key2)
             .EditPush(70, "01", "0101")
             .SetScriptError(ScriptError::SIG_DER));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                     "P2PK with high S but no LOW_S", 0)
             .PushSigECDSA(keys.key2, SigHashType(), 32, 33));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                     "P2PK with high S", SCRIPT_VERIFY_LOW_S)
             .PushSigECDSA(keys.key2, SigHashType(), 32, 33)
             .SetScriptError(ScriptError::SIG_HIGH_S));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
                     "P2PK with hybrid pubkey but no STRICTENC", 0)
             .PushSigECDSA(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
                     "P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC)
             .PushSigECDSA(keys.key0, SigHashType())
             .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
                                           << OP_CHECKSIG << OP_NOT,
                                 "P2PK NOT with hybrid pubkey but no STRICTENC",
                                 0)
                         .PushSigECDSA(keys.key0)
                         .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
                                           << OP_CHECKSIG << OP_NOT,
                                 "P2PK NOT with hybrid pubkey",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigECDSA(keys.key0)
                         .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(CScript()
                         << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
                     "P2PK NOT with invalid hybrid pubkey but no STRICTENC", 0)
             .PushSigECDSA(keys.key0)
             .DamagePush(10));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
                                           << OP_CHECKSIG << OP_NOT,
                                 "P2PK NOT with invalid hybrid pubkey",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigECDSA(keys.key0)
                         .DamagePush(10)
                         .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H)
                               << ToByteVector(keys.pubkey1C) << OP_2
                               << OP_CHECKMULTISIG,
                     "1-of-2 with the second 1 hybrid pubkey and no STRICTENC",
                     0)
             .Num(0)
             .PushSigECDSA(keys.key1));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H)
                                           << ToByteVector(keys.pubkey1C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "1-of-2 with the second 1 hybrid pubkey",
                                 SCRIPT_VERIFY_STRICTENC)
                         .Num(0)
                         .PushSigECDSA(keys.key1));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey0H) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "1-of-2 with the first 1 hybrid pubkey",
                                 SCRIPT_VERIFY_STRICTENC)
                         .Num(0)
                         .PushSigECDSA(keys.key1)
                         .SetScriptError(ScriptError::PUBKEYTYPE));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "P2PK with undefined hashtype but no STRICTENC", 0)
             .PushSigECDSA(keys.key1, SigHashType(5)));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "P2PK with undefined hashtype", SCRIPT_VERIFY_STRICTENC)
             .PushSigECDSA(keys.key1, SigHashType(5))
             .SetScriptError(ScriptError::SIG_HASHTYPE));
 
     // Generate P2PKH tests for invalid SigHashType
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey0.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "P2PKH with invalid sighashtype", 0)
                         .PushSigECDSA(keys.key0, SigHashType(0x21), 32, 32,
                                       Amount::zero(), 0)
                         .Push(keys.pubkey0));
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey0.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "P2PKH with invalid sighashtype and STRICTENC",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigECDSA(keys.key0, SigHashType(0x21), 32, 32,
                                       Amount::zero(), SCRIPT_VERIFY_STRICTENC)
                         .Push(keys.pubkey0)
                         // Should fail for STRICTENC
                         .SetScriptError(ScriptError::SIG_HASHTYPE));
 
     // Generate P2SH tests for invalid SigHashType
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "P2SH(P2PK) with invalid sighashtype", SCRIPT_VERIFY_P2SH,
                     true)
             .PushSigECDSA(keys.key1, SigHashType(0x21))
             .PushRedeem());
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "P2SH(P2PK) with invalid sighashtype and STRICTENC",
                     SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, true)
             .PushSigECDSA(keys.key1, SigHashType(0x21))
             .PushRedeem()
             // Should fail for STRICTENC
             .SetScriptError(ScriptError::SIG_HASHTYPE));
 
     tests.push_back(
         TestBuilder(
             CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
             "P2PK NOT with invalid sig and undefined hashtype but no STRICTENC",
             0)
             .PushSigECDSA(keys.key1, SigHashType(5))
             .DamagePush(10));
     tests.push_back(
         TestBuilder(CScript()
                         << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
                     "P2PK NOT with invalid sig and undefined hashtype",
                     SCRIPT_VERIFY_STRICTENC)
             .PushSigECDSA(keys.key1, SigHashType(5))
             .DamagePush(10)
             .SetScriptError(ScriptError::SIG_HASHTYPE));
 
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "3-of-3 with nonzero dummy", 0)
                         .Num(1)
                         .PushSigECDSA(keys.key0)
                         .PushSigECDSA(keys.key1)
                         .PushSigECDSA(keys.key2));
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "3-of-3 NOT with invalid sig and nonzero dummy",
                                 0)
                         .Num(1)
                         .PushSigECDSA(keys.key0)
                         .PushSigECDSA(keys.key1)
                         .PushSigECDSA(keys.key2)
                         .DamagePush(10));
 
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey1C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "2-of-2 with two identical keys and sigs "
                                 "pushed using OP_DUP but no SIGPUSHONLY",
                                 0)
                         .Num(0)
                         .PushSigECDSA(keys.key1)
                         .Add(CScript() << OP_DUP));
     tests.push_back(
         TestBuilder(
             CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                       << ToByteVector(keys.pubkey1C) << OP_2
                       << OP_CHECKMULTISIG,
             "2-of-2 with two identical keys and sigs pushed using OP_DUP",
             SCRIPT_VERIFY_SIGPUSHONLY)
             .Num(0)
             .PushSigECDSA(keys.key1)
             .Add(CScript() << OP_DUP)
             .SetScriptError(ScriptError::SIG_PUSHONLY));
     tests.push_back(
         TestBuilder(
             CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
             "P2SH(P2PK) with non-push scriptSig but no P2SH or SIGPUSHONLY", 0,
             true)
             .PushSigECDSA(keys.key2)
             .Add(CScript() << OP_NOP8)
             .PushRedeem());
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                     "P2PK with non-push scriptSig but with P2SH validation", 0)
             .PushSigECDSA(keys.key2)
             .Add(CScript() << OP_NOP8));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                     "P2SH(P2PK) with non-push scriptSig but no SIGPUSHONLY",
                     SCRIPT_VERIFY_P2SH, true)
             .PushSigECDSA(keys.key2)
             .Add(CScript() << OP_NOP8)
             .PushRedeem()
             .SetScriptError(ScriptError::SIG_PUSHONLY));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                     "P2SH(P2PK) with non-push scriptSig but not P2SH",
                     SCRIPT_VERIFY_SIGPUSHONLY, true)
             .PushSigECDSA(keys.key2)
             .Add(CScript() << OP_NOP8)
             .PushRedeem()
             .SetScriptError(ScriptError::SIG_PUSHONLY));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey1C) << OP_2
                               << OP_CHECKMULTISIG,
                     "2-of-2 with two identical keys and sigs pushed",
                     SCRIPT_VERIFY_SIGPUSHONLY)
             .Num(0)
             .PushSigECDSA(keys.key1)
             .PushSigECDSA(keys.key1));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK with unnecessary input but no CLEANSTACK",
                     SCRIPT_VERIFY_P2SH)
             .Num(11)
             .PushSigECDSA(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK with unnecessary input",
                     SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH)
             .Num(11)
             .PushSigECDSA(keys.key0)
             .SetScriptError(ScriptError::CLEANSTACK));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2SH with unnecessary input but no CLEANSTACK",
                     SCRIPT_VERIFY_P2SH, true)
             .Num(11)
             .PushSigECDSA(keys.key0)
             .PushRedeem());
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2SH with unnecessary input",
                     SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true)
             .Num(11)
             .PushSigECDSA(keys.key0)
             .PushRedeem()
             .SetScriptError(ScriptError::CLEANSTACK));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2SH with CLEANSTACK",
                     SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true)
             .PushSigECDSA(keys.key0)
             .PushRedeem());
 
     static const Amount TEST_AMOUNT(int64_t(12345000000000) * SATOSHI);
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK FORKID", SCRIPT_ENABLE_SIGHASH_FORKID, false,
                     TEST_AMOUNT)
             .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
                           TEST_AMOUNT));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK INVALID AMOUNT", SCRIPT_ENABLE_SIGHASH_FORKID, false,
                     TEST_AMOUNT)
             .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
                           TEST_AMOUNT + SATOSHI)
             .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK INVALID FORKID", SCRIPT_VERIFY_STRICTENC, false,
                     TEST_AMOUNT)
             .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
                           TEST_AMOUNT)
             .SetScriptError(ScriptError::ILLEGAL_FORKID));
 
     // Test replay protection
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK REPLAY PROTECTED",
                     SCRIPT_ENABLE_SIGHASH_FORKID |
                         SCRIPT_ENABLE_REPLAY_PROTECTION,
                     false, TEST_AMOUNT)
             .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
                           TEST_AMOUNT,
                           SCRIPT_ENABLE_SIGHASH_FORKID |
                               SCRIPT_ENABLE_REPLAY_PROTECTION));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK REPLAY PROTECTED",
                     SCRIPT_ENABLE_SIGHASH_FORKID |
                         SCRIPT_ENABLE_REPLAY_PROTECTION,
                     false, TEST_AMOUNT)
             .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
                           TEST_AMOUNT, SCRIPT_ENABLE_SIGHASH_FORKID)
             .SetScriptError(ScriptError::EVAL_FALSE));
 
     // Test OP_CHECKDATASIG
     const uint32_t checkdatasigflags =
         SCRIPT_VERIFY_STRICTENC | SCRIPT_VERIFY_NULLFAIL;
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
                     "Standard CHECKDATASIG", checkdatasigflags)
             .PushDataSigECDSA(keys.key1, {})
             .Num(0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIG << OP_NOT,
                                 "CHECKDATASIG with NULLFAIL flags",
                                 checkdatasigflags)
                         .PushDataSigECDSA(keys.key1, {})
                         .Num(1)
                         .SetScriptError(ScriptError::SIG_NULLFAIL));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIG << OP_NOT,
                                 "CHECKDATASIG without NULLFAIL flags",
                                 checkdatasigflags & ~SCRIPT_VERIFY_NULLFAIL)
                         .PushDataSigECDSA(keys.key1, {})
                         .Num(1));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIG << OP_NOT,
                                 "CHECKDATASIG empty signature",
                                 checkdatasigflags)
                         .Num(0)
                         .Num(0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
                     "CHECKDATASIG with High S but no Low S", checkdatasigflags)
             .PushDataSigECDSA(keys.key1, {}, 32, 33)
             .Num(0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
                     "CHECKDATASIG with High S",
                     checkdatasigflags | SCRIPT_VERIFY_LOW_S)
             .PushDataSigECDSA(keys.key1, {}, 32, 33)
             .Num(0)
             .SetScriptError(ScriptError::SIG_HIGH_S));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
                     "CHECKDATASIG with too little R padding but no DERSIG",
                     checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
             .PushDataSigECDSA(keys.key1, {}, 33, 32)
             .EditPush(1, "45022100", "440220")
             .Num(0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
                     "CHECKDATASIG with too little R padding", checkdatasigflags)
             .PushDataSigECDSA(keys.key1, {}, 33, 32)
             .EditPush(1, "45022100", "440220")
             .Num(0)
             .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
                     "CHECKDATASIG with hybrid pubkey but no STRICTENC",
                     checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
             .PushDataSigECDSA(keys.key0, {})
             .Num(0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
                     "CHECKDATASIG with hybrid pubkey", checkdatasigflags)
             .PushDataSigECDSA(keys.key0, {})
             .Num(0)
             .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG
                               << OP_NOT,
                     "CHECKDATASIG with invalid hybrid pubkey but no STRICTENC",
                     0)
             .PushDataSigECDSA(keys.key0, {})
             .DamagePush(10)
             .Num(0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
                     "CHECKDATASIG with invalid hybrid pubkey",
                     checkdatasigflags)
             .PushDataSigECDSA(keys.key0, {})
             .DamagePush(10)
             .Num(0)
             .SetScriptError(ScriptError::PUBKEYTYPE));
 
     // Test OP_CHECKDATASIGVERIFY
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "Standard CHECKDATASIGVERIFY",
                                 checkdatasigflags)
                         .PushDataSigECDSA(keys.key1, {})
                         .Num(0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIGVERIFY with NULLFAIL flags",
                                 checkdatasigflags)
                         .PushDataSigECDSA(keys.key1, {})
                         .Num(1)
                         .SetScriptError(ScriptError::SIG_NULLFAIL));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIGVERIFY without NULLFAIL flags",
                                 checkdatasigflags & ~SCRIPT_VERIFY_NULLFAIL)
                         .PushDataSigECDSA(keys.key1, {})
                         .Num(1)
                         .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIGVERIFY empty signature",
                                 checkdatasigflags)
                         .Num(0)
                         .Num(0)
                         .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIG with High S but no Low S",
                                 checkdatasigflags)
                         .PushDataSigECDSA(keys.key1, {}, 32, 33)
                         .Num(0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIG with High S",
                                 checkdatasigflags | SCRIPT_VERIFY_LOW_S)
                         .PushDataSigECDSA(keys.key1, {}, 32, 33)
                         .Num(0)
                         .SetScriptError(ScriptError::SIG_HIGH_S));
     tests.push_back(
         TestBuilder(
             CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIGVERIFY
                       << OP_TRUE,
             "CHECKDATASIGVERIFY with too little R padding but no DERSIG",
             checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
             .PushDataSigECDSA(keys.key1, {}, 33, 32)
             .EditPush(1, "45022100", "440220")
             .Num(0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIGVERIFY with too little R padding",
                                 checkdatasigflags)
                         .PushDataSigECDSA(keys.key1, {}, 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .Num(0)
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
                               << OP_CHECKDATASIGVERIFY << OP_TRUE,
                     "CHECKDATASIGVERIFY with hybrid pubkey but no STRICTENC",
                     checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
             .PushDataSigECDSA(keys.key0, {})
             .Num(0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIGVERIFY with hybrid pubkey",
                                 checkdatasigflags)
                         .PushDataSigECDSA(keys.key0, {})
                         .Num(0)
                         .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(
             CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIGVERIFY
                       << OP_TRUE,
             "CHECKDATASIGVERIFY with invalid hybrid pubkey but no STRICTENC", 0)
             .PushDataSigECDSA(keys.key0, {})
             .DamagePush(10)
             .Num(0)
             .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIGVERIFY with invalid hybrid pubkey",
                                 checkdatasigflags)
                         .PushDataSigECDSA(keys.key0, {})
                         .DamagePush(10)
                         .Num(0)
                         .SetScriptError(ScriptError::PUBKEYTYPE));
 
     // Test all six CHECK*SIG* opcodes with Schnorr signatures.
     // - STRICTENC flag on/off.
     // - test with different key / mismatching key
 
     // CHECKSIG and Schnorr
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "CHECKSIG Schnorr", 0)
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "CHECKSIG Schnorr w/ STRICTENC", SCRIPT_VERIFY_STRICTENC)
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "CHECKSIG Schnorr other key", SCRIPT_VERIFY_STRICTENC)
             .PushSigSchnorr(keys.key1));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
                                           << OP_CHECKSIG << OP_NOT,
                                 "CHECKSIG Schnorr mismatched key",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigSchnorr(keys.key1));
 
     // CHECKSIGVERIFY and Schnorr
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
                                           << OP_CHECKSIGVERIFY << OP_1,
                                 "CHECKSIGVERIFY Schnorr", 0)
                         .PushSigSchnorr(keys.key0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
                                           << OP_CHECKSIGVERIFY << OP_1,
                                 "CHECKSIGVERIFY Schnorr w/ STRICTENC",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigSchnorr(keys.key0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1)
                                           << OP_CHECKSIGVERIFY << OP_1,
                                 "CHECKSIGVERIFY Schnorr other key",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigSchnorr(keys.key1));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
                                           << OP_CHECKSIGVERIFY << OP_1,
                                 "CHECKSIGVERIFY Schnorr mismatched key",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigSchnorr(keys.key1)
                         .SetScriptError(ScriptError::CHECKSIGVERIFY));
 
     // CHECKDATASIG and Schnorr
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
                                           << OP_CHECKDATASIG,
                                 "CHECKDATASIG Schnorr", 0)
                         .PushDataSigSchnorr(keys.key0, {}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
                                           << OP_CHECKDATASIG,
                                 "CHECKDATASIG Schnorr w/ STRICTENC",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key0, {}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1)
                                           << OP_CHECKDATASIG,
                                 "CHECKDATASIG Schnorr other key",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
                                           << OP_CHECKDATASIG << OP_NOT,
                                 "CHECKDATASIG Schnorr mismatched key",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {}));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1)
                                           << OP_CHECKDATASIG,
                                 "CHECKDATASIG Schnorr other message",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {1}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1)
                                           << OP_CHECKDATASIG << OP_NOT,
                                 "CHECKDATASIG Schnorr wrong message",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {1}));
 
     // CHECKDATASIGVERIFY and Schnorr
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
                                           << OP_CHECKDATASIGVERIFY << OP_1,
                                 "CHECKDATASIGVERIFY Schnorr", 0)
                         .PushDataSigSchnorr(keys.key0, {}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
                                           << OP_CHECKDATASIGVERIFY << OP_1,
                                 "CHECKDATASIGVERIFY Schnorr w/ STRICTENC",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key0, {}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1)
                                           << OP_CHECKDATASIGVERIFY << OP_1,
                                 "CHECKDATASIGVERIFY Schnorr other key",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
                                           << OP_CHECKDATASIGVERIFY << OP_1,
                                 "CHECKDATASIGVERIFY Schnorr mismatched key",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {})
                         .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1)
                                           << OP_CHECKDATASIGVERIFY << OP_1,
                                 "CHECKDATASIGVERIFY Schnorr other message",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {1}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1)
                                           << OP_CHECKDATASIGVERIFY << OP_1,
                                 "CHECKDATASIGVERIFY Schnorr wrong message",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {1})
                         .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
 
     // CHECKMULTISIG 1-of-1 and Schnorr
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
                                           << OP_1 << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG Schnorr w/ no STRICTENC", 0)
                         .Num(0)
                         .PushSigSchnorr(keys.key0)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
                                           << OP_1 << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG Schnorr w/ STRICTENC",
                                 SCRIPT_VERIFY_STRICTENC)
                         .Num(0)
                         .PushSigSchnorr(keys.key0)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
 
     // Test multisig with multiple Schnorr signatures
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "Schnorr 3-of-3", 0)
                         .Num(0)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key1)
                         .PushSigSchnorr(keys.key2)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "Schnorr-ECDSA-mixed 3-of-3", 0)
                         .Num(0)
                         .PushSigECDSA(keys.key0)
                         .PushSigECDSA(keys.key1)
                         .PushSigSchnorr(keys.key2)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
 
     // CHECKMULTISIGVERIFY 1-of-1 and Schnorr
     tests.push_back(
         TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
                               << OP_CHECKMULTISIGVERIFY << OP_1,
                     "CHECKMULTISIGVERIFY Schnorr w/ no STRICTENC", 0)
             .Num(0)
             .PushSigSchnorr(keys.key0)
             .SetScriptError(ScriptError::SIG_BADLENGTH));
     tests.push_back(TestBuilder(CScript()
                                     << OP_1 << ToByteVector(keys.pubkey0)
                                     << OP_1 << OP_CHECKMULTISIGVERIFY << OP_1,
                                 "CHECKMULTISIGVERIFY Schnorr w/ STRICTENC",
                                 SCRIPT_VERIFY_STRICTENC)
                         .Num(0)
                         .PushSigSchnorr(keys.key0)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
 
     // Test damaged Schnorr signatures
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
                                           << OP_CHECKSIG << OP_NOT,
                                 "Schnorr P2PK, bad sig", 0)
                         .PushSigSchnorr(keys.key0)
                         .DamagePush(10));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
                                           << OP_CHECKSIG << OP_NOT,
                                 "Schnorr P2PK, bad sig STRICTENC",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigSchnorr(keys.key0)
                         .DamagePush(10));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
                                           << OP_CHECKSIG << OP_NOT,
                                 "Schnorr P2PK, bad sig NULLFAIL",
                                 SCRIPT_VERIFY_NULLFAIL)
                         .PushSigSchnorr(keys.key0)
                         .DamagePush(10)
                         .SetScriptError(ScriptError::SIG_NULLFAIL));
 
     // Make sure P2PKH works with Schnorr
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey1C.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "Schnorr P2PKH", 0)
                         .PushSigSchnorr(keys.key1)
                         .Push(keys.pubkey1C));
 
     // Test of different pubkey encodings with Schnorr
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
                     "Schnorr P2PK with compressed pubkey",
                     SCRIPT_VERIFY_STRICTENC)
             .PushSigSchnorr(keys.key0, SigHashType()));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "Schnorr P2PK with uncompressed pubkey",
                     SCRIPT_VERIFY_STRICTENC)
             .PushSigSchnorr(keys.key0, SigHashType()));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
                     "Schnorr P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC)
             .PushSigSchnorr(keys.key0, SigHashType())
             .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
                     "Schnorr P2PK with hybrid pubkey but no STRICTENC", 0)
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(
             CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
             "Schnorr P2PK NOT with damaged hybrid pubkey but no STRICTENC", 0)
             .PushSigSchnorr(keys.key0)
             .DamagePush(10));
 
     // Ensure sighash types get checked with schnorr
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "Schnorr P2PK with undefined basehashtype and STRICTENC",
                     SCRIPT_VERIFY_STRICTENC)
             .PushSigSchnorr(keys.key1, SigHashType(5))
             .SetScriptError(ScriptError::SIG_HASHTYPE));
     tests.push_back(
         TestBuilder(CScript() << OP_DUP << OP_HASH160
                               << ToByteVector(keys.pubkey0.GetID())
                               << OP_EQUALVERIFY << OP_CHECKSIG,
                     "Schnorr P2PKH with invalid sighashtype but no STRICTENC",
                     0)
             .PushSigSchnorr(keys.key0, SigHashType(0x21), Amount::zero(), 0)
             .Push(keys.pubkey0));
     tests.push_back(
         TestBuilder(CScript() << OP_DUP << OP_HASH160
                               << ToByteVector(keys.pubkey0.GetID())
                               << OP_EQUALVERIFY << OP_CHECKSIG,
                     "Schnorr P2PKH with invalid sighashtype and STRICTENC",
                     SCRIPT_VERIFY_STRICTENC)
             .PushSigSchnorr(keys.key0, SigHashType(0x21), Amount::zero(),
                             SCRIPT_VERIFY_STRICTENC)
             .Push(keys.pubkey0)
             .SetScriptError(ScriptError::SIG_HASHTYPE));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "Schnorr P2PK anyonecanpay", 0)
             .PushSigSchnorr(keys.key1, SigHashType().withAnyoneCanPay()));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "Schnorr P2PK anyonecanpay marked with normal hashtype", 0)
             .PushSigSchnorr(keys.key1, SigHashType().withAnyoneCanPay())
             .EditPush(64, "81", "01")
             .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "Schnorr P2PK with forkID",
                     SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SIGHASH_FORKID)
             .PushSigSchnorr(keys.key1, SigHashType().withForkId()));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "Schnorr P2PK with non-forkID sig",
                     SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SIGHASH_FORKID)
             .PushSigSchnorr(keys.key1)
             .SetScriptError(ScriptError::MUST_USE_FORKID));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "Schnorr P2PK with cheater forkID bit",
                     SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SIGHASH_FORKID)
             .PushSigSchnorr(keys.key1)
             .EditPush(64, "01", "41")
             .SetScriptError(ScriptError::EVAL_FALSE));
 
     {
         // There is a point with x = 7 + order but not x = 7.
         // Since r = x mod order, this can have valid signatures, as
         // demonstrated here.
         std::vector<uint8_t> rdata{7};
         std::vector<uint8_t> sdata{7};
         tests.push_back(TestBuilder(CScript() << OP_CHECKSIG,
                                     "recovered-pubkey CHECKSIG 7,7 (wrapped r)",
                                     SCRIPT_VERIFY_STRICTENC)
                             .PushECDSASigFromParts(rdata, sdata)
                             .PushECDSARecoveredPubKey(rdata, sdata));
     }
     {
         // Arbitrary r value that is 29 bytes long, to give room for varying
         // the length of s:
         std::vector<uint8_t> rdata = ParseHex(
             "776879206d757374207765207375666665722077697468206563647361");
         std::vector<uint8_t> sdata(58 - rdata.size() - 1, 33);
         tests.push_back(
             TestBuilder(CScript() << OP_CHECKSIG,
                         "recovered-pubkey CHECKSIG with 63-byte DER",
                         SCRIPT_VERIFY_STRICTENC)
                 .PushECDSASigFromParts(rdata, sdata)
                 .PushECDSARecoveredPubKey(rdata, sdata));
     }
     {
         // 64-byte ECDSA sig does not work.
         std::vector<uint8_t> rdata = ParseHex(
             "776879206d757374207765207375666665722077697468206563647361");
         std::vector<uint8_t> sdata(58 - rdata.size(), 33);
         tests.push_back(
             TestBuilder(CScript() << OP_CHECKSIG,
                         "recovered-pubkey CHECKSIG with 64-byte DER",
                         SCRIPT_VERIFY_STRICTENC)
                 .PushECDSASigFromParts(rdata, sdata)
                 .PushECDSARecoveredPubKey(rdata, sdata)
                 .SetScriptError(ScriptError::EVAL_FALSE));
     }
     {
         std::vector<uint8_t> rdata = ParseHex(
             "776879206d757374207765207375666665722077697468206563647361");
         std::vector<uint8_t> sdata(58 - rdata.size() + 1, 33);
         tests.push_back(
             TestBuilder(CScript() << OP_CHECKSIG,
                         "recovered-pubkey CHECKSIG with 65-byte DER",
                         SCRIPT_VERIFY_STRICTENC)
                 .PushECDSASigFromParts(rdata, sdata)
                 .PushECDSARecoveredPubKey(rdata, sdata));
     }
     {
         // Try 64-byte ECDSA sig again, in multisig.
         std::vector<uint8_t> rdata = ParseHex(
             "776879206d757374207765207375666665722077697468206563647361");
         std::vector<uint8_t> sdata(58 - rdata.size(), 33);
         tests.push_back(
             TestBuilder(CScript()
                             << OP_1 << OP_SWAP << OP_1 << OP_CHECKMULTISIG,
                         "recovered-pubkey CHECKMULTISIG with 64-byte DER",
                         SCRIPT_VERIFY_STRICTENC)
                 .Num(0)
                 .PushECDSASigFromParts(rdata, sdata)
                 .PushECDSARecoveredPubKey(rdata, sdata)
                 .SetScriptError(ScriptError::SIG_BADLENGTH));
     }
 
     // New-multisig tests follow. New multisig will activate with a bunch of
     // related flags active from other upgrades, so we do tests with this group
     // of flags turned on:
     uint32_t newmultisigflags =
         SCRIPT_ENABLE_SCHNORR_MULTISIG | SCRIPT_VERIFY_NULLFAIL |
         SCRIPT_VERIFY_MINIMALDATA | SCRIPT_VERIFY_STRICTENC;
 
     // Tests of the legacy multisig (null dummy element), but with the
     // SCRIPT_ENABLE_SCHNORR_MULTISIG flag turned on. These show the desired
     // legacy behaviour that should be retained.
     tests.push_back(
         TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H)
                               << ToByteVector(keys.pubkey1C) << OP_2
                               << OP_CHECKMULTISIG,
                     "1-of-2 with unchecked hybrid pubkey with SCHNORR_MULTISIG",
                     newmultisigflags)
             .Num(0)
             .PushSigECDSA(keys.key1));
     tests.push_back(
         TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey0H) << OP_2
                               << OP_CHECKMULTISIG,
                     "1-of-2 with checked hybrid pubkey with SCHNORR_MULTISIG",
                     newmultisigflags)
             .Num(0)
             .PushSigECDSA(keys.key1)
             .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(
             CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
                       << OP_CHECKMULTISIG,
             "Legacy 1-of-1 Schnorr w/ SCHNORR_MULTISIG but no STRICTENC",
             newmultisigflags & ~SCRIPT_VERIFY_STRICTENC)
             .Num(0)
             .PushSigSchnorr(keys.key0)
             .SetScriptError(ScriptError::SIG_BADLENGTH));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
                                           << OP_1 << OP_CHECKMULTISIG,
                                 "Legacy 1-of-1 Schnorr w/ SCHNORR_MULTISIG",
                                 newmultisigflags)
                         .Num(0)
                         .PushSigSchnorr(keys.key0)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "Legacy 3-of-3 Schnorr w/ SCHNORR_MULTISIG",
                                 newmultisigflags)
                         .Num(0)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key1)
                         .PushSigSchnorr(keys.key2)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
     tests.push_back(
         TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "Legacy 3-of-3 mixed Schnorr-ECDSA w/ SCHNORR_MULTISIG",
                     newmultisigflags)
             .Num(0)
             .PushSigECDSA(keys.key0)
             .PushSigECDSA(keys.key1)
             .PushSigSchnorr(keys.key2)
             .SetScriptError(ScriptError::SIG_BADLENGTH));
     {
         // Try valid 64-byte ECDSA sig in multisig.
         std::vector<uint8_t> rdata = ParseHex(
             "776879206d757374207765207375666665722077697468206563647361");
         std::vector<uint8_t> sdata(58 - rdata.size(), 33);
         tests.push_back(TestBuilder(CScript() << OP_1 << OP_SWAP << OP_1
                                               << OP_CHECKMULTISIG,
                                     "recovered-pubkey CHECKMULTISIG with "
                                     "64-byte DER w/ SCHNORR_MULTISIG",
                                     newmultisigflags)
                             .Num(0)
                             .PushECDSASigFromParts(rdata, sdata)
                             .PushECDSARecoveredPubKey(rdata, sdata)
                             .SetScriptError(ScriptError::SIG_BADLENGTH));
     }
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "CHECKMULTISIG 2-of-3 w/ SCHNORR_MULTISIG "
                                 "(return-false still valid via legacy mode)",
                                 newmultisigflags)
                         .Num(0)
                         .Num(0)
                         .Num(0));
     tests.push_back(TestBuilder(CScript() << OP_0 << OP_0 << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 0-of-0 w/ SCHNORR_MULTISIG",
                                 newmultisigflags)
                         .Num(0));
     tests.push_back(
         TestBuilder(CScript() << OP_0 << ToByteVector(ParseHex("BEEF")) << OP_1
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 0-of-1 w/ SCHNORR_MULTISIG, null dummy",
                     newmultisigflags)
             .Num(0));
 
     // Tests of schnorr checkmultisig actually turned on (flag on & dummy
     // element is not null).
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
                                           << OP_1 << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 1-of-1 Schnorr",
                                 newmultisigflags)
                         .Num(0b1)
                         .PushSigSchnorr(keys.key0));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
                                           << OP_1 << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 1-of-1 Schnorr, nonminimal bits",
                                 newmultisigflags)
                         .Push("0100")
                         .PushSigSchnorr(keys.key0)
                         .SetScriptError(ScriptError::INVALID_BITFIELD_SIZE));
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 3-of-3 Schnorr",
                                 newmultisigflags)
                         .Num(0b111)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key1)
                         .PushSigSchnorr(keys.key2));
     tests.push_back(TestBuilder(CScript() << OP_4 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 4-of-3 Schnorr",
                                 newmultisigflags)
                         .Num(0b1111)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key1)
                         .PushSigSchnorr(keys.key2)
                         .SetScriptError(ScriptError::SIG_COUNT));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 2-of-3 (110) Schnorr",
                                 newmultisigflags)
                         .Num(0b110)
                         .PushSigSchnorr(keys.key1)
                         .PushSigSchnorr(keys.key2));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 2-of-3 (101) Schnorr",
                                 newmultisigflags)
                         .Num(0b101)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key2));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 2-of-3 (011) Schnorr",
                                 newmultisigflags)
                         .Num(0b011)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key1));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 Schnorr, mismatched bits Schnorr",
                     newmultisigflags)
             .Num(0b011)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key2)
             .SetScriptError(ScriptError::SIG_NULLFAIL));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 2-of-3 Schnorr, all bits set",
                                 newmultisigflags)
                         .Num(0b111)
                         .PushSigSchnorr(keys.key1)
                         .PushSigSchnorr(keys.key2)
                         .SetScriptError(ScriptError::INVALID_BIT_COUNT));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 Schnorr, extra high bit set",
                     newmultisigflags)
             .Num(0b1110)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key1)
             .SetScriptError(ScriptError::INVALID_BIT_RANGE));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 Schnorr, too high bit set",
                     newmultisigflags)
             .Num(0b1010)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key1)
             .SetScriptError(ScriptError::INVALID_BIT_RANGE));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 Schnorr, too few bits set",
                     newmultisigflags)
             .Num(0b010)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key1)
             .SetScriptError(ScriptError::INVALID_BIT_COUNT));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 Schnorr, with no bits set "
                     "(attempt to malleate return-false)",
                     newmultisigflags)
             .Push("00")
             .Num(0)
             .Num(0)
             .SetScriptError(ScriptError::INVALID_BIT_COUNT));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG null dummy with schnorr sigs "
                                 "(with SCHNORR_MULTISIG on)",
                                 newmultisigflags)
                         .Num(0)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key1)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 Schnorr, misordered signatures",
                     newmultisigflags)
             .Num(0b011)
             .PushSigSchnorr(keys.key1)
             .PushSigSchnorr(keys.key0)
             .SetScriptError(ScriptError::SIG_NULLFAIL));
     tests.push_back(
         TestBuilder(
             CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                       << ToByteVector(keys.pubkey1C) << OP_DUP << OP_2DUP
                       << OP_2DUP << ToByteVector(keys.pubkey2C) << OP_8
                       << OP_CHECKMULTISIG,
             "CHECKMULTISIG 2-of-8 Schnorr, right way to represent 0b10000001",
             newmultisigflags)
             .Num(-1)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key2));
     tests.push_back(
         TestBuilder(
             CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                       << ToByteVector(keys.pubkey1C) << OP_DUP << OP_2DUP
                       << OP_2DUP << ToByteVector(keys.pubkey2C) << OP_8
                       << OP_CHECKMULTISIG,
             "CHECKMULTISIG 2-of-8 Schnorr, wrong way to represent 0b10000001",
             newmultisigflags)
             .Num(0b10000001)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key2)
             .SetScriptError(ScriptError::INVALID_BITFIELD_SIZE));
     tests.push_back(
         TestBuilder(CScript() << OP_1 << -1 << -1 << -1 << -1 << -1
                               << ToByteVector(keys.pubkey0C) << -1 << 7
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 1-of-7 Schnorr, second-to-last key",
                     newmultisigflags)
             .Push("20")
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << OP_1 << -1 << -1 << -1 << -1 << -1 << -1 << -1
                               << -1 << -1 << -1 << ToByteVector(keys.pubkey0C)
                               << -1 << -1 << 13 << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 1-of-13 Schnorr, third-to-last key",
                     newmultisigflags)
             .Push("0004")
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(CScript()
                         << OP_OVER << OP_DUP << OP_DUP << OP_2DUP << OP_3DUP
                         << OP_3DUP << OP_3DUP << OP_3DUP << 20
                         << ToByteVector(keys.pubkey0C)
                         << ToByteVector(keys.pubkey1C)
                         << ToByteVector(keys.pubkey2C) << OP_OVER << OP_DUP
                         << OP_DUP << OP_2DUP << OP_3DUP << OP_3DUP << OP_3DUP
                         << OP_3DUP << 20 << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 20-of-20 Schnorr", newmultisigflags)
             .Push("ffff0f")
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key1)
             .PushSigSchnorr(keys.key2));
     tests.push_back(
         TestBuilder(
             CScript() << OP_OVER << OP_DUP << OP_DUP << OP_2DUP << OP_3DUP
                       << OP_3DUP << OP_3DUP << OP_3DUP << 20
                       << ToByteVector(keys.pubkey0C)
                       << ToByteVector(keys.pubkey1C)
                       << ToByteVector(keys.pubkey2C) << OP_OVER << OP_DUP
                       << OP_DUP << OP_2DUP << OP_3DUP << OP_3DUP << OP_3DUP
                       << OP_3DUP << 20 << OP_CHECKMULTISIG,
             "CHECKMULTISIG 20-of-20 Schnorr, checkbits +1", newmultisigflags)
             .Push("000010")
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key1)
             .PushSigSchnorr(keys.key2)
             .SetScriptError(ScriptError::INVALID_BIT_RANGE));
     tests.push_back(
         TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0C) << OP_DUP
                               << ToByteVector(keys.pubkey1C) << OP_3DUP
                               << OP_3DUP << OP_3DUP << OP_3DUP << OP_3DUP
                               << OP_3DUP << 21 << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 1-of-21 Schnorr", newmultisigflags)
             .Push("000010")
             .PushSigSchnorr(keys.key0)
             .SetScriptError(ScriptError::PUBKEY_COUNT));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << OP_DUP << OP_2DUP << OP_3DUP
                                           << OP_3DUP << OP_3DUP << OP_3DUP
                                           << OP_3DUP << 20 << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 1-of-20 Schnorr, first key",
                                 newmultisigflags)
                         .Push("010000")
                         .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(
             CScript() << OP_1 << ToByteVector(keys.pubkey0C)
                       << ToByteVector(keys.pubkey1C) << OP_DUP << OP_2DUP
                       << OP_3DUP << OP_3DUP << OP_3DUP << OP_3DUP << OP_3DUP
                       << 20 << OP_CHECKMULTISIG,
             "CHECKMULTISIG 1-of-20 Schnorr, first key, wrong endianness",
             newmultisigflags)
             .Push("000001")
             .PushSigSchnorr(keys.key0)
             .SetScriptError(ScriptError::SIG_NULLFAIL));
     tests.push_back(
         TestBuilder(
             CScript() << OP_1 << ToByteVector(keys.pubkey0C) << OP_2DUP
                       << OP_2DUP << OP_3DUP << OP_3DUP << OP_3DUP << OP_3DUP
                       << OP_3DUP << 20 << OP_CHECKMULTISIG,
             "CHECKMULTISIG 1-of-20 Schnorr, truncating zeros not allowed",
             newmultisigflags)
             .Num(1)
             .PushSigSchnorr(keys.key0)
             .SetScriptError(ScriptError::INVALID_BITFIELD_SIZE));
     tests.push_back(
         TestBuilder(CScript()
                         << OP_1 << ToByteVector(keys.pubkey0C) << OP_DUP
                         << OP_2DUP << OP_3DUP << OP_3DUP << OP_3DUP << OP_3DUP
                         << OP_3DUP << ToByteVector(keys.pubkey1C) << 20
                         << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 1-of-20 Schnorr, last key", newmultisigflags)
             .Push("000008")
             .PushSigSchnorr(keys.key1));
     tests.push_back(
         TestBuilder(CScript()
                         << OP_1 << ToByteVector(keys.pubkey0C) << OP_DUP
                         << OP_2DUP << OP_3DUP << OP_3DUP << OP_3DUP << OP_3DUP
                         << OP_3DUP << ToByteVector(keys.pubkey1C) << 20
                         << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 1-of-20 Schnorr, last key, wrong endianness",
                     newmultisigflags)
             .Push("080000")
             .PushSigSchnorr(keys.key1)
             .SetScriptError(ScriptError::SIG_NULLFAIL));
     tests.push_back(TestBuilder(CScript()
                                     << OP_1 << ToByteVector(keys.pubkey0C)
                                     << OP_DUP << OP_2DUP << OP_3DUP << OP_3DUP
                                     << OP_3DUP << OP_3DUP << OP_3DUP
                                     << ToByteVector(keys.pubkey1C) << 20
                                     << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 1-of-20 Schnorr, last key, "
                                 "truncating zeros not allowed",
                                 newmultisigflags)
                         .Push("0800")
                         .PushSigSchnorr(keys.key1)
                         .SetScriptError(ScriptError::INVALID_BITFIELD_SIZE));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(ParseHex("BEEF"))
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 (110) Schnorr, first key garbage",
                     newmultisigflags)
             .Num(0b110)
             .PushSigSchnorr(keys.key1)
             .PushSigSchnorr(keys.key2));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(ParseHex("BEEF"))
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 (011) Schnorr, first key garbage",
                     newmultisigflags)
             .Num(0b011)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key1)
             .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(ParseHex("BEEF")) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 (011) Schnorr, last key garbage",
                     newmultisigflags)
             .Num(0b011)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key1));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(ParseHex("BEEF")) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 (110) Schnorr, last key garbage",
                     newmultisigflags)
             .Num(0b110)
             .PushSigSchnorr(keys.key1)
             .PushSigSchnorr(keys.key2)
             .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(
             CScript() << OP_0 << OP_0 << OP_CHECKMULTISIG,
             "CHECKMULTISIG 0-of-0 with SCHNORR_MULTISIG, dummy must be null",
             newmultisigflags)
             .Push("00")
             .SetScriptError(ScriptError::INVALID_BITFIELD_SIZE));
     tests.push_back(TestBuilder(CScript()
                                     << OP_0 << ToByteVector(ParseHex("BEEF"))
                                     << OP_1 << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 0-of-1 with SCHNORR_MULTISIG, "
                                 "dummy need not be null",
                                 newmultisigflags)
                         .Push("00"));
     tests.push_back(
         TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
                               << OP_CHECKMULTISIGVERIFY << OP_1,
                     "OP_CHECKMULTISIGVERIFY Schnorr", newmultisigflags)
             .Num(0b1)
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 1-of-1 ECDSA signature in Schnorr mode",
                     newmultisigflags)
             .Num(0b1)
             .PushSigECDSA(keys.key0)
             .SetScriptError(ScriptError::SIG_NONSCHNORR));
     tests.push_back(
         TestBuilder(
             CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                       << ToByteVector(keys.pubkey1C)
                       << ToByteVector(keys.pubkey2C) << OP_3
                       << OP_CHECKMULTISIG,
             "CHECKMULTISIG 3-of-3 Schnorr with mixed-in ECDSA signature",
             newmultisigflags)
             .Num(0b111)
             .PushSigECDSA(keys.key0)
             .PushSigSchnorr(keys.key1)
             .PushSigSchnorr(keys.key2)
             .SetScriptError(ScriptError::SIG_NONSCHNORR));
 
     // SigChecks tests follow. We want to primarily focus on behaviour with
     // the modern set of (relevant) flags.
     uint32_t sigchecksflags =
         SCRIPT_ENABLE_SCHNORR_MULTISIG | SCRIPT_VERIFY_NULLFAIL |
         SCRIPT_VERIFY_MINIMALDATA | SCRIPT_VERIFY_STRICTENC |
         SCRIPT_VERIFY_INPUT_SIGCHECKS | SCRIPT_VERIFY_P2SH;
     // First, try some important use cases that we want to make sure are
     // supported but that have high density of sigchecks.
     tests.push_back(TestBuilder(CScript() << 1 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << 3
                                           << OP_CHECKMULTISIG,
                                 "SigChecks on bare CHECKMULTISIG 1-of-3 ECDSA",
                                 sigchecksflags)
                         .Num(0)
                         .PushSigECDSA(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << 1 << ToByteVector(keys.pubkey0C) << -1 << -1
                               << -1 << -1 << -1 << -1 << -1 << -1 << -1 << -1
                               << -1 << -1 << -1 << -1 << -1 << -1 << -1 << -1
                               << -1 << 20 << OP_CHECKMULTISIG,
                     "SigChecks on bare CHECKMULTISIG 1-of-20 Schnorr",
                     sigchecksflags)
             .Push("010000")
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
                     "SigChecks on P2PK Schnorr", sigchecksflags)
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
                     "SigChecks on P2PK ECDSA", sigchecksflags)
             .PushSigECDSA(keys.key0));
     tests.push_back(
         TestBuilder(
             CScript()
                 << 1 << ToByteVector(keys.pubkey0C)
                 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C)
                 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C)
                 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C)
                 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C)
                 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C)
                 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C)
                 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C)
                 << 15 << OP_CHECKMULTISIG,
             "SigChecks on P2SH CHECKMULTISIG 1-of-15 ECDSA with compressed "
             "keys",
             sigchecksflags, true)
             .Num(0)
             .PushSigECDSA(keys.key0)
             .PushRedeem());
     tests.push_back(
         TestBuilder(CScript()
                         << ToByteVector(keys.pubkey0C) << 0 << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_DROP,
                     "Null signatures make no SigChecks (CHECKSIG)",
                     sigchecksflags, true)
             .PushRedeem());
     tests.push_back(
         TestBuilder(CScript()
                         << 0 << ToByteVector(keys.pubkey0C) << 0 << 0
                         << OP_2OVER << OP_CHECKDATASIG << OP_2OVER
                         << OP_CHECKDATASIG << OP_2OVER << OP_CHECKDATASIG
                         << OP_2OVER << OP_CHECKDATASIG << OP_2OVER
                         << OP_CHECKDATASIG << OP_2OVER << OP_CHECKDATASIG
                         << OP_2OVER << OP_CHECKDATASIG << OP_2OVER
                         << OP_CHECKDATASIG << OP_2OVER << OP_CHECKDATASIG
                         << OP_2OVER << OP_CHECKDATASIG << OP_2OVER
                         << OP_CHECKDATASIG << OP_2OVER << OP_CHECKDATASIG
                         << OP_2OVER << OP_CHECKDATASIG << OP_2OVER
                         << OP_CHECKDATASIG << OP_2OVER << OP_CHECKDATASIG
                         << OP_2OVER << OP_CHECKDATASIG << OP_2DROP << OP_NIP,
                     "Null signatures make no SigChecks (CHECKDATASIG)",
                     sigchecksflags, true)
             .PushRedeem());
     // Note that the following test case is "legacy-only", there is no schnorr
     // counterpart since schnorr mode does not permit any null signatures nor
     // an incorrect popcount in checkbits.
     tests.push_back(
         TestBuilder(CScript()
                         << OP_DUP << OP_2DUP << OP_3DUP << OP_3DUP << OP_3DUP
                         << OP_3DUP << 16 << ToByteVector(keys.pubkey0C)
                         << OP_DUP << OP_2DUP << OP_3DUP << OP_3DUP << OP_3DUP
                         << OP_3DUP << 16 << OP_CHECKMULTISIG << OP_NOT,
                     "Null signatures make no SigChecks (CHECKMULTISIG)",
                     sigchecksflags, true)
             .Num(0)
             .Num(0)
             .PushRedeem());
 
     // Now some unusual use cases (some are unsupported behaviour)
     tests.push_back(TestBuilder(CScript() << 1 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C)
                                           << OP_DUP << 4 << OP_CHECKMULTISIG,
                                 "SigChecks on bare CHECKMULTISIG 1-of-4 ECDSA",
                                 sigchecksflags)
                         .Num(0)
                         .PushSigECDSA(keys.key0)
                         .SetScriptError(ScriptError::INPUT_SIGCHECKS));
     tests.push_back(
         TestBuilder(
             CScript()
                 << 1 << -1 << ToByteVector(keys.pubkey0C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << 15 << OP_CHECKMULTISIG,
             "SigChecks on P2SH CHECKMULTISIG 1-of-15 ECDSA with a runt key",
             sigchecksflags, true)
             .Num(0)
             .PushSigECDSA(keys.key0)
             .PushRedeem()
             .SetScriptError(ScriptError::INPUT_SIGCHECKS));
     tests.push_back(
         TestBuilder(
             CScript()
                 << 1 << -1 << ToByteVector(keys.pubkey0C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << 15 << OP_CHECKMULTISIG,
             "SigChecks on P2SH CHECKMULTISIG 1-of-15 Schnorr with a runt key",
             sigchecksflags, true)
             .Push("0200")
             .PushSigSchnorr(keys.key0)
             .PushRedeem());
     tests.push_back(TestBuilder(CScript() << 0 << -1 << -1 << -1 << -1 << -1
                                           << -1 << -1 << -1 << -1 << -1 << 10
                                           << OP_CHECKMULTISIG,
                                 "Very short P2SH multisig 0-of-10, spent with "
                                 "legacy mode (0 sigchecks)",
                                 sigchecksflags, true)
                         .Num(0)
                         .PushRedeem());
     tests.push_back(TestBuilder(CScript() << 0 << -1 << -1 << -1 << -1 << -1
                                           << -1 << -1 << -1 << -1 << -1 << 10
                                           << OP_CHECKMULTISIG,
                                 "Very short P2SH multisig 0-of-10, spent with "
                                 "schnorr mode (0 sigchecks)",
                                 sigchecksflags, true)
                         .Push("0000")
                         .PushRedeem());
 
     std::set<std::string> tests_set;
 
     {
         UniValue json_tests = read_json(std::string(
             json_tests::script_tests,
             json_tests::script_tests + sizeof(json_tests::script_tests)));
 
         for (unsigned int idx = 0; idx < json_tests.size(); idx++) {
             const UniValue &tv = json_tests[idx];
             tests_set.insert(JSONPrettyPrint(tv.get_array()));
         }
     }
 
 #ifdef UPDATE_JSON_TESTS
     std::string strGen;
 #endif
 
     for (TestBuilder &test : tests) {
         test.Test();
         std::string str = JSONPrettyPrint(test.GetJSON());
 #ifdef UPDATE_JSON_TESTS
         strGen += str + ",\n";
 #else
         if (tests_set.count(str) == 0) {
             BOOST_CHECK_MESSAGE(false, "Missing auto script_valid test: " +
                                            test.GetComment());
         }
 #endif
     }
 
 #ifdef UPDATE_JSON_TESTS
     FILE *file = fopen("script_tests.json.gen", "w");
     fputs(strGen.c_str(), file);
     fclose(file);
 #endif
 }
 
 BOOST_AUTO_TEST_CASE(script_json_test) {
     // Read tests from test/data/script_tests.json
     // Format is an array of arrays
     // Inner arrays are [ ["wit"..., nValue]?, "scriptSig", "scriptPubKey",
     // "flags", "expected_scripterror" ]
     // ... where scriptSig and scriptPubKey are stringified
     // scripts.
     UniValue tests = read_json(std::string(
         json_tests::script_tests,
         json_tests::script_tests + sizeof(json_tests::script_tests)));
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
         Amount nValue = Amount::zero();
         unsigned int pos = 0;
         if (test.size() > 0 && test[pos].isArray()) {
             nValue = AmountFromValue(test[pos][0]);
             pos++;
         }
 
         // Allow size > 3; extra stuff ignored (useful for comments)
         if (test.size() < 4 + pos) {
             if (test.size() != 1) {
                 BOOST_ERROR("Bad test: " << strTest);
             }
             continue;
         }
 
         std::string scriptSigString = test[pos++].get_str();
         std::string scriptPubKeyString = test[pos++].get_str();
         try {
             CScript scriptSig = ParseScript(scriptSigString);
             CScript scriptPubKey = ParseScript(scriptPubKeyString);
             unsigned int scriptflags = ParseScriptFlags(test[pos++].get_str());
             ScriptError scriptError = ParseScriptError(test[pos++].get_str());
 
             DoTest(scriptPubKey, scriptSig, scriptflags, strTest, scriptError,
                    nValue);
         } catch (std::runtime_error &e) {
             BOOST_TEST_MESSAGE("Script test failed.  scriptSig:  "
                                << scriptSigString
                                << " scriptPubKey: " << scriptPubKeyString);
             BOOST_TEST_MESSAGE("Exception: " << e.what());
             throw;
         }
     }
 }
 
 BOOST_AUTO_TEST_CASE(script_PushData) {
     // Check that PUSHDATA1, PUSHDATA2, and PUSHDATA4 create the same value on
     // the stack as the 1-75 opcodes do.
     static const uint8_t direct[] = {1, 0x5a};
     static const uint8_t pushdata1[] = {OP_PUSHDATA1, 1, 0x5a};
     static const uint8_t pushdata2[] = {OP_PUSHDATA2, 1, 0, 0x5a};
     static const uint8_t pushdata4[] = {OP_PUSHDATA4, 1, 0, 0, 0, 0x5a};
 
     ScriptError err;
     std::vector<std::vector<uint8_t>> directStack;
     BOOST_CHECK(EvalScript(directStack,
                            CScript(direct, direct + sizeof(direct)),
                            SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     std::vector<std::vector<uint8_t>> pushdata1Stack;
     BOOST_CHECK(EvalScript(pushdata1Stack,
                            CScript(pushdata1, pushdata1 + sizeof(pushdata1)),
                            SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
     BOOST_CHECK(pushdata1Stack == directStack);
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     std::vector<std::vector<uint8_t>> pushdata2Stack;
     BOOST_CHECK(EvalScript(pushdata2Stack,
                            CScript(pushdata2, pushdata2 + sizeof(pushdata2)),
                            SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
     BOOST_CHECK(pushdata2Stack == directStack);
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     std::vector<std::vector<uint8_t>> pushdata4Stack;
     BOOST_CHECK(EvalScript(pushdata4Stack,
                            CScript(pushdata4, pushdata4 + sizeof(pushdata4)),
                            SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
     BOOST_CHECK(pushdata4Stack == directStack);
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     const std::vector<uint8_t> pushdata1_trunc{OP_PUSHDATA1, 1};
     const std::vector<uint8_t> pushdata2_trunc{OP_PUSHDATA2, 1, 0};
     const std::vector<uint8_t> pushdata4_trunc{OP_PUSHDATA4, 1, 0, 0, 0};
 
     std::vector<std::vector<uint8_t>> stack_ignore;
     BOOST_CHECK(!EvalScript(
         stack_ignore, CScript(pushdata1_trunc.begin(), pushdata1_trunc.end()),
         SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
     BOOST_CHECK_EQUAL(err, ScriptError::BAD_OPCODE);
     BOOST_CHECK(!EvalScript(
         stack_ignore, CScript(pushdata2_trunc.begin(), pushdata2_trunc.end()),
         SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
     BOOST_CHECK_EQUAL(err, ScriptError::BAD_OPCODE);
     BOOST_CHECK(!EvalScript(
         stack_ignore, CScript(pushdata4_trunc.begin(), pushdata4_trunc.end()),
         SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
     BOOST_CHECK_EQUAL(err, ScriptError::BAD_OPCODE);
 }
 
 BOOST_AUTO_TEST_CASE(script_cltv_truncated) {
     const auto script_cltv_trunc = CScript() << OP_CHECKLOCKTIMEVERIFY;
 
     std::vector<std::vector<uint8_t>> stack_ignore;
     ScriptError err;
     BOOST_CHECK(!EvalScript(stack_ignore, script_cltv_trunc,
                             SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY,
                             BaseSignatureChecker(), &err));
     BOOST_CHECK_EQUAL(err, ScriptError::INVALID_STACK_OPERATION);
 }
 
 static CScript sign_multisig(const CScript &scriptPubKey,
                              const std::vector<CKey> &keys,
                              const CTransaction &transaction) {
     uint256 hash = SignatureHash(scriptPubKey, transaction, 0, SigHashType(),
                                  Amount::zero());
 
     CScript result;
     //
     // NOTE: CHECKMULTISIG has an unfortunate bug; it requires one extra item on
     // the stack, before the signatures. Putting OP_0 on the stack is the
     // workaround; fixing the bug would mean splitting the block chain (old
     // clients would not accept new CHECKMULTISIG transactions, and vice-versa)
     //
     result << OP_0;
     for (const CKey &key : keys) {
         std::vector<uint8_t> vchSig;
         BOOST_CHECK(key.SignECDSA(hash, vchSig));
         vchSig.push_back(uint8_t(SIGHASH_ALL));
         result << vchSig;
     }
 
     return result;
 }
 
 static CScript sign_multisig(const CScript &scriptPubKey, const CKey &key,
                              const CTransaction &transaction) {
     std::vector<CKey> keys;
     keys.push_back(key);
     return sign_multisig(scriptPubKey, keys, transaction);
 }
 
 BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG12) {
     ScriptError err;
     CKey key1, key2, key3;
     key1.MakeNewKey(true);
     key2.MakeNewKey(false);
     key3.MakeNewKey(true);
 
     CScript scriptPubKey12;
     scriptPubKey12 << OP_1 << ToByteVector(key1.GetPubKey())
                    << ToByteVector(key2.GetPubKey()) << OP_2
                    << OP_CHECKMULTISIG;
 
     const CTransaction txFrom12{
         BuildCreditingTransaction(scriptPubKey12, Amount::zero())};
     CMutableTransaction txTo12 = BuildSpendingTransaction(CScript(), txFrom12);
 
     CScript goodsig1 =
         sign_multisig(scriptPubKey12, key1, CTransaction(txTo12));
     BOOST_CHECK(VerifyScript(
         goodsig1, scriptPubKey12, gFlags,
         MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
     txTo12.vout[0].nValue = 2 * SATOSHI;
     BOOST_CHECK(!VerifyScript(
         goodsig1, scriptPubKey12, gFlags,
         MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
 
     CScript goodsig2 =
         sign_multisig(scriptPubKey12, key2, CTransaction(txTo12));
     BOOST_CHECK(VerifyScript(
         goodsig2, scriptPubKey12, gFlags,
         MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     CScript badsig1 = sign_multisig(scriptPubKey12, key3, CTransaction(txTo12));
     BOOST_CHECK(!VerifyScript(
         badsig1, scriptPubKey12, gFlags,
         MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
 }
 
 BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23) {
     ScriptError err;
     CKey key1, key2, key3, key4;
     key1.MakeNewKey(true);
     key2.MakeNewKey(false);
     key3.MakeNewKey(true);
     key4.MakeNewKey(false);
 
     CScript scriptPubKey23;
     scriptPubKey23 << OP_2 << ToByteVector(key1.GetPubKey())
                    << ToByteVector(key2.GetPubKey())
                    << ToByteVector(key3.GetPubKey()) << OP_3
                    << OP_CHECKMULTISIG;
 
     const CTransaction txFrom23{
         BuildCreditingTransaction(scriptPubKey23, Amount::zero())};
     CMutableTransaction mutableTxTo23 =
         BuildSpendingTransaction(CScript(), txFrom23);
 
     // after it has been set up, mutableTxTo23 does not change in this test, so
     // we can convert it to readonly transaction and use
     // TransactionSignatureChecker instead of MutableTransactionSignatureChecker
     const CTransaction txTo23(mutableTxTo23);
 
     std::vector<CKey> keys;
     keys.push_back(key1);
     keys.push_back(key2);
     CScript goodsig1 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(VerifyScript(
         goodsig1, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     keys.clear();
     keys.push_back(key1);
     keys.push_back(key3);
     CScript goodsig2 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(VerifyScript(
         goodsig2, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     keys.clear();
     keys.push_back(key2);
     keys.push_back(key3);
     CScript goodsig3 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(VerifyScript(
         goodsig3, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     keys.clear();
     keys.push_back(key2);
     keys.push_back(key2); // Can't re-use sig
     CScript badsig1 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(!VerifyScript(
         badsig1, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
 
     keys.clear();
     keys.push_back(key2);
     keys.push_back(key1); // sigs must be in correct order
     CScript badsig2 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(!VerifyScript(
         badsig2, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
 
     keys.clear();
     keys.push_back(key3);
     keys.push_back(key2); // sigs must be in correct order
     CScript badsig3 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(!VerifyScript(
         badsig3, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
 
     keys.clear();
     keys.push_back(key4);
     keys.push_back(key2); // sigs must match pubkeys
     CScript badsig4 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(!VerifyScript(
         badsig4, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
 
     keys.clear();
     keys.push_back(key1);
     keys.push_back(key4); // sigs must match pubkeys
     CScript badsig5 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(!VerifyScript(
         badsig5, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
 
     keys.clear(); // Must have signatures
     CScript badsig6 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(!VerifyScript(
         badsig6, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::INVALID_STACK_OPERATION,
                         ScriptErrorString(err));
 }
 
 /* Wrapper around ProduceSignature to combine two scriptsigs */
 SignatureData CombineSignatures(const CTxOut &txout,
                                 const CMutableTransaction &tx,
                                 const SignatureData &scriptSig1,
                                 const SignatureData &scriptSig2) {
     SignatureData data;
     data.MergeSignatureData(scriptSig1);
     data.MergeSignatureData(scriptSig2);
     ProduceSignature(DUMMY_SIGNING_PROVIDER,
                      MutableTransactionSignatureCreator(&tx, 0, txout.nValue),
                      txout.scriptPubKey, data);
     return data;
 }
 
 BOOST_AUTO_TEST_CASE(script_combineSigs) {
     // Test the ProduceSignature's ability to combine signatures function
     CBasicKeyStore keystore;
     std::vector<CKey> keys;
     std::vector<CPubKey> pubkeys;
     for (int i = 0; i < 3; i++) {
         CKey key;
         key.MakeNewKey(i % 2 == 1);
         keys.push_back(key);
         pubkeys.push_back(key.GetPubKey());
         keystore.AddKey(key);
     }
 
     CMutableTransaction txFrom = BuildCreditingTransaction(
-        GetScriptForDestination(keys[0].GetPubKey().GetID()), Amount::zero());
+        GetScriptForDestination(PKHash(keys[0].GetPubKey())), Amount::zero());
     CMutableTransaction txTo =
         BuildSpendingTransaction(CScript(), CTransaction(txFrom));
     CScript &scriptPubKey = txFrom.vout[0].scriptPubKey;
     SignatureData scriptSig;
 
     SignatureData empty;
     SignatureData combined =
         CombineSignatures(txFrom.vout[0], txTo, empty, empty);
     BOOST_CHECK(combined.scriptSig.empty());
 
     // Single signature case:
     SignSignature(keystore, CTransaction(txFrom), txTo, 0,
                   SigHashType().withForkId());
     scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
     combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
     BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
     combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
     BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
     SignatureData scriptSigCopy = scriptSig;
     // Signing again will give a different, valid signature:
     SignSignature(keystore, CTransaction(txFrom), txTo, 0,
                   SigHashType().withForkId());
     scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, scriptSigCopy, scriptSig);
     BOOST_CHECK(combined.scriptSig == scriptSigCopy.scriptSig ||
                 combined.scriptSig == scriptSig.scriptSig);
 
     // P2SH, single-signature case:
     CScript pkSingle;
     pkSingle << ToByteVector(keys[0].GetPubKey()) << OP_CHECKSIG;
     keystore.AddCScript(pkSingle);
-    scriptPubKey = GetScriptForDestination(CScriptID(pkSingle));
+    scriptPubKey = GetScriptForDestination(ScriptHash(pkSingle));
     SignSignature(keystore, CTransaction(txFrom), txTo, 0,
                   SigHashType().withForkId());
     scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
     combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
     BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
     combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
     BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
     scriptSigCopy = scriptSig;
     SignSignature(keystore, CTransaction(txFrom), txTo, 0,
                   SigHashType().withForkId());
     scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, scriptSigCopy, scriptSig);
     BOOST_CHECK(combined.scriptSig == scriptSigCopy.scriptSig ||
                 combined.scriptSig == scriptSig.scriptSig);
 
     // Hardest case:  Multisig 2-of-3
     scriptPubKey = GetScriptForMultisig(2, pubkeys);
     keystore.AddCScript(scriptPubKey);
     SignSignature(keystore, CTransaction(txFrom), txTo, 0,
                   SigHashType().withForkId());
     scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
     combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
     BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
     combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
     BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
 
     // A couple of partially-signed versions:
     std::vector<uint8_t> sig1;
     uint256 hash1 = SignatureHash(scriptPubKey, CTransaction(txTo), 0,
                                   SigHashType().withForkId(), Amount::zero());
     BOOST_CHECK(keys[0].SignECDSA(hash1, sig1));
     sig1.push_back(SIGHASH_ALL | SIGHASH_FORKID);
     std::vector<uint8_t> sig2;
     uint256 hash2 = SignatureHash(
         scriptPubKey, CTransaction(txTo), 0,
         SigHashType().withBaseType(BaseSigHashType::NONE).withForkId(),
         Amount::zero());
     BOOST_CHECK(keys[1].SignECDSA(hash2, sig2));
     sig2.push_back(SIGHASH_NONE | SIGHASH_FORKID);
     std::vector<uint8_t> sig3;
     uint256 hash3 = SignatureHash(
         scriptPubKey, CTransaction(txTo), 0,
         SigHashType().withBaseType(BaseSigHashType::SINGLE).withForkId(),
         Amount::zero());
     BOOST_CHECK(keys[2].SignECDSA(hash3, sig3));
     sig3.push_back(SIGHASH_SINGLE | SIGHASH_FORKID);
 
     // Not fussy about order (or even existence) of placeholders or signatures:
     CScript partial1a = CScript() << OP_0 << sig1 << OP_0;
     CScript partial1b = CScript() << OP_0 << OP_0 << sig1;
     CScript partial2a = CScript() << OP_0 << sig2;
     CScript partial2b = CScript() << sig2 << OP_0;
     CScript partial3a = CScript() << sig3;
     CScript partial3b = CScript() << OP_0 << OP_0 << sig3;
     CScript partial3c = CScript() << OP_0 << sig3 << OP_0;
     CScript complete12 = CScript() << OP_0 << sig1 << sig2;
     CScript complete13 = CScript() << OP_0 << sig1 << sig3;
     CScript complete23 = CScript() << OP_0 << sig2 << sig3;
     SignatureData partial1_sigs;
     partial1_sigs.signatures.emplace(keys[0].GetPubKey().GetID(),
                                      SigPair(keys[0].GetPubKey(), sig1));
     SignatureData partial2_sigs;
     partial2_sigs.signatures.emplace(keys[1].GetPubKey().GetID(),
                                      SigPair(keys[1].GetPubKey(), sig2));
     SignatureData partial3_sigs;
     partial3_sigs.signatures.emplace(keys[2].GetPubKey().GetID(),
                                      SigPair(keys[2].GetPubKey(), sig3));
 
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial1_sigs);
     BOOST_CHECK(combined.scriptSig == partial1a);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial2_sigs);
     BOOST_CHECK(combined.scriptSig == complete12);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial2_sigs, partial1_sigs);
     BOOST_CHECK(combined.scriptSig == complete12);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial2_sigs);
     BOOST_CHECK(combined.scriptSig == complete12);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial1_sigs);
     BOOST_CHECK(combined.scriptSig == complete13);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial2_sigs, partial3_sigs);
     BOOST_CHECK(combined.scriptSig == complete23);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial2_sigs);
     BOOST_CHECK(combined.scriptSig == complete23);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial3_sigs);
     BOOST_CHECK(combined.scriptSig == partial3c);
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_push) {
     ScriptError err;
     for (int i = 0; i < 67000; i++) {
         CScript script;
         script << i;
         BOOST_CHECK_MESSAGE(script.IsPushOnly(),
                             "Number " << i << " is not pure push.");
         BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1,
                                          SCRIPT_VERIFY_MINIMALDATA,
                                          BaseSignatureChecker(), &err),
                             "Number " << i << " push is not minimal data.");
         BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
     }
 
     for (unsigned int i = 0; i <= MAX_SCRIPT_ELEMENT_SIZE; i++) {
         std::vector<uint8_t> data(i, '\111');
         CScript script;
         script << data;
         BOOST_CHECK_MESSAGE(script.IsPushOnly(),
                             "Length " << i << " is not pure push.");
         BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1,
                                          SCRIPT_VERIFY_MINIMALDATA,
                                          BaseSignatureChecker(), &err),
                             "Length " << i << " push is not minimal data.");
         BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
     }
 }
 
 BOOST_AUTO_TEST_CASE(script_IsPushOnly_on_invalid_scripts) {
     // IsPushOnly returns false when given a script containing only pushes that
     // are invalid due to truncation. IsPushOnly() is consensus critical because
     // P2SH evaluation uses it, although this specific behavior should not be
     // consensus critical as the P2SH evaluation would fail first due to the
     // invalid push. Still, it doesn't hurt to test it explicitly.
     static const uint8_t direct[] = {1};
     BOOST_CHECK(!CScript(direct, direct + sizeof(direct)).IsPushOnly());
 }
 
 BOOST_AUTO_TEST_CASE(script_GetScriptAsm) {
     BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY",
                       ScriptToAsmStr(CScript() << OP_NOP2, true));
     BOOST_CHECK_EQUAL(
         "OP_CHECKLOCKTIMEVERIFY",
         ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY, true));
     BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY",
                       ScriptToAsmStr(CScript() << OP_NOP2));
     BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY",
                       ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY));
 
     std::string derSig("304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e"
                        "3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38"
                        "d782e53023ee313d741ad0cfbc0c5090");
     std::string pubKey(
         "03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2");
     std::vector<uint8_t> vchPubKey = ToByteVector(ParseHex(pubKey));
 
     BOOST_CHECK_EQUAL(
         derSig + "00 " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "00"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "80 " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "80"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[ALL] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "01"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[ALL|ANYONECANPAY] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "81"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[ALL|FORKID] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "41"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[ALL|FORKID|ANYONECANPAY] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "c1"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[NONE] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "02"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[NONE|ANYONECANPAY] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "82"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[NONE|FORKID] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "42"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[NONE|FORKID|ANYONECANPAY] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "c2"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[SINGLE] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "03"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[SINGLE|ANYONECANPAY] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "83"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[SINGLE|FORKID] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "43"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[SINGLE|FORKID|ANYONECANPAY] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "c3"))
                                  << vchPubKey,
                        true));
 
     BOOST_CHECK_EQUAL(derSig + "00 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "00"))
                                      << vchPubKey));
     BOOST_CHECK_EQUAL(derSig + "80 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "80"))
                                      << vchPubKey));
     BOOST_CHECK_EQUAL(derSig + "01 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "01"))
                                      << vchPubKey));
     BOOST_CHECK_EQUAL(derSig + "02 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "02"))
                                      << vchPubKey));
     BOOST_CHECK_EQUAL(derSig + "03 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "03"))
                                      << vchPubKey));
     BOOST_CHECK_EQUAL(derSig + "81 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "81"))
                                      << vchPubKey));
     BOOST_CHECK_EQUAL(derSig + "82 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "82"))
                                      << vchPubKey));
     BOOST_CHECK_EQUAL(derSig + "83 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "83"))
                                      << vchPubKey));
 }
 
 static CScript ScriptFromHex(const char *hex) {
     std::vector<uint8_t> data = ParseHex(hex);
     return CScript(data.begin(), data.end());
 }
 
 BOOST_AUTO_TEST_CASE(script_FindAndDelete) {
     // Exercise the FindAndDelete functionality
     CScript s;
     CScript d;
     CScript expect;
 
     s = CScript() << OP_1 << OP_2;
     // delete nothing should be a no-op
     d = CScript();
     expect = s;
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
     BOOST_CHECK(s == expect);
 
     s = CScript() << OP_1 << OP_2 << OP_3;
     d = CScript() << OP_2;
     expect = CScript() << OP_1 << OP_3;
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
     BOOST_CHECK(s == expect);
 
     s = CScript() << OP_3 << OP_1 << OP_3 << OP_3 << OP_4 << OP_3;
     d = CScript() << OP_3;
     expect = CScript() << OP_1 << OP_4;
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 4);
     BOOST_CHECK(s == expect);
 
     // PUSH 0x02ff03 onto stack
     s = ScriptFromHex("0302ff03");
     d = ScriptFromHex("0302ff03");
     expect = CScript();
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
     BOOST_CHECK(s == expect);
 
     // PUSH 0x2ff03 PUSH 0x2ff03
     s = ScriptFromHex("0302ff030302ff03");
     d = ScriptFromHex("0302ff03");
     expect = CScript();
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
     BOOST_CHECK(s == expect);
 
     s = ScriptFromHex("0302ff030302ff03");
     d = ScriptFromHex("02");
     expect = s; // FindAndDelete matches entire opcodes
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
     BOOST_CHECK(s == expect);
 
     s = ScriptFromHex("0302ff030302ff03");
     d = ScriptFromHex("ff");
     expect = s;
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
     BOOST_CHECK(s == expect);
 
     // This is an odd edge case: strip of the push-three-bytes prefix, leaving
     // 02ff03 which is push-two-bytes:
     s = ScriptFromHex("0302ff030302ff03");
     d = ScriptFromHex("03");
     expect = CScript() << ParseHex("ff03") << ParseHex("ff03");
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
     BOOST_CHECK(s == expect);
 
     // Byte sequence that spans multiple opcodes:
     // PUSH(0xfeed) OP_1 OP_VERIFY
     s = ScriptFromHex("02feed5169");
     d = ScriptFromHex("feed51");
     expect = s;
     // doesn't match 'inside' opcodes
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
     BOOST_CHECK(s == expect);
 
     // PUSH(0xfeed) OP_1 OP_VERIFY
     s = ScriptFromHex("02feed5169");
     d = ScriptFromHex("02feed51");
     expect = ScriptFromHex("69");
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
     BOOST_CHECK(s == expect);
 
     s = ScriptFromHex("516902feed5169");
     d = ScriptFromHex("feed51");
     expect = s;
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
     BOOST_CHECK(s == expect);
 
     s = ScriptFromHex("516902feed5169");
     d = ScriptFromHex("02feed51");
     expect = ScriptFromHex("516969");
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
     BOOST_CHECK(s == expect);
 
     s = CScript() << OP_0 << OP_0 << OP_1 << OP_1;
     d = CScript() << OP_0 << OP_1;
     // FindAndDelete is single-pass
     expect = CScript() << OP_0 << OP_1;
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
     BOOST_CHECK(s == expect);
 
     s = CScript() << OP_0 << OP_0 << OP_1 << OP_0 << OP_1 << OP_1;
     d = CScript() << OP_0 << OP_1;
     // FindAndDelete is single-pass
     expect = CScript() << OP_0 << OP_1;
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
     BOOST_CHECK(s == expect);
 
     // Another weird edge case:
     // End with invalid push (not enough data)...
     s = ScriptFromHex("0003feed");
     // ... can remove the invalid push
     d = ScriptFromHex("03feed");
     expect = ScriptFromHex("00");
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
     BOOST_CHECK(s == expect);
 
     s = ScriptFromHex("0003feed");
     d = ScriptFromHex("00");
     expect = ScriptFromHex("03feed");
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
     BOOST_CHECK(s == expect);
 }
 
 BOOST_AUTO_TEST_CASE(IsWitnessProgram) {
     // Valid version: [0,16]
     // Valid program_len: [2,40]
     for (int version = -1; version <= 17; version++) {
         for (unsigned int program_len = 1; program_len <= 41; program_len++) {
             CScript script;
             std::vector<uint8_t> program(program_len, '\42');
             int parsed_version;
             std::vector<uint8_t> parsed_program;
             script << version << program;
             bool result =
                 script.IsWitnessProgram(parsed_version, parsed_program);
             bool expected = version >= 0 && version <= 16 && program_len >= 2 &&
                             program_len <= 40;
             BOOST_CHECK_EQUAL(result, expected);
             if (result) {
                 BOOST_CHECK_EQUAL(version, parsed_version);
                 BOOST_CHECK(program == parsed_program);
             }
         }
     }
     // Tests with 1 and 3 stack elements
     {
         CScript script;
         script << OP_0;
         BOOST_CHECK_MESSAGE(
             !script.IsWitnessProgram(),
             "Failed IsWitnessProgram check with 1 stack element");
     }
     {
         CScript script;
         script << OP_0 << std::vector<uint8_t>(20, '\42') << OP_1;
         BOOST_CHECK_MESSAGE(
             !script.IsWitnessProgram(),
             "Failed IsWitnessProgram check with 3 stack elements");
     }
 }
 
 BOOST_AUTO_TEST_CASE(script_HasValidOps) {
     // Exercise the HasValidOps functionality
     CScript script;
     // Normal script
     script =
         ScriptFromHex("76a9141234567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac");
     BOOST_CHECK(script.HasValidOps());
     script =
         ScriptFromHex("76a914ff34567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac");
     BOOST_CHECK(script.HasValidOps());
     // Script with OP_INVALIDOPCODE explicit
     script = ScriptFromHex("ff88ac");
     BOOST_CHECK(!script.HasValidOps());
     // Script with undefined opcode
     script = ScriptFromHex("88acc0");
     BOOST_CHECK(!script.HasValidOps());
 
     // Check all non push opcodes.
     for (uint8_t opcode = OP_1NEGATE; opcode < FIRST_UNDEFINED_OP_VALUE;
          opcode++) {
         script = CScript() << opcode;
         BOOST_CHECK(script.HasValidOps());
     }
 
     script = CScript() << FIRST_UNDEFINED_OP_VALUE;
     BOOST_CHECK(!script.HasValidOps());
 }
 
 BOOST_AUTO_TEST_CASE(script_can_append_self) {
     CScript s, d;
 
     s = ScriptFromHex("00");
     s += s;
     d = ScriptFromHex("0000");
     BOOST_CHECK(s == d);
 
     // check doubling a script that's large enough to require reallocation
     static const char hex[] =
         "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6"
         "bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f";
     s = CScript() << ParseHex(hex) << OP_CHECKSIG;
     d = CScript() << ParseHex(hex) << OP_CHECKSIG << ParseHex(hex)
                   << OP_CHECKSIG;
     s += s;
     BOOST_CHECK(s == d);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/transaction_tests.cpp b/src/test/transaction_tests.cpp
index b37a7939d..54da27319 100644
--- a/src/test/transaction_tests.cpp
+++ b/src/test/transaction_tests.cpp
@@ -1,808 +1,808 @@
 // 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 <keystore.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <script/script.h>
 #include <script/script_error.h>
 #include <script/sign.h>
 #include <script/standard.h>
 #include <streams.h>
 #include <util/strencodings.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 <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);
 
             CValidationState 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);
 
             CValidationState 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;
     CValidationState 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.");
 }
 
 //
 // Helper: create two dummy transactions, each with
 // two outputs.  The first has 11 and 50 CENT outputs
 // paid to a TX_PUBKEY, the second 21 and 22 CENT outputs
 // paid to a TX_PUBKEYHASH.
 //
 static std::vector<CMutableTransaction>
 SetupDummyInputs(CBasicKeyStore &keystoreRet, CCoinsViewCache &coinsRet) {
     std::vector<CMutableTransaction> dummyTransactions;
     dummyTransactions.resize(2);
 
     // Add some keys to the keystore:
     CKey key[4];
     for (int i = 0; i < 4; i++) {
         key[i].MakeNewKey(i % 2);
         keystoreRet.AddKey(key[i]);
     }
 
     // Create some dummy input transactions
     dummyTransactions[0].vout.resize(2);
     dummyTransactions[0].vout[0].nValue = 11 * CENT;
     dummyTransactions[0].vout[0].scriptPubKey
         << ToByteVector(key[0].GetPubKey()) << OP_CHECKSIG;
     dummyTransactions[0].vout[1].nValue = 50 * CENT;
     dummyTransactions[0].vout[1].scriptPubKey
         << ToByteVector(key[1].GetPubKey()) << OP_CHECKSIG;
     AddCoins(coinsRet, CTransaction(dummyTransactions[0]), 0);
 
     dummyTransactions[1].vout.resize(2);
     dummyTransactions[1].vout[0].nValue = 21 * CENT;
     dummyTransactions[1].vout[0].scriptPubKey =
-        GetScriptForDestination(key[2].GetPubKey().GetID());
+        GetScriptForDestination(PKHash(key[2].GetPubKey()));
     dummyTransactions[1].vout[1].nValue = 22 * CENT;
     dummyTransactions[1].vout[1].scriptPubKey =
-        GetScriptForDestination(key[3].GetPubKey().GetID());
+        GetScriptForDestination(PKHash(key[3].GetPubKey()));
     AddCoins(coinsRet, CTransaction(dummyTransactions[1]), 0);
 
     return dummyTransactions;
 }
 
 BOOST_AUTO_TEST_CASE(test_Get) {
     CBasicKeyStore keystore;
     CCoinsView coinsDummy;
     CCoinsViewCache coins(&coinsDummy);
     std::vector<CMutableTransaction> dummyTransactions =
         SetupDummyInputs(keystore, coins);
 
     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 CKeyStore &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);
     CBasicKeyStore keystore;
     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;
         CTxOut &out = coins[tx.vin[i].prevout.GetN()].GetTxOut();
         CScriptCheck check(out.scriptPubKey, out.nValue, 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) {
     CBasicKeyStore 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();
     keystore.AddKeyPubKey(key1, pubkey1);
     keystore.AddKeyPubKey(key2, pubkey2);
     keystore.AddKeyPubKey(key1L, pubkey1L);
     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);
     keystore.AddCScript(scriptPubkey1);
     keystore.AddCScript(scriptPubkey2);
     keystore.AddCScript(scriptPubkey1L);
     keystore.AddCScript(scriptPubkey2L);
     keystore.AddCScript(scriptMulti);
     keystore2.AddCScript(scriptMulti);
     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(CScriptID(scriptPubkey1)),
+                         GetScriptForDestination(ScriptHash(scriptPubkey1)),
                          output1, input1);
     CreateCreditAndSpend(keystore,
-                         GetScriptForDestination(CScriptID(scriptPubkey2)),
+                         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(CScriptID(scriptPubkey1L)),
+                         GetScriptForDestination(ScriptHash(scriptPubkey1L)),
                          output1, input1);
     CreateCreditAndSpend(keystore,
-                         GetScriptForDestination(CScriptID(scriptPubkey2L)),
+                         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(CScriptID(scriptMulti)),
+                         GetScriptForDestination(ScriptHash(scriptMulti)),
                          output1, input1, false);
     CheckWithFlag(output1, input1, 0, true);
     CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, false);
     CreateCreditAndSpend(keystore2,
-                         GetScriptForDestination(CScriptID(scriptMulti)),
+                         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);
     CBasicKeyStore keystore;
     CCoinsView coinsDummy;
     CCoinsViewCache coins(&coinsDummy);
     std::vector<CMutableTransaction> dummyTransactions =
         SetupDummyInputs(keystore, coins);
 
     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(key.GetPubKey().GetID());
+    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;
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     // not dust:
     t.vout[0].nValue = nDustThreshold;
     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;
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
     // 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;
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
 
     // 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());
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
 
     /**
      * Check when a custom value is used for -datacarriersize .
      */
     unsigned newMaxSize = 90;
     gArgs.ForceSetArg("-datacarriersize", std::to_string(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;
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
 
     // 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");
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
 
     t.vout[0].scriptPubKey =
         CScript() << OP_RETURN
                   << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef38");
     t.vout[1].scriptPubKey = CScript() << OP_RETURN;
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
 
     t.vout[0].scriptPubKey = CScript() << OP_RETURN;
     t.vout[1].scriptPubKey = CScript() << OP_RETURN;
     BOOST_CHECK(!IsStandardTx(CTransaction(t), reason));
 }
 
 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;
     CValidationState state;
 
     BOOST_CHECK(ContextualCheckTransaction(
         params, minTx, state, magneticAnomalyActivationHeight - 1, 5678, 1234));
     BOOST_CHECK(!ContextualCheckTransaction(
         params, minTx, state, magneticAnomalyActivationHeight, 5678, 1234));
     BOOST_CHECK_EQUAL(state.GetRejectCode(), REJECT_INVALID);
     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-txns-undersize");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/txindex_tests.cpp b/src/test/txindex_tests.cpp
index b91b8be5f..4d4fa2a87 100644
--- a/src/test/txindex_tests.cpp
+++ b/src/test/txindex_tests.cpp
@@ -1,84 +1,84 @@
 // 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 <index/txindex.h>
 
 #include <chainparams.h>
 #include <script/standard.h>
 #include <util/system.h>
 #include <util/time.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_AUTO_TEST_SUITE(txindex_tests)
 
 BOOST_FIXTURE_TEST_CASE(txindex_initial_sync, TestChain100Setup) {
     TxIndex txindex(1 << 20, true);
 
     CTransactionRef tx_disk;
     BlockHash block_hash;
 
     // Transaction should not be found in the index before it is started.
     for (const auto &txn : m_coinbase_txns) {
         BOOST_CHECK(!txindex.FindTx(txn->GetId(), block_hash, tx_disk));
     }
 
     // BlockUntilSyncedToCurrentChain should return false before txindex is
     // started.
     BOOST_CHECK(!txindex.BlockUntilSyncedToCurrentChain());
 
     txindex.Start();
 
     // Allow tx index to catch up with the block index.
     constexpr int64_t timeout_ms = 10 * 1000;
     int64_t time_start = GetTimeMillis();
     while (!txindex.BlockUntilSyncedToCurrentChain()) {
         BOOST_REQUIRE(time_start + timeout_ms > GetTimeMillis());
         MilliSleep(100);
     }
 
     // Check that txindex excludes genesis block transactions.
     const CBlock &genesis_block = Params().GenesisBlock();
     for (const auto &txn : genesis_block.vtx) {
         BOOST_CHECK(!txindex.FindTx(txn->GetId(), block_hash, tx_disk));
     }
 
     // Check that txindex has all txs that were in the chain before it started.
     for (const auto &txn : m_coinbase_txns) {
         if (!txindex.FindTx(txn->GetId(), block_hash, tx_disk)) {
             BOOST_ERROR("FindTx failed");
         } else if (tx_disk->GetId() != txn->GetId()) {
             BOOST_ERROR("Read incorrect tx");
         }
     }
 
     // Check that new transactions in new blocks make it into the index.
     for (int i = 0; i < 10; i++) {
         CScript coinbase_script_pub_key =
-            GetScriptForDestination(coinbaseKey.GetPubKey().GetID());
+            GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()));
         std::vector<CMutableTransaction> no_txns;
         const CBlock &block =
             CreateAndProcessBlock(no_txns, coinbase_script_pub_key);
         const CTransactionRef &txn = block.vtx[0];
 
         BOOST_CHECK(txindex.BlockUntilSyncedToCurrentChain());
         if (!txindex.FindTx(txn->GetId(), block_hash, tx_disk)) {
             BOOST_ERROR("FindTx failed");
         } else if (tx_disk->GetId() != txn->GetId()) {
             BOOST_ERROR("Read incorrect tx");
         }
     }
 
     // shutdown sequence (c.f. Shutdown() in init.cpp)
     txindex.Stop();
 
     threadGroup.interrupt_all();
     threadGroup.join_all();
 
     // Rest of shutdown sequence and destructors happen in ~TestingSetup()
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/txvalidationcache_tests.cpp b/src/test/txvalidationcache_tests.cpp
index b09ae0401..21bde51e9 100644
--- a/src/test/txvalidationcache_tests.cpp
+++ b/src/test/txvalidationcache_tests.cpp
@@ -1,667 +1,667 @@
 // 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 <chain.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <key.h>
 #include <keystore.h>
 #include <policy/policy.h>
 #include <script/scriptcache.h>
 #include <script/sighashtype.h>
 #include <script/sign.h>
 #include <txmempool.h>
 #include <validation.h>
 
 #include <test/lcg.h>
 #include <test/sigutil.h>
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_AUTO_TEST_SUITE(txvalidationcache_tests)
 
 static bool ToMemPool(const CMutableTransaction &tx) {
     LOCK(cs_main);
 
     CValidationState state;
     return AcceptToMemoryPool(
         GetConfig(), g_mempool, state, MakeTransactionRef(tx),
         nullptr /* pfMissingInputs */, true /* bypass_limits */,
         Amount::zero() /* nAbsurdFee */);
 }
 
 BOOST_FIXTURE_TEST_CASE(tx_mempool_block_doublespend, TestChain100Setup) {
     // Make sure skipping validation of transactions that were validated going
     // into the memory pool does not allow double-spends in blocks to pass
     // validation when they should not.
     CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey())
                                      << OP_CHECKSIG;
 
     // Create a double-spend of mature coinbase txn:
     std::vector<CMutableTransaction> spends;
     spends.resize(2);
     for (int i = 0; i < 2; i++) {
         spends[i].nVersion = 1;
         spends[i].vin.resize(1);
         spends[i].vin[0].prevout = COutPoint(m_coinbase_txns[0]->GetId(), 0);
         spends[i].vout.resize(1);
         spends[i].vout[0].nValue = 11 * CENT;
         spends[i].vout[0].scriptPubKey = scriptPubKey;
 
         // Sign:
         std::vector<uint8_t> vchSig;
         uint256 hash = SignatureHash(scriptPubKey, CTransaction(spends[i]), 0,
                                      SigHashType().withForkId(),
                                      m_coinbase_txns[0]->vout[0].nValue);
         BOOST_CHECK(coinbaseKey.SignECDSA(hash, vchSig));
         vchSig.push_back(uint8_t(SIGHASH_ALL | SIGHASH_FORKID));
         spends[i].vin[0].scriptSig << vchSig;
     }
 
     CBlock block;
 
     // Test 1: block with both of those transactions should be rejected.
     block = CreateAndProcessBlock(spends, scriptPubKey);
     {
         LOCK(cs_main);
         BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
     }
 
     // Test 2: ... and should be rejected if spend1 is in the memory pool
     BOOST_CHECK(ToMemPool(spends[0]));
     block = CreateAndProcessBlock(spends, scriptPubKey);
     {
         LOCK(cs_main);
         BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
     }
     g_mempool.clear();
 
     // Test 3: ... and should be rejected if spend2 is in the memory pool
     BOOST_CHECK(ToMemPool(spends[1]));
     block = CreateAndProcessBlock(spends, scriptPubKey);
     {
         LOCK(cs_main);
         BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
     }
     g_mempool.clear();
 
     // Final sanity test: first spend in mempool, second in block, that's OK:
     std::vector<CMutableTransaction> oneSpend;
     oneSpend.push_back(spends[0]);
     BOOST_CHECK(ToMemPool(spends[1]));
     block = CreateAndProcessBlock(oneSpend, scriptPubKey);
     {
         LOCK(cs_main);
         BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() == block.GetHash());
     }
     // spends[1] should have been removed from the mempool when the block with
     // spends[0] is accepted:
     BOOST_CHECK_EQUAL(g_mempool.size(), 0U);
 }
 
 static inline bool
 CheckInputs(const CTransaction &tx, CValidationState &state,
             const CCoinsViewCache &view, bool fScriptChecks,
             const uint32_t flags, bool sigCacheStore, bool scriptCacheStore,
             const PrecomputedTransactionData &txdata, int &nSigChecksOut,
             std::vector<CScriptCheck> *pvChecks,
             CheckInputsLimiter *pBlockLimitSigChecks = nullptr)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     // nSigChecksTxLimiter need to outlive this function call, because test
     // cases are using pvChecks, so the verification is done asynchronously.
     static TxSigCheckLimiter nSigChecksTxLimiter;
     nSigChecksTxLimiter = TxSigCheckLimiter();
     return CheckInputs(tx, state, view, fScriptChecks, flags, sigCacheStore,
                        scriptCacheStore, txdata, nSigChecksOut,
                        nSigChecksTxLimiter, pBlockLimitSigChecks, pvChecks);
 }
 
 // Run CheckInputs (using pcoinsTip) on the given transaction, for all script
 // flags. Test that CheckInputs passes for all flags that don't overlap with the
 // failing_flags argument, but otherwise fails.
 // CHECKLOCKTIMEVERIFY and CHECKSEQUENCEVERIFY (and future NOP codes that may
 // get reassigned) have an interaction with DISCOURAGE_UPGRADABLE_NOPS: if the
 // script flags used contain DISCOURAGE_UPGRADABLE_NOPS but don't contain
 // CHECKLOCKTIMEVERIFY (or CHECKSEQUENCEVERIFY), but the script does contain
 // OP_CHECKLOCKTIMEVERIFY (or OP_CHECKSEQUENCEVERIFY), then script execution
 // should fail.
 // Capture this interaction with the upgraded_nop argument: set it when
 // evaluating any script flag that is implemented as an upgraded NOP code.
 static void
 ValidateCheckInputsForAllFlags(const CTransaction &tx, uint32_t failing_flags,
                                uint32_t required_flags, bool add_to_cache,
                                int expected_sigchecks)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     PrecomputedTransactionData txdata(tx);
 
     MMIXLinearCongruentialGenerator lcg;
     for (int i = 0; i < 4096; i++) {
         uint32_t test_flags = lcg.next() | required_flags;
         CValidationState state;
 
         // Filter out incompatible flag choices
         if ((test_flags & SCRIPT_VERIFY_CLEANSTACK)) {
             // CLEANSTACK requires P2SH, see VerifyScript() in
             // script/interpreter.cpp
             test_flags |= SCRIPT_VERIFY_P2SH;
         }
 
         int nSigChecksDirect = 0xf00d;
         bool ret = CheckInputs(tx, state, pcoinsTip.get(), true, test_flags,
                                true, add_to_cache, txdata, nSigChecksDirect);
 
         // CheckInputs should succeed iff test_flags doesn't intersect with
         // failing_flags
         bool expected_return_value = !(test_flags & failing_flags);
         BOOST_CHECK_EQUAL(ret, expected_return_value);
 
         if (ret) {
             if (test_flags & SCRIPT_REPORT_SIGCHECKS) {
                 BOOST_CHECK(nSigChecksDirect == expected_sigchecks);
             } else {
                 BOOST_CHECK(nSigChecksDirect == 0);
             }
         }
 
         // Test the caching
         if (ret && add_to_cache) {
             // Check that we get a cache hit if the tx was valid
             std::vector<CScriptCheck> scriptchecks;
             int nSigChecksCached = 0xbeef;
             BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true,
                                     test_flags, true, add_to_cache, txdata,
                                     nSigChecksCached, &scriptchecks));
             BOOST_CHECK(nSigChecksCached == nSigChecksDirect);
             BOOST_CHECK(scriptchecks.empty());
         } else {
             // Check that we get script executions to check, if the transaction
             // was invalid, or we didn't add to cache.
             std::vector<CScriptCheck> scriptchecks;
             int nSigChecksUncached = 0xbabe;
             BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true,
                                     test_flags, true, add_to_cache, txdata,
                                     nSigChecksUncached, &scriptchecks));
             BOOST_CHECK(!ret || nSigChecksUncached == 0);
             BOOST_CHECK_EQUAL(scriptchecks.size(), tx.vin.size());
         }
     }
 }
 
 BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup) {
     // Test that passing CheckInputs with one set of script flags doesn't imply
     // that we would pass again with a different set of flags.
     {
         LOCK(cs_main);
         InitScriptExecutionCache();
     }
 
     CScript p2pk_scriptPubKey =
         CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
     CScript p2sh_scriptPubKey =
-        GetScriptForDestination(CScriptID(p2pk_scriptPubKey));
+        GetScriptForDestination(ScriptHash(p2pk_scriptPubKey));
     CScript p2pkh_scriptPubKey =
-        GetScriptForDestination(coinbaseKey.GetPubKey().GetID());
+        GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()));
 
     CBasicKeyStore keystore;
     keystore.AddKey(coinbaseKey);
     keystore.AddCScript(p2pk_scriptPubKey);
 
     CMutableTransaction funding_tx;
     // Needed when spending the output of this transaction
     CScript noppyScriptPubKey;
     // Create a transaction output that can fail DISCOURAGE_UPGRADABLE_NOPS
     // checks when spent. This is for testing consensus vs non-standard rules in
     // `checkinputs_test`.
     {
         funding_tx.nVersion = 1;
         funding_tx.vin.resize(1);
         funding_tx.vin[0].prevout = COutPoint(m_coinbase_txns[0]->GetId(), 0);
         funding_tx.vout.resize(1);
         funding_tx.vout[0].nValue = 50 * COIN;
 
         noppyScriptPubKey << OP_IF << OP_NOP10 << OP_ENDIF << OP_1;
         funding_tx.vout[0].scriptPubKey = noppyScriptPubKey;
         std::vector<uint8_t> fundingVchSig;
         uint256 fundingSigHash = SignatureHash(
             p2pk_scriptPubKey, CTransaction(funding_tx), 0,
             SigHashType().withForkId(), m_coinbase_txns[0]->vout[0].nValue);
         BOOST_CHECK(coinbaseKey.SignECDSA(fundingSigHash, fundingVchSig));
         fundingVchSig.push_back(uint8_t(SIGHASH_ALL | SIGHASH_FORKID));
         funding_tx.vin[0].scriptSig << fundingVchSig;
     }
 
     // Spend the funding transaction by mining it into a block
     {
         CBlock block = CreateAndProcessBlock({funding_tx}, p2pk_scriptPubKey);
         BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() == block.GetHash());
         BOOST_CHECK(pcoinsTip->GetBestBlock() == block.GetHash());
     }
 
     // flags to test: SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY,
     // SCRIPT_VERIFY_CHECKSEQUENCE_VERIFY,
     // SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS, uncompressed pubkey thing
 
     // Create 2 outputs that match the three scripts above, spending the first
     // coinbase tx.
     CMutableTransaction spend_tx;
     spend_tx.nVersion = 1;
     spend_tx.vin.resize(1);
     spend_tx.vin[0].prevout = COutPoint(funding_tx.GetId(), 0);
     spend_tx.vout.resize(4);
     spend_tx.vout[0].nValue = 11 * CENT;
     spend_tx.vout[0].scriptPubKey = p2sh_scriptPubKey;
     spend_tx.vout[1].nValue = 11 * CENT;
     spend_tx.vout[1].scriptPubKey =
         CScript() << OP_CHECKLOCKTIMEVERIFY << OP_DROP
                   << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
     spend_tx.vout[2].nValue = 11 * CENT;
     spend_tx.vout[2].scriptPubKey =
         CScript() << OP_CHECKSEQUENCEVERIFY << OP_DROP
                   << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
     spend_tx.vout[3].nValue = 11 * CENT;
     spend_tx.vout[3].scriptPubKey = p2sh_scriptPubKey;
 
     // "Sign" the main transaction that we spend from.
     {
         // This will cause OP_NOP10 to execute.
         spend_tx.vin[0].scriptSig << OP_1;
     }
 
     // Test that invalidity under a set of flags doesn't preclude validity under
     // other (eg consensus) flags.
     // spend_tx is invalid according to DISCOURAGE_UPGRADABLE_NOPS
     {
         const CTransaction tx(spend_tx);
 
         LOCK(cs_main);
 
         CValidationState state;
         PrecomputedTransactionData ptd_spend_tx(tx);
         int nSigChecksDummy;
 
         BOOST_CHECK(!CheckInputs(tx, state, pcoinsTip.get(), true,
                                  STANDARD_SCRIPT_VERIFY_FLAGS, true, true,
                                  ptd_spend_tx, nSigChecksDummy, nullptr));
 
         // If we call again asking for scriptchecks (as happens in
         // ConnectBlock), we should add a script check object for this -- we're
         // not caching invalidity (if that changes, delete this test case).
         std::vector<CScriptCheck> scriptchecks;
         BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true,
                                 STANDARD_SCRIPT_VERIFY_FLAGS, true, true,
                                 ptd_spend_tx, nSigChecksDummy, &scriptchecks));
         BOOST_CHECK_EQUAL(scriptchecks.size(), 1U);
 
         // Test that CheckInputs returns true iff cleanstack-enforcing flags are
         // not present. Don't add these checks to the cache, so that we can test
         // later that block validation works fine in the absence of cached
         // successes.
         ValidateCheckInputsForAllFlags(
             tx, SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS, 0, false, 0);
     }
 
     // And if we produce a block with this tx, it should be valid, even though
     // there's no cache entry.
     CBlock block;
 
     block = CreateAndProcessBlock({spend_tx}, p2pk_scriptPubKey);
     LOCK(cs_main);
     BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() == block.GetHash());
     BOOST_CHECK(pcoinsTip->GetBestBlock() == block.GetHash());
 
     // Test P2SH: construct a transaction that is valid without P2SH, and then
     // test validity with P2SH.
     {
         CMutableTransaction invalid_under_p2sh_tx;
         invalid_under_p2sh_tx.nVersion = 1;
         invalid_under_p2sh_tx.vin.resize(1);
         invalid_under_p2sh_tx.vin[0].prevout = COutPoint(spend_tx.GetId(), 0);
         invalid_under_p2sh_tx.vout.resize(1);
         invalid_under_p2sh_tx.vout[0].nValue = 11 * CENT;
         invalid_under_p2sh_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
         std::vector<uint8_t> vchSig2(p2pk_scriptPubKey.begin(),
                                      p2pk_scriptPubKey.end());
         invalid_under_p2sh_tx.vin[0].scriptSig << vchSig2;
 
         ValidateCheckInputsForAllFlags(CTransaction(invalid_under_p2sh_tx),
                                        SCRIPT_VERIFY_P2SH, 0, true, 0);
     }
 
     // Test CHECKLOCKTIMEVERIFY
     {
         CMutableTransaction invalid_with_cltv_tx;
         invalid_with_cltv_tx.nVersion = 1;
         invalid_with_cltv_tx.nLockTime = 100;
         invalid_with_cltv_tx.vin.resize(1);
         invalid_with_cltv_tx.vin[0].prevout = COutPoint(spend_tx.GetId(), 1);
         invalid_with_cltv_tx.vin[0].nSequence = 0;
         invalid_with_cltv_tx.vout.resize(1);
         invalid_with_cltv_tx.vout[0].nValue = 11 * CENT;
         invalid_with_cltv_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
 
         // Sign
         std::vector<uint8_t> vchSig;
         uint256 hash = SignatureHash(
             spend_tx.vout[1].scriptPubKey, CTransaction(invalid_with_cltv_tx),
             0, SigHashType().withForkId(), spend_tx.vout[1].nValue);
         BOOST_CHECK(coinbaseKey.SignECDSA(hash, vchSig));
         vchSig.push_back(uint8_t(SIGHASH_ALL | SIGHASH_FORKID));
         invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 101;
 
         ValidateCheckInputsForAllFlags(CTransaction(invalid_with_cltv_tx),
                                        SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY |
                                            SCRIPT_ENABLE_REPLAY_PROTECTION,
                                        SCRIPT_ENABLE_SIGHASH_FORKID, true, 1);
 
         // Make it valid, and check again
         invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
         CValidationState state;
 
         CTransaction transaction(invalid_with_cltv_tx);
         PrecomputedTransactionData txdata(transaction);
 
         int nSigChecksRet;
         BOOST_CHECK(
             CheckInputs(transaction, state, pcoinsTip.get(), true,
                         STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_REPORT_SIGCHECKS,
                         true, true, txdata, nSigChecksRet, nullptr));
         BOOST_CHECK(nSigChecksRet == 1);
     }
 
     // TEST CHECKSEQUENCEVERIFY
     {
         CMutableTransaction invalid_with_csv_tx;
         invalid_with_csv_tx.nVersion = 2;
         invalid_with_csv_tx.vin.resize(1);
         invalid_with_csv_tx.vin[0].prevout = COutPoint(spend_tx.GetId(), 2);
         invalid_with_csv_tx.vin[0].nSequence = 100;
         invalid_with_csv_tx.vout.resize(1);
         invalid_with_csv_tx.vout[0].nValue = 11 * CENT;
         invalid_with_csv_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
 
         // Sign
         std::vector<uint8_t> vchSig;
         uint256 hash = SignatureHash(
             spend_tx.vout[2].scriptPubKey, CTransaction(invalid_with_csv_tx), 0,
             SigHashType().withForkId(), spend_tx.vout[2].nValue);
         BOOST_CHECK(coinbaseKey.SignECDSA(hash, vchSig));
         vchSig.push_back(uint8_t(SIGHASH_ALL | SIGHASH_FORKID));
         invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 101;
 
         ValidateCheckInputsForAllFlags(CTransaction(invalid_with_csv_tx),
                                        SCRIPT_VERIFY_CHECKSEQUENCEVERIFY |
                                            SCRIPT_ENABLE_REPLAY_PROTECTION,
                                        SCRIPT_ENABLE_SIGHASH_FORKID, true, 1);
 
         // Make it valid, and check again
         invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
         CValidationState state;
 
         CTransaction transaction(invalid_with_csv_tx);
         PrecomputedTransactionData txdata(transaction);
 
         int nSigChecksRet;
         BOOST_CHECK(
             CheckInputs(transaction, state, pcoinsTip.get(), true,
                         STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_REPORT_SIGCHECKS,
                         true, true, txdata, nSigChecksRet, nullptr));
         BOOST_CHECK(nSigChecksRet == 1);
     }
 
     // TODO: add tests for remaining script flags
 
     {
         // Test a transaction with multiple inputs.
         CMutableTransaction tx;
 
         tx.nVersion = 1;
         tx.vin.resize(2);
         tx.vin[0].prevout = COutPoint(spend_tx.GetId(), 0);
         tx.vin[1].prevout = COutPoint(spend_tx.GetId(), 3);
         tx.vout.resize(1);
         tx.vout[0].nValue = 22 * CENT;
         tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
 
         // Sign
         {
             SignatureData sigdata;
             BOOST_CHECK(ProduceSignature(
                 keystore,
                 MutableTransactionSignatureCreator(&tx, 0, 11 * CENT,
                                                    SigHashType().withForkId()),
                 spend_tx.vout[0].scriptPubKey, sigdata));
             UpdateInput(tx.vin[0], sigdata);
         }
         {
             SignatureData sigdata;
             BOOST_CHECK(ProduceSignature(
                 keystore,
                 MutableTransactionSignatureCreator(&tx, 1, 11 * CENT,
                                                    SigHashType().withForkId()),
                 spend_tx.vout[3].scriptPubKey, sigdata));
             UpdateInput(tx.vin[1], sigdata);
         }
 
         // This should be valid under all script flags that support our sighash
         // convention.
         ValidateCheckInputsForAllFlags(
             CTransaction(tx), SCRIPT_ENABLE_REPLAY_PROTECTION,
             SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_VERIFY_P2SH, true, 2);
 
         {
             // Try checking this valid transaction with sigchecks limiter
             // supplied. Each input consumes 1 sigcheck.
 
             CValidationState state;
             CTransaction transaction(tx);
             PrecomputedTransactionData txdata(transaction);
             uint32_t flags =
                 STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_REPORT_SIGCHECKS;
             int nSigChecksDummy;
 
             /**
              * Parallel validation initially works (no cached value), but
              * evaluation of the script checks produces a failure.
              */
             std::vector<CScriptCheck> scriptchecks1;
             CheckInputsLimiter sigchecklimiter1(1);
             BOOST_CHECK(CheckInputs(transaction, state, pcoinsTip.get(), true,
                                     flags, true, true, txdata, nSigChecksDummy,
                                     &scriptchecks1, &sigchecklimiter1));
             // the first check passes but it did consume the limit.
             BOOST_CHECK(scriptchecks1[1]());
             BOOST_CHECK(sigchecklimiter1.check());
             // the second check (the first input) fails due to the limiter.
             BOOST_CHECK(!scriptchecks1[0]());
             BOOST_CHECK_EQUAL(scriptchecks1[0].GetScriptError(),
                               ScriptError::SIGCHECKS_LIMIT_EXCEEDED);
             BOOST_CHECK(!sigchecklimiter1.check());
 
             // Serial validation fails with the limiter.
             CheckInputsLimiter sigchecklimiter2(1);
             CValidationState state2;
             BOOST_CHECK(!CheckInputs(transaction, state2, pcoinsTip.get(), true,
                                      flags, true, true, txdata, nSigChecksDummy,
                                      nullptr, &sigchecklimiter2));
             BOOST_CHECK(!sigchecklimiter2.check());
             BOOST_CHECK_EQUAL(state2.GetRejectReason(),
                               "non-mandatory-script-verify-flag (Validation "
                               "resources exceeded (SigChecks))");
 
             /**
              * A slightly more permissive limiter (just enough) passes, and
              * allows caching the result.
              */
             std::vector<CScriptCheck> scriptchecks3;
             CheckInputsLimiter sigchecklimiter3(2);
             // first in parallel
             BOOST_CHECK(CheckInputs(transaction, state, pcoinsTip.get(), true,
                                     flags, true, true, txdata, nSigChecksDummy,
                                     &scriptchecks3, &sigchecklimiter3));
             BOOST_CHECK(scriptchecks3[1]());
             BOOST_CHECK(scriptchecks3[0]());
             BOOST_CHECK(sigchecklimiter3.check());
             // then in serial, caching the result.
             CheckInputsLimiter sigchecklimiter4(2);
             BOOST_CHECK(CheckInputs(transaction, state, pcoinsTip.get(), true,
                                     flags, true, true, txdata, nSigChecksDummy,
                                     nullptr, &sigchecklimiter4));
             BOOST_CHECK(sigchecklimiter4.check());
             // now in parallel again, grabbing the cached result.
             std::vector<CScriptCheck> scriptchecks5;
             CheckInputsLimiter sigchecklimiter5(2);
             BOOST_CHECK(CheckInputs(transaction, state, pcoinsTip.get(), true,
                                     flags, true, true, txdata, nSigChecksDummy,
                                     &scriptchecks5, &sigchecklimiter5));
             BOOST_CHECK(scriptchecks5.empty());
             BOOST_CHECK(sigchecklimiter5.check());
 
             /**
              * Going back to the lower limit, we now fail immediately due to the
              * caching.
              */
             CheckInputsLimiter sigchecklimiter6(1);
             CValidationState state6;
             BOOST_CHECK(!CheckInputs(transaction, state6, pcoinsTip.get(), true,
                                      flags, true, true, txdata, nSigChecksDummy,
                                      nullptr, &sigchecklimiter6));
             BOOST_CHECK_EQUAL(state6.GetRejectReason(), "too-many-sigchecks");
             BOOST_CHECK(!sigchecklimiter6.check());
             // even in parallel validation, immediate fail from the cache.
             std::vector<CScriptCheck> scriptchecks7;
             CheckInputsLimiter sigchecklimiter7(1);
             CValidationState state7;
             BOOST_CHECK(!CheckInputs(transaction, state7, pcoinsTip.get(), true,
                                      flags, true, true, txdata, nSigChecksDummy,
                                      &scriptchecks7, &sigchecklimiter7));
             BOOST_CHECK_EQUAL(state7.GetRejectReason(), "too-many-sigchecks");
             BOOST_CHECK(!sigchecklimiter7.check());
             BOOST_CHECK(scriptchecks7.empty());
         }
 
         // Check that if the second input is invalid, but the first input is
         // valid, the transaction is not cached.
         // Invalidate vin[1]
         tx.vin[1].scriptSig = CScript();
 
         CValidationState state;
         CTransaction transaction(tx);
         PrecomputedTransactionData txdata(transaction);
 
         // This transaction is now invalid because the second signature is
         // missing.
         int nSigChecksDummy;
         BOOST_CHECK(
             !CheckInputs(transaction, state, pcoinsTip.get(), true,
                          STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_REPORT_SIGCHECKS,
                          true, true, txdata, nSigChecksDummy, nullptr));
 
         // Make sure this transaction was not cached (ie becausethe first input
         // was valid)
         std::vector<CScriptCheck> scriptchecks;
         BOOST_CHECK(
             CheckInputs(transaction, state, pcoinsTip.get(), true,
                         STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_REPORT_SIGCHECKS,
                         true, true, txdata, nSigChecksDummy, &scriptchecks));
         // Should get 2 script checks back -- caching is on a whole-transaction
         // basis.
         BOOST_CHECK_EQUAL(scriptchecks.size(), 2U);
 
         // Execute the first check, and check its result
         BOOST_CHECK(scriptchecks[0]());
         BOOST_CHECK_EQUAL(scriptchecks[0].GetScriptError(), ScriptError::OK);
         BOOST_CHECK_EQUAL(
             scriptchecks[0].GetScriptExecutionMetrics().nSigChecks, 1);
         // The second check does fail
         BOOST_CHECK(!scriptchecks[1]());
         BOOST_CHECK_EQUAL(scriptchecks[1].GetScriptError(),
                           ScriptError::INVALID_STACK_OPERATION);
     }
 }
 
 BOOST_AUTO_TEST_CASE(scriptcache_values) {
     LOCK(cs_main);
     // Test insertion and querying of keys&values from the script cache.
 
     // Define a couple of macros (handier than functions since errors will print
     // out the correct line number)
 #define CHECK_CACHE_HAS(key, expected_sigchecks)                               \
     {                                                                          \
         int nSigChecksRet(0x12345678 ^ (expected_sigchecks));                  \
         BOOST_CHECK(IsKeyInScriptCache(key, false, nSigChecksRet));            \
         BOOST_CHECK(nSigChecksRet == (expected_sigchecks));                    \
     }
 #define CHECK_CACHE_MISSING(key)                                               \
     {                                                                          \
         int dummy;                                                             \
         BOOST_CHECK(!IsKeyInScriptCache(key, false, dummy));                   \
     }
 
     InitScriptExecutionCache();
 
     // construct four distinct keys from very slightly different data
     CMutableTransaction tx1;
     tx1.nVersion = 1;
     CMutableTransaction tx2;
     tx2.nVersion = 2;
     uint32_t flagsA = 0x7fffffff;
     uint32_t flagsB = 0xffffffff;
     ScriptCacheKey key1A(CTransaction(tx1), flagsA);
     ScriptCacheKey key1B(CTransaction(tx1), flagsB);
     ScriptCacheKey key2A(CTransaction(tx2), flagsA);
     ScriptCacheKey key2B(CTransaction(tx2), flagsB);
 
     BOOST_CHECK(key1A == key1A);
     BOOST_CHECK(!(key1A == key1B));
     BOOST_CHECK(!(key1A == key2A));
     BOOST_CHECK(!(key1A == key2B));
     BOOST_CHECK(key1B == key1B);
     BOOST_CHECK(!(key1B == key2A));
     BOOST_CHECK(!(key1B == key2B));
     BOOST_CHECK(key2A == key2A);
     BOOST_CHECK(!(key2A == key2B));
     BOOST_CHECK(key2B == key2B);
 
     // Key is not yet inserted.
     CHECK_CACHE_MISSING(key1A);
     // Add the key and check it worked
     AddKeyInScriptCache(key1A, 42);
     CHECK_CACHE_HAS(key1A, 42);
 
     CHECK_CACHE_MISSING(key1B);
     CHECK_CACHE_MISSING(key2A);
     CHECK_CACHE_MISSING(key2B);
 
     // 0 may be stored
     AddKeyInScriptCache(key1B, 0);
 
     // Calculate the most possible transaction sigchecks that can occur in a
     // standard transaction, and make sure the cache can hold it.
     //
     // To be pessimistic, use consensus (MAX_TX_SIZE) instead of policy
     // (MAX_STANDARD_TX_SIZE) since that particular policy limit is bypassed on
     // testnet.
     //
     // Assume that a standardness rule limiting density to ~33 bytes/sigcheck is
     // in place.
     const int max_standard_sigchecks = 1 + (MAX_TX_SIZE / 33);
     AddKeyInScriptCache(key2A, max_standard_sigchecks);
 
     // Read out values again.
     CHECK_CACHE_HAS(key1A, 42);
     CHECK_CACHE_HAS(key1B, 0);
     CHECK_CACHE_HAS(key2A, max_standard_sigchecks);
     CHECK_CACHE_MISSING(key2B);
 
     // Try overwriting an existing entry with different value (should never
     // happen in practice but see what happens).
     AddKeyInScriptCache(key1A, 99);
     // This succeeds without error, but (currently) no replacement is done.
     // It would also be acceptable to overwrite, but if we ever come to a
     // situation where this matters then neither alternative is better.
     CHECK_CACHE_HAS(key1A, 42);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index e8d294298..46c7c4137 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -1,1882 +1,1882 @@
 // 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 <chain.h>
 #include <config.h>
 #include <core_io.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
 #include <merkleblock.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <sync.h>
 #include <util/bip32.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <util/translation.h>
 #include <wallet/rpcwallet.h>
 #include <wallet/wallet.h>
 
 #include <boost/algorithm/string.hpp>
 
 #include <univalue.h>
 
 #include <cstdint>
 
 static std::string EncodeDumpString(const std::string &str) {
     std::stringstream ret;
     for (const uint8_t c : str) {
         if (c <= 32 || c >= 128 || c == '%') {
             ret << '%' << HexStr(&c, &c + 1);
         } else {
             ret << c;
         }
     }
     return ret.str();
 }
 
 static std::string DecodeDumpString(const std::string &str) {
     std::stringstream ret;
     for (unsigned int pos = 0; pos < str.length(); pos++) {
         uint8_t c = str[pos];
         if (c == '%' && pos + 2 < str.length()) {
             c = (((str[pos + 1] >> 6) * 9 + ((str[pos + 1] - '0') & 15)) << 4) |
                 ((str[pos + 2] >> 6) * 9 + ((str[pos + 2] - '0') & 15));
             pos += 2;
         }
         ret << c;
     }
     return ret.str();
 }
 
 static bool GetWalletAddressesForKey(const Config &config,
                                      CWallet *const pwallet,
                                      const CKeyID &keyid, std::string &strAddr,
                                      std::string &strLabel)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     bool fLabelFound = false;
     CKey key;
     pwallet->GetKey(keyid, key);
     for (const auto &dest : GetAllDestinationsForKey(key.GetPubKey())) {
         if (pwallet->mapAddressBook.count(dest)) {
             if (!strAddr.empty()) {
                 strAddr += ",";
             }
             strAddr += EncodeDestination(dest, config);
             strLabel = EncodeDumpString(pwallet->mapAddressBook[dest].name);
             fLabelFound = true;
         }
     }
     if (!fLabelFound) {
         strAddr = EncodeDestination(
             GetDestinationForKey(key.GetPubKey(),
                                  pwallet->m_default_address_type),
             config);
     }
     return fLabelFound;
 }
 
 static const int64_t TIMESTAMP_MIN = 0;
 
 static void RescanWallet(CWallet &wallet, const WalletRescanReserver &reserver,
                          int64_t time_begin = TIMESTAMP_MIN,
                          bool update = true) {
     int64_t scanned_time = wallet.RescanFromTime(time_begin, reserver, update);
     if (wallet.IsAbortingRescan()) {
         throw JSONRPCError(RPC_MISC_ERROR, "Rescan aborted by user.");
     } else if (scanned_time > time_begin) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Rescan was unable to fully rescan the blockchain. "
                            "Some transactions may be missing.");
     }
 }
 
 UniValue importprivkey(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 3) {
         throw std::runtime_error(RPCHelpMan{
             "importprivkey",
             "\nAdds a private key (as returned by dumpprivkey) to "
             "your wallet. Requires a new wallet backup.\n"
             "Hint: use importmulti to import more than one private key.\n"
             "\nNote: This call can take minutes to complete if rescan is true, "
             "during that time, other rpc calls\n"
             "may report that the imported key exists but related transactions "
             "are still missing, leading to temporarily incorrect/bogus "
             "balances and unspent outputs until rescan completes.\n",
             {
                 {"privkey", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The private key (see dumpprivkey)"},
                 {"label", RPCArg::Type::STR, /* default */
                  "current label if address exists, otherwise \"\"",
                  "An optional label"},
                 {"rescan", RPCArg::Type::BOOL, /* default */ "true",
                  "Rescan the wallet for transactions"},
             },
             RPCResults{},
             RPCExamples{
                 "\nDump a private key\n" +
                 HelpExampleCli("dumpprivkey", "\"myaddress\"") +
                 "\nImport the private key with rescan\n" +
                 HelpExampleCli("importprivkey", "\"mykey\"") +
                 "\nImport using a label and without rescan\n" +
                 HelpExampleCli("importprivkey", "\"mykey\" \"testing\" false") +
                 "\nImport using default blank label and without rescan\n" +
                 HelpExampleCli("importprivkey", "\"mykey\" \"\" false") +
                 "\nAs a JSON-RPC call\n" +
                 HelpExampleRpc("importprivkey",
                                "\"mykey\", \"testing\", false")},
         }
                                      .ToString());
     }
 
     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Cannot import private keys to a wallet with "
                            "private keys disabled");
     }
 
     WalletRescanReserver reserver(pwallet);
     bool fRescan = true;
     {
         auto locked_chain = pwallet->chain().lock();
         LOCK(pwallet->cs_wallet);
 
         EnsureWalletIsUnlocked(pwallet);
 
         std::string strSecret = request.params[0].get_str();
         std::string strLabel = "";
         if (!request.params[1].isNull()) {
             strLabel = request.params[1].get_str();
         }
 
         // Whether to perform rescan after import
         if (!request.params[2].isNull()) {
             fRescan = request.params[2].get_bool();
         }
 
         if (fRescan && pwallet->chain().getPruneMode()) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Rescan is disabled in pruned mode");
         }
 
         if (fRescan && !reserver.reserve()) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Wallet is currently rescanning. Abort existing "
                                "rescan or wait.");
         }
 
         CKey key = DecodeSecret(strSecret);
         if (!key.IsValid()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid private key encoding");
         }
 
         CPubKey pubkey = key.GetPubKey();
         assert(key.VerifyPubKey(pubkey));
         CKeyID vchAddress = pubkey.GetID();
         {
             pwallet->MarkDirty();
 
             // We don't know which corresponding address will be used;
             // label all new addresses, and label existing addresses if a
             // label was passed.
             for (const auto &dest : GetAllDestinationsForKey(pubkey)) {
                 if (!request.params[1].isNull() ||
                     pwallet->mapAddressBook.count(dest) == 0) {
                     pwallet->SetAddressBook(dest, strLabel, "receive");
                 }
             }
 
             // Don't throw error in case a key is already there
             if (pwallet->HaveKey(vchAddress)) {
                 return NullUniValue;
             }
 
             pwallet->LearnAllRelatedScripts(pubkey);
 
             // whenever a key is imported, we need to scan the whole chain
             pwallet->UpdateTimeFirstKey(1);
             pwallet->mapKeyMetadata[vchAddress].nCreateTime = 1;
 
             if (!pwallet->AddKeyPubKey(key, pubkey)) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Error adding key to wallet");
             }
         }
     }
     if (fRescan) {
         RescanWallet(*pwallet, reserver);
     }
 
     return NullUniValue;
 }
 
 UniValue abortrescan(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 0) {
         throw std::runtime_error(RPCHelpMan{
             "abortrescan",
             "\nStops current wallet rescan triggered by "
             "an RPC call, e.g. by an importprivkey call.\n",
             {},
             RPCResults{},
             RPCExamples{"\nImport a private key\n" +
                         HelpExampleCli("importprivkey", "\"mykey\"") +
                         "\nAbort the running wallet rescan\n" +
                         HelpExampleCli("abortrescan", "") +
                         "\nAs a JSON-RPC call\n" +
                         HelpExampleRpc("abortrescan", "")},
         }
                                      .ToString());
     }
 
     if (!pwallet->IsScanning() || pwallet->IsAbortingRescan()) {
         return false;
     }
     pwallet->AbortRescan();
     return true;
 }
 
 static void ImportAddress(CWallet *, const CTxDestination &dest,
                           const std::string &strLabel);
 static void ImportScript(CWallet *const pwallet, const CScript &script,
                          const std::string &strLabel, bool isRedeemScript)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     if (!isRedeemScript && ::IsMine(*pwallet, script) == ISMINE_SPENDABLE) {
         throw JSONRPCError(RPC_WALLET_ERROR, "The wallet already contains the "
                                              "private key for this address or "
                                              "script");
     }
 
     pwallet->MarkDirty();
 
     if (!pwallet->HaveWatchOnly(script) &&
         !pwallet->AddWatchOnly(script, 0 /* nCreateTime */)) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Error adding address to wallet");
     }
 
     if (isRedeemScript) {
         const CScriptID id(script);
         if (!pwallet->HaveCScript(id) && !pwallet->AddCScript(script)) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Error adding p2sh redeemScript to wallet");
         }
-        ImportAddress(pwallet, id, strLabel);
+        ImportAddress(pwallet, ScriptHash(id), strLabel);
     } else {
         CTxDestination destination;
         if (ExtractDestination(script, destination)) {
             pwallet->SetAddressBook(destination, strLabel, "receive");
         }
     }
 }
 
 static void ImportAddress(CWallet *const pwallet, const CTxDestination &dest,
                           const std::string &strLabel)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     CScript script = GetScriptForDestination(dest);
     ImportScript(pwallet, script, strLabel, false);
     // add to address book or update label
     if (IsValidDestination(dest)) {
         pwallet->SetAddressBook(dest, strLabel, "receive");
     }
 }
 
 UniValue importaddress(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 4) {
         throw std::runtime_error(RPCHelpMan{
             "importaddress",
             "\nAdds an address or script (in hex) that can be "
             "watched as if it were in your wallet but cannot be "
             "used to spend. Requires a new wallet backup.\n"
             "\nNote: This call can take minutes to complete if rescan is true, "
             "during that time, other rpc calls\n"
             "may report that the imported address exists but related "
             "transactions are still missing, leading to temporarily "
             "incorrect/bogus balances and unspent outputs until rescan "
             "completes.\n"
             "If you have the full public key, you should call importpubkey "
             "instead of this.\n"
             "\nNote: If you import a non-standard raw script in hex form, "
             "outputs sending to it will be treated\n"
             "as change, and not show up in many RPCs.\n",
             {
                 {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The Bitcoin address (or hex-encoded script)"},
                 {"label", RPCArg::Type::STR, /* default */ "\"\"",
                  "An optional label"},
                 {"rescan", RPCArg::Type::BOOL, /* default */ "true",
                  "Rescan the wallet for transactions"},
                 {"p2sh", RPCArg::Type::BOOL, /* default */ "false",
                  "Add the P2SH version of the script as well"},
             },
             RPCResults{},
             RPCExamples{"\nImport an address with rescan\n" +
                         HelpExampleCli("importaddress", "\"myaddress\"") +
                         "\nImport using a label without rescan\n" +
                         HelpExampleCli("importaddress",
                                        "\"myaddress\" \"testing\" false") +
                         "\nAs a JSON-RPC call\n" +
                         HelpExampleRpc("importaddress",
                                        "\"myaddress\", \"testing\", false")},
         }
                                      .ToString());
     }
 
     std::string strLabel;
     if (!request.params[1].isNull()) {
         strLabel = request.params[1].get_str();
     }
 
     // Whether to perform rescan after import
     bool fRescan = true;
     if (!request.params[2].isNull()) {
         fRescan = request.params[2].get_bool();
     }
 
     if (fRescan && pwallet->chain().getPruneMode()) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Rescan is disabled in pruned mode");
     }
 
     WalletRescanReserver reserver(pwallet);
     if (fRescan && !reserver.reserve()) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Wallet is currently rescanning. Abort existing rescan or wait.");
     }
 
     // Whether to import a p2sh version, too
     bool fP2SH = false;
     if (!request.params[3].isNull()) {
         fP2SH = request.params[3].get_bool();
     }
 
     {
         auto locked_chain = pwallet->chain().lock();
         LOCK(pwallet->cs_wallet);
 
         CTxDestination dest = DecodeDestination(request.params[0].get_str(),
                                                 config.GetChainParams());
         if (IsValidDestination(dest)) {
             if (fP2SH) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Cannot use the p2sh flag with an address - "
                                    "use a script instead");
             }
             ImportAddress(pwallet, dest, strLabel);
         } else if (IsHex(request.params[0].get_str())) {
             std::vector<uint8_t> data(ParseHex(request.params[0].get_str()));
             ImportScript(pwallet, CScript(data.begin(), data.end()), strLabel,
                          fP2SH);
         } else {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid Bitcoin address or script");
         }
     }
     if (fRescan) {
         RescanWallet(*pwallet, reserver);
         {
             auto locked_chain = pwallet->chain().lock();
             LOCK(pwallet->cs_wallet);
             pwallet->ReacceptWalletTransactions(*locked_chain);
         }
     }
 
     return NullUniValue;
 }
 
 UniValue importprunedfunds(const Config &config,
                            const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 2) {
         throw std::runtime_error(RPCHelpMan{
             "importprunedfunds",
             "\nImports funds without rescan. Corresponding address or script "
             "must previously be included in wallet. Aimed towards pruned "
             "wallets. The end-user is responsible to import additional "
             "transactions that subsequently spend the imported outputs or "
             "rescan after the point in the blockchain the transaction is "
             "included.\n",
             {
                 {"rawtransaction", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "A raw transaction in hex funding an already-existing "
                  "address in wallet"},
                 {"txoutproof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "The hex output from gettxoutproof that contains the "
                  "transaction"},
             },
             RPCResults{},
             RPCExamples{""},
         }
                                      .ToString());
     }
 
     CMutableTransaction tx;
     if (!DecodeHexTx(tx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
     uint256 txid = tx.GetId();
     CWalletTx wtx(pwallet, MakeTransactionRef(std::move(tx)));
 
     CDataStream ssMB(ParseHexV(request.params[1], "proof"), SER_NETWORK,
                      PROTOCOL_VERSION);
     CMerkleBlock merkleBlock;
     ssMB >> merkleBlock;
 
     // Search partial merkle tree in proof for our transaction and index in
     // valid block
     std::vector<uint256> vMatch;
     std::vector<size_t> vIndex;
     size_t txnIndex = 0;
     if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) ==
         merkleBlock.header.hashMerkleRoot) {
         auto locked_chain = pwallet->chain().lock();
         if (locked_chain->getBlockHeight(merkleBlock.header.GetHash()) ==
             nullopt) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Block not found in chain");
         }
 
         std::vector<uint256>::const_iterator it;
         if ((it = std::find(vMatch.begin(), vMatch.end(), txid)) ==
             vMatch.end()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Transaction given doesn't exist in proof");
         }
 
         txnIndex = vIndex[it - vMatch.begin()];
     } else {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Something wrong with merkleblock");
     }
 
     wtx.nIndex = txnIndex;
     wtx.hashBlock = merkleBlock.header.GetHash();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     if (pwallet->IsMine(*wtx.tx)) {
         pwallet->AddToWallet(wtx, false);
         return NullUniValue;
     }
 
     throw JSONRPCError(
         RPC_INVALID_ADDRESS_OR_KEY,
         "No addresses in wallet correspond to included transaction");
 }
 
 UniValue removeprunedfunds(const Config &config,
                            const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "removeprunedfunds",
             "\nDeletes the specified transaction from the wallet. Meant "
             "for use with pruned wallets and as a companion to "
             "importprunedfunds. This will affect wallet balances.\n",
             {
                 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "The hex-encoded id of the transaction you are deleting"},
             },
             RPCResults{},
             RPCExamples{
                 HelpExampleCli("removeprunedfunds",
                                "\"a8d0c0184dde994a09ec054286f1"
                                "ce581bebf46446a512166eae762873"
                                "4ea0a5\"") +
                 "\nAs a JSON-RPC call\n" +
                 HelpExampleRpc(
                     "removeprunedfunds",
                     "\"a8d0c0184dde994a09ec054286f1ce581bebf46446a512166"
                     "eae7628734ea0a5\"")},
         }
                                      .ToString());
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     TxId txid(ParseHashV(request.params[0], "txid"));
     std::vector<TxId> txIds;
     txIds.push_back(txid);
     std::vector<TxId> txIdsOut;
 
     if (pwallet->ZapSelectTx(txIds, txIdsOut) != DBErrors::LOAD_OK) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Could not properly delete the transaction.");
     }
 
     if (txIdsOut.empty()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Transaction does not exist in wallet.");
     }
 
     return NullUniValue;
 }
 
 UniValue importpubkey(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 3) {
         throw std::runtime_error(RPCHelpMan{
             "importpubkey",
             "\nAdds a public key (in hex) that can be watched as if "
             "it were in your wallet but cannot be used to spend. "
             "Requires a new wallet backup.\n"
             "\nNote: This call can take minutes to complete if rescan is true, "
             "during that time, other rpc calls\n"
             "may report that the imported pubkey exists but related "
             "transactions are still missing, leading to temporarily "
             "incorrect/bogus balances and unspent outputs until rescan "
             "completes.\n",
             {
                 {"pubkey", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The hex-encoded public key"},
                 {"label", RPCArg::Type::STR, /* default */ "\"\"",
                  "An optional label"},
                 {"rescan", RPCArg::Type::BOOL, /* default */ "true",
                  "Rescan the wallet for transactions"},
             },
             RPCResults{},
             RPCExamples{"\nImport a public key with rescan\n" +
                         HelpExampleCli("importpubkey", "\"mypubkey\"") +
                         "\nImport using a label without rescan\n" +
                         HelpExampleCli("importpubkey",
                                        "\"mypubkey\" \"testing\" false") +
                         "\nAs a JSON-RPC call\n" +
                         HelpExampleRpc("importpubkey",
                                        "\"mypubkey\", \"testing\", false")},
         }
                                      .ToString());
     }
 
     std::string strLabel;
     if (!request.params[1].isNull()) {
         strLabel = request.params[1].get_str();
     }
 
     // Whether to perform rescan after import
     bool fRescan = true;
     if (!request.params[2].isNull()) {
         fRescan = request.params[2].get_bool();
     }
 
     if (fRescan && pwallet->chain().getPruneMode()) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Rescan is disabled in pruned mode");
     }
 
     WalletRescanReserver reserver(pwallet);
     if (fRescan && !reserver.reserve()) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Wallet is currently rescanning. Abort existing rescan or wait.");
     }
 
     if (!IsHex(request.params[0].get_str())) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Pubkey must be a hex string");
     }
     std::vector<uint8_t> data(ParseHex(request.params[0].get_str()));
     CPubKey pubKey(data.begin(), data.end());
     if (!pubKey.IsFullyValid()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Pubkey is not a valid public key");
     }
 
     {
         auto locked_chain = pwallet->chain().lock();
         LOCK(pwallet->cs_wallet);
 
         for (const auto &dest : GetAllDestinationsForKey(pubKey)) {
             ImportAddress(pwallet, dest, strLabel);
         }
         ImportScript(pwallet, GetScriptForRawPubKey(pubKey), strLabel, false);
         pwallet->LearnAllRelatedScripts(pubKey);
     }
     if (fRescan) {
         RescanWallet(*pwallet, reserver);
         {
             auto locked_chain = pwallet->chain().lock();
             LOCK(pwallet->cs_wallet);
             pwallet->ReacceptWalletTransactions(*locked_chain);
         }
     }
 
     return NullUniValue;
 }
 
 UniValue importwallet(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "importwallet",
             "\nImports keys from a wallet dump file (see dumpwallet). "
             "Requires a new wallet backup to include imported keys.\n",
             {
                 {"filename", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The wallet file"},
             },
             RPCResults{},
             RPCExamples{"\nDump the wallet\n" +
                         HelpExampleCli("dumpwallet", "\"test\"") +
                         "\nImport the wallet\n" +
                         HelpExampleCli("importwallet", "\"test\"") +
                         "\nImport using the json rpc call\n" +
                         HelpExampleRpc("importwallet", "\"test\"")},
         }
                                      .ToString());
     }
 
     if (pwallet->chain().getPruneMode()) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Importing wallets is disabled in pruned mode");
     }
 
     WalletRescanReserver reserver(pwallet);
     if (!reserver.reserve()) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Wallet is currently rescanning. Abort existing rescan or wait.");
     }
 
     int64_t nTimeBegin = 0;
     bool fGood = true;
     {
         auto locked_chain = pwallet->chain().lock();
         LOCK(pwallet->cs_wallet);
 
         EnsureWalletIsUnlocked(pwallet);
 
         fsbridge::ifstream file;
         file.open(request.params[0].get_str(), std::ios::in | std::ios::ate);
         if (!file.is_open()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Cannot open wallet dump file");
         }
         Optional<int> tip_height = locked_chain->getHeight();
         nTimeBegin = tip_height ? locked_chain->getBlockTime(*tip_height) : 0;
 
         int64_t nFilesize = std::max<int64_t>(1, file.tellg());
         file.seekg(0, file.beg);
 
         // Use uiInterface.ShowProgress instead of pwallet.ShowProgress because
         // pwallet.ShowProgress has a cancel button tied to AbortRescan which we
         // don't want for this progress bar showing the import progress.
         // uiInterface.ShowProgress does not have a cancel button.
 
         // show progress dialog in GUI
         pwallet->chain().showProgress(
             strprintf("%s " + _("Importing...").translated,
                       pwallet->GetDisplayName()),
             0, false);
         std::vector<std::tuple<CKey, int64_t, bool, std::string>> keys;
         std::vector<std::pair<CScript, int64_t>> scripts;
         while (file.good()) {
             pwallet->chain().showProgress(
                 "",
                 std::max(1, std::min<int>(50, 100 * double(file.tellg()) /
                                                   double(nFilesize))),
                 false);
             std::string line;
             std::getline(file, line);
             if (line.empty() || line[0] == '#') {
                 continue;
             }
 
             std::vector<std::string> vstr;
             boost::split(vstr, line, boost::is_any_of(" "));
             if (vstr.size() < 2) {
                 continue;
             }
             CKey key = DecodeSecret(vstr[0]);
             if (key.IsValid()) {
                 int64_t nTime = ParseISO8601DateTime(vstr[1]);
                 std::string strLabel;
                 bool fLabel = true;
                 for (size_t nStr = 2; nStr < vstr.size(); nStr++) {
                     if (vstr[nStr].front() == '#') {
                         break;
                     }
                     if (vstr[nStr] == "change=1") {
                         fLabel = false;
                     }
                     if (vstr[nStr] == "reserve=1") {
                         fLabel = false;
                     }
                     if (vstr[nStr].substr(0, 6) == "label=") {
                         strLabel = DecodeDumpString(vstr[nStr].substr(6));
                         fLabel = true;
                     }
                 }
                 keys.push_back(std::make_tuple(key, nTime, fLabel, strLabel));
             } else if (IsHex(vstr[0])) {
                 std::vector<uint8_t> vData(ParseHex(vstr[0]));
                 CScript script = CScript(vData.begin(), vData.end());
                 int64_t birth_time = ParseISO8601DateTime(vstr[1]);
                 scripts.push_back(
                     std::pair<CScript, int64_t>(script, birth_time));
             }
         }
         file.close();
         // We now know whether we are importing private keys, so we can error if
         // private keys are disabled
         if (keys.size() > 0 &&
             pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
             // hide progress dialog in GUI
             pwallet->chain().showProgress("", 100, false);
             throw JSONRPCError(
                 RPC_WALLET_ERROR,
                 "Importing wallets is disabled when private keys are disabled");
         }
         double total = double(keys.size() + scripts.size());
         double progress = 0;
         for (const auto &key_tuple : keys) {
             pwallet->chain().showProgress(
                 "",
                 std::max(50, std::min<int>(75, 100 * progress / total) + 50),
                 false);
             const CKey &key = std::get<0>(key_tuple);
             int64_t time = std::get<1>(key_tuple);
             bool has_label = std::get<2>(key_tuple);
             std::string label = std::get<3>(key_tuple);
 
             CPubKey pubkey = key.GetPubKey();
             assert(key.VerifyPubKey(pubkey));
             CKeyID keyid = pubkey.GetID();
             if (pwallet->HaveKey(keyid)) {
                 pwallet->WalletLogPrintf(
                     "Skipping import of %s (key already present)\n",
-                    EncodeDestination(keyid, config));
+                    EncodeDestination(PKHash(keyid), config));
                 continue;
             }
             pwallet->WalletLogPrintf("Importing %s...\n",
-                                     EncodeDestination(keyid, config));
+                                     EncodeDestination(PKHash(keyid), config));
             if (!pwallet->AddKeyPubKey(key, pubkey)) {
                 fGood = false;
                 continue;
             }
             pwallet->mapKeyMetadata[keyid].nCreateTime = time;
             if (has_label) {
-                pwallet->SetAddressBook(keyid, label, "receive");
+                pwallet->SetAddressBook(PKHash(keyid), label, "receive");
             }
             nTimeBegin = std::min(nTimeBegin, time);
             progress++;
         }
         for (const auto &script_pair : scripts) {
             pwallet->chain().showProgress(
                 "",
                 std::max(50, std::min<int>(75, 100 * progress / total) + 50),
                 false);
             const CScript &script = script_pair.first;
             int64_t time = script_pair.second;
             CScriptID id(script);
             if (pwallet->HaveCScript(id)) {
                 pwallet->WalletLogPrintf(
                     "Skipping import of %s (script already present)\n",
                     HexStr(script));
                 continue;
             }
             if (!pwallet->AddCScript(script)) {
                 pwallet->WalletLogPrintf("Error importing script %s\n",
                                          HexStr(script));
                 fGood = false;
                 continue;
             }
             if (time > 0) {
                 pwallet->m_script_metadata[id].nCreateTime = time;
                 nTimeBegin = std::min(nTimeBegin, time);
             }
             progress++;
         }
         // hide progress dialog in GUI
         pwallet->chain().showProgress("", 100, false);
         pwallet->UpdateTimeFirstKey(nTimeBegin);
     }
     // hide progress dialog in GUI
     pwallet->chain().showProgress("", 100, false);
     RescanWallet(*pwallet, reserver, nTimeBegin, false /* update */);
     pwallet->MarkDirty();
 
     if (!fGood) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Error adding some keys/scripts to wallet");
     }
 
     return NullUniValue;
 }
 
 UniValue dumpprivkey(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "dumpprivkey",
             "\nReveals the private key corresponding to 'address'.\n"
             "Then the importprivkey can be used with this output\n",
             {
                 {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The bitcoin address for the private key"},
             },
             RPCResult{"\"key\"                (string) The private key\n"},
             RPCExamples{HelpExampleCli("dumpprivkey", "\"myaddress\"") +
                         HelpExampleCli("importprivkey", "\"mykey\"") +
                         HelpExampleRpc("dumpprivkey", "\"myaddress\"")},
         }
                                      .ToString());
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     EnsureWalletIsUnlocked(pwallet);
 
     std::string strAddress = request.params[0].get_str();
     CTxDestination dest =
         DecodeDestination(strAddress, config.GetChainParams());
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid Bitcoin address");
     }
     auto keyid = GetKeyForDestination(*pwallet, dest);
     if (keyid.IsNull()) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to a key");
     }
     CKey vchSecret;
     if (!pwallet->GetKey(keyid, vchSecret)) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Private key for address " +
                                                  strAddress + " is not known");
     }
     return EncodeSecret(vchSecret);
 }
 
 UniValue dumpwallet(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "dumpwallet",
             "\nDumps all wallet keys in a human-readable format to "
             "a server-side file. This does not allow overwriting "
             "existing files.\n"
             "Imported scripts are included in the dumpsfile, but "
             "corresponding addresses may not be added automatically "
             "by importwallet.\n"
             "Note that if your wallet contains keys which are not "
             "derived from your HD seed (e.g. imported keys), these "
             "are not covered by\n"
             "only backing up the seed itself, and must be backed up "
             "too (e.g. ensure you back up the whole dumpfile).\n",
             {
                 {"filename", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The filename with path (either absolute or relative to "
                  "bitcoind)"},
             },
             RPCResult{
                 "{                           (json object)\n"
                 "  \"filename\" : {        (string) The filename with full "
                 "absolute path\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("dumpwallet", "\"test\"") +
                         HelpExampleRpc("dumpwallet", "\"test\"")},
         }
                                      .ToString());
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     EnsureWalletIsUnlocked(pwallet);
 
     fs::path filepath = request.params[0].get_str();
     filepath = fs::absolute(filepath);
 
     /**
      * Prevent arbitrary files from being overwritten. There have been reports
      * that users have overwritten wallet files this way:
      * https://github.com/bitcoin/bitcoin/issues/9934
      * It may also avoid other security issues.
      */
     if (fs::exists(filepath)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            filepath.string() + " already exists. If you are "
                                                "sure this is what you want, "
                                                "move it out of the way first");
     }
 
     fsbridge::ofstream file;
     file.open(filepath);
     if (!file.is_open()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Cannot open wallet dump file");
     }
 
     std::map<CTxDestination, int64_t> mapKeyBirth;
     const std::map<CKeyID, int64_t> &mapKeyPool = pwallet->GetAllReserveKeys();
     pwallet->GetKeyBirthTimes(*locked_chain, mapKeyBirth);
 
     std::set<CScriptID> scripts = pwallet->GetCScripts();
     // TODO: include scripts in GetKeyBirthTimes() output instead of separate
 
     // sort time/key pairs
     std::vector<std::pair<int64_t, CKeyID>> vKeyBirth;
     for (const auto &entry : mapKeyBirth) {
-        if (const CKeyID *keyID = boost::get<CKeyID>(&entry.first)) {
+        if (const PKHash *keyID = boost::get<PKHash>(&entry.first)) {
             // set and test
-            vKeyBirth.push_back(std::make_pair(entry.second, *keyID));
+            vKeyBirth.push_back(std::make_pair(entry.second, CKeyID(*keyID)));
         }
     }
     mapKeyBirth.clear();
     std::sort(vKeyBirth.begin(), vKeyBirth.end());
 
     // produce output
     file << strprintf("# Wallet dump created by Bitcoin %s\n", CLIENT_BUILD);
     file << strprintf("# * Created on %s\n", FormatISO8601DateTime(GetTime()));
     const Optional<int> tip_height = locked_chain->getHeight();
     file << strprintf("# * Best block at time of backup was %i (%s),\n",
                       tip_height.value_or(-1),
                       tip_height
                           ? locked_chain->getBlockHash(*tip_height).ToString()
                           : "(missing block hash)");
     file << strprintf("#   mined on %s\n",
                       tip_height ? FormatISO8601DateTime(
                                        locked_chain->getBlockTime(*tip_height))
                                  : "(missing block time)");
     file << "\n";
 
     // add the base58check encoded extended master if the wallet uses HD
     CKeyID seed_id = pwallet->GetHDChain().seed_id;
     if (!seed_id.IsNull()) {
         CKey seed;
         if (pwallet->GetKey(seed_id, seed)) {
             CExtKey masterKey;
             masterKey.SetSeed(seed.begin(), seed.size());
 
             file << "# extended private masterkey: " << EncodeExtKey(masterKey)
                  << "\n\n";
         }
     }
     for (std::vector<std::pair<int64_t, CKeyID>>::const_iterator it =
              vKeyBirth.begin();
          it != vKeyBirth.end(); it++) {
         const CKeyID &keyid = it->second;
         std::string strTime = FormatISO8601DateTime(it->first);
         std::string strAddr;
         std::string strLabel;
         CKey key;
         if (pwallet->GetKey(keyid, key)) {
             file << strprintf("%s %s ", EncodeSecret(key), strTime);
             if (GetWalletAddressesForKey(config, pwallet, keyid, strAddr,
                                          strLabel)) {
                 file << strprintf("label=%s", strLabel);
             } else if (keyid == seed_id) {
                 file << "hdseed=1";
             } else if (mapKeyPool.count(keyid)) {
                 file << "reserve=1";
             } else if (pwallet->mapKeyMetadata[keyid].hdKeypath == "s") {
                 file << "inactivehdseed=1";
             } else {
                 file << "change=1";
             }
             file << strprintf(
                 " # addr=%s%s\n", strAddr,
                 (pwallet->mapKeyMetadata[keyid].has_key_origin
                      ? " hdkeypath=" +
                            WriteHDKeypath(
                                pwallet->mapKeyMetadata[keyid].key_origin.path)
                      : ""));
         }
     }
     file << "\n";
     for (const CScriptID &scriptid : scripts) {
         CScript script;
         std::string create_time = "0";
-        std::string address = EncodeDestination(scriptid, config);
+        std::string address = EncodeDestination(ScriptHash(scriptid), config);
         // get birth times for scripts with metadata
         auto it = pwallet->m_script_metadata.find(scriptid);
         if (it != pwallet->m_script_metadata.end()) {
             create_time = FormatISO8601DateTime(it->second.nCreateTime);
         }
         if (pwallet->GetCScript(scriptid, script)) {
             file << strprintf("%s %s script=1",
                               HexStr(script.begin(), script.end()),
                               create_time);
             file << strprintf(" # addr=%s\n", address);
         }
     }
     file << "\n";
     file << "# End of dump\n";
     file.close();
 
     UniValue reply(UniValue::VOBJ);
     reply.pushKV("filename", filepath.string());
 
     return reply;
 }
 
 struct ImportData {
     // Input data
     //! Provided redeemScript; will be moved to `import_scripts` if relevant.
     std::unique_ptr<CScript> redeemscript;
 
     // Output data
     std::set<CScript> import_scripts;
     //! Import these private keys if available (the value indicates whether if
     //! the key is required for solvability)
     std::map<CKeyID, bool> used_keys;
     std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> key_origins;
 };
 
 enum class ScriptContext {
     //! Top-level scriptPubKey
     TOP,
     //! P2SH redeemScript
     P2SH,
 };
 
 // Analyse the provided scriptPubKey, determining which keys and which redeem
 // scripts from the ImportData struct are needed to spend it, and mark them as
 // used. Returns an error string, or the empty string for success.
 static std::string RecurseImportData(const CScript &script,
                                      ImportData &import_data,
                                      const ScriptContext script_ctx) {
     // Use Solver to obtain script type and parsed pubkeys or hashes:
     std::vector<std::vector<uint8_t>> solverdata;
     txnouttype script_type = Solver(script, solverdata);
 
     switch (script_type) {
         case TX_PUBKEY: {
             CPubKey pubkey(solverdata[0].begin(), solverdata[0].end());
             import_data.used_keys.emplace(pubkey.GetID(), false);
             return "";
         }
         case TX_PUBKEYHASH: {
             CKeyID id = CKeyID(uint160(solverdata[0]));
             import_data.used_keys[id] = true;
             return "";
         }
         case TX_SCRIPTHASH: {
             if (script_ctx == ScriptContext::P2SH) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Trying to nest P2SH inside another P2SH");
             }
             assert(script_ctx == ScriptContext::TOP);
             CScriptID id = CScriptID(uint160(solverdata[0]));
             // Remove redeemscript from import_data to check for superfluous
             // script later.
             auto subscript = std::move(import_data.redeemscript);
             if (!subscript) {
                 return "missing redeemscript";
             }
             if (CScriptID(*subscript) != id) {
                 return "redeemScript does not match the scriptPubKey";
             }
             import_data.import_scripts.emplace(*subscript);
             return RecurseImportData(*subscript, import_data,
                                      ScriptContext::P2SH);
         }
         case TX_MULTISIG: {
             for (size_t i = 1; i + 1 < solverdata.size(); ++i) {
                 CPubKey pubkey(solverdata[i].begin(), solverdata[i].end());
                 import_data.used_keys.emplace(pubkey.GetID(), false);
             }
             return "";
         }
         case TX_NULL_DATA:
             return "unspendable script";
         case TX_NONSTANDARD:
         default:
             return "unrecognized script";
     }
 }
 
 static UniValue ProcessImportLegacy(
     CWallet *const pwallet, ImportData &import_data,
     std::map<CKeyID, CPubKey> &pubkey_map, std::map<CKeyID, CKey> &privkey_map,
     std::set<CScript> &script_pub_keys, bool &have_solving_data,
     const UniValue &data, std::vector<CKeyID> &ordered_pubkeys) {
     UniValue warnings(UniValue::VARR);
 
     // First ensure scriptPubKey has either a script or JSON with "address"
     // string
     const UniValue &scriptPubKey = data["scriptPubKey"];
     bool isScript = scriptPubKey.getType() == UniValue::VSTR;
     if (!isScript && !(scriptPubKey.getType() == UniValue::VOBJ &&
                        scriptPubKey.exists("address"))) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "scriptPubKey must be string with script or JSON "
                            "with address string");
     }
     const std::string &output =
         isScript ? scriptPubKey.get_str() : scriptPubKey["address"].get_str();
 
     // Optional fields.
     const std::string &strRedeemScript =
         data.exists("redeemscript") ? data["redeemscript"].get_str() : "";
     const UniValue &pubKeys =
         data.exists("pubkeys") ? data["pubkeys"].get_array() : UniValue();
     const UniValue &keys =
         data.exists("keys") ? data["keys"].get_array() : UniValue();
     const bool internal =
         data.exists("internal") ? data["internal"].get_bool() : false;
     const bool watchOnly =
         data.exists("watchonly") ? data["watchonly"].get_bool() : false;
 
     if (data.exists("range")) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "Range should not be specified for a non-descriptor import");
     }
 
     // Generate the script and destination for the scriptPubKey provided
     CScript script;
     if (!isScript) {
         CTxDestination dest = DecodeDestination(output, pwallet->chainParams);
         if (!IsValidDestination(dest)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid address \"" + output + "\"");
         }
         script = GetScriptForDestination(dest);
     } else {
         if (!IsHex(output)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid scriptPubKey \"" + output + "\"");
         }
         std::vector<uint8_t> vData(ParseHex(output));
         script = CScript(vData.begin(), vData.end());
         CTxDestination dest;
         if (!ExtractDestination(script, dest) && !internal) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Internal must be set to true for "
                                "nonstandard scriptPubKey imports.");
         }
     }
     script_pub_keys.emplace(script);
 
     // Parse all arguments
     if (strRedeemScript.size()) {
         if (!IsHex(strRedeemScript)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid redeem script \"" + strRedeemScript +
                                    "\": must be hex string");
         }
         auto parsed_redeemscript = ParseHex(strRedeemScript);
         import_data.redeemscript = std::make_unique<CScript>(
             parsed_redeemscript.begin(), parsed_redeemscript.end());
     }
     for (size_t i = 0; i < pubKeys.size(); ++i) {
         const auto &str = pubKeys[i].get_str();
         if (!IsHex(str)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Pubkey \"" + str + "\" must be a hex string");
         }
         auto parsed_pubkey = ParseHex(str);
         CPubKey pubkey(parsed_pubkey.begin(), parsed_pubkey.end());
         if (!pubkey.IsFullyValid()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Pubkey \"" + str +
                                    "\" is not a valid public key");
         }
         pubkey_map.emplace(pubkey.GetID(), pubkey);
         ordered_pubkeys.push_back(pubkey.GetID());
     }
     for (size_t i = 0; i < keys.size(); ++i) {
         const auto &str = keys[i].get_str();
         CKey key = DecodeSecret(str);
         if (!key.IsValid()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid private key encoding");
         }
         CPubKey pubkey = key.GetPubKey();
         CKeyID id = pubkey.GetID();
         if (pubkey_map.count(id)) {
             pubkey_map.erase(id);
         }
         privkey_map.emplace(id, key);
     }
 
     // Verify and process input data
     have_solving_data =
         import_data.redeemscript || pubkey_map.size() || privkey_map.size();
     if (have_solving_data) {
         // Match up data in import_data with the scriptPubKey in script.
         auto error = RecurseImportData(script, import_data, ScriptContext::TOP);
 
         // Verify whether the watchonly option corresponds to the
         // availability of private keys.
         bool spendable = std::all_of(
             import_data.used_keys.begin(), import_data.used_keys.end(),
             [&](const std::pair<CKeyID, bool> &used_key) {
                 return privkey_map.count(used_key.first) > 0;
             });
         if (!watchOnly && !spendable) {
             warnings.push_back("Some private keys are missing, outputs "
                                "will be considered watchonly. If this is "
                                "intentional, specify the watchonly flag.");
         }
         if (watchOnly && spendable) {
             warnings.push_back(
                 "All private keys are provided, outputs will be considered "
                 "spendable. If this is intentional, do not specify the "
                 "watchonly flag.");
         }
 
         // Check that all required keys for solvability are provided.
         if (error.empty()) {
             for (const auto &require_key : import_data.used_keys) {
                 if (!require_key.second) {
                     // Not a required key
                     continue;
                 }
 
                 if (pubkey_map.count(require_key.first) == 0 &&
                     privkey_map.count(require_key.first) == 0) {
                     error = "some required keys are missing";
                 }
             }
         }
 
         if (!error.empty()) {
             warnings.push_back("Importing as non-solvable: " + error +
                                ". If this is intentional, don't provide "
                                "any keys, pubkeys or redeemscript.");
             import_data = ImportData();
             pubkey_map.clear();
             privkey_map.clear();
             have_solving_data = false;
         } else {
             // RecurseImportData() removes any relevant redeemscript from
             // import_data, so we can use that to discover if a superfluous
             // one was provided.
             if (import_data.redeemscript) {
                 warnings.push_back(
                     "Ignoring redeemscript as this is not a P2SH script.");
             }
             for (auto it = privkey_map.begin(); it != privkey_map.end();) {
                 auto oldit = it++;
                 if (import_data.used_keys.count(oldit->first) == 0) {
                     warnings.push_back("Ignoring irrelevant private key.");
                     privkey_map.erase(oldit);
                 }
             }
             for (auto it = pubkey_map.begin(); it != pubkey_map.end();) {
                 auto oldit = it++;
                 auto key_data_it = import_data.used_keys.find(oldit->first);
                 if (key_data_it == import_data.used_keys.end() ||
                     !key_data_it->second) {
                     warnings.push_back("Ignoring public key \"" +
                                        HexStr(oldit->first) +
                                        "\" as it doesn't appear inside P2PKH.");
                     pubkey_map.erase(oldit);
                 }
             }
         }
     }
 
     return warnings;
 }
 
 static UniValue ProcessImportDescriptor(ImportData &import_data,
                                         std::map<CKeyID, CPubKey> &pubkey_map,
                                         std::map<CKeyID, CKey> &privkey_map,
                                         std::set<CScript> &script_pub_keys,
                                         bool &have_solving_data,
                                         const UniValue &data,
                                         std::vector<CKeyID> &ordered_pubkeys) {
     UniValue warnings(UniValue::VARR);
 
     const std::string &descriptor = data["desc"].get_str();
     FlatSigningProvider keys;
     auto parsed_desc = Parse(descriptor, keys);
     if (!parsed_desc) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Descriptor is invalid");
     }
 
     have_solving_data = parsed_desc->IsSolvable();
     const bool watch_only =
         data.exists("watchonly") ? data["watchonly"].get_bool() : false;
 
     int64_t range_start = 0, range_end = 0;
     if (!parsed_desc->IsRange() && data.exists("range")) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "Range should not be specified for an un-ranged descriptor");
     } else if (parsed_desc->IsRange()) {
         if (!data.exists("range")) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Descriptor is ranged, please specify the range");
         }
         const UniValue &range = data["range"];
         range_start = range.exists("start") ? range["start"].get_int64() : 0;
         if (!range.exists("end")) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "End of range for descriptor must be specified");
         }
         range_end = range["end"].get_int64();
         if (range_end < range_start || range_start < 0) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid descriptor range specified");
         }
     }
 
     const UniValue &priv_keys =
         data.exists("keys") ? data["keys"].get_array() : UniValue();
 
     // Expand all descriptors to get public keys and scripts.
     // TODO: get private keys from descriptors too
     for (int i = range_start; i <= range_end; ++i) {
         FlatSigningProvider out_keys;
         std::vector<CScript> scripts_temp;
         parsed_desc->Expand(i, keys, scripts_temp, out_keys);
         std::copy(scripts_temp.begin(), scripts_temp.end(),
                   std::inserter(script_pub_keys, script_pub_keys.end()));
         for (const auto &key_pair : out_keys.pubkeys) {
             ordered_pubkeys.push_back(key_pair.first);
         }
 
         for (const auto &x : out_keys.scripts) {
             import_data.import_scripts.emplace(x.second);
         }
 
         std::copy(out_keys.pubkeys.begin(), out_keys.pubkeys.end(),
                   std::inserter(pubkey_map, pubkey_map.end()));
         import_data.key_origins.insert(out_keys.origins.begin(),
                                        out_keys.origins.end());
     }
 
     for (size_t i = 0; i < priv_keys.size(); ++i) {
         const auto &str = priv_keys[i].get_str();
         CKey key = DecodeSecret(str);
         if (!key.IsValid()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid private key encoding");
         }
         CPubKey pubkey = key.GetPubKey();
         CKeyID id = pubkey.GetID();
 
         // Check if this private key corresponds to a public key from the
         // descriptor
         if (!pubkey_map.count(id)) {
             warnings.push_back("Ignoring irrelevant private key.");
         } else {
             privkey_map.emplace(id, key);
         }
     }
 
     // Check if all the public keys have corresponding private keys in the
     // import for spendability. This does not take into account threshold
     // multisigs which could be spendable without all keys. Thus, threshold
     // multisigs without all keys will be considered not spendable here, even if
     // they are, perhaps triggering a false warning message. This is consistent
     // with the current wallet IsMine check.
     bool spendable =
         std::all_of(pubkey_map.begin(), pubkey_map.end(),
                     [&](const std::pair<CKeyID, CPubKey> &used_key) {
                         return privkey_map.count(used_key.first) > 0;
                     }) &&
         std::all_of(
             import_data.key_origins.begin(), import_data.key_origins.end(),
             [&](const std::pair<CKeyID, std::pair<CPubKey, KeyOriginInfo>>
                     &entry) { return privkey_map.count(entry.first) > 0; });
     if (!watch_only && !spendable) {
         warnings.push_back(
             "Some private keys are missing, outputs will be considered "
             "watchonly. If this is intentional, specify the watchonly flag.");
     }
     if (watch_only && spendable) {
         warnings.push_back("All private keys are provided, outputs will be "
                            "considered spendable. If this is intentional, do "
                            "not specify the watchonly flag.");
     }
 
     return warnings;
 }
 
 static UniValue ProcessImport(CWallet *const pwallet, const UniValue &data,
                               const int64_t timestamp)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     UniValue warnings(UniValue::VARR);
     UniValue result(UniValue::VOBJ);
 
     try {
         const bool internal =
             data.exists("internal") ? data["internal"].get_bool() : false;
         // Internal addresses should not have a label
         if (internal && data.exists("label")) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Internal addresses should not have a label");
         }
         const std::string &label =
             data.exists("label") ? data["label"].get_str() : "";
         const bool add_keypool =
             data.exists("keypool") ? data["keypool"].get_bool() : false;
 
         // Add to keypool only works with privkeys disabled
         if (add_keypool &&
             !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Keys can only be imported to the keypool when "
                                "private keys are disabled");
         }
 
         ImportData import_data;
         std::map<CKeyID, CPubKey> pubkey_map;
         std::map<CKeyID, CKey> privkey_map;
         std::set<CScript> script_pub_keys;
         std::vector<CKeyID> ordered_pubkeys;
         bool have_solving_data;
 
         if (data.exists("scriptPubKey") && data.exists("desc")) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Both a descriptor and a scriptPubKey should not be provided.");
         } else if (data.exists("scriptPubKey")) {
             warnings = ProcessImportLegacy(
                 pwallet, import_data, pubkey_map, privkey_map, script_pub_keys,
                 have_solving_data, data, ordered_pubkeys);
         } else if (data.exists("desc")) {
             warnings = ProcessImportDescriptor(
                 import_data, pubkey_map, privkey_map, script_pub_keys,
                 have_solving_data, data, ordered_pubkeys);
         } else {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Either a descriptor or scriptPubKey must be provided.");
         }
 
         // If private keys are disabled, abort if private keys are being
         // imported
         if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
             !privkey_map.empty()) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Cannot import private keys to a wallet with "
                                "private keys disabled");
         }
 
         // Check whether we have any work to do
         for (const CScript &script : script_pub_keys) {
             if (::IsMine(*pwallet, script) & ISMINE_SPENDABLE) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "The wallet already contains the private "
                                    "key for this address or script (\"" +
                                        HexStr(script.begin(), script.end()) +
                                        "\")");
             }
         }
 
         // All good, time to import
         pwallet->MarkDirty();
         if (!pwallet->ImportScripts(import_data.import_scripts)) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Error adding script to wallet");
         }
         if (!pwallet->ImportPrivKeys(privkey_map, timestamp)) {
             throw JSONRPCError(RPC_WALLET_ERROR, "Error adding key to wallet");
         }
         if (!pwallet->ImportPubKeys(ordered_pubkeys, pubkey_map,
                                     import_data.key_origins, add_keypool,
                                     internal, timestamp)) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Error adding address to wallet");
         }
         if (!pwallet->ImportScriptPubKeys(label, script_pub_keys,
                                           have_solving_data, internal,
                                           timestamp)) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Error adding address to wallet");
         }
 
         result.pushKV("success", UniValue(true));
     } catch (const UniValue &e) {
         result.pushKV("success", UniValue(false));
         result.pushKV("error", e);
     } catch (...) {
         result.pushKV("success", UniValue(false));
         result.pushKV("error",
                       JSONRPCError(RPC_MISC_ERROR, "Missing required fields"));
     }
 
     if (warnings.size()) {
         result.pushKV("warnings", warnings);
     }
     return result;
 }
 
 static int64_t GetImportTimestamp(const UniValue &data, int64_t now) {
     if (data.exists("timestamp")) {
         const UniValue &timestamp = data["timestamp"];
         if (timestamp.isNum()) {
             return timestamp.get_int64();
         } else if (timestamp.isStr() && timestamp.get_str() == "now") {
             return now;
         }
         throw JSONRPCError(RPC_TYPE_ERROR,
                            strprintf("Expected number or \"now\" timestamp "
                                      "value for key. got type %s",
                                      uvTypeName(timestamp.type())));
     }
     throw JSONRPCError(RPC_TYPE_ERROR,
                        "Missing required timestamp field for key");
 }
 
 UniValue importmulti(const Config &config, const JSONRPCRequest &mainRequest) {
     std::shared_ptr<CWallet> const wallet =
         GetWalletForJSONRPCRequest(mainRequest);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, mainRequest.fHelp)) {
         return NullUniValue;
     }
 
     if (mainRequest.fHelp || mainRequest.params.size() < 1 ||
         mainRequest.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "importmulti",
             "\nImport addresses/scripts (with private or public keys, redeem "
             "script (P2SH)), rescanning all addresses in one-shot-only (rescan "
             "can be disabled via options). Requires a new wallet backup.\n",
             {
                 {"requests",
                  RPCArg::Type::ARR,
                  RPCArg::Optional::NO,
                  "Data to be imported",
                  {
                      {
                          "",
                          RPCArg::Type::OBJ,
                          RPCArg::Optional::OMITTED,
                          "",
                          {
                              {"desc", RPCArg::Type::STR,
                               RPCArg::Optional::OMITTED,
                               "Descriptor to import. If using descriptor, do "
                               "not also provide address/scriptPubKey, scripts, "
                               "or pubkeys"},
                              {"scriptPubKey",
                               RPCArg::Type::STR,
                               RPCArg::Optional::NO,
                               "Type of scriptPubKey (string for script, json "
                               "for address). Should not be provided if using a "
                               "descriptor",
                               /* oneline_description */ "",
                               {"\"<script>\" | { \"address\":\"<address>\" }",
                                "string / json"}},
                              {"timestamp",
                               RPCArg::Type::NUM,
                               RPCArg::Optional::NO,
                               "Creation time of the key in seconds since "
                               "epoch (Jan 1 1970 GMT),\n"
                               "                                            "
                               "                  or the string \"now\" to "
                               "substitute the current synced blockchain "
                               "time. The timestamp of the oldest\n"
                               "                                            "
                               "                  key will determine how "
                               "far back blockchain rescans need to begin "
                               "for missing wallet transactions.\n"
                               "                                            "
                               "                  \"now\" can be specified "
                               "to bypass scanning, for keys which are "
                               "known to never have been used, and\n"
                               "                                            "
                               "                  0 can be specified to "
                               "scan the entire blockchain. Blocks up to 2 "
                               "hours before the earliest key\n"
                               "                                            "
                               "                  creation time of all keys "
                               "being imported by the importmulti call will "
                               "be scanned.",
                               /* oneline_description */ "",
                               {"timestamp | \"now\"", "integer / string"}},
                              {"redeemscript", RPCArg::Type::STR,
                               RPCArg::Optional::OMITTED,
                               "Allowed only if the scriptPubKey is a P2SH "
                               "address/scriptPubKey"},
                              {"pubkeys",
                               RPCArg::Type::ARR,
                               /* default */ "empty array",
                               "Array of strings giving pubkeys to import. They "
                               "must occur in P2PKH scripts. They are not "
                               "required when the private key is also provided "
                               "(see the \"keys\" argument).",
                               {
                                   {"pubKey", RPCArg::Type::STR,
                                    RPCArg::Optional::OMITTED, ""},
                               }},
                              {"keys",
                               RPCArg::Type::ARR,
                               /* default */ "empty array",
                               "Array of strings giving private keys to import. "
                               "The corresponding public keys must occur in the "
                               "output or redeemscript.",
                               {
                                   {"key", RPCArg::Type::STR,
                                    RPCArg::Optional::OMITTED, ""},
                               }},
                              {"range",
                               RPCArg::Type::OBJ,
                               RPCArg::Optional::OMITTED,
                               "If a ranged descriptor is used, this specifies "
                               "the start and end of the range to import",
                               {
                                   {"start", RPCArg::Type::NUM,
                                    /* default */ "0",
                                    "Start of the range to import"},
                                   {"end", RPCArg::Type::NUM,
                                    RPCArg::Optional::NO,
                                    "End of the range to import (inclusive)"},
                               }},
                              {"internal", RPCArg::Type::BOOL,
                               /* default */ "false",
                               "Stating whether matching outputs should be "
                               "treated as not incoming payments (also known as "
                               "change)"},
                              {"watchonly", RPCArg::Type::BOOL,
                               /* default */ "false",
                               "Stating whether matching outputs should be "
                               "considered watched even when not all private "
                               "keys are provided."},
                              {"label", RPCArg::Type::STR, /* default */ "''",
                               "Label to assign to the address, only "
                               "allowed with internal=false"},
                          },
                      },
                  },
                  "\"requests\""},
                 {"options",
                  RPCArg::Type::OBJ,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "",
                  {
                      {"rescan", RPCArg::Type::BOOL, /* default */ "true",
                       "Stating if should rescan the blockchain after all "
                       "imports"},
                  },
                  "\"options\""},
             },
             RPCResult{"\nResponse is an array with the same size as the input "
                       "that has the execution result :\n"
                       "  [{\"success\": true}, {\"success\": true, "
                       "\"warnings\": [\"Ignoring irrelevant private key\"]}, "
                       "{\"success\": false, \"error\": {\"code\": -1, "
                       "\"message\": \"Internal Server Error\"}}, ...]\n"},
             RPCExamples{
                 HelpExampleCli(
                     "importmulti",
                     "'[{ \"scriptPubKey\": { \"address\": \"<my address>\" }, "
                     "\"timestamp\":1455191478 }, "
                     "{ \"scriptPubKey\": { \"address\": \"<my 2nd address>\" "
                     "}, "
                     "\"label\": \"example 2\", \"timestamp\": 1455191480 }]'") +
                 HelpExampleCli(
                     "importmulti",
                     "'[{ \"scriptPubKey\": { \"address\": \"<my address>\" }, "
                     "\"timestamp\":1455191478 }]' '{ \"rescan\": false}'")
 
             },
         }
                                      .ToString());
     }
 
     RPCTypeCheck(mainRequest.params, {UniValue::VARR, UniValue::VOBJ});
 
     const UniValue &requests = mainRequest.params[0];
 
     // Default options
     bool fRescan = true;
 
     if (!mainRequest.params[1].isNull()) {
         const UniValue &options = mainRequest.params[1];
 
         if (options.exists("rescan")) {
             fRescan = options["rescan"].get_bool();
         }
     }
 
     WalletRescanReserver reserver(pwallet);
     if (fRescan && !reserver.reserve()) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Wallet is currently rescanning. Abort existing rescan or wait.");
     }
 
     int64_t now = 0;
     bool fRunScan = false;
     int64_t nLowestTimestamp = 0;
     UniValue response(UniValue::VARR);
     {
         auto locked_chain = pwallet->chain().lock();
         LOCK(pwallet->cs_wallet);
         EnsureWalletIsUnlocked(pwallet);
 
         // Verify all timestamps are present before importing any keys.
         const Optional<int> tip_height = locked_chain->getHeight();
         now =
             tip_height ? locked_chain->getBlockMedianTimePast(*tip_height) : 0;
         for (const UniValue &data : requests.getValues()) {
             GetImportTimestamp(data, now);
         }
 
         const int64_t minimumTimestamp = 1;
 
         if (fRescan && tip_height) {
             nLowestTimestamp = locked_chain->getBlockTime(*tip_height);
         } else {
             fRescan = false;
         }
 
         for (const UniValue &data : requests.getValues()) {
             const int64_t timestamp =
                 std::max(GetImportTimestamp(data, now), minimumTimestamp);
             const UniValue result = ProcessImport(pwallet, data, timestamp);
             response.push_back(result);
 
             if (!fRescan) {
                 continue;
             }
 
             // If at least one request was successful then allow rescan.
             if (result["success"].get_bool()) {
                 fRunScan = true;
             }
 
             // Get the lowest timestamp.
             if (timestamp < nLowestTimestamp) {
                 nLowestTimestamp = timestamp;
             }
         }
     }
     if (fRescan && fRunScan && requests.size()) {
         int64_t scannedTime = pwallet->RescanFromTime(
             nLowestTimestamp, reserver, true /* update */);
         {
             auto locked_chain = pwallet->chain().lock();
             LOCK(pwallet->cs_wallet);
             pwallet->ReacceptWalletTransactions(*locked_chain);
         }
 
         if (pwallet->IsAbortingRescan()) {
             throw JSONRPCError(RPC_MISC_ERROR, "Rescan aborted by user.");
         }
         if (scannedTime > nLowestTimestamp) {
             std::vector<UniValue> results = response.getValues();
             response.clear();
             response.setArray();
             size_t i = 0;
             for (const UniValue &request : requests.getValues()) {
                 // If key creation date is within the successfully scanned
                 // range, or if the import result already has an error set, let
                 // the result stand unmodified. Otherwise replace the result
                 // with an error message.
                 if (scannedTime <= GetImportTimestamp(request, now) ||
                     results.at(i).exists("error")) {
                     response.push_back(results.at(i));
                 } else {
                     UniValue result = UniValue(UniValue::VOBJ);
                     result.pushKV("success", UniValue(false));
                     result.pushKV(
                         "error",
                         JSONRPCError(
                             RPC_MISC_ERROR,
                             strprintf(
                                 "Rescan failed for key with creation timestamp "
                                 "%d. There was an error reading a block from "
                                 "time %d, which is after or within %d seconds "
                                 "of key creation, and could contain "
                                 "transactions pertaining to the key. As a "
                                 "result, transactions and coins using this key "
                                 "may not appear in the wallet. This error "
                                 "could be caused by pruning or data corruption "
                                 "(see bitcoind log for details) and could be "
                                 "dealt with by downloading and rescanning the "
                                 "relevant blocks (see -reindex and -rescan "
                                 "options).",
                                 GetImportTimestamp(request, now),
                                 scannedTime - TIMESTAMP_WINDOW - 1,
                                 TIMESTAMP_WINDOW)));
                     response.push_back(std::move(result));
                 }
                 ++i;
             }
         }
     }
 
     return response;
 }
 
 // clang-format off
 static const CRPCCommand commands[] = {
     //  category            name                        actor (function)          argNames
     //  ------------------- ------------------------    ----------------------    ----------
     { "wallet",             "abortrescan",              abortrescan,              {} },
     { "wallet",             "dumpprivkey",              dumpprivkey,              {"address"}  },
     { "wallet",             "dumpwallet",               dumpwallet,               {"filename"} },
     { "wallet",             "importmulti",              importmulti,              {"requests","options"} },
     { "wallet",             "importprivkey",            importprivkey,            {"privkey","label","rescan"} },
     { "wallet",             "importwallet",             importwallet,             {"filename"} },
     { "wallet",             "importaddress",            importaddress,            {"address","label","rescan","p2sh"} },
     { "wallet",             "importprunedfunds",        importprunedfunds,        {"rawtransaction","txoutproof"} },
     { "wallet",             "importpubkey",             importpubkey,             {"pubkey","label","rescan"} },
     { "wallet",             "removeprunedfunds",        removeprunedfunds,        {"txid"} },
 };
 // clang-format on
 
 void RegisterDumpRPCCommands(
     interfaces::Chain &chain,
     std::vector<std::unique_ptr<interfaces::Handler>> &handlers) {
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         handlers.emplace_back(chain.handleRpc(commands[vcidx]));
     }
 }
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 3d2149f13..79c93ec31 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -1,4802 +1,4806 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-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 <amount.h>
 #include <chainparams.h> // for GetConsensus.
 #include <coins.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <init.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
 #include <node/transaction.h>
 #include <outputtype.h>
 #include <policy/fees.h>
 #include <rpc/mining.h>
 #include <rpc/rawtransaction_util.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <util/bip32.h>
 #include <util/error.h>
 #include <util/moneystr.h>
 #include <util/system.h>
 #include <util/url.h>
 #include <util/validation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/psbtwallet.h>
 #include <wallet/rpcwallet.h>
 #include <wallet/wallet.h>
 #include <wallet/walletdb.h>
 #include <wallet/walletutil.h>
 
 #include <univalue.h>
 
 #include <event2/http.h>
 
 #include <functional>
 
 static const std::string WALLET_ENDPOINT_BASE = "/wallet/";
 
 [[maybe_unused]] static inline bool GetAvoidReuseFlag(CWallet *const pwallet,
                                                       const UniValue &param) {
     bool can_avoid_reuse = pwallet->IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE);
     bool avoid_reuse = param.isNull() ? can_avoid_reuse : param.get_bool();
 
     if (avoid_reuse && !can_avoid_reuse) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "wallet does not have the \"avoid reuse\" feature enabled");
     }
 
     return avoid_reuse;
 }
 
 bool GetWalletNameFromJSONRPCRequest(const JSONRPCRequest &request,
                                      std::string &wallet_name) {
     if (request.URI.substr(0, WALLET_ENDPOINT_BASE.size()) ==
         WALLET_ENDPOINT_BASE) {
         // wallet endpoint was used
         wallet_name =
             urlDecode(request.URI.substr(WALLET_ENDPOINT_BASE.size()));
         return true;
     }
     return false;
 }
 
 std::shared_ptr<CWallet>
 GetWalletForJSONRPCRequest(const JSONRPCRequest &request) {
     std::string wallet_name;
     if (GetWalletNameFromJSONRPCRequest(request, wallet_name)) {
         std::shared_ptr<CWallet> pwallet = GetWallet(wallet_name);
         if (!pwallet) {
             throw JSONRPCError(
                 RPC_WALLET_NOT_FOUND,
                 "Requested wallet does not exist or is not loaded");
         }
         return pwallet;
     }
 
     std::vector<std::shared_ptr<CWallet>> wallets = GetWallets();
     return wallets.size() == 1 || (request.fHelp && wallets.size() > 0)
                ? wallets[0]
                : nullptr;
 }
 
 std::string HelpRequiringPassphrase(CWallet *const pwallet) {
     return pwallet && pwallet->IsCrypted()
                ? "\nRequires wallet passphrase to be set with walletpassphrase "
                  "call."
                : "";
 }
 
 bool EnsureWalletIsAvailable(CWallet *const pwallet, bool avoidException) {
     if (pwallet) {
         return true;
     }
     if (avoidException) {
         return false;
     }
     if (!HasWallets()) {
         throw JSONRPCError(RPC_METHOD_NOT_FOUND,
                            "Method not found (wallet method is disabled "
                            "because no wallet is loaded)");
     }
 
     throw JSONRPCError(RPC_WALLET_NOT_SPECIFIED,
                        "Wallet file not specified (must request wallet RPC "
                        "through /wallet/<filename> uri-path).");
 }
 
 void EnsureWalletIsUnlocked(CWallet *const pwallet) {
     if (pwallet->IsLocked()) {
         throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED,
                            "Error: Please enter the wallet passphrase with "
                            "walletpassphrase first.");
     }
 }
 
 static void WalletTxToJSON(interfaces::Chain &chain,
                            interfaces::Chain::Lock &locked_chain,
                            const CWalletTx &wtx, UniValue &entry) {
     int confirms = wtx.GetDepthInMainChain(locked_chain);
     entry.pushKV("confirmations", confirms);
     if (wtx.IsCoinBase()) {
         entry.pushKV("generated", true);
     }
     if (confirms > 0) {
         entry.pushKV("blockhash", wtx.hashBlock.GetHex());
         entry.pushKV("blockindex", wtx.nIndex);
         int64_t block_time;
         bool found_block =
             chain.findBlock(wtx.hashBlock, nullptr /* block */, &block_time);
         assert(found_block);
         entry.pushKV("blocktime", block_time);
     } else {
         entry.pushKV("trusted", wtx.IsTrusted(locked_chain));
     }
     uint256 hash = wtx.GetId();
     entry.pushKV("txid", hash.GetHex());
     UniValue conflicts(UniValue::VARR);
     for (const uint256 &conflict : wtx.GetConflicts()) {
         conflicts.push_back(conflict.GetHex());
     }
     entry.pushKV("walletconflicts", conflicts);
     entry.pushKV("time", wtx.GetTxTime());
     entry.pushKV("timereceived", (int64_t)wtx.nTimeReceived);
 
     for (const std::pair<const std::string, std::string> &item : wtx.mapValue) {
         entry.pushKV(item.first, item.second);
     }
 }
 
 static std::string LabelFromValue(const UniValue &value) {
     std::string label = value.get_str();
     if (label == "*") {
         throw JSONRPCError(RPC_WALLET_INVALID_LABEL_NAME, "Invalid label name");
     }
     return label;
 }
 
 static UniValue getnewaddress(const Config &config,
                               const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "getnewaddress",
             "\nReturns a new Bitcoin address for receiving payments.\n"
             "If 'label' is specified, it is added to the address book \n"
             "so payments received with the address will be associated with "
             "'label'.\n",
             {
                 {"label", RPCArg::Type::STR, /* default */ "null",
                  "The label name for the address to be linked to. If not "
                  "provided, the default label \"\" is used. It can also be set "
                  "to the empty string \"\" to represent the default label. The "
                  "label does not need to exist, it will be created if there is "
                  "no label by the given name."},
             },
             RPCResult{"\"address\"    (string) The new bitcoin address\n"},
             RPCExamples{HelpExampleCli("getnewaddress", "") +
                         HelpExampleRpc("getnewaddress", "")},
         }
                                      .ToString());
     }
 
     LOCK(pwallet->cs_wallet);
 
     if (!pwallet->CanGetAddresses()) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Error: This wallet has no available keys");
     }
 
     // Parse the label first so we don't generate a key if there's an error
     std::string label;
     if (!request.params[0].isNull()) {
         label = LabelFromValue(request.params[0]);
     }
 
     OutputType output_type = pwallet->m_default_address_type;
     if (!request.params[1].isNull()) {
         if (!ParseOutputType(request.params[1].get_str(), output_type)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                strprintf("Unknown address type '%s'",
                                          request.params[1].get_str()));
         }
     }
 
     if (!pwallet->IsLocked()) {
         pwallet->TopUpKeyPool();
     }
 
     // Generate a new key that is added to wallet
     CPubKey newKey;
     if (!pwallet->GetKeyFromPool(newKey)) {
         throw JSONRPCError(
             RPC_WALLET_KEYPOOL_RAN_OUT,
             "Error: Keypool ran out, please call keypoolrefill first");
     }
     pwallet->LearnRelatedScripts(newKey, output_type);
     CTxDestination dest = GetDestinationForKey(newKey, output_type);
 
     pwallet->SetAddressBook(dest, label, "receive");
 
     return EncodeDestination(dest, config);
 }
 
 static UniValue getrawchangeaddress(const Config &config,
                                     const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 1) {
         throw std::runtime_error(RPCHelpMan{
             "getrawchangeaddress",
             "\nReturns a new Bitcoin address, for receiving change.\n"
             "This is for use with raw transactions, NOT normal use.\n",
             {},
             RPCResult{"\"address\"    (string) The address\n"},
             RPCExamples{HelpExampleCli("getrawchangeaddress", "") +
                         HelpExampleRpc("getrawchangeaddress", "")},
         }
                                      .ToString());
     }
 
     LOCK(pwallet->cs_wallet);
 
     if (!pwallet->CanGetAddresses(true)) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Error: This wallet has no available keys");
     }
 
     if (!pwallet->IsLocked()) {
         pwallet->TopUpKeyPool();
     }
 
     OutputType output_type =
         pwallet->m_default_change_type != OutputType::CHANGE_AUTO
             ? pwallet->m_default_change_type
             : pwallet->m_default_address_type;
     if (!request.params[0].isNull()) {
         if (!ParseOutputType(request.params[0].get_str(), output_type)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                strprintf("Unknown address type '%s'",
                                          request.params[0].get_str()));
         }
     }
 
     CReserveKey reservekey(pwallet);
     CPubKey vchPubKey;
     if (!reservekey.GetReservedKey(vchPubKey, true)) {
         throw JSONRPCError(
             RPC_WALLET_KEYPOOL_RAN_OUT,
             "Error: Keypool ran out, please call keypoolrefill first");
     }
 
     reservekey.KeepKey();
 
     pwallet->LearnRelatedScripts(vchPubKey, output_type);
     CTxDestination dest = GetDestinationForKey(vchPubKey, output_type);
 
     return EncodeDestination(dest, config);
 }
 
 static UniValue setlabel(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 2) {
         throw std::runtime_error(RPCHelpMan{
             "setlabel",
             "\nSets the label associated with the given address.\n",
             {
                 {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The bitcoin address to be associated with a label."},
                 {"label", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The label to assign to the address."},
             },
             RPCResults{},
             RPCExamples{
                 HelpExampleCli(
                     "setlabel",
                     "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"tabby\"") +
                 HelpExampleRpc(
                     "setlabel",
                     "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\", \"tabby\"")},
         }
                                      .ToString());
     }
     LOCK(pwallet->cs_wallet);
 
     CTxDestination dest =
         DecodeDestination(request.params[0].get_str(), config.GetChainParams());
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid Bitcoin address");
     }
 
     std::string old_label = pwallet->mapAddressBook[dest].name;
     std::string label = LabelFromValue(request.params[1]);
 
     if (IsMine(*pwallet, dest)) {
         pwallet->SetAddressBook(dest, label, "receive");
     } else {
         pwallet->SetAddressBook(dest, label, "send");
     }
 
     return NullUniValue;
 }
 
 static CTransactionRef SendMoney(interfaces::Chain::Lock &locked_chain,
                                  CWallet *const pwallet,
                                  const CTxDestination &address, Amount nValue,
                                  bool fSubtractFeeFromAmount,
                                  const CCoinControl &coin_control,
                                  mapValue_t mapValue) {
     Amount curBalance = pwallet->GetBalance().m_mine_trusted;
 
     // Check amount
     if (nValue <= Amount::zero()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid amount");
     }
 
     if (nValue > curBalance) {
         throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Insufficient funds");
     }
 
     if (pwallet->GetBroadcastTransactions() && !pwallet->chain().p2pEnabled()) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     // Parse Bitcoin address
     CScript scriptPubKey = GetScriptForDestination(address);
 
     // Create and send the transaction
     CReserveKey reservekey(pwallet);
     Amount nFeeRequired;
     std::string strError;
     std::vector<CRecipient> vecSend;
     int nChangePosRet = -1;
     CRecipient recipient = {scriptPubKey, nValue, fSubtractFeeFromAmount};
     vecSend.push_back(recipient);
 
     CCoinControl coinControl;
     CTransactionRef tx;
     if (!pwallet->CreateTransaction(locked_chain, vecSend, tx, reservekey,
                                     nFeeRequired, nChangePosRet, strError,
                                     coinControl)) {
         if (!fSubtractFeeFromAmount && nValue + nFeeRequired > curBalance) {
             strError = strprintf("Error: This transaction requires a "
                                  "transaction fee of at least %s",
                                  FormatMoney(nFeeRequired));
         }
         throw JSONRPCError(RPC_WALLET_ERROR, strError);
     }
     CValidationState state;
     if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */,
                                     reservekey, state)) {
         strError =
             strprintf("Error: The transaction was rejected! Reason given: %s",
                       FormatStateMessage(state));
         throw JSONRPCError(RPC_WALLET_ERROR, strError);
     }
     return tx;
 }
 
 static UniValue sendtoaddress(const Config &config,
                               const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 5) {
         throw std::runtime_error(RPCHelpMan{
             "sendtoaddress",
             "\nSend an amount to a given address.\n" +
                 HelpRequiringPassphrase(pwallet) + "\n",
             {
                 {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The bitcoin address to send to."},
                 {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO,
                  "The amount in " + CURRENCY_UNIT + " to send. eg 0.1"},
                 {"comment", RPCArg::Type::STR,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "A comment used to store what the transaction is for.\n"
                  "                             This is not part of the "
                  "transaction, just kept in your wallet."},
                 {"comment_to", RPCArg::Type::STR,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "A comment to store the name of the person or organization\n"
                  "                             to which you're sending the "
                  "transaction. This is not part of the \n"
                  "                             transaction, just kept in "
                  "your wallet."},
                 {"subtractfeefromamount", RPCArg::Type::BOOL,
                  /* default */ "false",
                  "The fee will be deducted from the amount being sent.\n"
                  "                             The recipient will receive "
                  "less bitcoins than you enter in the amount field."},
             },
             RPCResult{
                 "\"txid\"                  (string) The transaction id.\n"},
             RPCExamples{
                 HelpExampleCli("sendtoaddress",
                                "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 0.1") +
                 HelpExampleCli("sendtoaddress",
                                "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvay"
                                "dd\" 0.1 \"donation\" \"seans "
                                "outpost\"") +
                 HelpExampleCli("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44"
                                                 "Jvaydd\" 0.1 \"\" \"\" true") +
                 HelpExampleRpc("sendtoaddress",
                                "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvay"
                                "dd\", 0.1, \"donation\", \"seans "
                                "outpost\"")},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     CTxDestination dest =
         DecodeDestination(request.params[0].get_str(), config.GetChainParams());
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
     }
 
     // Amount
     Amount nAmount = AmountFromValue(request.params[1]);
     if (nAmount <= Amount::zero()) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount for send");
     }
 
     // Wallet comments
     mapValue_t mapValue;
     if (!request.params[2].isNull() && !request.params[2].get_str().empty()) {
         mapValue["comment"] = request.params[2].get_str();
     }
     if (!request.params[3].isNull() && !request.params[3].get_str().empty()) {
         mapValue["to"] = request.params[3].get_str();
     }
 
     bool fSubtractFeeFromAmount = false;
     if (!request.params[4].isNull()) {
         fSubtractFeeFromAmount = request.params[4].get_bool();
     }
 
     CCoinControl coin_control;
 
     EnsureWalletIsUnlocked(pwallet);
 
     CTransactionRef tx =
         SendMoney(*locked_chain, pwallet, dest, nAmount, fSubtractFeeFromAmount,
                   coin_control, std::move(mapValue));
     return tx->GetId().GetHex();
 }
 
 static UniValue listaddressgroupings(const Config &config,
                                      const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(RPCHelpMan{
             "listaddressgroupings",
             "\nLists groups of addresses which have had their "
             "common ownership\n"
             "made public by common use as inputs or as the "
             "resulting change\n"
             "in past transactions\n",
             {},
             RPCResult{
                 "[\n"
                 "  [\n"
                 "    [\n"
                 "      \"address\",            (string) The bitcoin address\n"
                 "      amount,                 (numeric) The amount in " +
                 CURRENCY_UNIT +
                 "\n"
                 "      \"label\"               (string, optional) The label\n"
                 "    ]\n"
                 "    ,...\n"
                 "  ]\n"
                 "  ,...\n"
                 "]\n"},
             RPCExamples{HelpExampleCli("listaddressgroupings", "") +
                         HelpExampleRpc("listaddressgroupings", "")},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     UniValue jsonGroupings(UniValue::VARR);
     std::map<CTxDestination, Amount> balances =
         pwallet->GetAddressBalances(*locked_chain);
     for (const std::set<CTxDestination> &grouping :
          pwallet->GetAddressGroupings()) {
         UniValue jsonGrouping(UniValue::VARR);
         for (const CTxDestination &address : grouping) {
             UniValue addressInfo(UniValue::VARR);
             addressInfo.push_back(EncodeDestination(address, config));
             addressInfo.push_back(ValueFromAmount(balances[address]));
 
             if (pwallet->mapAddressBook.find(address) !=
                 pwallet->mapAddressBook.end()) {
                 addressInfo.push_back(
                     pwallet->mapAddressBook.find(address)->second.name);
             }
             jsonGrouping.push_back(addressInfo);
         }
         jsonGroupings.push_back(jsonGrouping);
     }
 
     return jsonGroupings;
 }
 
 static UniValue signmessage(const Config &config,
                             const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 2) {
         throw std::runtime_error(RPCHelpMan{
             "signmessage",
             "\nSign a message with the private key of an address" +
                 HelpRequiringPassphrase(pwallet) + "\n",
             {
                 {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The bitcoin address to use for the private key."},
                 {"message", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The message to create a signature of."},
             },
             RPCResult{
                 "\"signature\"          (string) The signature of the message "
                 "encoded in base 64\n"},
             RPCExamples{
                 "\nUnlock the wallet for 30 seconds\n" +
                 HelpExampleCli("walletpassphrase", "\"mypassphrase\" 30") +
                 "\nCreate the signature\n" +
                 HelpExampleCli(
                     "signmessage",
                     "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"my message\"") +
                 "\nVerify the signature\n" +
                 HelpExampleCli("verifymessage",
                                "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4"
                                "XX\" \"signature\" \"my "
                                "message\"") +
                 "\nAs a JSON-RPC call\n" +
                 HelpExampleRpc(
                     "signmessage",
                     "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\", \"my message\"")},
         }
                                      .ToString());
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     EnsureWalletIsUnlocked(pwallet);
 
     std::string strAddress = request.params[0].get_str();
     std::string strMessage = request.params[1].get_str();
 
     CTxDestination dest =
         DecodeDestination(strAddress, config.GetChainParams());
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");
     }
 
-    const CKeyID *keyID = boost::get<CKeyID>(&dest);
-    if (!keyID) {
+    const PKHash *pkhash = boost::get<PKHash>(&dest);
+    if (!pkhash) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");
     }
 
     CKey key;
-    if (!pwallet->GetKey(*keyID, key)) {
+    CKeyID keyID(*pkhash);
+    if (!pwallet->GetKey(keyID, key)) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Private key not available");
     }
 
     CHashWriter ss(SER_GETHASH, 0);
     ss << strMessageMagic;
     ss << strMessage;
 
     std::vector<uint8_t> vchSig;
     if (!key.SignCompact(ss.GetHash(), vchSig)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Sign failed");
     }
 
     return EncodeBase64(vchSig.data(), vchSig.size());
 }
 
 static UniValue getreceivedbyaddress(const Config &config,
                                      const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "getreceivedbyaddress",
             "\nReturns the total amount received by the given address in "
             "transactions with at least minconf confirmations.\n",
             {
                 {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The bitcoin address for transactions."},
                 {"minconf", RPCArg::Type::NUM, /* default */ "1",
                  "Only include transactions confirmed at least this many "
                  "times."},
             },
             RPCResult{"amount   (numeric) The total amount in " +
                       CURRENCY_UNIT + " received at this address.\n"},
             RPCExamples{
                 "\nThe amount from transactions with at least 1 "
                 "confirmation\n" +
                 HelpExampleCli("getreceivedbyaddress",
                                "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\"") +
                 "\nThe amount including unconfirmed transactions, zero "
                 "confirmations\n" +
                 HelpExampleCli("getreceivedbyaddress",
                                "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" 0") +
                 "\nThe amount with at least 6 confirmations\n" +
                 HelpExampleCli("getreceivedbyaddress",
                                "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" 6") +
                 "\nAs a JSON-RPC call\n" +
                 HelpExampleRpc("getreceivedbyaddress",
                                "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\", 6")},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     // Bitcoin address
     CTxDestination dest =
         DecodeDestination(request.params[0].get_str(), config.GetChainParams());
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid Bitcoin address");
     }
     CScript scriptPubKey = GetScriptForDestination(dest);
     if (!IsMine(*pwallet, scriptPubKey)) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Address not found in wallet");
     }
 
     // Minimum confirmations
     int nMinDepth = 1;
     if (!request.params[1].isNull()) {
         nMinDepth = request.params[1].get_int();
     }
 
     // Tally
     Amount nAmount = Amount::zero();
     for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
         const CWalletTx &wtx = pairWtx.second;
 
         CValidationState state;
         if (wtx.IsCoinBase() ||
             !locked_chain->contextualCheckTransactionForCurrentBlock(
                 config.GetChainParams().GetConsensus(), *wtx.tx, state)) {
             continue;
         }
 
         for (const CTxOut &txout : wtx.tx->vout) {
             if (txout.scriptPubKey == scriptPubKey) {
                 if (wtx.GetDepthInMainChain(*locked_chain) >= nMinDepth) {
                     nAmount += txout.nValue;
                 }
             }
         }
     }
 
     return ValueFromAmount(nAmount);
 }
 
 static UniValue getreceivedbylabel(const Config &config,
                                    const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "getreceivedbylabel",
             "\nReturns the total amount received by addresses with <label> "
             "in transactions with at least [minconf] confirmations.\n",
             {
                 {"label", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The selected label, may be the default label "
                  "using \"\"."},
                 {"minconf", RPCArg::Type::NUM, /* default */ "1",
                  "Only include transactions confirmed at least this "
                  "many times."},
             },
             RPCResult{"amount              (numeric) The total amount in " +
                       CURRENCY_UNIT + " received for this label.\n"},
             RPCExamples{
                 "\nAmount received by the default label with at least 1 "
                 "confirmation\n" +
                 HelpExampleCli("getreceivedbylabel", "\"\"") +
                 "\nAmount received at the tabby label including unconfirmed "
                 "amounts with zero confirmations\n" +
                 HelpExampleCli("getreceivedbylabel", "\"tabby\" 0") +
                 "\nThe amount with at least 6 confirmations\n" +
                 HelpExampleCli("getreceivedbylabel", "\"tabby\" 6") +
                 "\nAs a JSON-RPC call\n" +
                 HelpExampleRpc("getreceivedbylabel", "\"tabby\", 6")},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     // Minimum confirmations
     int nMinDepth = 1;
     if (!request.params[1].isNull()) {
         nMinDepth = request.params[1].get_int();
     }
 
     // Get the set of pub keys assigned to label
     std::string label = LabelFromValue(request.params[0]);
     std::set<CTxDestination> setAddress = pwallet->GetLabelAddresses(label);
 
     // Tally
     Amount nAmount = Amount::zero();
     for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
         const CWalletTx &wtx = pairWtx.second;
         CValidationState state;
         if (wtx.IsCoinBase() ||
             !locked_chain->contextualCheckTransactionForCurrentBlock(
                 config.GetChainParams().GetConsensus(), *wtx.tx, state)) {
             continue;
         }
 
         for (const CTxOut &txout : wtx.tx->vout) {
             CTxDestination address;
             if (ExtractDestination(txout.scriptPubKey, address) &&
                 IsMine(*pwallet, address) && setAddress.count(address)) {
                 if (wtx.GetDepthInMainChain(*locked_chain) >= nMinDepth) {
                     nAmount += txout.nValue;
                 }
             }
         }
     }
 
     return ValueFromAmount(nAmount);
 }
 
 static UniValue getbalance(const Config &config,
                            const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || (request.params.size() > 3)) {
         throw std::runtime_error(RPCHelpMan{
             "getbalance",
             "\nReturns the total available balance.\n"
             "The available balance is what the wallet considers "
             "currently spendable, and is\n"
             "thus affected by options which limit spendability such "
             "as -spendzeroconfchange.\n",
             {
                 {"dummy", RPCArg::Type::STR,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "Remains for backward compatibility. Must be excluded or set "
                  "to \"*\"."},
                 {"minconf", RPCArg::Type::NUM, /* default */ "0",
                  "Only include transactions confirmed at least this "
                  "many times."},
                 {"include_watchonly", RPCArg::Type::BOOL,
                  /* default */ "false",
                  "Also include balance in watch-only addresses (see "
                  "'importaddress')"},
             },
             RPCResult{"amount              (numeric) The total amount in " +
                       CURRENCY_UNIT + " received for this wallet.\n"},
             RPCExamples{"\nThe total amount in the wallet with 1 or more "
                         "confirmations\n" +
                         HelpExampleCli("getbalance", "") +
                         "\nThe total amount in the wallet at least 6 blocks "
                         "confirmed\n" +
                         HelpExampleCli("getbalance", "\"*\" 6") +
                         "\nAs a JSON-RPC call\n" +
                         HelpExampleRpc("getbalance", "\"*\", 6")},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     const UniValue &dummy_value = request.params[0];
     if (!dummy_value.isNull() && dummy_value.get_str() != "*") {
         throw JSONRPCError(
             RPC_METHOD_DEPRECATED,
             "dummy first argument must be excluded or set to \"*\".");
     }
 
     int min_depth = 0;
     if (!request.params[1].isNull()) {
         min_depth = request.params[1].get_int();
     }
 
     bool include_watchonly = false;
     if (!request.params[2].isNull() && request.params[2].get_bool()) {
         include_watchonly = true;
     }
 
     const auto bal = pwallet->GetBalance(min_depth);
 
     return ValueFromAmount(bal.m_mine_trusted + (include_watchonly
                                                      ? bal.m_watchonly_trusted
                                                      : Amount::zero()));
 }
 
 static UniValue getunconfirmedbalance(const Config &config,
                                       const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 0) {
         throw std::runtime_error(RPCHelpMan{
             "getunconfirmedbalance",
             "Returns the server's total unconfirmed balance\n",
             {},
             RPCResults{},
             RPCExamples{""},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     return ValueFromAmount(pwallet->GetBalance().m_mine_untrusted_pending);
 }
 
 static UniValue sendmany(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     const RPCHelpMan help{
         "sendmany",
         "\nSend multiple times. Amounts are double-precision "
         "floating point numbers." +
             HelpRequiringPassphrase(pwallet) + "\n",
         {
             {"dummy", RPCArg::Type::STR, RPCArg::Optional::NO,
              "Must be set to \"\" for backwards compatibility.", "\"\""},
             {
                 "amounts",
                 RPCArg::Type::OBJ,
                 RPCArg::Optional::NO,
                 "A json object with addresses and amounts",
                 {
                     {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO,
                      "The bitcoin address is the key, the numeric amount (can "
                      "be string) in " +
                          CURRENCY_UNIT + " is the value"},
                 },
             },
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "Only use the balance confirmed at least this many times."},
             {"comment", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              "A comment"},
             {
                 "subtractfeefrom",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::OMITTED_NAMED_ARG,
                 "A json array with addresses.\n"
                 "                           The fee will be equally deducted "
                 "from the amount of each selected address.\n"
                 "                           Those recipients will receive less "
                 "bitcoins than you enter in their corresponding amount field.\n"
                 "                           If no addresses are specified "
                 "here, the sender pays the fee.",
                 {
                     {"address", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                      "Subtract fee from this address"},
                 },
             },
         },
         RPCResult{
             "\"txid\"                   (string) The transaction id for the "
             "send. Only 1 transaction is created regardless of \n"
             "                                    the number of addresses.\n"},
         RPCExamples{
             "\nSend two amounts to two different addresses:\n" +
             HelpExampleCli(
                 "sendmany",
                 "\"\" "
                 "\"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,"
                 "\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\"") +
             "\nSend two amounts to two different addresses setting the "
             "confirmation and comment:\n" +
             HelpExampleCli("sendmany",
                            "\"\" "
                            "\"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,"
                            "\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\" "
                            "6 \"testing\"") +
             "\nSend two amounts to two different addresses, subtract fee "
             "from amount:\n" +
             HelpExampleCli(
                 "sendmany",
                 "\"\" "
                 "\"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,"
                 "\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\" 1 \"\" "
                 "\"[\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\","
                 "\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\"]\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("sendmany",
                            "\"\", "
                            "\"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,"
                            "\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\","
                            " 6, \"testing\"")},
     };
 
     if (request.fHelp || !help.IsValidNumArgs(request.params.size())) {
         throw std::runtime_error(help.ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     if (pwallet->GetBroadcastTransactions() && !pwallet->chain().p2pEnabled()) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     if (!request.params[0].isNull() && !request.params[0].get_str().empty()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Dummy value must be set to \"\"");
     }
     UniValue sendTo = request.params[1].get_obj();
 
     mapValue_t mapValue;
     if (!request.params[3].isNull() && !request.params[3].get_str().empty()) {
         mapValue["comment"] = request.params[3].get_str();
     }
 
     UniValue subtractFeeFromAmount(UniValue::VARR);
     if (!request.params[4].isNull()) {
         subtractFeeFromAmount = request.params[4].get_array();
     }
 
     std::set<CTxDestination> destinations;
     std::vector<CRecipient> vecSend;
 
     std::vector<std::string> keys = sendTo.getKeys();
     for (const std::string &name_ : keys) {
         CTxDestination dest = DecodeDestination(name_, config.GetChainParams());
         if (!IsValidDestination(dest)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                std::string("Invalid Bitcoin address: ") +
                                    name_);
         }
 
         if (destinations.count(dest)) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 std::string("Invalid parameter, duplicated address: ") + name_);
         }
         destinations.insert(dest);
 
         CScript scriptPubKey = GetScriptForDestination(dest);
         Amount nAmount = AmountFromValue(sendTo[name_]);
         if (nAmount <= Amount::zero()) {
             throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount for send");
         }
 
         bool fSubtractFeeFromAmount = false;
         for (size_t idx = 0; idx < subtractFeeFromAmount.size(); idx++) {
             const UniValue &addr = subtractFeeFromAmount[idx];
             if (addr.get_str() == name_) {
                 fSubtractFeeFromAmount = true;
             }
         }
 
         CRecipient recipient = {scriptPubKey, nAmount, fSubtractFeeFromAmount};
         vecSend.push_back(recipient);
     }
 
     EnsureWalletIsUnlocked(pwallet);
 
     // Shuffle recipient list
     std::shuffle(vecSend.begin(), vecSend.end(), FastRandomContext());
 
     // Send
     CReserveKey keyChange(pwallet);
     Amount nFeeRequired = Amount::zero();
     int nChangePosRet = -1;
     std::string strFailReason;
     CTransactionRef tx;
     CCoinControl coinControl;
     bool fCreated = pwallet->CreateTransaction(
         *locked_chain, vecSend, tx, keyChange, nFeeRequired, nChangePosRet,
         strFailReason, coinControl);
     if (!fCreated) {
         throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, strFailReason);
     }
     CValidationState state;
     if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */,
                                     keyChange, state)) {
         strFailReason = strprintf("Transaction commit failed:: %s",
                                   FormatStateMessage(state));
         throw JSONRPCError(RPC_WALLET_ERROR, strFailReason);
     }
 
     return tx->GetId().GetHex();
 }
 
 static UniValue addmultisigaddress(const Config &config,
                                    const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 3) {
         std::string msg =
             RPCHelpMan{
                 "addmultisigaddress",
                 "\nAdd a nrequired-to-sign multisignature address to the "
                 "wallet. "
                 "Requires a new wallet backup.\n"
                 "Each key is a Bitcoin address or hex-encoded public key.\n"
                 "If 'label' is specified (DEPRECATED), assign address to that "
                 "label.\n",
                 {
                     {"nrequired", RPCArg::Type::NUM, RPCArg::Optional::NO,
                      "The number of required signatures out of the n keys or "
                      "addresses."},
                     {
                         "keys",
                         RPCArg::Type::ARR,
                         RPCArg::Optional::NO,
                         "A json array of bitcoin addresses or hex-encoded "
                         "public keys",
                         {
                             {"key", RPCArg::Type::STR,
                              RPCArg::Optional::OMITTED,
                              "bitcoin address or hex-encoded public key"},
                         },
                     },
                     {"label", RPCArg::Type::STR,
                      RPCArg::Optional::OMITTED_NAMED_ARG,
                      "A label to assign the addresses to."},
                 },
                 RPCResult{"{\n"
                           "  \"address\":\"multisigaddress\",    (string) The "
                           "value of the new multisig address.\n"
                           "  \"redeemScript\":\"script\"         (string) The "
                           "string value of the hex-encoded redemption script.\n"
                           "}\n"},
                 RPCExamples{
                     "\nAdd a multisig address from 2 addresses\n" +
                     HelpExampleCli(
                         "addmultisigaddress",
                         "2 "
                         "\"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\","
                         "\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc(
                         "addmultisigaddress",
                         "2, "
                         "\"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\","
                         "\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"")},
             }
                 .ToString();
         throw std::runtime_error(msg);
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     std::string label;
     if (!request.params[2].isNull()) {
         label = LabelFromValue(request.params[2]);
     }
 
     int required = request.params[0].get_int();
 
     // Get the public keys
     const UniValue &keys_or_addrs = request.params[1].get_array();
     std::vector<CPubKey> pubkeys;
     for (size_t i = 0; i < keys_or_addrs.size(); ++i) {
         if (IsHex(keys_or_addrs[i].get_str()) &&
             (keys_or_addrs[i].get_str().length() == 66 ||
              keys_or_addrs[i].get_str().length() == 130)) {
             pubkeys.push_back(HexToPubKey(keys_or_addrs[i].get_str()));
         } else {
             pubkeys.push_back(AddrToPubKey(config.GetChainParams(), pwallet,
                                            keys_or_addrs[i].get_str()));
         }
     }
 
     OutputType output_type = pwallet->m_default_address_type;
 
     // Construct using pay-to-script-hash:
     CScript inner = CreateMultisigRedeemscript(required, pubkeys);
     CTxDestination dest =
         AddAndGetDestinationForScript(*pwallet, inner, output_type);
     pwallet->SetAddressBook(dest, label, "send");
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("address", EncodeDestination(dest, config));
     result.pushKV("redeemScript", HexStr(inner.begin(), inner.end()));
     return result;
 }
 
 struct tallyitem {
     Amount nAmount{Amount::zero()};
     int nConf{std::numeric_limits<int>::max()};
     std::vector<uint256> txids;
     bool fIsWatchonly{false};
     tallyitem() {}
 };
 
 static UniValue
 ListReceived(const Config &config, interfaces::Chain::Lock &locked_chain,
              CWallet *const pwallet, const UniValue &params, bool by_label)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     // Minimum confirmations
     int nMinDepth = 1;
     if (!params[0].isNull()) {
         nMinDepth = params[0].get_int();
     }
 
     // Whether to include empty labels
     bool fIncludeEmpty = false;
     if (!params[1].isNull()) {
         fIncludeEmpty = params[1].get_bool();
     }
 
     isminefilter filter = ISMINE_SPENDABLE;
     if (!params[2].isNull() && params[2].get_bool()) {
         filter = filter | ISMINE_WATCH_ONLY;
     }
 
     bool has_filtered_address = false;
     CTxDestination filtered_address = CNoDestination();
     if (!by_label && params.size() > 3) {
         if (!IsValidDestinationString(params[3].get_str(),
                                       config.GetChainParams())) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "address_filter parameter was invalid");
         }
         filtered_address =
             DecodeDestination(params[3].get_str(), config.GetChainParams());
         has_filtered_address = true;
     }
 
     // Tally
     std::map<CTxDestination, tallyitem> mapTally;
     for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
         const CWalletTx &wtx = pairWtx.second;
 
         CValidationState state;
         if (wtx.IsCoinBase() ||
             !locked_chain.contextualCheckTransactionForCurrentBlock(
                 config.GetChainParams().GetConsensus(), *wtx.tx, state)) {
             continue;
         }
 
         int nDepth = wtx.GetDepthInMainChain(locked_chain);
         if (nDepth < nMinDepth) {
             continue;
         }
 
         for (const CTxOut &txout : wtx.tx->vout) {
             CTxDestination address;
             if (!ExtractDestination(txout.scriptPubKey, address)) {
                 continue;
             }
 
             if (has_filtered_address && !(filtered_address == address)) {
                 continue;
             }
 
             isminefilter mine = IsMine(*pwallet, address);
             if (!(mine & filter)) {
                 continue;
             }
 
             tallyitem &item = mapTally[address];
             item.nAmount += txout.nValue;
             item.nConf = std::min(item.nConf, nDepth);
             item.txids.push_back(wtx.GetId());
             if (mine & ISMINE_WATCH_ONLY) {
                 item.fIsWatchonly = true;
             }
         }
     }
 
     // Reply
     UniValue ret(UniValue::VARR);
     std::map<std::string, tallyitem> label_tally;
 
     // Create mapAddressBook iterator
     // If we aren't filtering, go from begin() to end()
     auto start = pwallet->mapAddressBook.begin();
     auto end = pwallet->mapAddressBook.end();
     // If we are filtering, find() the applicable entry
     if (has_filtered_address) {
         start = pwallet->mapAddressBook.find(filtered_address);
         if (start != end) {
             end = std::next(start);
         }
     }
 
     for (auto item_it = start; item_it != end; ++item_it) {
         const CTxDestination &address = item_it->first;
         const std::string &label = item_it->second.name;
         std::map<CTxDestination, tallyitem>::iterator it =
             mapTally.find(address);
         if (it == mapTally.end() && !fIncludeEmpty) {
             continue;
         }
 
         Amount nAmount = Amount::zero();
         int nConf = std::numeric_limits<int>::max();
         bool fIsWatchonly = false;
         if (it != mapTally.end()) {
             nAmount = (*it).second.nAmount;
             nConf = (*it).second.nConf;
             fIsWatchonly = (*it).second.fIsWatchonly;
         }
 
         if (by_label) {
             tallyitem &_item = label_tally[label];
             _item.nAmount += nAmount;
             _item.nConf = std::min(_item.nConf, nConf);
             _item.fIsWatchonly = fIsWatchonly;
         } else {
             UniValue obj(UniValue::VOBJ);
             if (fIsWatchonly) {
                 obj.pushKV("involvesWatchonly", true);
             }
             obj.pushKV("address", EncodeDestination(address, config));
             obj.pushKV("amount", ValueFromAmount(nAmount));
             obj.pushKV("confirmations",
                        (nConf == std::numeric_limits<int>::max() ? 0 : nConf));
             obj.pushKV("label", label);
             UniValue transactions(UniValue::VARR);
             if (it != mapTally.end()) {
                 for (const uint256 &_item : (*it).second.txids) {
                     transactions.push_back(_item.GetHex());
                 }
             }
             obj.pushKV("txids", transactions);
             ret.push_back(obj);
         }
     }
 
     if (by_label) {
         for (const auto &entry : label_tally) {
             Amount nAmount = entry.second.nAmount;
             int nConf = entry.second.nConf;
             UniValue obj(UniValue::VOBJ);
             if (entry.second.fIsWatchonly) {
                 obj.pushKV("involvesWatchonly", true);
             }
             obj.pushKV("amount", ValueFromAmount(nAmount));
             obj.pushKV("confirmations",
                        (nConf == std::numeric_limits<int>::max() ? 0 : nConf));
             obj.pushKV("label", entry.first);
             ret.push_back(obj);
         }
     }
 
     return ret;
 }
 
 static UniValue listreceivedbyaddress(const Config &config,
                                       const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 4) {
         throw std::runtime_error(RPCHelpMan{
             "listreceivedbyaddress",
             "\nList balances by receiving address.\n",
             {
                 {"minconf", RPCArg::Type::NUM, /* default */ "1",
                  "The minimum number of confirmations before payments are "
                  "included."},
                 {"include_empty", RPCArg::Type::BOOL, /* default */ "false",
                  "Whether to include addresses that haven't received any "
                  "payments."},
                 {"include_watchonly", RPCArg::Type::BOOL, /* default */ "false",
                  "Whether to include watch-only addresses (see "
                  "'importaddress')."},
                 {"address_filter", RPCArg::Type::STR,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "If present, only return information on this address."},
             },
             RPCResult{
                 "[\n"
                 "  {\n"
                 "    \"involvesWatchonly\" : true,        (bool) Only returned "
                 "if imported addresses were involved in transaction\n"
                 "    \"address\" : \"receivingaddress\",  (string) The "
                 "receiving address\n"
                 "    \"amount\" : x.xxx,                  (numeric) The total "
                 "amount in " +
                 CURRENCY_UNIT +
                 " received by the address\n"
                 "    \"confirmations\" : n,               (numeric) The number "
                 "of confirmations of the most recent transaction included\n"
                 "    \"label\" : \"label\",               (string) The label "
                 "of the receiving address. The default label is \"\".\n"
                 "    \"txids\": [\n"
                 "       \"txid\",                         (string) The ids of "
                 "transactions received with the address \n"
                 "       ...\n"
                 "    ]\n"
                 "  }\n"
                 "  ,...\n"
                 "]\n"},
             RPCExamples{
                 HelpExampleCli("listreceivedbyaddress", "") +
                 HelpExampleCli("listreceivedbyaddress", "6 true") +
                 HelpExampleRpc("listreceivedbyaddress", "6, true, true") +
                 HelpExampleRpc(
                     "listreceivedbyaddress",
                     "6, true, true, \"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\"")},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     return ListReceived(config, *locked_chain, pwallet, request.params, false);
 }
 
 static UniValue listreceivedbylabel(const Config &config,
                                     const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 3) {
         throw std::runtime_error(RPCHelpMan{
             "listreceivedbylabel",
             "\nList received transactions by label.\n",
             {
                 {"minconf", RPCArg::Type::NUM, /* default */ "1",
                  "The minimum number of confirmations before "
                  "payments are included."},
                 {"include_empty", RPCArg::Type::BOOL, /* default */ "false",
                  "Whether to include labels that haven't received "
                  "any payments."},
                 {"include_watchonly", RPCArg::Type::BOOL,
                  /* default */ "false",
                  "Whether to include watch-only addresses (see "
                  "'importaddress')."},
             },
             RPCResult{
                 "[\n"
                 "  {\n"
                 "    \"involvesWatchonly\" : true,   (bool) Only returned if "
                 "imported addresses were involved in transaction\n"
                 "    \"amount\" : x.xxx,             (numeric) The total "
                 "amount received by addresses with this label\n"
                 "    \"confirmations\" : n,          (numeric) The number of "
                 "confirmations of the most recent transaction included\n"
                 "    \"label\" : \"label\"           (string) The label of the "
                 "receiving address. The default label is \"\".\n"
                 "  }\n"
                 "  ,...\n"
                 "]\n"},
             RPCExamples{HelpExampleCli("listreceivedbylabel", "") +
                         HelpExampleCli("listreceivedbylabel", "6 true") +
                         HelpExampleRpc("listreceivedbylabel", "6, true, true")},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     return ListReceived(config, *locked_chain, pwallet, request.params, true);
 }
 
 static void MaybePushAddress(UniValue &entry, const CTxDestination &dest) {
     if (IsValidDestination(dest)) {
         entry.pushKV("address", EncodeDestination(dest, GetConfig()));
     }
 }
 
 /**
  * List transactions based on the given criteria.
  *
  * @param  pwallet        The wallet.
  * @param  wtx            The wallet transaction.
  * @param  nMinDepth      The minimum confirmation depth.
  * @param  fLong          Whether to include the JSON version of the
  * transaction.
  * @param  ret            The UniValue into which the result is stored.
  * @param  filter_ismine  The "is mine" filter flags.
  * @param  filter_label   Optional label string to filter incoming transactions.
  */
 static void ListTransactions(interfaces::Chain::Lock &locked_chain,
                              CWallet *const pwallet, const CWalletTx &wtx,
                              int nMinDepth, bool fLong, UniValue &ret,
                              const isminefilter &filter_ismine,
                              const std::string *filter_label)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     Amount nFee;
     std::list<COutputEntry> listReceived;
     std::list<COutputEntry> listSent;
 
     wtx.GetAmounts(listReceived, listSent, nFee, filter_ismine);
 
     bool involvesWatchonly = wtx.IsFromMe(ISMINE_WATCH_ONLY);
 
     // Sent
     if (!filter_label) {
         for (const COutputEntry &s : listSent) {
             UniValue entry(UniValue::VOBJ);
             if (involvesWatchonly ||
                 (::IsMine(*pwallet, s.destination) & ISMINE_WATCH_ONLY)) {
                 entry.pushKV("involvesWatchonly", true);
             }
             MaybePushAddress(entry, s.destination);
             entry.pushKV("category", "send");
             entry.pushKV("amount", ValueFromAmount(-s.amount));
             if (pwallet->mapAddressBook.count(s.destination)) {
                 entry.pushKV("label",
                              pwallet->mapAddressBook[s.destination].name);
             }
             entry.pushKV("vout", s.vout);
             entry.pushKV("fee", ValueFromAmount(-1 * nFee));
             if (fLong) {
                 WalletTxToJSON(pwallet->chain(), locked_chain, wtx, entry);
             }
             entry.pushKV("abandoned", wtx.isAbandoned());
             ret.push_back(entry);
         }
     }
 
     // Received
     if (listReceived.size() > 0 &&
         wtx.GetDepthInMainChain(locked_chain) >= nMinDepth) {
         for (const COutputEntry &r : listReceived) {
             std::string label;
             if (pwallet->mapAddressBook.count(r.destination)) {
                 label = pwallet->mapAddressBook[r.destination].name;
             }
             if (filter_label && label != *filter_label) {
                 continue;
             }
             UniValue entry(UniValue::VOBJ);
             if (involvesWatchonly ||
                 (::IsMine(*pwallet, r.destination) & ISMINE_WATCH_ONLY)) {
                 entry.pushKV("involvesWatchonly", true);
             }
             MaybePushAddress(entry, r.destination);
             if (wtx.IsCoinBase()) {
                 if (wtx.GetDepthInMainChain(locked_chain) < 1) {
                     entry.pushKV("category", "orphan");
                 } else if (wtx.IsImmatureCoinBase(locked_chain)) {
                     entry.pushKV("category", "immature");
                 } else {
                     entry.pushKV("category", "generate");
                 }
             } else {
                 entry.pushKV("category", "receive");
             }
             entry.pushKV("amount", ValueFromAmount(r.amount));
             if (pwallet->mapAddressBook.count(r.destination)) {
                 entry.pushKV("label", label);
             }
             entry.pushKV("vout", r.vout);
             if (fLong) {
                 WalletTxToJSON(pwallet->chain(), locked_chain, wtx, entry);
             }
             ret.push_back(entry);
         }
     }
 }
 
 UniValue listtransactions(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 4) {
         throw std::runtime_error(RPCHelpMan{
             "listtransactions",
             "\nIf a label name is provided, this will return only incoming "
             "transactions paying to addresses with the specified label.\n"
             "\nReturns up to 'count' most recent transactions skipping the "
             "first 'from' transactions.\n",
             {
                 {"label", RPCArg::Type::STR,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "If set, should be a valid label name to return only incoming "
                  "transactions with the specified label, or \"*\" to disable "
                  "filtering and return all transactions."},
                 {"count", RPCArg::Type::NUM, /* default */ "10",
                  "The number of transactions to return"},
                 {"skip", RPCArg::Type::NUM, /* default */ "0",
                  "The number of transactions to skip"},
                 {"include_watchonly", RPCArg::Type::BOOL, /* default */ "false",
                  "Include transactions to watch-only addresses (see "
                  "'importaddress')"},
             },
             RPCResult{
                 "[\n"
                 "  {\n"
                 "    \"address\":\"address\",    (string) The bitcoin address "
                 "of the transaction.\n"
                 "    \"category\":\"send|receive\", (string) The transaction "
                 "category.\n"
                 "    \"amount\": x.xxx,          (numeric) The amount in " +
                 CURRENCY_UNIT +
                 ". This is negative for the 'send' category, and is positive\n"
                 "                                        for the 'receive' "
                 "category,\n"
                 "    \"label\": \"label\",       (string) A comment for the "
                 "address/transaction, if any\n"
                 "    \"vout\": n,                (numeric) the vout value\n"
                 "    \"fee\": x.xxx,             (numeric) The amount of the "
                 "fee in " +
                 CURRENCY_UNIT +
                 ". This is negative and only available for the \n"
                 "                                         'send' category of "
                 "transactions.\n"
                 "    \"confirmations\": n,       (numeric) The number of "
                 "confirmations for the transaction. Negative confirmations "
                 "indicate the\n"
                 "                                         transaction "
                 "conflicts with the block chain\n"
                 "    \"trusted\": xxx,           (bool) Whether we consider "
                 "the outputs of this unconfirmed transaction safe to spend.\n"
                 "    \"blockhash\": \"hashvalue\", (string) The block hash "
                 "containing the transaction.\n"
                 "    \"blockindex\": n,          (numeric) The index of the "
                 "transaction in the block that includes it.\n"
                 "    \"blocktime\": xxx,         (numeric) The block time in "
                 "seconds since epoch (1 Jan 1970 GMT).\n"
                 "    \"txid\": \"transactionid\", (string) The transaction "
                 "id.\n"
                 "    \"time\": xxx,              (numeric) The transaction "
                 "time in seconds since epoch (midnight Jan 1 1970 GMT).\n"
                 "    \"timereceived\": xxx,      (numeric) The time received "
                 "in seconds since epoch (midnight Jan 1 1970 GMT).\n"
                 "    \"comment\": \"...\",       (string) If a comment is "
                 "associated with the transaction.\n"
                 "    \"abandoned\": xxx          (bool) 'true' if the "
                 "transaction has been abandoned (inputs are respendable). Only "
                 "available for the \n"
                 "                                         'send' category of "
                 "transactions.\n"
                 "  }\n"
                 "]\n"},
             RPCExamples{
                 "\nList the most recent 10 transactions in the systems\n" +
                 HelpExampleCli("listtransactions", "") +
                 "\nList transactions 100 to 120\n" +
                 HelpExampleCli("listtransactions", "\"*\" 20 100") +
                 "\nAs a JSON-RPC call\n" +
                 HelpExampleRpc("listtransactions", "\"*\", 20, 100")},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     const std::string *filter_label = nullptr;
     if (!request.params[0].isNull() && request.params[0].get_str() != "*") {
         filter_label = &request.params[0].get_str();
         if (filter_label->empty()) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Label argument must be a valid label name or \"*\".");
         }
     }
     int nCount = 10;
     if (!request.params[1].isNull()) {
         nCount = request.params[1].get_int();
     }
 
     int nFrom = 0;
     if (!request.params[2].isNull()) {
         nFrom = request.params[2].get_int();
     }
 
     isminefilter filter = ISMINE_SPENDABLE;
     if (!request.params[3].isNull() && request.params[3].get_bool()) {
         filter = filter | ISMINE_WATCH_ONLY;
     }
 
     if (nCount < 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative count");
     }
     if (nFrom < 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative from");
     }
     UniValue ret(UniValue::VARR);
 
     {
         auto locked_chain = pwallet->chain().lock();
         LOCK(pwallet->cs_wallet);
 
         const CWallet::TxItems &txOrdered = pwallet->wtxOrdered;
 
         // iterate backwards until we have nCount items to return:
         for (CWallet::TxItems::const_reverse_iterator it = txOrdered.rbegin();
              it != txOrdered.rend(); ++it) {
             CWalletTx *const pwtx = (*it).second;
             ListTransactions(*locked_chain, pwallet, *pwtx, 0, true, ret,
                              filter, filter_label);
             if (int(ret.size()) >= (nCount + nFrom)) {
                 break;
             }
         }
     }
 
     // ret is newest to oldest
 
     if (nFrom > (int)ret.size()) {
         nFrom = ret.size();
     }
     if ((nFrom + nCount) > (int)ret.size()) {
         nCount = ret.size() - nFrom;
     }
 
     std::vector<UniValue> arrTmp = ret.getValues();
 
     std::vector<UniValue>::iterator first = arrTmp.begin();
     std::advance(first, nFrom);
     std::vector<UniValue>::iterator last = arrTmp.begin();
     std::advance(last, nFrom + nCount);
 
     if (last != arrTmp.end()) {
         arrTmp.erase(last, arrTmp.end());
     }
     if (first != arrTmp.begin()) {
         arrTmp.erase(arrTmp.begin(), first);
     }
 
     // Return oldest to newest
     std::reverse(arrTmp.begin(), arrTmp.end());
 
     ret.clear();
     ret.setArray();
     ret.push_backV(arrTmp);
 
     return ret;
 }
 
 static UniValue listsinceblock(const Config &config,
                                const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 4) {
         throw std::runtime_error(RPCHelpMan{
             "listsinceblock",
             "\nGet all transactions in blocks since block [blockhash], or all "
             "transactions if omitted.\n"
             "If \"blockhash\" is no longer a part of the main chain, "
             "transactions from the fork point onward are included.\n"
             "Additionally, if include_removed is set, transactions affecting "
             "the wallet which were removed are returned in the \"removed\" "
             "array.\n",
             {
                 {"blockhash", RPCArg::Type::STR,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "If set, the block hash to list transactions since, otherwise "
                  "list all transactions."},
                 {"target_confirmations", RPCArg::Type::NUM, /* default */ "1",
                  "Return the nth block hash from the main chain. e.g. 1 "
                  "would mean the best block hash. Note: this is not used "
                  "as a filter, but only affects [lastblock] in the return "
                  "value"},
                 {"include_watchonly", RPCArg::Type::BOOL, /* default */ "false",
                  "Include transactions to watch-only addresses (see "
                  "'importaddress')"},
                 {"include_removed", RPCArg::Type::BOOL, /* default */ "true",
                  "Show transactions that were removed due to a reorg in "
                  "the \"removed\" array\n"
                  "                                                         "
                  "  (not guaranteed to work on pruned nodes)"},
             },
             RPCResult{
                 "{\n"
                 "  \"transactions\": [\n"
                 "    \"address\":\"address\",    (string) The bitcoin address "
                 "of the transaction. Not present for move transactions "
                 "(category = move).\n"
                 "    \"category\":\"send|receive\",     (string) The "
                 "transaction category. 'send' has negative amounts, 'receive' "
                 "has positive amounts.\n"
                 "    \"amount\": x.xxx,          (numeric) The amount in " +
                 CURRENCY_UNIT +
                 ". This is negative for the 'send' category, and for the "
                 "'move' category for moves \n"
                 "                                          outbound. It is "
                 "positive for the 'receive' category, and for the 'move' "
                 "category for inbound funds.\n"
                 "    \"vout\" : n,               (numeric) the vout value\n"
                 "    \"fee\": x.xxx,             (numeric) The amount of the "
                 "fee in " +
                 CURRENCY_UNIT +
                 ". This is negative and only available for the 'send' category "
                 "of transactions.\n"
                 "    \"confirmations\": n,       (numeric) The number of "
                 "confirmations for the transaction. Available for 'send' and "
                 "'receive' category of transactions.\n"
                 "                                          When it's < 0, it "
                 "means the transaction conflicted that many blocks ago.\n"
                 "    \"blockhash\": \"hashvalue\",     (string) The block hash "
                 "containing the transaction. Available for 'send' and "
                 "'receive' category of transactions.\n"
                 "    \"blockindex\": n,          (numeric) The index of the "
                 "transaction in the block that includes it. Available for "
                 "'send' and 'receive' category of transactions.\n"
                 "    \"blocktime\": xxx,         (numeric) The block time in "
                 "seconds since epoch (1 Jan 1970 GMT).\n"
                 "    \"txid\": \"transactionid\",  (string) The transaction "
                 "id. Available for 'send' and 'receive' category of "
                 "transactions.\n"
                 "    \"time\": xxx,              (numeric) The transaction "
                 "time in seconds since epoch (Jan 1 1970 GMT).\n"
                 "    \"timereceived\": xxx,      (numeric) The time received "
                 "in seconds since epoch (Jan 1 1970 GMT). Available for 'send' "
                 "and 'receive' category of transactions.\n"
                 "    \"abandoned\": xxx,         (bool) 'true' if the "
                 "transaction has been abandoned (inputs are respendable). Only "
                 "available for the 'send' category of transactions.\n"
                 "    \"comment\": \"...\",       (string) If a comment is "
                 "associated with the transaction.\n"
                 "    \"label\" : \"label\"       (string) A comment for the "
                 "address/transaction, if any\n"
                 "    \"to\": \"...\",            (string) If a comment to is "
                 "associated with the transaction.\n"
                 "  ],\n"
                 "  \"removed\": [\n"
                 "    <structure is the same as \"transactions\" above, only "
                 "present if include_removed=true>\n"
                 "    Note: transactions that were re-added in the active chain "
                 "will appear as-is in this array, and may thus have a positive "
                 "confirmation count.\n"
                 "  ],\n"
                 "  \"lastblock\": \"lastblockhash\"     (string) The hash of "
                 "the block (target_confirmations-1) from the best block on the "
                 "main chain. This is typically used to feed back into "
                 "listsinceblock the next time you call it. So you would "
                 "generally use a target_confirmations of say 6, so you will be "
                 "continually re-notified of transactions until they've reached "
                 "6 confirmations plus any new ones\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("listsinceblock", "") +
                         HelpExampleCli("listsinceblock",
                                        "\"000000000000000bacf66f7497b7dc4"
                                        "5ef753ee9a7d38571037cdb1a57f663ad"
                                        "\" 6") +
                         HelpExampleRpc("listsinceblock",
                                        "\"000000000000000bacf66f7497b7dc4"
                                        "5ef753ee9a7d38571037cdb1a57f663ad"
                                        "\", 6")},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     // The way the 'height' is initialized is just a workaround for the gcc bug
     // #47679 since version 4.6.0. Height of the specified block or the common
     // ancestor, if the block provided was in a deactivated chain.
     Optional<int> height = MakeOptional(false, int());
 
     // Height of the specified block, even if it's in a deactivated chain.
     Optional<int> altheight;
     int target_confirms = 1;
     isminefilter filter = ISMINE_SPENDABLE;
 
     BlockHash blockId;
     if (!request.params[0].isNull() && !request.params[0].get_str().empty()) {
         blockId = BlockHash(ParseHashV(request.params[0], "blockhash"));
         height = locked_chain->findFork(blockId, &altheight);
         if (!height) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
     }
 
     if (!request.params[1].isNull()) {
         target_confirms = request.params[1].get_int();
 
         if (target_confirms < 1) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter");
         }
     }
 
     if (!request.params[2].isNull() && request.params[2].get_bool()) {
         filter = filter | ISMINE_WATCH_ONLY;
     }
 
     bool include_removed =
         (request.params[3].isNull() || request.params[3].get_bool());
 
     const Optional<int> tip_height = locked_chain->getHeight();
     int depth = tip_height && height ? (1 + *tip_height - *height) : -1;
 
     UniValue transactions(UniValue::VARR);
 
     for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
         CWalletTx tx = pairWtx.second;
 
         if (depth == -1 || tx.GetDepthInMainChain(*locked_chain) < depth) {
             ListTransactions(*locked_chain, pwallet, tx, 0, true, transactions,
                              filter, nullptr /* filter_label */);
         }
     }
 
     // when a reorg'd block is requested, we also list any relevant transactions
     // in the blocks of the chain that was detached
     UniValue removed(UniValue::VARR);
     while (include_removed && altheight && *altheight > *height) {
         CBlock block;
         if (!pwallet->chain().findBlock(blockId, &block) || block.IsNull()) {
             throw JSONRPCError(RPC_INTERNAL_ERROR,
                                "Can't read block from disk");
         }
         for (const CTransactionRef &tx : block.vtx) {
             auto it = pwallet->mapWallet.find(tx->GetId());
             if (it != pwallet->mapWallet.end()) {
                 // We want all transactions regardless of confirmation count to
                 // appear here, even negative confirmation ones, hence the big
                 // negative.
                 ListTransactions(*locked_chain, pwallet, it->second, -100000000,
                                  true, removed, filter,
                                  nullptr /* filter_label */);
             }
         }
         blockId = block.hashPrevBlock;
         --*altheight;
     }
 
     int last_height = tip_height ? *tip_height + 1 - target_confirms : -1;
     BlockHash lastblock = last_height >= 0
                               ? locked_chain->getBlockHash(last_height)
                               : BlockHash();
 
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("transactions", transactions);
     if (include_removed) {
         ret.pushKV("removed", removed);
     }
     ret.pushKV("lastblock", lastblock.GetHex());
 
     return ret;
 }
 
 static UniValue gettransaction(const Config &config,
                                const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "gettransaction",
             "\nGet detailed information about in-wallet transaction "
             "<txid>\n",
             {
                 {"txid", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The transaction id"},
                 {"include_watchonly", RPCArg::Type::BOOL,
                  /* default */ "false",
                  "Whether to include watch-only addresses in "
                  "balance calculation and details[]"},
             },
             RPCResult{
                 "{\n"
                 "  \"amount\" : x.xxx,        (numeric) The transaction amount "
                 "in " +
                 CURRENCY_UNIT +
                 "\n"
                 "  \"fee\": x.xxx,            (numeric) The amount of the fee "
                 "in " +
                 CURRENCY_UNIT +
                 ". This is negative and only available for the \n"
                 "                              'send' category of "
                 "transactions.\n"
                 "  \"confirmations\" : n,     (numeric) The number of "
                 "confirmations\n"
                 "  \"blockhash\" : \"hash\",  (string) The block hash\n"
                 "  \"blockindex\" : xx,       (numeric) The index of the "
                 "transaction in the block that includes it\n"
                 "  \"blocktime\" : ttt,       (numeric) The time in seconds "
                 "since epoch (1 Jan 1970 GMT)\n"
                 "  \"txid\" : \"transactionid\",   (string) The transaction "
                 "id.\n"
                 "  \"time\" : ttt,            (numeric) The transaction time "
                 "in seconds since epoch (1 Jan 1970 GMT)\n"
                 "  \"timereceived\" : ttt,    (numeric) The time received in "
                 "seconds since epoch (1 Jan 1970 GMT)\n"
                 "  \"bip125-replaceable\": \"yes|no|unknown\",  (string) "
                 "Whether this transaction could be replaced due to BIP125 "
                 "(replace-by-fee);\n"
                 "                                                   may be "
                 "unknown for unconfirmed transactions not in the mempool\n"
                 "  \"details\" : [\n"
                 "    {\n"
                 "      \"address\" : \"address\",          (string) The "
                 "bitcoin address involved in the transaction\n"
                 "      \"category\" : \"send|receive\",    (string) The "
                 "category, either 'send' or 'receive'\n"
                 "      \"amount\" : x.xxx,                 (numeric) The "
                 "amount in " +
                 CURRENCY_UNIT +
                 "\n"
                 "      \"label\" : \"label\",              (string) A comment "
                 "for the address/transaction, if any\n"
                 "      \"vout\" : n,                       (numeric) the vout "
                 "value\n"
                 "      \"fee\": x.xxx,                     (numeric) The "
                 "amount of the fee in " +
                 CURRENCY_UNIT +
                 ". This is negative and only available for the \n"
                 "                                           'send' category of "
                 "transactions.\n"
                 "      \"abandoned\": xxx                  (bool) 'true' if "
                 "the transaction has been abandoned (inputs are respendable). "
                 "Only available for the \n"
                 "                                           'send' category of "
                 "transactions.\n"
                 "    }\n"
                 "    ,...\n"
                 "  ],\n"
                 "  \"hex\" : \"data\"         (string) Raw data for "
                 "transaction\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("gettransaction",
                                        "\"1075db55d416d3ca199f55b6084e211"
                                        "5b9345e16c5cf302fc80e9d5fbf5d48d"
                                        "\"") +
                         HelpExampleCli("gettransaction",
                                        "\"1075db55d416d3ca199f55b6084e211"
                                        "5b9345e16c5cf302fc80e9d5fbf5d48d"
                                        "\" true") +
                         HelpExampleRpc("gettransaction",
                                        "\"1075db55d416d3ca199f55b6084e211"
                                        "5b9345e16c5cf302fc80e9d5fbf5d48d"
                                        "\"")},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     TxId txid(ParseHashV(request.params[0], "txid"));
 
     isminefilter filter = ISMINE_SPENDABLE;
     if (!request.params[1].isNull() && request.params[1].get_bool()) {
         filter = filter | ISMINE_WATCH_ONLY;
     }
 
     UniValue entry(UniValue::VOBJ);
     auto it = pwallet->mapWallet.find(txid);
     if (it == pwallet->mapWallet.end()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid or non-wallet transaction id");
     }
     const CWalletTx &wtx = it->second;
 
     Amount nCredit = wtx.GetCredit(*locked_chain, filter);
     Amount nDebit = wtx.GetDebit(filter);
     Amount nNet = nCredit - nDebit;
     Amount nFee = (wtx.IsFromMe(filter) ? wtx.tx->GetValueOut() - nDebit
                                         : Amount::zero());
 
     entry.pushKV("amount", ValueFromAmount(nNet - nFee));
     if (wtx.IsFromMe(filter)) {
         entry.pushKV("fee", ValueFromAmount(nFee));
     }
 
     WalletTxToJSON(pwallet->chain(), *locked_chain, wtx, entry);
 
     UniValue details(UniValue::VARR);
     ListTransactions(*locked_chain, pwallet, wtx, 0, false, details, filter,
                      nullptr /* filter_label */);
     entry.pushKV("details", details);
 
     std::string strHex =
         EncodeHexTx(*wtx.tx, pwallet->chain().rpcSerializationFlags());
     entry.pushKV("hex", strHex);
 
     return entry;
 }
 
 static UniValue abandontransaction(const Config &config,
                                    const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "abandontransaction",
             "\nMark in-wallet transaction <txid> as abandoned\n"
             "This will mark this transaction and all its in-wallet descendants "
             "as abandoned which will allow\n"
             "for their inputs to be respent.  It can be used to replace "
             "\"stuck\" or evicted transactions.\n"
             "It only works on transactions which are not included in a block "
             "and are not currently in the mempool.\n"
             "It has no effect on transactions which are already abandoned.\n",
             {
                 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "The transaction id"},
             },
             RPCResults{},
             RPCExamples{HelpExampleCli("abandontransaction",
                                        "\"1075db55d416d3ca199f55b6084"
                                        "e2115b9345e16c5cf302fc80e9d5f"
                                        "bf5d48d\"") +
                         HelpExampleRpc("abandontransaction",
                                        "\"1075db55d416d3ca199f55b6084"
                                        "e2115b9345e16c5cf302fc80e9d5f"
                                        "bf5d48d\"")},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     TxId txid(ParseHashV(request.params[0], "txid"));
 
     if (!pwallet->mapWallet.count(txid)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid or non-wallet transaction id");
     }
 
     if (!pwallet->AbandonTransaction(*locked_chain, txid)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Transaction not eligible for abandonment");
     }
 
     return NullUniValue;
 }
 
 static UniValue backupwallet(const Config &config,
                              const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "backupwallet",
             "\nSafely copies current wallet file to destination, "
             "which can be a directory or a path with filename.\n",
             {
                 {"destination", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The destination directory or file"},
             },
             RPCResults{},
             RPCExamples{HelpExampleCli("backupwallet", "\"backup.dat\"") +
                         HelpExampleRpc("backupwallet", "\"backup.dat\"")},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     std::string strDest = request.params[0].get_str();
     if (!pwallet->BackupWallet(strDest)) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Error: Wallet backup failed!");
     }
 
     return NullUniValue;
 }
 
 static UniValue keypoolrefill(const Config &config,
                               const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 1) {
         throw std::runtime_error(RPCHelpMan{
             "keypoolrefill",
             "\nFills the keypool." + HelpRequiringPassphrase(pwallet) + "\n",
             {
                 {"newsize", RPCArg::Type::NUM, /* default */ "100",
                  "The new keypool size"},
             },
             RPCResults{},
             RPCExamples{HelpExampleCli("keypoolrefill", "") +
                         HelpExampleRpc("keypoolrefill", "")},
         }
                                      .ToString());
     }
 
     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Error: Private keys are disabled for this wallet");
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     // 0 is interpreted by TopUpKeyPool() as the default keypool size given by
     // -keypool
     unsigned int kpSize = 0;
     if (!request.params[0].isNull()) {
         if (request.params[0].get_int() < 0) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, expected valid size.");
         }
         kpSize = (unsigned int)request.params[0].get_int();
     }
 
     EnsureWalletIsUnlocked(pwallet);
     pwallet->TopUpKeyPool(kpSize);
 
     if (pwallet->GetKeyPoolSize() < kpSize) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Error refreshing keypool.");
     }
 
     return NullUniValue;
 }
 
 static UniValue walletpassphrase(const Config &config,
                                  const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (pwallet->IsCrypted() && (request.fHelp || request.params.size() != 2)) {
         throw std::runtime_error(RPCHelpMan{
             "walletpassphrase",
             "\nStores the wallet decryption key in memory for 'timeout' "
             "seconds.\n"
             "This is needed prior to performing transactions related to "
             "private keys such as sending bitcoins\n"
             "\nNote:\n"
             "Issuing the walletpassphrase command while the wallet is already "
             "unlocked will set a new unlock\n"
             "time that overrides the old one.\n",
             {
                 {"passphrase", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The wallet passphrase"},
                 {"timeout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                  "The time to keep the decryption key in seconds; capped "
                  "at 100000000 (~3 years)."},
             },
             RPCResults{},
             RPCExamples{
                 "\nUnlock the wallet for 60 seconds\n" +
                 HelpExampleCli("walletpassphrase", "\"my pass phrase\" 60") +
                 "\nLock the wallet again (before 60 seconds)\n" +
                 HelpExampleCli("walletlock", "") + "\nAs a JSON-RPC call\n" +
                 HelpExampleRpc("walletpassphrase", "\"my pass phrase\", 60")},
         }
                                      .ToString());
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     if (request.fHelp) {
         return true;
     }
 
     if (!pwallet->IsCrypted()) {
         throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE,
                            "Error: running with an unencrypted wallet, but "
                            "walletpassphrase was called.");
     }
 
     // Note that the walletpassphrase is stored in request.params[0] which is
     // not mlock()ed
     SecureString strWalletPass;
     strWalletPass.reserve(100);
     // TODO: get rid of this .c_str() by implementing
     // SecureString::operator=(std::string)
     // Alternately, find a way to make request.params[0] mlock()'d to begin
     // with.
     strWalletPass = request.params[0].get_str().c_str();
 
     // Get the timeout
     int64_t nSleepTime = request.params[1].get_int64();
     // Timeout cannot be negative, otherwise it will relock immediately
     if (nSleepTime < 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Timeout cannot be negative.");
     }
     // Clamp timeout
     // larger values trigger a macos/libevent bug?
     constexpr int64_t MAX_SLEEP_TIME = 100000000;
     if (nSleepTime > MAX_SLEEP_TIME) {
         nSleepTime = MAX_SLEEP_TIME;
     }
 
     if (strWalletPass.empty()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "passphrase can not be empty");
     }
 
     if (!pwallet->Unlock(strWalletPass)) {
         throw JSONRPCError(
             RPC_WALLET_PASSPHRASE_INCORRECT,
             "Error: The wallet passphrase entered was incorrect.");
     }
 
     pwallet->TopUpKeyPool();
 
     pwallet->nRelockTime = GetTime() + nSleepTime;
 
     // Keep a weak pointer to the wallet so that it is possible to unload the
     // wallet before the following callback is called. If a valid shared pointer
     // is acquired in the callback then the wallet is still loaded.
     std::weak_ptr<CWallet> weak_wallet = wallet;
     pwallet->chain().rpcRunLater(
         strprintf("lockwallet(%s)", pwallet->GetName()),
         [weak_wallet] {
             if (auto shared_wallet = weak_wallet.lock()) {
                 LOCK(shared_wallet->cs_wallet);
                 shared_wallet->Lock();
                 shared_wallet->nRelockTime = 0;
             }
         },
         nSleepTime);
 
     return NullUniValue;
 }
 
 static UniValue walletpassphrasechange(const Config &config,
                                        const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (pwallet->IsCrypted() && (request.fHelp || request.params.size() != 2)) {
         throw std::runtime_error(RPCHelpMan{
             "walletpassphrasechange",
             "\nChanges the wallet passphrase from 'oldpassphrase' to "
             "'newpassphrase'.\n",
             {
                 {"oldpassphrase", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The current passphrase"},
                 {"newpassphrase", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The new passphrase"},
             },
             RPCResults{},
             RPCExamples{HelpExampleCli("walletpassphrasechange",
                                        "\"old one\" \"new one\"") +
                         HelpExampleRpc("walletpassphrasechange",
                                        "\"old one\", \"new one\"")},
         }
                                      .ToString());
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     if (request.fHelp) {
         return true;
     }
     if (!pwallet->IsCrypted()) {
         throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE,
                            "Error: running with an unencrypted wallet, but "
                            "walletpassphrasechange was called.");
     }
 
     // TODO: get rid of these .c_str() calls by implementing
     // SecureString::operator=(std::string)
     // Alternately, find a way to make request.params[0] mlock()'d to begin
     // with.
     SecureString strOldWalletPass;
     strOldWalletPass.reserve(100);
     strOldWalletPass = request.params[0].get_str().c_str();
 
     SecureString strNewWalletPass;
     strNewWalletPass.reserve(100);
     strNewWalletPass = request.params[1].get_str().c_str();
 
     if (strOldWalletPass.empty() || strNewWalletPass.empty()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "passphrase can not be empty");
     }
 
     if (!pwallet->ChangeWalletPassphrase(strOldWalletPass, strNewWalletPass)) {
         throw JSONRPCError(
             RPC_WALLET_PASSPHRASE_INCORRECT,
             "Error: The wallet passphrase entered was incorrect.");
     }
 
     return NullUniValue;
 }
 
 static UniValue walletlock(const Config &config,
                            const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (pwallet->IsCrypted() && (request.fHelp || request.params.size() != 0)) {
         throw std::runtime_error(RPCHelpMan{
             "walletlock",
             "\nRemoves the wallet encryption key from memory, locking the "
             "wallet.\n"
             "After calling this method, you will need to call walletpassphrase "
             "again\n"
             "before being able to call any methods which require the wallet to "
             "be unlocked.\n",
             {},
             RPCResults{},
             RPCExamples{
                 "\nSet the passphrase for 2 minutes to perform a "
                 "transaction\n" +
                 HelpExampleCli("walletpassphrase", "\"my pass phrase\" 120") +
                 "\nPerform a send (requires passphrase set)\n" +
                 HelpExampleCli("sendtoaddress",
                                "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 1.0") +
                 "\nClear the passphrase since we are done before 2 minutes is "
                 "up\n" +
                 HelpExampleCli("walletlock", "") + "\nAs a JSON-RPC call\n" +
                 HelpExampleRpc("walletlock", "")},
         }
                                      .ToString());
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     if (request.fHelp) {
         return true;
     }
     if (!pwallet->IsCrypted()) {
         throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE,
                            "Error: running with an unencrypted wallet, but "
                            "walletlock was called.");
     }
 
     pwallet->Lock();
     pwallet->nRelockTime = 0;
 
     return NullUniValue;
 }
 
 static UniValue encryptwallet(const Config &config,
                               const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (!pwallet->IsCrypted() &&
         (request.fHelp || request.params.size() != 1)) {
         throw std::runtime_error(RPCHelpMan{
             "encryptwallet",
             "\nEncrypts the wallet with 'passphrase'. This is for first time "
             "encryption.\n"
             "After this, any calls that interact with private keys such as "
             "sending or signing \n"
             "will require the passphrase to be set prior the making these "
             "calls.\n"
             "Use the walletpassphrase call for this, and then walletlock "
             "call.\n"
             "If the wallet is already encrypted, use the "
             "walletpassphrasechange call.\n",
             {
                 {"passphrase", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The pass phrase to encrypt the wallet with. It must be "
                  "at least 1 character, but should be long."},
             },
             RPCResults{},
             RPCExamples{
                 "\nEncrypt your wallet\n" +
                 HelpExampleCli("encryptwallet", "\"my pass phrase\"") +
                 "\nNow set the passphrase to use the wallet, such as for "
                 "signing or sending bitcoin\n" +
                 HelpExampleCli("walletpassphrase", "\"my pass phrase\"") +
                 "\nNow we can do something like sign\n" +
                 HelpExampleCli("signmessage", "\"address\" \"test message\"") +
                 "\nNow lock the wallet again by removing the passphrase\n" +
                 HelpExampleCli("walletlock", "") + "\nAs a JSON-RPC call\n" +
                 HelpExampleRpc("encryptwallet", "\"my pass phrase\"")},
         }
                                      .ToString());
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     if (request.fHelp) {
         return true;
     }
     if (pwallet->IsCrypted()) {
         throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE,
                            "Error: running with an encrypted wallet, but "
                            "encryptwallet was called.");
     }
 
     // TODO: get rid of this .c_str() by implementing
     // SecureString::operator=(std::string)
     // Alternately, find a way to make request.params[0] mlock()'d to begin
     // with.
     SecureString strWalletPass;
     strWalletPass.reserve(100);
     strWalletPass = request.params[0].get_str().c_str();
 
     if (strWalletPass.empty()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "passphrase can not be empty");
     }
 
     if (!pwallet->EncryptWallet(strWalletPass)) {
         throw JSONRPCError(RPC_WALLET_ENCRYPTION_FAILED,
                            "Error: Failed to encrypt the wallet.");
     }
 
     return "wallet encrypted; The keypool has been flushed and a new HD seed "
            "was generated (if you are using HD). You need to make a new "
            "backup.";
 }
 
 static UniValue lockunspent(const Config &config,
                             const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "lockunspent",
             "\nUpdates list of temporarily unspendable outputs.\n"
             "Temporarily lock (unlock=false) or unlock (unlock=true) specified "
             "transaction outputs.\n"
             "If no transaction outputs are specified when unlocking then all "
             "current locked transaction outputs are unlocked.\n"
             "A locked transaction output will not be chosen by automatic coin "
             "selection, when spending bitcoins.\n"
             "Locks are stored in memory only. Nodes start with zero locked "
             "outputs, and the locked output list\n"
             "is always cleared (by virtue of process exit) when a node stops "
             "or fails.\n"
             "Also see the listunspent call\n",
             {
                 {"unlock", RPCArg::Type::BOOL, RPCArg::Optional::NO,
                  "Whether to unlock (true) or lock (false) the specified "
                  "transactions"},
                 {
                     "transactions",
                     RPCArg::Type::ARR,
                     /* default */ "empty array",
                     "A json array of objects. Each object the txid (string) "
                     "vout (numeric).",
                     {
                         {
                             "",
                             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"},
                             },
                         },
                     },
                 },
             },
             RPCResult{"true|false    (boolean) Whether the command was "
                       "successful or not\n"},
             RPCExamples{"\nList the unspent transactions\n" +
                         HelpExampleCli("listunspent", "") +
                         "\nLock an unspent transaction\n" +
                         HelpExampleCli("lockunspent",
                                        "false "
                                        "\"[{\\\"txid\\\":"
                                        "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                        "b764ed838b5655e72f463568df1aadf0\\\""
                                        ",\\\"vout\\\":1}]\"") +
                         "\nList the locked transactions\n" +
                         HelpExampleCli("listlockunspent", "") +
                         "\nUnlock the transaction again\n" +
                         HelpExampleCli("lockunspent",
                                        "true "
                                        "\"[{\\\"txid\\\":"
                                        "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                        "b764ed838b5655e72f463568df1aadf0\\\""
                                        ",\\\"vout\\\":1}]\"") +
                         "\nAs a JSON-RPC call\n" +
                         HelpExampleRpc("lockunspent",
                                        "false, "
                                        "\"[{\\\"txid\\\":"
                                        "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                        "b764ed838b5655e72f463568df1aadf0\\\""
                                        ",\\\"vout\\\":1}]\"")},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     RPCTypeCheckArgument(request.params[0], UniValue::VBOOL);
 
     bool fUnlock = request.params[0].get_bool();
 
     if (request.params[1].isNull()) {
         if (fUnlock) {
             pwallet->UnlockAllCoins();
         }
         return true;
     }
 
     RPCTypeCheckArgument(request.params[1], UniValue::VARR);
 
     const UniValue &output_params = request.params[1];
 
     // Create and validate the COutPoints first.
 
     std::vector<COutPoint> outputs;
     outputs.reserve(output_params.size());
 
     for (size_t idx = 0; idx < output_params.size(); idx++) {
         const UniValue &o = output_params[idx].get_obj();
 
         RPCTypeCheckObj(o, {
                                {"txid", UniValueType(UniValue::VSTR)},
                                {"vout", UniValueType(UniValue::VNUM)},
                            });
 
         const int nOutput = find_value(o, "vout").get_int();
         if (nOutput < 0) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, vout must be positive");
         }
 
         const TxId txid(ParseHashO(o, "txid"));
         const auto it = pwallet->mapWallet.find(txid);
         if (it == pwallet->mapWallet.end()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, unknown transaction");
         }
 
         const COutPoint output(txid, nOutput);
         const CWalletTx &trans = it->second;
         if (output.GetN() >= trans.tx->vout.size()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, vout index out of bounds");
         }
 
         if (pwallet->IsSpent(*locked_chain, output)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, expected unspent output");
         }
 
         const bool is_locked = pwallet->IsLockedCoin(output);
         if (fUnlock && !is_locked) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, expected locked output");
         }
 
         if (!fUnlock && is_locked) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, output already locked");
         }
 
         outputs.push_back(output);
     }
 
     // Atomically set (un)locked status for the outputs.
     for (const COutPoint &output : outputs) {
         if (fUnlock) {
             pwallet->UnlockCoin(output);
         } else {
             pwallet->LockCoin(output);
         }
     }
 
     return true;
 }
 
 static UniValue listlockunspent(const Config &config,
                                 const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 0) {
         throw std::runtime_error(RPCHelpMan{
             "listlockunspent",
             "\nReturns list of temporarily unspendable outputs.\n"
             "See the lockunspent call to lock and unlock transactions for "
             "spending.\n",
             {},
             RPCResult{"[\n"
                       "  {\n"
                       "    \"txid\" : \"transactionid\",     (string) The "
                       "transaction id locked\n"
                       "    \"vout\" : n                      (numeric) The "
                       "vout value\n"
                       "  }\n"
                       "  ,...\n"
                       "]\n"},
             RPCExamples{"\nList the unspent transactions\n" +
                         HelpExampleCli("listunspent", "") +
                         "\nLock an unspent transaction\n" +
                         HelpExampleCli("lockunspent",
                                        "false "
                                        "\"[{\\\"txid\\\":"
                                        "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                        "b764ed838b5655e72f463568df1aadf0\\\""
                                        ",\\\"vout\\\":1}]\"") +
                         "\nList the locked transactions\n" +
                         HelpExampleCli("listlockunspent", "") +
                         "\nUnlock the transaction again\n" +
                         HelpExampleCli("lockunspent",
                                        "true "
                                        "\"[{\\\"txid\\\":"
                                        "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                        "b764ed838b5655e72f463568df1aadf0\\\""
                                        ",\\\"vout\\\":1}]\"") +
                         "\nAs a JSON-RPC call\n" +
                         HelpExampleRpc("listlockunspent", "")},
         }
                                      .ToString());
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     std::vector<COutPoint> vOutpts;
     pwallet->ListLockedCoins(vOutpts);
 
     UniValue ret(UniValue::VARR);
 
     for (const COutPoint &output : vOutpts) {
         UniValue o(UniValue::VOBJ);
 
         o.pushKV("txid", output.GetTxId().GetHex());
         o.pushKV("vout", int(output.GetN()));
         ret.push_back(o);
     }
 
     return ret;
 }
 
 static UniValue settxfee(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 1) {
         throw std::runtime_error(RPCHelpMan{
             "settxfee",
             "\nSet the transaction fee per kB for this wallet. Overrides the "
             "global -paytxfee command line parameter.\n",
             {
                 {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO,
                  "The transaction fee in " + CURRENCY_UNIT + "/kB"},
             },
             RPCResult{
                 "true|false        (boolean) Returns true if successful\n"},
             RPCExamples{HelpExampleCli("settxfee", "0.00001") +
                         HelpExampleRpc("settxfee", "0.00001")},
         }
                                      .ToString());
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     Amount nAmount = AmountFromValue(request.params[0]);
     CFeeRate tx_fee_rate(nAmount, 1000);
     if (tx_fee_rate == CFeeRate()) {
         // automatic selection
     } else if (tx_fee_rate < pwallet->chain().relayMinFee()) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             strprintf("txfee cannot be less than min relay tx fee (%s)",
                       pwallet->chain().relayMinFee().ToString()));
     } else if (tx_fee_rate < pwallet->m_min_fee) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             strprintf("txfee cannot be less than wallet min fee (%s)",
                       pwallet->m_min_fee.ToString()));
     }
 
     pwallet->m_pay_tx_fee = tx_fee_rate;
     return true;
 }
 
 static UniValue getwalletinfo(const Config &config,
                               const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(RPCHelpMan{
             "getwalletinfo",
             "Returns an object containing various wallet state info.\n",
             {},
             RPCResult{
                 "{\n"
                 "  \"walletname\": xxxxx,             (string) the wallet "
                 "name\n"
                 "  \"walletversion\": xxxxx,          (numeric) the wallet "
                 "version\n"
                 "  \"balance\": xxxxxxx,              (numeric) the total "
                 "confirmed balance of the wallet in " +
                 CURRENCY_UNIT +
                 "\n"
                 "  \"unconfirmed_balance\": xxx,      (numeric) the total "
                 "unconfirmed balance of the wallet in " +
                 CURRENCY_UNIT +
                 "\n"
                 "  \"immature_balance\": xxxxxx,      (numeric) the total "
                 "immature balance of the wallet in " +
                 CURRENCY_UNIT +
                 "\n"
                 "  \"txcount\": xxxxxxx,              (numeric) the total "
                 "number of transactions in the wallet\n"
                 "  \"keypoololdest\": xxxxxx,         (numeric) the timestamp "
                 "(seconds since Unix epoch) of the oldest pre-generated key in "
                 "the key pool\n"
                 "  \"keypoolsize\": xxxx,             (numeric) how many new "
                 "keys are pre-generated (only counts external keys)\n"
                 "  \"keypoolsize_hd_internal\": xxxx, (numeric) how many new "
                 "keys are pre-generated for internal use (used for change "
                 "outputs, only appears if the wallet is using this feature, "
                 "otherwise external keys are used)\n"
                 "  \"unlocked_until\": ttt,           (numeric) the timestamp "
                 "in seconds since epoch (midnight Jan 1 1970 GMT) that the "
                 "wallet is unlocked for transfers, or 0 if the wallet is "
                 "locked\n"
                 "  \"paytxfee\": x.xxxx,              (numeric) the "
                 "transaction fee configuration, set in " +
                 CURRENCY_UNIT +
                 "/kB\n"
                 "  \"hdseedid\": \"<hash160>\"          (string, optional) the "
                 "Hash160 of the HD seed (only present when HD is enabled)\n"
                 "  \"private_keys_enabled\": true|false (boolean) false if "
                 "privatekeys are disabled for this wallet (enforced watch-only "
                 "wallet)\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("getwalletinfo", "") +
                         HelpExampleRpc("getwalletinfo", "")},
         }
                                      .ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     UniValue obj(UniValue::VOBJ);
 
     size_t kpExternalSize = pwallet->KeypoolCountExternalKeys();
     const auto bal = pwallet->GetBalance();
     obj.pushKV("walletname", pwallet->GetName());
     obj.pushKV("walletversion", pwallet->GetVersion());
     obj.pushKV("balance", ValueFromAmount(bal.m_mine_trusted));
     obj.pushKV("unconfirmed_balance",
                ValueFromAmount(bal.m_mine_untrusted_pending));
     obj.pushKV("immature_balance", ValueFromAmount(bal.m_mine_immature));
     obj.pushKV("txcount", (int)pwallet->mapWallet.size());
     obj.pushKV("keypoololdest", pwallet->GetOldestKeyPoolTime());
     obj.pushKV("keypoolsize", (int64_t)kpExternalSize);
     CKeyID seed_id = pwallet->GetHDChain().seed_id;
     if (pwallet->CanSupportFeature(FEATURE_HD_SPLIT)) {
         obj.pushKV("keypoolsize_hd_internal",
                    int64_t(pwallet->GetKeyPoolSize() - kpExternalSize));
     }
     if (pwallet->IsCrypted()) {
         obj.pushKV("unlocked_until", pwallet->nRelockTime);
     }
     obj.pushKV("paytxfee", ValueFromAmount(pwallet->m_pay_tx_fee.GetFeePerK()));
     if (!seed_id.IsNull()) {
         obj.pushKV("hdseedid", seed_id.GetHex());
     }
     obj.pushKV("private_keys_enabled",
                !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
     return obj;
 }
 
 static UniValue listwalletdir(const Config &config,
                               const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(RPCHelpMan{
             "listwalletdir",
             "Returns a list of wallets in the wallet directory.\n",
             {},
             RPCResult{
                 "{\n"
                 "  \"wallets\" : [                (json array of objects)\n"
                 "    {\n"
                 "      \"name\" : \"name\"          (string) The wallet name\n"
                 "    }\n"
                 "    ,...\n"
                 "  ]\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("listwalletdir", "") +
                         HelpExampleRpc("listwalletdir", "")},
         }
                                      .ToString());
     }
 
     UniValue wallets(UniValue::VARR);
     for (const auto &path : ListWalletDir()) {
         UniValue wallet(UniValue::VOBJ);
         wallet.pushKV("name", path.string());
         wallets.push_back(wallet);
     }
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("wallets", wallets);
     return result;
 }
 
 static UniValue listwallets(const Config &config,
                             const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(RPCHelpMan{
             "listwallets",
             "Returns a list of currently loaded wallets.\n"
             "For full information on the wallet, use \"getwalletinfo\"\n",
             {},
             RPCResult{"[                         (json array of strings)\n"
                       "  \"walletname\"            (string) the wallet name\n"
                       "   ...\n"
                       "]\n"},
             RPCExamples{HelpExampleCli("listwallets", "") +
                         HelpExampleRpc("listwallets", "")},
         }
                                      .ToString());
     }
 
     UniValue obj(UniValue::VARR);
 
     for (const std::shared_ptr<CWallet> &wallet : GetWallets()) {
         if (!EnsureWalletIsAvailable(wallet.get(), request.fHelp)) {
             return NullUniValue;
         }
 
         LOCK(wallet->cs_wallet);
 
         obj.push_back(wallet->GetName());
     }
 
     return obj;
 }
 
 static UniValue loadwallet(const Config &config,
                            const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "loadwallet",
             "\nLoads a wallet from a wallet file or directory."
             "\nNote that all wallet command-line options used when starting "
             "bitcoind will be"
             "\napplied to the new wallet (eg -zapwallettxes, upgradewallet, "
             "rescan, etc).\n",
             {
                 {"filename", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The wallet directory or .dat file."},
             },
             RPCResult{"{\n"
                       "  \"name\" :    <wallet_name>,        (string) The "
                       "wallet name if loaded successfully.\n"
                       "  \"warning\" : <warning>,            (string) Warning "
                       "message if wallet was not loaded cleanly.\n"
                       "}\n"},
             RPCExamples{HelpExampleCli("loadwallet", "\"test.dat\"") +
                         HelpExampleRpc("loadwallet", "\"test.dat\"")},
         }
                                      .ToString());
     }
 
     const CChainParams &chainParams = config.GetChainParams();
 
     WalletLocation location(request.params[0].get_str());
 
     if (!location.Exists()) {
         throw JSONRPCError(RPC_WALLET_NOT_FOUND,
                            "Wallet " + location.GetName() + " not found.");
     } else if (fs::is_directory(location.GetPath())) {
         // The given filename is a directory. Check that there's a wallet.dat
         // file.
         fs::path wallet_dat_file = location.GetPath() / "wallet.dat";
         if (fs::symlink_status(wallet_dat_file).type() == fs::file_not_found) {
             throw JSONRPCError(RPC_WALLET_NOT_FOUND,
                                "Directory " + location.GetName() +
                                    " does not contain a wallet.dat file.");
         }
     }
 
     std::string error, warning;
     std::shared_ptr<CWallet> const wallet =
         LoadWallet(chainParams, *g_rpc_node->chain, location, error, warning);
     if (!wallet) {
         throw JSONRPCError(RPC_WALLET_ERROR, error);
     }
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("name", wallet->GetName());
     obj.pushKV("warning", warning);
 
     return obj;
 }
 
 static UniValue createwallet(const Config &config,
                              const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 3) {
         throw std::runtime_error(RPCHelpMan{
             "createwallet",
             "\nCreates and loads a new wallet.\n",
             {
                 {"wallet_name", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The name for the new wallet. If this is a path, "
                  "the wallet will be created at the path location."},
                 {"disable_private_keys", RPCArg::Type::BOOL,
                  /* default */ "false",
                  "Disable the possibility of private keys (only "
                  "watchonlys are possible in this mode)."},
                 {"blank", RPCArg::Type::BOOL, /* default */ "false",
                  "Create a blank wallet. A blank wallet has no keys "
                  "or HD seed. One can be set using sethdseed.\n"},
             },
             RPCResult{
                 "{\n"
                 "  \"name\" :    <wallet_name>,        (string) The wallet "
                 "name if created successfully. If the wallet was created using "
                 "a full path, the wallet_name will be the full path.\n"
                 "  \"warning\" : <warning>,            (string) Warning "
                 "message if wallet was not loaded cleanly.\n"
                 "}\n"},
             RPCExamples{HelpExampleCli("createwallet", "\"testwallet\"") +
                         HelpExampleRpc("createwallet", "\"testwallet\"")},
         }
                                      .ToString());
     }
 
     const CChainParams &chainParams = config.GetChainParams();
 
     std::string error;
     std::string warning;
 
     uint64_t flags = 0;
     if (!request.params[1].isNull() && request.params[1].get_bool()) {
         flags |= WALLET_FLAG_DISABLE_PRIVATE_KEYS;
     }
 
     if (!request.params[2].isNull() && request.params[2].get_bool()) {
         flags |= WALLET_FLAG_BLANK_WALLET;
     }
 
     WalletLocation location(request.params[0].get_str());
     if (location.Exists()) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Wallet " + location.GetName() + " already exists.");
     }
 
     // Wallet::Verify will check if we're trying to create a wallet with a
     // duplicate name.
     if (!CWallet::Verify(chainParams, *g_rpc_node->chain, location, false,
                          error, warning)) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Wallet file verification failed: " + error);
     }
 
     std::shared_ptr<CWallet> const wallet = CWallet::CreateWalletFromFile(
         chainParams, *g_rpc_node->chain, location, flags);
     if (!wallet) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Wallet creation failed.");
     }
     AddWallet(wallet);
 
     wallet->postInitProcess();
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("name", wallet->GetName());
     obj.pushKV("warning", warning);
 
     return obj;
 }
 
 static UniValue unloadwallet(const Config &config,
                              const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() > 1) {
         throw std::runtime_error(RPCHelpMan{
             "unloadwallet",
             "Unloads the wallet referenced by the request endpoint "
             "otherwise unloads the wallet specified in the argument.\n"
             "Specifying the wallet name on a wallet endpoint is invalid.",
             {
                 {"wallet_name", RPCArg::Type::STR,
                  /* default */ "the wallet name from the RPC request",
                  "The name of the wallet to unload."},
             },
             RPCResults{},
             RPCExamples{HelpExampleCli("unloadwallet", "wallet_name") +
                         HelpExampleRpc("unloadwallet", "wallet_name")},
         }
                                      .ToString());
     }
 
     std::string wallet_name;
     if (GetWalletNameFromJSONRPCRequest(request, wallet_name)) {
         if (!request.params[0].isNull()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Cannot unload the requested wallet");
         }
     } else {
         wallet_name = request.params[0].get_str();
     }
 
     std::shared_ptr<CWallet> wallet = GetWallet(wallet_name);
     if (!wallet) {
         throw JSONRPCError(RPC_WALLET_NOT_FOUND,
                            "Requested wallet does not exist or is not loaded");
     }
 
     // Release the "main" shared pointer and prevent further notifications.
     // Note that any attempt to load the same wallet would fail until the wallet
     // is destroyed (see CheckUniqueFileid).
     if (!RemoveWallet(wallet)) {
         throw JSONRPCError(RPC_MISC_ERROR, "Requested wallet already unloaded");
     }
 
     UnloadWallet(std::move(wallet));
 
     return NullUniValue;
 }
 
 static UniValue listunspent(const Config &config,
                             const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 5) {
         throw std::runtime_error(RPCHelpMan{
             "listunspent",
             "\nReturns array of unspent transaction outputs\n"
             "with between minconf and maxconf (inclusive) confirmations.\n"
             "Optionally filter to only include txouts paid to specified "
             "addresses.\n",
             {
                 {"minconf", RPCArg::Type::NUM, /* default */ "1",
                  "The minimum confirmations to filter"},
                 {"maxconf", RPCArg::Type::NUM, /* default */ "9999999",
                  "The maximum confirmations to filter"},
                 {
                     "addresses",
                     RPCArg::Type::ARR,
                     /* default */ "empty array",
                     "A json array of bitcoin addresses to filter",
                     {
                         {"address", RPCArg::Type::STR,
                          RPCArg::Optional::OMITTED, "bitcoin address"},
                     },
                 },
                 {"include_unsafe", RPCArg::Type::BOOL, /* default */ "true",
                  "Include outputs that are not safe to spend\n"
                  "                  See description of \"safe\" attribute "
                  "below."},
                 {"query_options",
                  RPCArg::Type::OBJ,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "JSON with query options",
                  {
                      {"minimumAmount", RPCArg::Type::AMOUNT, /* default */ "0",
                       "Minimum value of each UTXO in " + CURRENCY_UNIT + ""},
                      {"maximumAmount", RPCArg::Type::AMOUNT,
                       /* default */ "unlimited",
                       "Maximum value of each UTXO in " + CURRENCY_UNIT + ""},
                      {"maximumCount", RPCArg::Type::NUM,
                       /* default */ "unlimited", "Maximum number of UTXOs"},
                      {"minimumSumAmount", RPCArg::Type::AMOUNT,
                       /* default */ "unlimited",
                       "Minimum sum value of all UTXOs in " + CURRENCY_UNIT +
                           ""},
                  },
                  "query_options"},
             },
             RPCResult{
                 "[                   (array of json object)\n"
                 "  {\n"
                 "    \"txid\" : \"txid\",          (string) the transaction id "
                 "\n"
                 "    \"vout\" : n,               (numeric) the vout value\n"
                 "    \"address\" : \"address\",    (string) the bitcoin "
                 "address\n"
                 "    \"label\" : \"label\",        (string) The associated "
                 "label, or \"\" for the default label\n"
                 "    \"scriptPubKey\" : \"key\",   (string) the script key\n"
                 "    \"amount\" : x.xxx,         (numeric) the transaction "
                 "output amount in " +
                 CURRENCY_UNIT +
                 "\n"
                 "    \"confirmations\" : n,      (numeric) The number of "
                 "confirmations\n"
                 "    \"redeemScript\" : n        (string) The redeemScript if "
                 "scriptPubKey is P2SH\n"
                 "    \"spendable\" : xxx,        (bool) Whether we have the "
                 "private keys to spend this output\n"
                 "    \"solvable\" : xxx,         (bool) Whether we know how to "
                 "spend this output, ignoring the lack of keys\n"
                 "    \"desc\" : xxx,             (string, only when solvable) "
                 "A descriptor for spending this output\n"
                 "    \"safe\" : xxx              (bool) Whether this output is "
                 "considered safe to spend. Unconfirmed transactions\n"
                 "                              from outside keys are "
                 "considered unsafe and are not eligible for spending by\n"
                 "                              fundrawtransaction and "
                 "sendtoaddress.\n"
                 "  }\n"
                 "  ,...\n"
                 "]\n"},
             RPCExamples{
                 HelpExampleCli("listunspent", "") +
                 HelpExampleCli(
                     "listunspent",
                     "6 9999999 "
                     "\"[\\\"1PGFqEzfmQch1gKD3ra4k18PNj3tTUUSqg\\\","
                     "\\\"1LtvqCaApEdUGFkpKMM4MstjcaL4dKg8SP\\\"]\"") +
                 HelpExampleRpc(
                     "listunspent",
                     "6, 9999999 "
                     "\"[\\\"1PGFqEzfmQch1gKD3ra4k18PNj3tTUUSqg\\\","
                     "\\\"1LtvqCaApEdUGFkpKMM4MstjcaL4dKg8SP\\\"]\"") +
                 HelpExampleCli(
                     "listunspent",
                     "6 9999999 '[]' true '{ \"minimumAmount\": 0.005 }'") +
                 HelpExampleRpc(
                     "listunspent",
                     "6, 9999999, [] , true, { \"minimumAmount\": 0.005 } ")},
         }
                                      .ToString());
     }
 
     int nMinDepth = 1;
     if (!request.params[0].isNull()) {
         RPCTypeCheckArgument(request.params[0], UniValue::VNUM);
         nMinDepth = request.params[0].get_int();
     }
 
     int nMaxDepth = 9999999;
     if (!request.params[1].isNull()) {
         RPCTypeCheckArgument(request.params[1], UniValue::VNUM);
         nMaxDepth = request.params[1].get_int();
     }
 
     std::set<CTxDestination> destinations;
     if (!request.params[2].isNull()) {
         RPCTypeCheckArgument(request.params[2], UniValue::VARR);
         UniValue inputs = request.params[2].get_array();
         for (size_t idx = 0; idx < inputs.size(); idx++) {
             const UniValue &input = inputs[idx];
             CTxDestination dest =
                 DecodeDestination(input.get_str(), config.GetChainParams());
             if (!IsValidDestination(dest)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    std::string("Invalid Bitcoin address: ") +
                                        input.get_str());
             }
             if (!destinations.insert(dest).second) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     std::string("Invalid parameter, duplicated address: ") +
                         input.get_str());
             }
         }
     }
 
     bool include_unsafe = true;
     if (!request.params[3].isNull()) {
         RPCTypeCheckArgument(request.params[3], UniValue::VBOOL);
         include_unsafe = request.params[3].get_bool();
     }
 
     Amount nMinimumAmount = Amount::zero();
     Amount nMaximumAmount = MAX_MONEY;
     Amount nMinimumSumAmount = MAX_MONEY;
     uint64_t nMaximumCount = 0;
 
     if (!request.params[4].isNull()) {
         const UniValue &options = request.params[4].get_obj();
 
         if (options.exists("minimumAmount")) {
             nMinimumAmount = AmountFromValue(options["minimumAmount"]);
         }
 
         if (options.exists("maximumAmount")) {
             nMaximumAmount = AmountFromValue(options["maximumAmount"]);
         }
 
         if (options.exists("minimumSumAmount")) {
             nMinimumSumAmount = AmountFromValue(options["minimumSumAmount"]);
         }
 
         if (options.exists("maximumCount")) {
             nMaximumCount = options["maximumCount"].get_int64();
         }
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     UniValue results(UniValue::VARR);
     std::vector<COutput> vecOutputs;
     {
         auto locked_chain = pwallet->chain().lock();
         LOCK(pwallet->cs_wallet);
         pwallet->AvailableCoins(*locked_chain, vecOutputs, !include_unsafe,
                                 nullptr, nMinimumAmount, nMaximumAmount,
                                 nMinimumSumAmount, nMaximumCount, nMinDepth,
                                 nMaxDepth);
     }
 
     LOCK(pwallet->cs_wallet);
 
     for (const COutput &out : vecOutputs) {
         CTxDestination address;
         const CScript &scriptPubKey = out.tx->tx->vout[out.i].scriptPubKey;
         bool fValidAddress = ExtractDestination(scriptPubKey, address);
 
         if (destinations.size() &&
             (!fValidAddress || !destinations.count(address))) {
             continue;
         }
 
         UniValue entry(UniValue::VOBJ);
         entry.pushKV("txid", out.tx->GetId().GetHex());
         entry.pushKV("vout", out.i);
 
         if (fValidAddress) {
             entry.pushKV("address", EncodeDestination(address, config));
 
             auto i = pwallet->mapAddressBook.find(address);
             if (i != pwallet->mapAddressBook.end()) {
                 entry.pushKV("label", i->second.name);
             }
 
             if (scriptPubKey.IsPayToScriptHash()) {
-                const CScriptID &hash = boost::get<CScriptID>(address);
+                const CScriptID &hash =
+                    CScriptID(boost::get<ScriptHash>(address));
                 CScript redeemScript;
                 if (pwallet->GetCScript(hash, redeemScript)) {
                     entry.pushKV("redeemScript", HexStr(redeemScript.begin(),
                                                         redeemScript.end()));
                 }
             }
         }
 
         entry.pushKV("scriptPubKey",
                      HexStr(scriptPubKey.begin(), scriptPubKey.end()));
         entry.pushKV("amount", ValueFromAmount(out.tx->tx->vout[out.i].nValue));
         entry.pushKV("confirmations", out.nDepth);
         entry.pushKV("spendable", out.fSpendable);
         entry.pushKV("solvable", out.fSolvable);
         if (out.fSolvable) {
             auto descriptor = InferDescriptor(scriptPubKey, *pwallet);
             entry.pushKV("desc", descriptor->ToString());
         }
         entry.pushKV("safe", out.fSafe);
         results.push_back(entry);
     }
 
     return results;
 }
 
 void FundTransaction(CWallet *const pwallet, CMutableTransaction &tx,
                      Amount &fee_out, int &change_position, UniValue options) {
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     CCoinControl coinControl;
     change_position = -1;
     bool lockUnspents = false;
     UniValue subtractFeeFromOutputs;
     std::set<int> setSubtractFeeFromOutputs;
 
     if (!options.isNull()) {
         if (options.type() == UniValue::VBOOL) {
             // backward compatibility bool only fallback
             coinControl.fAllowWatchOnly = options.get_bool();
         } else {
             RPCTypeCheckArgument(options, UniValue::VOBJ);
             RPCTypeCheckObj(
                 options,
                 {
                     {"changeAddress", UniValueType(UniValue::VSTR)},
                     {"changePosition", UniValueType(UniValue::VNUM)},
                     {"includeWatching", UniValueType(UniValue::VBOOL)},
                     {"lockUnspents", UniValueType(UniValue::VBOOL)},
                     // will be checked below
                     {"feeRate", UniValueType()},
                     {"subtractFeeFromOutputs", UniValueType(UniValue::VARR)},
                 },
                 true, true);
 
             if (options.exists("changeAddress")) {
                 CTxDestination dest = DecodeDestination(
                     options["changeAddress"].get_str(), pwallet->chainParams);
 
                 if (!IsValidDestination(dest)) {
                     throw JSONRPCError(
                         RPC_INVALID_ADDRESS_OR_KEY,
                         "changeAddress must be a valid bitcoin address");
                 }
 
                 coinControl.destChange = dest;
             }
 
             if (options.exists("changePosition")) {
                 change_position = options["changePosition"].get_int();
             }
 
             if (options.exists("includeWatching")) {
                 coinControl.fAllowWatchOnly =
                     options["includeWatching"].get_bool();
             }
 
             if (options.exists("lockUnspents")) {
                 lockUnspents = options["lockUnspents"].get_bool();
             }
 
             if (options.exists("feeRate")) {
                 coinControl.m_feerate =
                     CFeeRate(AmountFromValue(options["feeRate"]));
                 coinControl.fOverrideFeeRate = true;
             }
 
             if (options.exists("subtractFeeFromOutputs")) {
                 subtractFeeFromOutputs =
                     options["subtractFeeFromOutputs"].get_array();
             }
         }
     }
 
     if (tx.vout.size() == 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "TX must have at least one output");
     }
 
     if (change_position != -1 &&
         (change_position < 0 ||
          (unsigned int)change_position > tx.vout.size())) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "changePosition out of bounds");
     }
 
     for (size_t idx = 0; idx < subtractFeeFromOutputs.size(); idx++) {
         int pos = subtractFeeFromOutputs[idx].get_int();
         if (setSubtractFeeFromOutputs.count(pos)) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Invalid parameter, duplicated position: %d", pos));
         }
         if (pos < 0) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Invalid parameter, negative position: %d", pos));
         }
         if (pos >= int(tx.vout.size())) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Invalid parameter, position too large: %d", pos));
         }
         setSubtractFeeFromOutputs.insert(pos);
     }
 
     std::string strFailReason;
 
     if (!pwallet->FundTransaction(tx, fee_out, change_position, strFailReason,
                                   lockUnspents, setSubtractFeeFromOutputs,
                                   coinControl)) {
         throw JSONRPCError(RPC_WALLET_ERROR, strFailReason);
     }
 }
 
 static UniValue fundrawtransaction(const Config &config,
                                    const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "fundrawtransaction",
             "\nAdd inputs to a transaction until it has enough in value to "
             "meet its out value.\n"
             "This will not modify existing inputs, and will add at most one "
             "change output to the outputs.\n"
             "No existing outputs will be modified unless "
             "\"subtractFeeFromOutputs\" is specified.\n"
             "Note that inputs which were signed may need to be resigned after "
             "completion since in/outputs have been added.\n"
             "The inputs added will not be signed, use "
             "signrawtransactionwithkey or signrawtransactionwithwallet for "
             "that.\n"
             "Note that all existing inputs must have their previous output "
             "transaction be in the wallet.\n"
             "Note that all inputs selected must be of standard form and P2SH "
             "scripts must be\n"
             "in the wallet using importaddress or addmultisigaddress (to "
             "calculate fees).\n"
             "You can see whether this is the case by checking the \"solvable\" "
             "field in the listunspent output.\n"
             "Only pay-to-pubkey, multisig, and P2SH versions thereof are "
             "currently supported for watch-only\n",
             {
                 {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                  "The hex string of the raw transaction"},
                 {"options",
                  RPCArg::Type::OBJ,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "for backward compatibility: passing in a true instead of an "
                  "object will result in {\"includeWatching\":true}",
                  {
                      {"changeAddress", RPCArg::Type::STR,
                       /* default */ "pool address",
                       "The bitcoin address to receive the change"},
                      {"changePosition", RPCArg::Type::NUM, /* default */ "",
                       "The index of the change output"},
                      {"includeWatching", RPCArg::Type::BOOL,
                       /* default */ "false",
                       "Also select inputs which are watch only"},
                      {"lockUnspents", RPCArg::Type::BOOL, /* default */ "false",
                       "Lock selected unspent outputs"},
                      {"feeRate", RPCArg::Type::AMOUNT, /* default */
                       "not set: makes wallet determine the fee",
                       "Set a specific fee rate in " + CURRENCY_UNIT + "/kB"},
                      {
                          "subtractFeeFromOutputs",
                          RPCArg::Type::ARR,
                          /* default */ "empty array",
                          "A json array of integers.\n"
                          "                              The fee will be "
                          "equally deducted from the amount of each "
                          "specified output.\n"
                          "                              Those recipients "
                          "will receive less bitcoins than you enter in "
                          "their corresponding amount field.\n"
                          "                              If no outputs are "
                          "specified here, the sender pays the fee.",
                          {
                              {"vout_index", RPCArg::Type::NUM,
                               RPCArg::Optional::OMITTED,
                               "The zero-based output index, before a "
                               "change output is added."},
                          },
                      },
                  },
                  "options"},
             },
             RPCResult{"{\n"
                       "  \"hex\":       \"value\", (string)  The resulting raw "
                       "transaction (hex-encoded string)\n"
                       "  \"fee\":       n,         (numeric) Fee in " +
                       CURRENCY_UNIT +
                       " the resulting transaction pays\n"
                       "  \"changepos\": n          (numeric) The position of "
                       "the added change output, or -1\n"
                       "}\n"},
             RPCExamples{
                 "\nCreate a transaction with no inputs\n" +
                 HelpExampleCli("createrawtransaction",
                                "\"[]\" \"{\\\"myaddress\\\":0.01}\"") +
                 "\nAdd sufficient unsigned inputs to meet the output value\n" +
                 HelpExampleCli("fundrawtransaction", "\"rawtransactionhex\"") +
                 "\nSign the transaction\n" +
                 HelpExampleCli("signrawtransactionwithwallet",
                                "\"fundedtransactionhex\"") +
                 "\nSend the transaction\n" +
                 HelpExampleCli("sendrawtransaction",
                                "\"signedtransactionhex\"")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValueType()});
 
     // parse hex string from parameter
     CMutableTransaction tx;
     if (!DecodeHexTx(tx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     Amount fee;
     int change_position;
     FundTransaction(pwallet, tx, fee, change_position, request.params[1]);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("hex", EncodeHexTx(CTransaction(tx)));
     result.pushKV("fee", ValueFromAmount(fee));
     result.pushKV("changepos", change_position);
 
     return result;
 }
 
 UniValue signrawtransactionwithwallet(const Config &config,
                                       const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 3) {
         throw std::runtime_error(RPCHelpMan{
             "signrawtransactionwithwallet",
             "\nSign inputs for raw transaction (serialized, hex-encoded).\n"
             "The second optional argument (may be null) is an array of "
             "previous transaction outputs that\n"
             "this transaction depends on but may not yet be in the block "
             "chain.\n" +
                 HelpRequiringPassphrase(pwallet) + "\n",
             {
                 {"hexstring", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The transaction hex string"},
                 {
                     "prevtxs",
                     RPCArg::Type::ARR,
                     RPCArg::Optional::OMITTED_NAMED_ARG,
                     "A json array of previous dependent transaction outputs",
                     {
                         {
                             "",
                             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)"},
                                 {"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{"{\n"
                       "  \"hex\" : \"value\",                  (string) The "
                       "hex-encoded raw transaction with signature(s)\n"
                       "  \"complete\" : true|false,          (boolean) If the "
                       "transaction has a complete set of signatures\n"
                       "  \"errors\" : [                      (json array of "
                       "objects) Script verification errors (if there are any)\n"
                       "    {\n"
                       "      \"txid\" : \"hash\",              (string) The "
                       "hash of the referenced, previous transaction\n"
                       "      \"vout\" : n,                   (numeric) The "
                       "index of the output to spent and used as input\n"
                       "      \"scriptSig\" : \"hex\",          (string) The "
                       "hex-encoded signature script\n"
                       "      \"sequence\" : n,               (numeric) Script "
                       "sequence number\n"
                       "      \"error\" : \"text\"              (string) "
                       "Verification or signing error related to the input\n"
                       "    }\n"
                       "    ,...\n"
                       "  ]\n"
                       "}\n"},
             RPCExamples{
                 HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
                 HelpExampleRpc("signrawtransactionwithwallet", "\"myhex\"")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params,
                  {UniValue::VSTR, UniValue::VARR, UniValue::VSTR}, true);
 
     CMutableTransaction mtx;
     if (!DecodeHexTx(mtx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     // Sign the transaction
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
     EnsureWalletIsUnlocked(pwallet);
 
     // 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];
     }
     pwallet->chain().findCoins(coins);
 
     return SignTransaction(mtx, request.params[1], pwallet, coins, false,
                            request.params[2]);
 }
 
 UniValue generate(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "generate",
             "\nMine up to nblocks blocks immediately (before the RPC call "
             "returns) to an address in the wallet.\n",
             {
                 {"nblocks", RPCArg::Type::NUM, RPCArg::Optional::NO,
                  "How many blocks are generated immediately."},
                 {"maxtries", RPCArg::Type::NUM, /* default */ "1000000",
                  "How many iterations to try."},
             },
             RPCResult{
                 "[ blockhashes ]     (array) hashes of blocks generated\n"},
             RPCExamples{"\nGenerate 11 blocks\n" +
                         HelpExampleCli("generate", "11")}}
                                      .ToString());
     }
 
     if (!IsDeprecatedRPCEnabled(gArgs, "generate")) {
         throw JSONRPCError(RPC_METHOD_DEPRECATED,
                            "The wallet generate rpc method is deprecated and "
                            "will be fully removed in v0.22. "
                            "To use generate in v0.21, restart bitcoind with "
                            "-deprecatedrpc=generate.\n"
                            "Clients should transition to using the node rpc "
                            "method generatetoaddress\n");
     }
 
     int num_generate = request.params[0].get_int();
     uint64_t max_tries = 1000000;
     if (!request.params[1].isNull()) {
         max_tries = request.params[1].get_int();
     }
 
     std::shared_ptr<CReserveScript> coinbase_script;
     pwallet->GetScriptForMining(coinbase_script);
 
     // If the keypool is exhausted, no script is returned at all.  Catch this.
     if (!coinbase_script) {
         throw JSONRPCError(
             RPC_WALLET_KEYPOOL_RAN_OUT,
             "Error: Keypool ran out, please call keypoolrefill first");
     }
 
     // throw an error if no script was provided
     if (coinbase_script->reserveScript.empty()) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "No coinbase script available");
     }
 
     return generateBlocks(config, coinbase_script, num_generate, max_tries,
                           true);
 }
 
 UniValue rescanblockchain(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "rescanblockchain",
             "\nRescan the local blockchain for wallet related transactions.\n",
             {
                 {"start_height", RPCArg::Type::NUM, /* default */ "0",
                  "block height where the rescan should start"},
                 {"stop_height", RPCArg::Type::NUM,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "the last block height that should be scanned"},
             },
             RPCResult{"{\n"
                       "  \"start_height\"     (numeric) The block height where "
                       "the rescan started (the requested height or 0\n"
                       "  \"stop_height\"      (numeric) The height of the last "
                       "rescanned block. May be null in rare cases if there was "
                       "a reorg and the call didn't scan any blocks because "
                       "they were already scanned in the background.\n"
                       "}\n"},
             RPCExamples{HelpExampleCli("rescanblockchain", "100000 120000") +
                         HelpExampleRpc("rescanblockchain", "100000, 120000")},
         }
                                      .ToString());
     }
 
     WalletRescanReserver reserver(pwallet);
     if (!reserver.reserve()) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Wallet is currently rescanning. Abort existing rescan or wait.");
     }
 
     int start_height = 0;
     BlockHash start_block, stop_block;
     {
         auto locked_chain = pwallet->chain().lock();
         Optional<int> tip_height = locked_chain->getHeight();
 
         if (!request.params[0].isNull()) {
             start_height = request.params[0].get_int();
             if (start_height < 0 || !tip_height || start_height > *tip_height) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Invalid start_height");
             }
         }
 
         Optional<int> stop_height;
         if (!request.params[1].isNull()) {
             stop_height = request.params[1].get_int();
             if (*stop_height < 0 || !tip_height || *stop_height > *tip_height) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Invalid stop_height");
             } else if (*stop_height < start_height) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     "stop_height must be greater than start_height");
             }
         }
 
         // We can't rescan beyond non-pruned blocks, stop and throw an error
         if (locked_chain->findPruned(start_height, stop_height)) {
             throw JSONRPCError(
                 RPC_MISC_ERROR,
                 "Can't rescan beyond pruned data. Use RPC call "
                 "getblockchaininfo to determine your pruned height.");
         }
 
         if (tip_height) {
             start_block = locked_chain->getBlockHash(start_height);
 
             // If called with a stop_height, set the stop_height here to
             // trigger a rescan to that height.
             // If called without a stop height, leave stop_height as null here
             // so rescan continues to the tip (even if the tip advances during
             // rescan).
             if (stop_height) {
                 stop_block = locked_chain->getBlockHash(*stop_height);
             }
         }
     }
 
     CWallet::ScanResult result = pwallet->ScanForWalletTransactions(
         start_block, stop_block, reserver, true /* fUpdate */);
     switch (result.status) {
         case CWallet::ScanResult::SUCCESS:
             break;
         case CWallet::ScanResult::FAILURE:
             throw JSONRPCError(
                 RPC_MISC_ERROR,
                 "Rescan failed. Potentially corrupted data files.");
         case CWallet::ScanResult::USER_ABORT:
             throw JSONRPCError(RPC_MISC_ERROR, "Rescan aborted.");
             // no default case, so the compiler can warn about missing cases
     }
     UniValue response(UniValue::VOBJ);
     response.pushKV("start_height", start_height);
     response.pushKV("stop_height", result.last_scanned_height
                                        ? *result.last_scanned_height
                                        : UniValue());
     return response;
 }
 
 class DescribeWalletAddressVisitor : public boost::static_visitor<UniValue> {
 public:
     CWallet *const pwallet;
 
     void ProcessSubScript(const CScript &subscript, UniValue &obj) const {
         // Always present: script type and redeemscript
         std::vector<std::vector<uint8_t>> solutions_data;
         txnouttype which_type = Solver(subscript, solutions_data);
         obj.pushKV("script", GetTxnOutputType(which_type));
         obj.pushKV("hex", HexStr(subscript.begin(), subscript.end()));
 
         CTxDestination embedded;
         if (ExtractDestination(subscript, embedded)) {
             // Only when the script corresponds to an address.
             UniValue subobj(UniValue::VOBJ);
             UniValue detail = DescribeAddress(embedded);
             subobj.pushKVs(detail);
             UniValue wallet_detail = boost::apply_visitor(*this, embedded);
             subobj.pushKVs(wallet_detail);
             subobj.pushKV("address", EncodeDestination(embedded, GetConfig()));
             subobj.pushKV("scriptPubKey",
                           HexStr(subscript.begin(), subscript.end()));
             // Always report the pubkey at the top level, so that
             // `getnewaddress()['pubkey']` always works.
             if (subobj.exists("pubkey")) {
                 obj.pushKV("pubkey", subobj["pubkey"]);
             }
             obj.pushKV("embedded", std::move(subobj));
         } else if (which_type == TX_MULTISIG) {
             // Also report some information on multisig scripts (which do not
             // have a corresponding address).
             // TODO: abstract out the common functionality between this logic
             // and ExtractDestinations.
             obj.pushKV("sigsrequired", solutions_data[0][0]);
             UniValue pubkeys(UniValue::VARR);
             for (size_t i = 1; i < solutions_data.size() - 1; ++i) {
                 CPubKey key(solutions_data[i].begin(), solutions_data[i].end());
                 pubkeys.push_back(HexStr(key.begin(), key.end()));
             }
             obj.pushKV("pubkeys", std::move(pubkeys));
         }
     }
 
     explicit DescribeWalletAddressVisitor(CWallet *_pwallet)
         : pwallet(_pwallet) {}
 
     UniValue operator()(const CNoDestination &dest) const {
         return UniValue(UniValue::VOBJ);
     }
 
-    UniValue operator()(const CKeyID &keyID) const {
+    UniValue operator()(const PKHash &pkhash) const {
+        CKeyID keyID(pkhash);
         UniValue obj(UniValue::VOBJ);
         CPubKey vchPubKey;
         if (pwallet && pwallet->GetPubKey(keyID, vchPubKey)) {
             obj.pushKV("pubkey", HexStr(vchPubKey));
             obj.pushKV("iscompressed", vchPubKey.IsCompressed());
         }
         return obj;
     }
 
-    UniValue operator()(const CScriptID &scriptID) const {
+    UniValue operator()(const ScriptHash &scripthash) const {
+        CScriptID scriptID(scripthash);
         UniValue obj(UniValue::VOBJ);
         CScript subscript;
         if (pwallet && pwallet->GetCScript(scriptID, subscript)) {
             ProcessSubScript(subscript, obj);
         }
         return obj;
     }
 };
 
 static UniValue DescribeWalletAddress(CWallet *pwallet,
                                       const CTxDestination &dest) {
     UniValue ret(UniValue::VOBJ);
     UniValue detail = DescribeAddress(dest);
     ret.pushKVs(detail);
     ret.pushKVs(
         boost::apply_visitor(DescribeWalletAddressVisitor(pwallet), dest));
     return ret;
 }
 
 /** Convert CAddressBookData to JSON record.  */
 static UniValue AddressBookDataToJSON(const CAddressBookData &data,
                                       const bool verbose) {
     UniValue ret(UniValue::VOBJ);
     if (verbose) {
         ret.pushKV("name", data.name);
     }
     ret.pushKV("purpose", data.purpose);
     return ret;
 }
 
 UniValue getaddressinfo(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "getaddressinfo",
             "\nReturn information about the given bitcoin address. Some "
             "information requires the address\n"
             "to be in the wallet.\n",
             {
                 {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The bitcoin address to get the information of."},
             },
             RPCResult{
                 "{\n"
                 "  \"address\" : \"address\",        (string) The bitcoin "
                 "address validated\n"
                 "  \"scriptPubKey\" : \"hex\",       (string) The hex-encoded "
                 "scriptPubKey generated by the address\n"
                 "  \"ismine\" : true|false,        (boolean) If the address is "
                 "yours or not\n"
                 "  \"iswatchonly\" : true|false,   (boolean) If the address is "
                 "watchonly\n"
                 "  \"solvable\" : true|false,      (boolean) Whether we know "
                 "how to spend coins sent to this address, ignoring the "
                 "possible lack of private keys\n"
                 "  \"desc\" : \"desc\",            (string, optional) A "
                 "descriptor for spending coins sent to this address (only when "
                 "solvable)\n"
                 "  \"isscript\" : true|false,      (boolean) If the key is a "
                 "script\n"
                 "  \"ischange\" : true|false,      (boolean) If the address "
                 "was used for change output\n"
                 "  \"script\" : \"type\"             (string, optional) The "
                 "output script type. Only if \"isscript\" is true and the "
                 "redeemscript is known. Possible types: nonstandard, pubkey, "
                 "pubkeyhash, scripthash, multisig, nulldata\n"
                 "  \"hex\" : \"hex\",                (string, optional) The "
                 "redeemscript for the p2sh address\n"
                 "  \"pubkeys\"                     (string, optional) Array of "
                 "pubkeys associated with the known redeemscript (only if "
                 "\"script\" is \"multisig\")\n"
                 "    [\n"
                 "      \"pubkey\"\n"
                 "      ,...\n"
                 "    ]\n"
                 "  \"sigsrequired\" : xxxxx        (numeric, optional) Number "
                 "of signatures required to spend multisig output (only if "
                 "\"script\" is \"multisig\")\n"
                 "  \"pubkey\" : \"publickeyhex\",    (string, optional) The "
                 "hex value of the raw public key, for single-key addresses "
                 "(possibly embedded in P2SH or P2WSH)\n"
                 "  \"embedded\" : {...},           (object, optional) "
                 "Information about the address embedded in P2SH or P2WSH, if "
                 "relevant and known. It includes all getaddressinfo output "
                 "fields for the embedded address, excluding metadata "
                 "(\"timestamp\", \"hdkeypath\", \"hdseedid\") and relation to "
                 "the wallet (\"ismine\", \"iswatchonly\").\n"
                 "  \"iscompressed\" : true|false,  (boolean) If the address is "
                 "compressed\n"
                 "  \"label\" :  \"label\"         (string) The label "
                 "associated with the address, \"\" is the default label\n"
                 "  \"timestamp\" : timestamp,      (number, optional) The "
                 "creation time of the key if available in seconds since epoch "
                 "(Jan 1 1970 GMT)\n"
                 "  \"hdkeypath\" : \"keypath\"       (string, optional) The HD "
                 "keypath if the key is HD and available\n"
                 "  \"hdseedid\" : \"<hash160>\"      (string, optional) The "
                 "Hash160 of the HD seed\n"
                 "  \"hdmasterfingerprint\" : \"<hash160>\" (string, optional) "
                 "The fingperint of the master key.\n"
                 "  \"labels\"                      (object) Array of labels "
                 "associated with the address.\n"
                 "    [\n"
                 "      { (json object of label data)\n"
                 "        \"name\": \"labelname\" (string) The label\n"
                 "        \"purpose\": \"string\" (string) Purpose of address "
                 "(\"send\" for sending address, \"receive\" for receiving "
                 "address)\n"
                 "      },...\n"
                 "    ]\n"
                 "}\n"},
             RPCExamples{
                 HelpExampleCli("getaddressinfo",
                                "\"1PSSGeFHDnKNxiEyFrD1wcEaHr9hrQDDWc\"") +
                 HelpExampleRpc("getaddressinfo",
                                "\"1PSSGeFHDnKNxiEyFrD1wcEaHr9hrQDDWc\"")},
         }
                                      .ToString());
     }
 
     LOCK(pwallet->cs_wallet);
 
     UniValue ret(UniValue::VOBJ);
     CTxDestination dest =
         DecodeDestination(request.params[0].get_str(), config.GetChainParams());
 
     // Make sure the destination is valid
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
     }
 
     std::string currentAddress = EncodeDestination(dest, config);
     ret.pushKV("address", currentAddress);
 
     CScript scriptPubKey = GetScriptForDestination(dest);
     ret.pushKV("scriptPubKey",
                HexStr(scriptPubKey.begin(), scriptPubKey.end()));
 
     isminetype mine = IsMine(*pwallet, dest);
     ret.pushKV("ismine", bool(mine & ISMINE_SPENDABLE));
     bool solvable = IsSolvable(*pwallet, scriptPubKey);
     ret.pushKV("solvable", solvable);
     if (solvable) {
         ret.pushKV("desc", InferDescriptor(scriptPubKey, *pwallet)->ToString());
     }
     ret.pushKV("iswatchonly", bool(mine & ISMINE_WATCH_ONLY));
     UniValue detail = DescribeWalletAddress(pwallet, dest);
     ret.pushKVs(detail);
     if (pwallet->mapAddressBook.count(dest)) {
         ret.pushKV("label", pwallet->mapAddressBook[dest].name);
     }
     ret.pushKV("ischange", pwallet->IsChange(scriptPubKey));
     const CKeyMetadata *meta = nullptr;
     CKeyID key_id = GetKeyForDestination(*pwallet, dest);
     if (!key_id.IsNull()) {
         auto it = pwallet->mapKeyMetadata.find(key_id);
         if (it != pwallet->mapKeyMetadata.end()) {
             meta = &it->second;
         }
     }
     if (!meta) {
         auto it = pwallet->m_script_metadata.find(CScriptID(scriptPubKey));
         if (it != pwallet->m_script_metadata.end()) {
             meta = &it->second;
         }
     }
     if (meta) {
         ret.pushKV("timestamp", meta->nCreateTime);
         if (meta->has_key_origin) {
             ret.pushKV("hdkeypath", WriteHDKeypath(meta->key_origin.path));
             ret.pushKV("hdseedid", meta->hd_seed_id.GetHex());
             ret.pushKV("hdmasterfingerprint",
                        HexStr(meta->key_origin.fingerprint,
                               meta->key_origin.fingerprint + 4));
         }
     }
 
     // Currently only one label can be associated with an address, return an
     // array so the API remains stable if we allow multiple labels to be
     // associated with an address.
     UniValue labels(UniValue::VARR);
     std::map<CTxDestination, CAddressBookData>::iterator mi =
         pwallet->mapAddressBook.find(dest);
     if (mi != pwallet->mapAddressBook.end()) {
         labels.push_back(AddressBookDataToJSON(mi->second, true));
     }
     ret.pushKV("labels", std::move(labels));
 
     return ret;
 }
 
 UniValue getaddressesbylabel(const Config &config,
                              const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(RPCHelpMan{
             "getaddressesbylabel",
             "\nReturns the list of addresses assigned the specified "
             "label.\n",
             {
                 {"label", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The label."},
             },
             RPCResult{"{ (json object with addresses as keys)\n"
                       "  \"address\": { (json object with information about "
                       "address)\n"
                       "    \"purpose\": \"string\" (string)  Purpose of "
                       "address (\"send\" for sending address, \"receive\" for "
                       "receiving address)\n"
                       "  },...\n"
                       "}\n"},
             RPCExamples{HelpExampleCli("getaddressesbylabel", "\"tabby\"") +
                         HelpExampleRpc("getaddressesbylabel", "\"tabby\"")},
         }
                                      .ToString());
     }
 
     LOCK(pwallet->cs_wallet);
 
     std::string label = LabelFromValue(request.params[0]);
 
     // Find all addresses that have the given label
     UniValue ret(UniValue::VOBJ);
     std::set<std::string> addresses;
     for (const std::pair<const CTxDestination, CAddressBookData> &item :
          pwallet->mapAddressBook) {
         if (item.second.name == label) {
             std::string address = EncodeDestination(item.first, config);
             // CWallet::mapAddressBook is not expected to contain duplicate
             // address strings, but build a separate set as a precaution just in
             // case it does.
             bool unique = addresses.emplace(address).second;
             assert(unique);
             // UniValue::pushKV checks if the key exists in O(N)
             // and since duplicate addresses are unexpected (checked with
             // std::set in O(log(N))), UniValue::__pushKV is used instead,
             // which currently is O(1).
             ret.__pushKV(address, AddressBookDataToJSON(item.second, false));
         }
     }
 
     if (ret.empty()) {
         throw JSONRPCError(RPC_WALLET_INVALID_LABEL_NAME,
                            std::string("No addresses with label " + label));
     }
 
     return ret;
 }
 
 UniValue listlabels(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 1) {
         throw std::runtime_error(RPCHelpMan{
             "listlabels",
             "\nReturns the list of all labels, or labels that are "
             "assigned to addresses with a specific purpose.\n",
             {
                 {"purpose", RPCArg::Type::STR,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "Address purpose to list labels for ('send','receive'). An "
                  "empty string is the same as not providing this argument."},
             },
             RPCResult{"[               (json array of string)\n"
                       "  \"label\",      (string) Label name\n"
                       "  ...\n"
                       "]\n"},
             RPCExamples{"\nList all labels\n" +
                         HelpExampleCli("listlabels", "") +
                         "\nList labels that have receiving addresses\n" +
                         HelpExampleCli("listlabels", "receive") +
                         "\nList labels that have sending addresses\n" +
                         HelpExampleCli("listlabels", "send") +
                         "\nAs a JSON-RPC call\n" +
                         HelpExampleRpc("listlabels", "receive")},
         }
                                      .ToString());
     }
 
     LOCK(pwallet->cs_wallet);
 
     std::string purpose;
     if (!request.params[0].isNull()) {
         purpose = request.params[0].get_str();
     }
 
     // Add to a set to sort by label name, then insert into Univalue array
     std::set<std::string> label_set;
     for (const std::pair<const CTxDestination, CAddressBookData> &entry :
          pwallet->mapAddressBook) {
         if (purpose.empty() || entry.second.purpose == purpose) {
             label_set.insert(entry.second.name);
         }
     }
 
     UniValue ret(UniValue::VARR);
     for (const std::string &name : label_set) {
         ret.push_back(name);
     }
 
     return ret;
 }
 
 static UniValue sethdseed(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 2) {
         throw std::runtime_error(RPCHelpMan{
             "sethdseed",
             "\nSet or generate a new HD wallet seed. Non-HD wallets will not "
             "be upgraded to being a HD wallet. Wallets that are already\n"
             "HD will have a new HD seed set so that new keys added to the "
             "keypool will be derived from this new seed.\n"
             "\nNote that you will need to MAKE A NEW BACKUP of your wallet "
             "after setting the HD wallet seed.\n" +
                 HelpRequiringPassphrase(pwallet) + "\n",
             {
                 {"newkeypool", RPCArg::Type::BOOL, /* default */ "true",
                  "Whether to flush old unused addresses, including change "
                  "addresses, from the keypool and regenerate it.\n"
                  "                             If true, the next address from "
                  "getnewaddress and change address from getrawchangeaddress "
                  "will be from this new seed.\n"
                  "                             If false, addresses (including "
                  "change addresses if the wallet already had HD Chain Split "
                  "enabled) from the existing\n"
                  "                             keypool will be used until it "
                  "has been depleted."},
                 {"seed", RPCArg::Type::STR, /* default */ "random seed",
                  "The WIF private key to use as the new HD seed.\n"
                  "                             The seed value can be retrieved "
                  "using the dumpwallet command. It is the private key marked "
                  "hdseed=1"},
             },
             RPCResults{},
             RPCExamples{HelpExampleCli("sethdseed", "") +
                         HelpExampleCli("sethdseed", "false") +
                         HelpExampleCli("sethdseed", "true \"wifkey\"") +
                         HelpExampleRpc("sethdseed", "true, \"wifkey\"")},
         }
                                      .ToString());
     }
 
     if (pwallet->chain().isInitialBlockDownload()) {
         throw JSONRPCError(
             RPC_CLIENT_IN_INITIAL_DOWNLOAD,
             "Cannot set a new HD seed while still in Initial Block Download");
     }
 
     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Cannot set a HD seed to a wallet with private keys disabled");
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     // Do not do anything to non-HD wallets
     if (!pwallet->CanSupportFeature(FEATURE_HD)) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Cannot set a HD seed on a non-HD wallet. Start with "
             "-upgradewallet in order to upgrade a non-HD wallet to HD");
     }
 
     EnsureWalletIsUnlocked(pwallet);
 
     bool flush_key_pool = true;
     if (!request.params[0].isNull()) {
         flush_key_pool = request.params[0].get_bool();
     }
 
     CPubKey master_pub_key;
     if (request.params[1].isNull()) {
         master_pub_key = pwallet->GenerateNewSeed();
     } else {
         CKey key = DecodeSecret(request.params[1].get_str());
         if (!key.IsValid()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid private key");
         }
 
         if (HaveKey(*pwallet, key)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Already have this key (either as an HD seed or "
                                "as a loose private key)");
         }
 
         master_pub_key = pwallet->DeriveNewSeed(key);
     }
 
     pwallet->SetHDSeed(master_pub_key);
     if (flush_key_pool) {
         pwallet->NewKeyPool();
     }
 
     return NullUniValue;
 }
 
 static UniValue walletprocesspsbt(const Config &config,
                                   const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 4) {
         throw std::runtime_error(RPCHelpMan{
             "walletprocesspsbt",
             "\nUpdate a PSBT with input information from our wallet and then "
             "sign inputs that we can sign for." +
                 HelpRequiringPassphrase(pwallet) + "\n",
             {
                 {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The transaction base64 string"},
                 {"sign", RPCArg::Type::BOOL, /* default */ "true",
                  "Also sign the transaction when updating"},
                 {"sighashtype", RPCArg::Type::STR, /* default */ "ALL|FORKID",
                  "The signature hash type to sign with if not specified by "
                  "the PSBT. 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\""},
                 {"bip32derivs", RPCArg::Type::BOOL, /* default */ "false",
                  "If true, includes the BIP 32 derivation paths for public "
                  "keys if we know them"},
             },
             RPCResult{"{\n"
                       "  \"psbt\" : \"value\",          (string) The "
                       "base64-encoded partially signed transaction\n"
                       "  \"complete\" : true|false,   (boolean) If the "
                       "transaction has a complete set of signatures\n"
                       "  ]\n"
                       "}\n"},
             RPCExamples{HelpExampleCli("walletprocesspsbt", "\"psbt\"")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params,
                  {UniValue::VSTR, UniValue::VBOOL, 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));
     }
 
     // Get the sighash type
     SigHashType nHashType = ParseSighashString(request.params[2]);
     if (!nHashType.hasForkId()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Signature must use SIGHASH_FORKID");
     }
 
     // Fill transaction with our data and also sign
     bool sign =
         request.params[1].isNull() ? true : request.params[1].get_bool();
     bool bip32derivs =
         request.params[3].isNull() ? false : request.params[3].get_bool();
     bool complete = true;
     const TransactionError err =
         FillPSBT(pwallet, psbtx, complete, nHashType, sign, bip32derivs);
     if (err != TransactionError::OK) {
         throw JSONRPCTransactionError(err);
     }
 
     UniValue result(UniValue::VOBJ);
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
     result.pushKV("psbt", EncodeBase64(ssTx.str()));
     result.pushKV("complete", complete);
 
     return result;
 }
 
 static UniValue walletcreatefundedpsbt(const Config &config,
                                        const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 5) {
         throw std::runtime_error(RPCHelpMan{
             "walletcreatefundedpsbt",
             "\nCreates and funds a transaction in the Partially Signed "
             "Transaction format. Inputs will be added if supplied inputs are "
             "not enough\n"
             "Implements the Creator and Updater roles.\n",
             {
                 {
                     "inputs",
                     RPCArg::Type::ARR,
                     RPCArg::Optional::NO,
                     "A json array of 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,
                                  RPCArg::Optional::NO, "The sequence number"},
                             },
                         },
                     },
                 },
                 {
                     "outputs",
                     RPCArg::Type::ARR,
                     RPCArg::Optional::NO,
                     "a json array with outputs (key-value pairs).\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\n"
                  "                             Allows this transaction to "
                  "be replaced by a transaction with higher fees. If provided, "
                  "it is an error if explicit sequence numbers are "
                  "incompatible."},
                 {"options",
                  RPCArg::Type::OBJ,
                  RPCArg::Optional::OMITTED_NAMED_ARG,
                  "",
                  {
                      {"changeAddress", RPCArg::Type::STR_HEX,
                       /* default */ "pool address",
                       "The bitcoin address to receive the change"},
                      {"changePosition", RPCArg::Type::NUM,
                       /* default */ "random", "The index of the change output"},
                      {"includeWatching", RPCArg::Type::BOOL,
                       /* default */ "false",
                       "Also select inputs which are watch only"},
                      {"lockUnspents", RPCArg::Type::BOOL, /* default */ "false",
                       "Lock selected unspent outputs"},
                      {"feeRate", RPCArg::Type::AMOUNT, /* default */
                       "not set: makes wallet determine the fee",
                       "Set a specific fee rate in " + CURRENCY_UNIT + "/kB"},
                      {
                          "subtractFeeFromOutputs",
                          RPCArg::Type::ARR,
                          /* default */ "empty array",
                          "A json array of integers.\n"
                          "                              The fee will be "
                          "equally deducted from the amount of each specified "
                          "output.\n"
                          "                              Those recipients will "
                          "receive less bitcoins than you enter in their "
                          "corresponding amount field.\n"
                          "                              If no outputs are "
                          "specified here, the sender pays the fee.",
                          {
                              {"vout_index", RPCArg::Type::NUM,
                               RPCArg::Optional::OMITTED,
                               "The zero-based output index, before a change "
                               "output is added."},
                          },
                      },
                  },
                  "options"},
                 {"bip32derivs", RPCArg::Type::BOOL, /* default */ "false",
                  "If true, includes the BIP 32 derivation paths for public "
                  "keys if we know them"},
             },
             RPCResult{"{\n"
                       "  \"psbt\": \"value\",        (string)  The resulting "
                       "raw transaction (base64-encoded string)\n"
                       "  \"fee\":       n,         (numeric) Fee in " +
                       CURRENCY_UNIT +
                       " the resulting transaction pays\n"
                       "  \"changepos\": n          (numeric) The position of "
                       "the added change output, or -1\n"
                       "}\n"},
             RPCExamples{"\nCreate a transaction with no inputs\n" +
                         HelpExampleCli(
                             "walletcreatefundedpsbt",
                             "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" "
                             "\"[{\\\"data\\\":\\\"00010203\\\"}]\"")},
         }
                                      .ToString());
     }
 
     RPCTypeCheck(request.params,
                  {UniValue::VARR,
                   UniValueType(), // ARR or OBJ, checked later
                   UniValue::VNUM, UniValue::VOBJ},
                  true);
 
     Amount fee;
     int change_position;
     CMutableTransaction rawTx =
         ConstructTransaction(config.GetChainParams(), request.params[0],
                              request.params[1], request.params[2]);
     FundTransaction(pwallet, rawTx, fee, change_position, request.params[3]);
 
     // Make a blank psbt
     PartiallySignedTransaction psbtx(rawTx);
 
     // Fill transaction with out data but don't sign
     bool bip32derivs =
         request.params[4].isNull() ? false : request.params[4].get_bool();
     bool complete = true;
     const TransactionError err =
         FillPSBT(pwallet, psbtx, complete, SigHashType().withForkId(), false,
                  bip32derivs);
     if (err != TransactionError::OK) {
         throw JSONRPCTransactionError(err);
     }
 
     // Serialize the PSBT
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("psbt", EncodeBase64(ssTx.str()));
     result.pushKV("fee", ValueFromAmount(fee));
     result.pushKV("changepos", change_position);
     return result;
 }
 
 // clang-format off
 static const CRPCCommand commands[] = {
     //  category            name                            actor (function)              argNames
     //  ------------------- ------------------------        ----------------------        ----------
     { "generating",         "generate",                     generate,                     {"nblocks","maxtries"} },
     { "rawtransactions",    "fundrawtransaction",           fundrawtransaction,           {"hexstring","options"} },
     { "wallet",             "abandontransaction",           abandontransaction,           {"txid"} },
     { "wallet",             "addmultisigaddress",           addmultisigaddress,           {"nrequired","keys","label"} },
     { "wallet",             "backupwallet",                 backupwallet,                 {"destination"} },
     { "wallet",             "createwallet",                 createwallet,                 {"wallet_name", "disable_private_keys", "blank"} },
     { "wallet",             "encryptwallet",                encryptwallet,                {"passphrase"} },
     { "wallet",             "getaddressesbylabel",          getaddressesbylabel,          {"label"} },
     { "wallet",             "getaddressinfo",               getaddressinfo,               {"address"} },
     { "wallet",             "getbalance",                   getbalance,                   {"dummy","minconf","include_watchonly"} },
     { "wallet",             "getnewaddress",                getnewaddress,                {"label", "address_type"} },
     { "wallet",             "getrawchangeaddress",          getrawchangeaddress,          {"address_type"} },
     { "wallet",             "getreceivedbyaddress",         getreceivedbyaddress,         {"address","minconf"} },
     { "wallet",             "getreceivedbylabel",           getreceivedbylabel,           {"label","minconf"} },
     { "wallet",             "gettransaction",               gettransaction,               {"txid","include_watchonly"} },
     { "wallet",             "getunconfirmedbalance",        getunconfirmedbalance,        {} },
     { "wallet",             "getwalletinfo",                getwalletinfo,                {} },
     { "wallet",             "keypoolrefill",                keypoolrefill,                {"newsize"} },
     { "wallet",             "listaddressgroupings",         listaddressgroupings,         {} },
     { "wallet",             "listlabels",                   listlabels,                   {"purpose"} },
     { "wallet",             "listlockunspent",              listlockunspent,              {} },
     { "wallet",             "listreceivedbyaddress",        listreceivedbyaddress,        {"minconf","include_empty","include_watchonly","address_filter"} },
     { "wallet",             "listreceivedbylabel",          listreceivedbylabel,          {"minconf","include_empty","include_watchonly"} },
     { "wallet",             "listsinceblock",               listsinceblock,               {"blockhash","target_confirmations","include_watchonly","include_removed"} },
     { "wallet",             "listtransactions",             listtransactions,             {"label|dummy","count","skip","include_watchonly"} },
     { "wallet",             "listunspent",                  listunspent,                  {"minconf","maxconf","addresses","include_unsafe","query_options"} },
     { "wallet",             "listwalletdir",                listwalletdir,                {} },
     { "wallet",             "listwallets",                  listwallets,                  {} },
     { "wallet",             "loadwallet",                   loadwallet,                   {"filename"} },
     { "wallet",             "lockunspent",                  lockunspent,                  {"unlock","transactions"} },
     { "wallet",             "rescanblockchain",             rescanblockchain,             {"start_height", "stop_height"} },
     { "wallet",             "sendmany",                     sendmany,                     {"dummy","amounts","minconf","comment","subtractfeefrom"} },
     { "wallet",             "sendtoaddress",                sendtoaddress,                {"address","amount","comment","comment_to","subtractfeefromamount"} },
     { "wallet",             "sethdseed",                    sethdseed,                    {"newkeypool","seed"} },
     { "wallet",             "setlabel",                     setlabel,                     {"address","label"} },
     { "wallet",             "settxfee",                     settxfee,                     {"amount"} },
     { "wallet",             "signmessage",                  signmessage,                  {"address","message"} },
     { "wallet",             "signrawtransactionwithwallet", signrawtransactionwithwallet, {"hextring","prevtxs","sighashtype"} },
     { "wallet",             "unloadwallet",                 unloadwallet,                 {"wallet_name"} },
     { "wallet",             "walletcreatefundedpsbt",       walletcreatefundedpsbt,       {"inputs","outputs","locktime","options","bip32derivs"} },
     { "wallet",             "walletlock",                   walletlock,                   {} },
     { "wallet",             "walletpassphrase",             walletpassphrase,             {"passphrase","timeout"} },
     { "wallet",             "walletpassphrasechange",       walletpassphrasechange,       {"oldpassphrase","newpassphrase"} },
     { "wallet",             "walletprocesspsbt",            walletprocesspsbt,            {"psbt","sign","sighashtype","bip32derivs"} },
 };
 // clang-format on
 
 void RegisterWalletRPCCommands(
     interfaces::Chain &chain,
     std::vector<std::unique_ptr<interfaces::Handler>> &handlers) {
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         handlers.emplace_back(chain.handleRpc(commands[vcidx]));
     }
 }
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index c28b776e7..c82bcf8ff 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -1,504 +1,504 @@
 // Copyright (c) 2012-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 <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <interfaces/chain.h>
 #include <policy/policy.h>
 #include <rpc/server.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/rpcdump.h>
 #include <wallet/wallet.h>
 
 #include <test/util/setup_common.h>
 #include <wallet/test/wallet_test_fixture.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <univalue.h>
 
 #include <cstdint>
 #include <memory>
 #include <vector>
 
 BOOST_FIXTURE_TEST_SUITE(wallet_tests, WalletTestingSetup)
 
 static void AddKey(CWallet &wallet, const CKey &key) {
     LOCK(wallet.cs_wallet);
     wallet.AddKeyPubKey(key, key.GetPubKey());
 }
 
 BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup) {
     // Cap last block file size, and mine new block in a new block file.
     CBlockIndex *oldTip = ::ChainActive().Tip();
     GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE;
     CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
     CBlockIndex *newTip = ::ChainActive().Tip();
 
     auto chain = interfaces::MakeChain();
     auto locked_chain = chain->lock();
     LockAssertion lock(::cs_main);
 
     // Verify ScanForWalletTransactions accommodates a null start block.
     {
         CWallet wallet(Params(), chain.get(), WalletLocation(),
                        WalletDatabase::CreateDummy());
         AddKey(wallet, coinbaseKey);
         WalletRescanReserver reserver(&wallet);
         reserver.reserve();
         CWallet::ScanResult result = wallet.ScanForWalletTransactions(
             BlockHash(), BlockHash(), reserver, false /* update */);
         BOOST_CHECK_EQUAL(result.status, CWallet::ScanResult::SUCCESS);
         BOOST_CHECK(result.last_failed_block.IsNull());
         BOOST_CHECK(result.last_scanned_block.IsNull());
         BOOST_CHECK(!result.last_scanned_height);
         BOOST_CHECK_EQUAL(wallet.GetBalance().m_mine_immature, Amount::zero());
     }
 
     // Verify ScanForWalletTransactions picks up transactions in both the old
     // and new block files.
     {
         CWallet wallet(Params(), chain.get(), WalletLocation(),
                        WalletDatabase::CreateDummy());
         AddKey(wallet, coinbaseKey);
         WalletRescanReserver reserver(&wallet);
         reserver.reserve();
         CWallet::ScanResult result = wallet.ScanForWalletTransactions(
             oldTip->GetBlockHash(), BlockHash(), reserver, false /* update */);
         BOOST_CHECK_EQUAL(result.status, CWallet::ScanResult::SUCCESS);
         BOOST_CHECK(result.last_failed_block.IsNull());
         BOOST_CHECK_EQUAL(result.last_scanned_block, newTip->GetBlockHash());
         BOOST_CHECK_EQUAL(*result.last_scanned_height, newTip->nHeight);
         BOOST_CHECK_EQUAL(wallet.GetBalance().m_mine_immature, 100 * COIN);
     }
 
     // Prune the older block file.
     PruneOneBlockFile(oldTip->GetBlockPos().nFile);
     UnlinkPrunedFiles({oldTip->GetBlockPos().nFile});
 
     // Verify ScanForWalletTransactions only picks transactions in the new block
     // file.
     {
         CWallet wallet(Params(), chain.get(), WalletLocation(),
                        WalletDatabase::CreateDummy());
         AddKey(wallet, coinbaseKey);
         WalletRescanReserver reserver(&wallet);
         reserver.reserve();
         CWallet::ScanResult result = wallet.ScanForWalletTransactions(
             oldTip->GetBlockHash(), BlockHash(), reserver, false /* update */);
         BOOST_CHECK_EQUAL(result.status, CWallet::ScanResult::FAILURE);
         BOOST_CHECK_EQUAL(result.last_failed_block, oldTip->GetBlockHash());
         BOOST_CHECK_EQUAL(result.last_scanned_block, newTip->GetBlockHash());
         BOOST_CHECK_EQUAL(*result.last_scanned_height, newTip->nHeight);
         BOOST_CHECK_EQUAL(wallet.GetBalance().m_mine_immature, 50 * COIN);
     }
 
     // Prune the remaining block file.
     PruneOneBlockFile(newTip->GetBlockPos().nFile);
     UnlinkPrunedFiles({newTip->GetBlockPos().nFile});
 
     // Verify ScanForWalletTransactions scans no blocks.
     {
         CWallet wallet(Params(), chain.get(), WalletLocation(),
                        WalletDatabase::CreateDummy());
         AddKey(wallet, coinbaseKey);
         WalletRescanReserver reserver(&wallet);
         reserver.reserve();
         CWallet::ScanResult result = wallet.ScanForWalletTransactions(
             oldTip->GetBlockHash(), BlockHash(), reserver, false /* update */);
         BOOST_CHECK_EQUAL(result.status, CWallet::ScanResult::FAILURE);
         BOOST_CHECK_EQUAL(result.last_failed_block, newTip->GetBlockHash());
         BOOST_CHECK(result.last_scanned_block.IsNull());
         BOOST_CHECK(!result.last_scanned_height);
         BOOST_CHECK_EQUAL(wallet.GetBalance().m_mine_immature, Amount::zero());
     }
 }
 
 BOOST_FIXTURE_TEST_CASE(importmulti_rescan, TestChain100Setup) {
     // Cap last block file size, and mine new block in a new block file.
     CBlockIndex *oldTip = ::ChainActive().Tip();
     GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE;
     CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
     CBlockIndex *newTip = ::ChainActive().Tip();
 
     auto chain = interfaces::MakeChain();
     auto locked_chain = chain->lock();
     LockAssertion lock(::cs_main);
 
     // Prune the older block file.
     PruneOneBlockFile(oldTip->GetBlockPos().nFile);
     UnlinkPrunedFiles({oldTip->GetBlockPos().nFile});
 
     // Verify importmulti RPC returns failure for a key whose creation time is
     // before the missing block, and success for a key whose creation time is
     // after.
     {
         std::shared_ptr<CWallet> wallet =
             std::make_shared<CWallet>(Params(), chain.get(), WalletLocation(),
                                       WalletDatabase::CreateDummy());
         AddWallet(wallet);
         UniValue keys;
         keys.setArray();
         UniValue key;
         key.setObject();
         key.pushKV("scriptPubKey",
                    HexStr(GetScriptForRawPubKey(coinbaseKey.GetPubKey())));
         key.pushKV("timestamp", 0);
         key.pushKV("internal", UniValue(true));
         keys.push_back(key);
         key.clear();
         key.setObject();
         CKey futureKey;
         futureKey.MakeNewKey(true);
         key.pushKV("scriptPubKey",
                    HexStr(GetScriptForRawPubKey(futureKey.GetPubKey())));
         key.pushKV("timestamp",
                    newTip->GetBlockTimeMax() + TIMESTAMP_WINDOW + 1);
         key.pushKV("internal", UniValue(true));
         keys.push_back(key);
         JSONRPCRequest request;
         request.params.setArray();
         request.params.push_back(keys);
 
         UniValue response = importmulti(GetConfig(), request);
         BOOST_CHECK_EQUAL(
             response.write(),
             strprintf("[{\"success\":false,\"error\":{\"code\":-1,\"message\":"
                       "\"Rescan failed for key with creation timestamp %d. "
                       "There was an error reading a block from time %d, which "
                       "is after or within %d seconds of key creation, and "
                       "could contain transactions pertaining to the key. As a "
                       "result, transactions and coins using this key may not "
                       "appear in the wallet. This error could be caused by "
                       "pruning or data corruption (see bitcoind log for "
                       "details) and could be dealt with by downloading and "
                       "rescanning the relevant blocks (see -reindex and "
                       "-rescan options).\"}},{\"success\":true}]",
                       0, oldTip->GetBlockTimeMax(), TIMESTAMP_WINDOW));
         RemoveWallet(wallet);
     }
 }
 
 // Verify importwallet RPC starts rescan at earliest block with timestamp
 // greater or equal than key birthday. Previously there was a bug where
 // importwallet RPC would start the scan at the latest block with timestamp less
 // than or equal to key birthday.
 BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup) {
     // Create two blocks with same timestamp to verify that importwallet rescan
     // will pick up both blocks, not just the first.
     const int64_t BLOCK_TIME = ::ChainActive().Tip()->GetBlockTimeMax() + 5;
     SetMockTime(BLOCK_TIME);
     m_coinbase_txns.emplace_back(
         CreateAndProcessBlock({},
                               GetScriptForRawPubKey(coinbaseKey.GetPubKey()))
             .vtx[0]);
     m_coinbase_txns.emplace_back(
         CreateAndProcessBlock({},
                               GetScriptForRawPubKey(coinbaseKey.GetPubKey()))
             .vtx[0]);
 
     // Set key birthday to block time increased by the timestamp window, so
     // rescan will start at the block time.
     const int64_t KEY_TIME = BLOCK_TIME + TIMESTAMP_WINDOW;
     SetMockTime(KEY_TIME);
     m_coinbase_txns.emplace_back(
         CreateAndProcessBlock({},
                               GetScriptForRawPubKey(coinbaseKey.GetPubKey()))
             .vtx[0]);
 
     auto chain = interfaces::MakeChain();
     auto locked_chain = chain->lock();
     LockAssertion lock(::cs_main);
 
     std::string backup_file = (GetDataDir() / "wallet.backup").string();
 
     // Import key into wallet and call dumpwallet to create backup file.
     {
         std::shared_ptr<CWallet> wallet =
             std::make_shared<CWallet>(Params(), chain.get(), WalletLocation(),
                                       WalletDatabase::CreateDummy());
         LOCK(wallet->cs_wallet);
         wallet->mapKeyMetadata[coinbaseKey.GetPubKey().GetID()].nCreateTime =
             KEY_TIME;
         wallet->AddKeyPubKey(coinbaseKey, coinbaseKey.GetPubKey());
 
         JSONRPCRequest request;
         request.params.setArray();
         request.params.push_back(backup_file);
         AddWallet(wallet);
         ::dumpwallet(GetConfig(), request);
         RemoveWallet(wallet);
     }
 
     // Call importwallet RPC and verify all blocks with timestamps >= BLOCK_TIME
     // were scanned, and no prior blocks were scanned.
     {
         std::shared_ptr<CWallet> wallet =
             std::make_shared<CWallet>(Params(), chain.get(), WalletLocation(),
                                       WalletDatabase::CreateDummy());
 
         JSONRPCRequest request;
         request.params.setArray();
         request.params.push_back(backup_file);
         AddWallet(wallet);
         ::importwallet(GetConfig(), request);
         RemoveWallet(wallet);
 
         LOCK(wallet->cs_wallet);
         BOOST_CHECK_EQUAL(wallet->mapWallet.size(), 3U);
         BOOST_CHECK_EQUAL(m_coinbase_txns.size(), 103U);
         for (size_t i = 0; i < m_coinbase_txns.size(); ++i) {
             bool found = wallet->GetWalletTx(m_coinbase_txns[i]->GetId());
             bool expected = i >= 100;
             BOOST_CHECK_EQUAL(found, expected);
         }
     }
 }
 
 // Check that GetImmatureCredit() returns a newly calculated value instead of
 // the cached value after a MarkDirty() call.
 //
 // This is a regression test written to verify a bugfix for the immature credit
 // function. Similar tests probably should be written for the other credit and
 // debit functions.
 BOOST_FIXTURE_TEST_CASE(coin_mark_dirty_immature_credit, TestChain100Setup) {
     auto chain = interfaces::MakeChain();
     CWallet wallet(Params(), chain.get(), WalletLocation(),
                    WalletDatabase::CreateDummy());
     CWalletTx wtx(&wallet, m_coinbase_txns.back());
 
     auto locked_chain = chain->lock();
     LockAssertion lock(::cs_main);
     LOCK(wallet.cs_wallet);
 
     wtx.hashBlock = ::ChainActive().Tip()->GetBlockHash();
     wtx.nIndex = 0;
 
     // Call GetImmatureCredit() once before adding the key to the wallet to
     // cache the current immature credit amount, which is 0.
     BOOST_CHECK_EQUAL(wtx.GetImmatureCredit(*locked_chain), Amount::zero());
 
     // Invalidate the cached value, add the key, and make sure a new immature
     // credit amount is calculated.
     wtx.MarkDirty();
     wallet.AddKeyPubKey(coinbaseKey, coinbaseKey.GetPubKey());
     BOOST_CHECK_EQUAL(wtx.GetImmatureCredit(*locked_chain), 50 * COIN);
 }
 
 static int64_t AddTx(CWallet &wallet, uint32_t lockTime, int64_t mockTime,
                      int64_t blockTime) {
     CMutableTransaction tx;
     tx.nLockTime = lockTime;
     SetMockTime(mockTime);
     CBlockIndex *block = nullptr;
     if (blockTime > 0) {
         auto locked_chain = wallet.chain().lock();
         LockAssertion lock(::cs_main);
         auto inserted =
             mapBlockIndex.emplace(BlockHash(GetRandHash()), new CBlockIndex);
         assert(inserted.second);
         const BlockHash &hash = inserted.first->first;
         block = inserted.first->second;
         block->nTime = blockTime;
         block->phashBlock = &hash;
     }
 
     CWalletTx wtx(&wallet, MakeTransactionRef(tx));
     if (block) {
         wtx.SetMerkleBranch(block->GetBlockHash(), 0);
     }
     {
         LOCK(cs_main);
         wallet.AddToWallet(wtx);
     }
     LOCK(wallet.cs_wallet);
     return wallet.mapWallet.at(wtx.GetId()).nTimeSmart;
 }
 
 // Simple test to verify assignment of CWalletTx::nSmartTime value. Could be
 // expanded to cover more corner cases of smart time logic.
 BOOST_AUTO_TEST_CASE(ComputeTimeSmart) {
     // New transaction should use clock time if lower than block time.
     BOOST_CHECK_EQUAL(AddTx(m_wallet, 1, 100, 120), 100);
 
     // Test that updating existing transaction does not change smart time.
     BOOST_CHECK_EQUAL(AddTx(m_wallet, 1, 200, 220), 100);
 
     // New transaction should use clock time if there's no block time.
     BOOST_CHECK_EQUAL(AddTx(m_wallet, 2, 300, 0), 300);
 
     // New transaction should use block time if lower than clock time.
     BOOST_CHECK_EQUAL(AddTx(m_wallet, 3, 420, 400), 400);
 
     // New transaction should use latest entry time if higher than
     // min(block time, clock time).
     BOOST_CHECK_EQUAL(AddTx(m_wallet, 4, 500, 390), 400);
 
     // If there are future entries, new transaction should use time of the
     // newest entry that is no more than 300 seconds ahead of the clock time.
     BOOST_CHECK_EQUAL(AddTx(m_wallet, 5, 50, 600), 300);
 
     // Reset mock time for other tests.
     SetMockTime(0);
 }
 
 BOOST_AUTO_TEST_CASE(LoadReceiveRequests) {
-    CTxDestination dest = CKeyID();
+    CTxDestination dest = PKHash();
     LOCK(m_wallet.cs_wallet);
     m_wallet.AddDestData(dest, "misc", "val_misc");
     m_wallet.AddDestData(dest, "rr0", "val_rr0");
     m_wallet.AddDestData(dest, "rr1", "val_rr1");
 
     auto values = m_wallet.GetDestValues("rr");
     BOOST_CHECK_EQUAL(values.size(), 2U);
     BOOST_CHECK_EQUAL(values[0], "val_rr0");
     BOOST_CHECK_EQUAL(values[1], "val_rr1");
 }
 
 class ListCoinsTestingSetup : public TestChain100Setup {
 public:
     ListCoinsTestingSetup() {
         CreateAndProcessBlock({},
                               GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
         wallet =
             std::make_unique<CWallet>(Params(), m_chain.get(), WalletLocation(),
                                       WalletDatabase::CreateMock());
         bool firstRun;
         wallet->LoadWallet(firstRun);
         AddKey(*wallet, coinbaseKey);
         WalletRescanReserver reserver(wallet.get());
         reserver.reserve();
         CWallet::ScanResult result = wallet->ScanForWalletTransactions(
             ::ChainActive().Genesis()->GetBlockHash(), BlockHash(), reserver,
             false /* update */);
         BOOST_CHECK_EQUAL(result.status, CWallet::ScanResult::SUCCESS);
         BOOST_CHECK_EQUAL(result.last_scanned_block,
                           ::ChainActive().Tip()->GetBlockHash());
         BOOST_CHECK_EQUAL(*result.last_scanned_height,
                           ::ChainActive().Height());
         BOOST_CHECK(result.last_failed_block.IsNull());
     }
 
     ~ListCoinsTestingSetup() { wallet.reset(); }
 
     CWalletTx &AddTx(CRecipient recipient) {
         CTransactionRef tx;
         CReserveKey reservekey(wallet.get());
         Amount fee;
         int changePos = -1;
         std::string error;
         CCoinControl dummy;
         {
             auto locked_chain = m_chain->lock();
             BOOST_CHECK(wallet->CreateTransaction(*locked_chain, {recipient},
                                                   tx, reservekey, fee,
                                                   changePos, error, dummy));
         }
         CValidationState state;
         BOOST_CHECK(wallet->CommitTransaction(tx, {}, {}, reservekey, state));
         CMutableTransaction blocktx;
         {
             LOCK(wallet->cs_wallet);
             blocktx =
                 CMutableTransaction(*wallet->mapWallet.at(tx->GetId()).tx);
         }
         CreateAndProcessBlock({CMutableTransaction(blocktx)},
                               GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
 
         LOCK(cs_main);
         LOCK(wallet->cs_wallet);
         auto it = wallet->mapWallet.find(tx->GetId());
         BOOST_CHECK(it != wallet->mapWallet.end());
         it->second.SetMerkleBranch(::ChainActive().Tip()->GetBlockHash(), 1);
         return it->second;
     }
 
     std::unique_ptr<interfaces::Chain> m_chain = interfaces::MakeChain();
     std::unique_ptr<CWallet> wallet;
 };
 
 BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup) {
     std::string coinbaseAddress = coinbaseKey.GetPubKey().GetID().ToString();
 
     // Confirm ListCoins initially returns 1 coin grouped under coinbaseKey
     // address.
     std::map<CTxDestination, std::vector<COutput>> list;
     {
         auto locked_chain = m_chain->lock();
         LOCK(wallet->cs_wallet);
         list = wallet->ListCoins(*locked_chain);
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
-    BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(),
+    BOOST_CHECK_EQUAL(boost::get<PKHash>(list.begin()->first).ToString(),
                       coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 1U);
 
     // Check initial balance from one mature coinbase transaction.
     BOOST_CHECK_EQUAL(50 * COIN, wallet->GetAvailableBalance());
 
     // Add a transaction creating a change address, and confirm ListCoins still
     // returns the coin associated with the change address underneath the
     // coinbaseKey pubkey, even though the change address has a different
     // pubkey.
     AddTx(CRecipient{GetScriptForRawPubKey({}), 1 * COIN,
                      false /* subtract fee */});
     {
         auto locked_chain = m_chain->lock();
         LOCK(wallet->cs_wallet);
         list = wallet->ListCoins(*locked_chain);
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
-    BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(),
+    BOOST_CHECK_EQUAL(boost::get<PKHash>(list.begin()->first).ToString(),
                       coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 2U);
 
     // Lock both coins. Confirm number of available coins drops to 0.
     {
         auto locked_chain = m_chain->lock();
         LOCK(wallet->cs_wallet);
         std::vector<COutput> available;
         wallet->AvailableCoins(*locked_chain, available);
         BOOST_CHECK_EQUAL(available.size(), 2U);
     }
     for (const auto &group : list) {
         for (const auto &coin : group.second) {
             LOCK(wallet->cs_wallet);
             wallet->LockCoin(COutPoint(coin.tx->GetId(), coin.i));
         }
     }
     {
         auto locked_chain = m_chain->lock();
         LOCK(wallet->cs_wallet);
         std::vector<COutput> available;
         wallet->AvailableCoins(*locked_chain, available);
         BOOST_CHECK_EQUAL(available.size(), 0U);
     }
     // Confirm ListCoins still returns same result as before, despite coins
     // being locked.
     {
         auto locked_chain = m_chain->lock();
         LOCK(wallet->cs_wallet);
         list = wallet->ListCoins(*locked_chain);
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
-    BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(),
+    BOOST_CHECK_EQUAL(boost::get<PKHash>(list.begin()->first).ToString(),
                       coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 2U);
 }
 
 BOOST_FIXTURE_TEST_CASE(wallet_disableprivkeys, TestChain100Setup) {
     auto chain = interfaces::MakeChain();
     std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(
         Params(), chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
     wallet->SetMinVersion(FEATURE_LATEST);
     wallet->SetWalletFlag(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
     BOOST_CHECK(!wallet->TopUpKeyPool(1000));
     CPubKey pubkey;
     BOOST_CHECK(!wallet->GetKeyFromPool(pubkey, false));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/test/walletdb_tests.cpp b/src/wallet/test/walletdb_tests.cpp
index 75f23602b..ead9cc1c5 100644
--- a/src/wallet/test/walletdb_tests.cpp
+++ b/src/wallet/test/walletdb_tests.cpp
@@ -1,129 +1,129 @@
 // 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 <wallet/walletdb.h>
 
 #include <chainparams.h>
 #include <interfaces/chain.h>
 #include <wallet/wallet.h>
 
 #include <test/util/setup_common.h>
 #include <wallet/test/wallet_test_fixture.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <memory>
 
 namespace {
 static std::unique_ptr<CWallet> LoadWallet(WalletBatch &batch) {
     auto chain = interfaces::MakeChain();
     std::unique_ptr<CWallet> wallet = std::make_unique<CWallet>(
         Params(), chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
     DBErrors res = batch.LoadWallet(wallet.get());
     BOOST_CHECK(res == DBErrors::LOAD_OK);
     return wallet;
 }
 } // namespace
 
 BOOST_FIXTURE_TEST_SUITE(walletdb_tests, WalletTestingSetup)
 
 BOOST_AUTO_TEST_CASE(write_erase_name) {
     WalletBatch batch(m_wallet.GetDBHandle(), "cr+");
 
-    CTxDestination dst1 = CKeyID(uint160S("c0ffee"));
-    CTxDestination dst2 = CKeyID(uint160S("f00d"));
+    CTxDestination dst1 = PKHash(uint160S("c0ffee"));
+    CTxDestination dst2 = PKHash(uint160S("f00d"));
 
     BOOST_CHECK(batch.WriteName(dst1, "name1"));
     BOOST_CHECK(batch.WriteName(dst2, "name2"));
     {
         auto w = LoadWallet(batch);
         LOCK(w->cs_wallet);
         BOOST_CHECK_EQUAL(1, w->mapAddressBook.count(dst1));
         BOOST_CHECK_EQUAL("name1", w->mapAddressBook[dst1].name);
         BOOST_CHECK_EQUAL("name2", w->mapAddressBook[dst2].name);
     }
 
     batch.EraseName(dst1);
 
     {
         auto w = LoadWallet(batch);
         LOCK(w->cs_wallet);
         BOOST_CHECK_EQUAL(0, w->mapAddressBook.count(dst1));
         BOOST_CHECK_EQUAL(1, w->mapAddressBook.count(dst2));
     }
 }
 
 BOOST_AUTO_TEST_CASE(write_erase_purpose) {
     WalletBatch batch(m_wallet.GetDBHandle(), "cr+");
 
-    CTxDestination dst1 = CKeyID(uint160S("c0ffee"));
-    CTxDestination dst2 = CKeyID(uint160S("f00d"));
+    CTxDestination dst1 = PKHash(uint160S("c0ffee"));
+    CTxDestination dst2 = PKHash(uint160S("f00d"));
 
     BOOST_CHECK(batch.WritePurpose(dst1, "purpose1"));
     BOOST_CHECK(batch.WritePurpose(dst2, "purpose2"));
     {
         auto w = LoadWallet(batch);
         LOCK(w->cs_wallet);
         BOOST_CHECK_EQUAL(1, w->mapAddressBook.count(dst1));
         BOOST_CHECK_EQUAL("purpose1", w->mapAddressBook[dst1].purpose);
         BOOST_CHECK_EQUAL("purpose2", w->mapAddressBook[dst2].purpose);
     }
 
     batch.ErasePurpose(dst1);
 
     {
         auto w = LoadWallet(batch);
         LOCK(w->cs_wallet);
         BOOST_CHECK_EQUAL(0, w->mapAddressBook.count(dst1));
         BOOST_CHECK_EQUAL(1, w->mapAddressBook.count(dst2));
     }
 }
 
 BOOST_AUTO_TEST_CASE(write_erase_destdata) {
     WalletBatch batch(m_wallet.GetDBHandle(), "cr+");
 
-    CTxDestination dst1 = CKeyID(uint160S("c0ffee"));
-    CTxDestination dst2 = CKeyID(uint160S("f00d"));
+    CTxDestination dst1 = PKHash(uint160S("c0ffee"));
+    CTxDestination dst2 = PKHash(uint160S("f00d"));
 
     BOOST_CHECK(batch.WriteDestData(dst1, "key1", "value1"));
     BOOST_CHECK(batch.WriteDestData(dst1, "key2", "value2"));
     BOOST_CHECK(batch.WriteDestData(dst2, "key1", "value3"));
     BOOST_CHECK(batch.WriteDestData(dst2, "key2", "value4"));
     {
         auto w = LoadWallet(batch);
         LOCK(w->cs_wallet);
         std::string val;
         BOOST_CHECK(w->GetDestData(dst1, "key1", &val));
         BOOST_CHECK_EQUAL("value1", val);
         BOOST_CHECK(w->GetDestData(dst1, "key2", &val));
         BOOST_CHECK_EQUAL("value2", val);
         BOOST_CHECK(w->GetDestData(dst2, "key1", &val));
         BOOST_CHECK_EQUAL("value3", val);
         BOOST_CHECK(w->GetDestData(dst2, "key2", &val));
         BOOST_CHECK_EQUAL("value4", val);
     }
 
     batch.EraseDestData(dst1, "key2");
 
     {
         auto w = LoadWallet(batch);
         LOCK(w->cs_wallet);
         std::string dummy;
         BOOST_CHECK(w->GetDestData(dst1, "key1", &dummy));
         BOOST_CHECK(!w->GetDestData(dst1, "key2", &dummy));
         BOOST_CHECK(w->GetDestData(dst2, "key1", &dummy));
         BOOST_CHECK(w->GetDestData(dst2, "key2", &dummy));
     }
 }
 
 BOOST_AUTO_TEST_CASE(no_dest_fails) {
     WalletBatch batch(m_wallet.GetDBHandle(), "cr+");
 
     CTxDestination dst = CNoDestination{};
     BOOST_CHECK(!batch.WriteName(dst, "name"));
     BOOST_CHECK(!batch.WritePurpose(dst, "purpose"));
     BOOST_CHECK(!batch.WriteDestData(dst, "key", "value"));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 6781dcc03..10684dae3 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -1,5084 +1,5084 @@
 // Copyright (c) 2009-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 <wallet/wallet.h>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <checkpoints.h>
 #include <config.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
 #include <fs.h>
 #include <interfaces/chain.h>
 #include <interfaces/wallet.h>
 #include <key.h>
 #include <key_io.h>
 #include <keystore.h>
 #include <policy/mempool.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/sighashtype.h>
 #include <script/sign.h>
 #include <ui_interface.h>
 #include <util/bip32.h>
 #include <util/error.h>
 #include <util/moneystr.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <util/validation.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/coinselection.h>
 #include <wallet/fees.h>
 
 #include <boost/algorithm/string/replace.hpp>
 
 #include <algorithm>
 #include <cassert>
 #include <future>
 
 const std::map<uint64_t, std::string> WALLET_FLAG_CAVEATS{
     {WALLET_FLAG_AVOID_REUSE,
      "You need to rescan the blockchain in order to correctly mark used "
      "destinations in the past. Until this is done, some destinations may "
      "be considered unused, even if the opposite is the case."},
 };
 
 static RecursiveMutex cs_wallets;
 static std::vector<std::shared_ptr<CWallet>> vpwallets GUARDED_BY(cs_wallets);
 
 bool AddWallet(const std::shared_ptr<CWallet> &wallet) {
     LOCK(cs_wallets);
     assert(wallet);
     std::vector<std::shared_ptr<CWallet>>::const_iterator i =
         std::find(vpwallets.begin(), vpwallets.end(), wallet);
     if (i != vpwallets.end()) {
         return false;
     }
     vpwallets.push_back(wallet);
     return true;
 }
 
 bool RemoveWallet(const std::shared_ptr<CWallet> &wallet) {
     LOCK(cs_wallets);
     assert(wallet);
     std::vector<std::shared_ptr<CWallet>>::iterator i =
         std::find(vpwallets.begin(), vpwallets.end(), wallet);
     if (i == vpwallets.end()) {
         return false;
     }
     vpwallets.erase(i);
     return true;
 }
 
 bool HasWallets() {
     LOCK(cs_wallets);
     return !vpwallets.empty();
 }
 
 std::vector<std::shared_ptr<CWallet>> GetWallets() {
     LOCK(cs_wallets);
     return vpwallets;
 }
 
 std::shared_ptr<CWallet> GetWallet(const std::string &name) {
     LOCK(cs_wallets);
     for (const std::shared_ptr<CWallet> &wallet : vpwallets) {
         if (wallet->GetName() == name) {
             return wallet;
         }
     }
     return nullptr;
 }
 
 static Mutex g_wallet_release_mutex;
 static std::condition_variable g_wallet_release_cv;
 static std::set<std::string> g_unloading_wallet_set;
 
 // Custom deleter for shared_ptr<CWallet>.
 static void ReleaseWallet(CWallet *wallet) {
     // Unregister and delete the wallet right after
     // BlockUntilSyncedToCurrentChain so that it's in sync with the current
     // chainstate.
     const std::string name = wallet->GetName();
     wallet->WalletLogPrintf("Releasing wallet\n");
     wallet->BlockUntilSyncedToCurrentChain();
     wallet->Flush();
     wallet->m_chain_notifications_handler.reset();
     delete wallet;
     // Wallet is now released, notify UnloadWallet, if any.
     {
         LOCK(g_wallet_release_mutex);
         if (g_unloading_wallet_set.erase(name) == 0) {
             // UnloadWallet was not called for this wallet, all done.
             return;
         }
     }
     g_wallet_release_cv.notify_all();
 }
 
 void UnloadWallet(std::shared_ptr<CWallet> &&wallet) {
     // Mark wallet for unloading.
     const std::string name = wallet->GetName();
     {
         LOCK(g_wallet_release_mutex);
         auto it = g_unloading_wallet_set.insert(name);
         assert(it.second);
     }
     // The wallet can be in use so it's not possible to explicitly unload here.
     // Notify the unload intent so that all remaining shared pointers are
     // released.
     wallet->NotifyUnload();
     // Time to ditch our shared_ptr and wait for ReleaseWallet call.
     wallet.reset();
     {
         WAIT_LOCK(g_wallet_release_mutex, lock);
         while (g_unloading_wallet_set.count(name) == 1) {
             g_wallet_release_cv.wait(lock);
         }
     }
 }
 
 static const size_t OUTPUT_GROUP_MAX_ENTRIES = 10;
 
 std::shared_ptr<CWallet> LoadWallet(const CChainParams &chainParams,
                                     interfaces::Chain &chain,
                                     const WalletLocation &location,
                                     std::string &error, std::string &warning) {
     if (!CWallet::Verify(chainParams, chain, location, false, error, warning)) {
         error = "Wallet file verification failed: " + error;
         return nullptr;
     }
 
     std::shared_ptr<CWallet> wallet =
         CWallet::CreateWalletFromFile(chainParams, chain, location);
     if (!wallet) {
         error = "Wallet loading failed.";
         return nullptr;
     }
     AddWallet(wallet);
     wallet->postInitProcess();
     return wallet;
 }
 
 std::shared_ptr<CWallet> LoadWallet(const CChainParams &chainParams,
                                     interfaces::Chain &chain,
                                     const std::string &name, std::string &error,
                                     std::string &warning) {
     return LoadWallet(chainParams, chain, WalletLocation(name), error, warning);
 }
 
 const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000;
 
 const BlockHash CMerkleTx::ABANDON_HASH(uint256S(
     "0000000000000000000000000000000000000000000000000000000000000001"));
 
 /** @defgroup mapWallet
  *
  * @{
  */
 
 std::string COutput::ToString() const {
     return strprintf("COutput(%s, %d, %d) [%s]", tx->GetId().ToString(), i,
                      nDepth, FormatMoney(tx->tx->vout[i].nValue));
 }
 
 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;
 }
 
 const CWalletTx *CWallet::GetWalletTx(const TxId &txid) const {
     LOCK(cs_wallet);
     std::map<TxId, CWalletTx>::const_iterator it = mapWallet.find(txid);
     if (it == mapWallet.end()) {
         return nullptr;
     }
 
     return &(it->second);
 }
 
 CPubKey CWallet::GenerateNewKey(WalletBatch &batch, bool internal) {
     assert(!IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
     assert(!IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET));
     // mapKeyMetadata
     AssertLockHeld(cs_wallet);
     // default to compressed public keys if we want 0.6.0 wallets
     bool fCompressed = 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,
             (CanSupportFeature(FEATURE_HD_SPLIT) ? internal : false));
     } else {
         secret.MakeNewKey(fCompressed);
     }
 
     // Compressed public keys were introduced in version 0.6.0
     if (fCompressed) {
         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;
 }
 
 void CWallet::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 ? 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.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.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");
     }
 }
 
 bool CWallet::AddKeyPubKeyWithDB(WalletBatch &batch, const CKey &secret,
                                  const CPubKey &pubkey) {
     // mapKeyMetadata
     AssertLockHeld(cs_wallet);
 
     // Make sure we aren't adding private keys to private key disabled wallets
     assert(!IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
 
     // CCryptoKeyStore 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 (!CCryptoKeyStore::AddKeyPubKey(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(pubkey.GetID());
+    script = GetScriptForDestination(PKHash(pubkey));
     if (HaveWatchOnly(script)) {
         RemoveWatchOnly(script);
     }
 
     script = GetScriptForRawPubKey(pubkey);
     if (HaveWatchOnly(script)) {
         RemoveWatchOnly(script);
     }
 
     if (!IsCrypted()) {
         return batch.WriteKey(pubkey, secret.GetPrivKey(),
                               mapKeyMetadata[pubkey.GetID()]);
     }
 
     UnsetWalletFlagWithDB(batch, WALLET_FLAG_BLANK_WALLET);
     return true;
 }
 
 bool CWallet::AddKeyPubKey(const CKey &secret, const CPubKey &pubkey) {
     WalletBatch batch(*database);
     return CWallet::AddKeyPubKeyWithDB(batch, secret, pubkey);
 }
 
 bool CWallet::AddCryptedKey(const CPubKey &vchPubKey,
                             const std::vector<uint8_t> &vchCryptedSecret) {
     if (!CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret)) {
         return false;
     }
 
     LOCK(cs_wallet);
     if (encrypted_batch) {
         return encrypted_batch->WriteCryptedKey(
             vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]);
     }
 
     return WalletBatch(*database).WriteCryptedKey(
         vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]);
 }
 
 void CWallet::LoadKeyMetadata(const CKeyID &keyID, const CKeyMetadata &meta) {
     // mapKeyMetadata
     AssertLockHeld(cs_wallet);
     UpdateTimeFirstKey(meta.nCreateTime);
     mapKeyMetadata[keyID] = meta;
 }
 
 void CWallet::LoadScriptMetadata(const CScriptID &script_id,
                                  const CKeyMetadata &meta) {
     // m_script_metadata
     AssertLockHeld(cs_wallet);
     UpdateTimeFirstKey(meta.nCreateTime);
     m_script_metadata[script_id] = meta;
 }
 
 void CWallet::UpgradeKeyMetadata() {
     // mapKeyMetadata
     AssertLockHeld(cs_wallet);
     if (IsLocked() || IsWalletFlagSet(WALLET_FLAG_KEY_ORIGIN_METADATA)) {
         return;
     }
 
     auto batch = std::make_unique<WalletBatch>(*database);
     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);
             }
         }
     }
 
     // write before setting the flag
     batch.reset();
     SetWalletFlag(WALLET_FLAG_KEY_ORIGIN_METADATA);
 }
 
 bool CWallet::LoadCryptedKey(const CPubKey &vchPubKey,
                              const std::vector<uint8_t> &vchCryptedSecret) {
     return CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret);
 }
 
 /**
  * Update wallet first key creation time. This should be called whenever keys
  * are added to the wallet, with the oldest key creation time.
  */
 void CWallet::UpdateTimeFirstKey(int64_t nCreateTime) {
     AssertLockHeld(cs_wallet);
     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 CWallet::AddCScript(const CScript &redeemScript) {
     WalletBatch batch(*database);
     return AddCScriptWithDB(batch, redeemScript);
 }
 
 bool CWallet::AddCScriptWithDB(WalletBatch &batch,
                                const CScript &redeemScript) {
     if (!CCryptoKeyStore::AddCScript(redeemScript)) {
         return false;
     }
     if (batch.WriteCScript(Hash160(redeemScript), redeemScript)) {
         UnsetWalletFlagWithDB(batch, WALLET_FLAG_BLANK_WALLET);
         return true;
     }
     return false;
 }
 
 bool CWallet::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(CScriptID(redeemScript), GetConfig());
+            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 CCryptoKeyStore::AddCScript(redeemScript);
 }
 
 bool CWallet::AddWatchOnlyWithDB(WalletBatch &batch, const CScript &dest) {
     if (!CCryptoKeyStore::AddWatchOnly(dest)) {
         return false;
     }
 
     const CKeyMetadata &meta = m_script_metadata[CScriptID(dest)];
     UpdateTimeFirstKey(meta.nCreateTime);
     NotifyWatchonlyChanged(true);
     if (batch.WriteWatchOnly(dest, meta)) {
         UnsetWalletFlagWithDB(batch, WALLET_FLAG_BLANK_WALLET);
         return true;
     }
     return false;
 }
 
 bool CWallet::AddWatchOnlyWithDB(WalletBatch &batch, const CScript &dest,
                                  int64_t create_time) {
     m_script_metadata[CScriptID(dest)].nCreateTime = create_time;
     return AddWatchOnlyWithDB(batch, dest);
 }
 
 bool CWallet::AddWatchOnly(const CScript &dest) {
     WalletBatch batch(*database);
     return AddWatchOnlyWithDB(batch, dest);
 }
 
 bool CWallet::AddWatchOnly(const CScript &dest, int64_t nCreateTime) {
     m_script_metadata[CScriptID(dest)].nCreateTime = nCreateTime;
     return AddWatchOnly(dest);
 }
 
 bool CWallet::RemoveWatchOnly(const CScript &dest) {
     AssertLockHeld(cs_wallet);
     if (!CCryptoKeyStore::RemoveWatchOnly(dest)) {
         return false;
     }
 
     if (!HaveWatchOnly()) {
         NotifyWatchonlyChanged(false);
     }
 
     return WalletBatch(*database).EraseWatchOnly(dest);
 }
 
 bool CWallet::LoadWatchOnly(const CScript &dest) {
     return CCryptoKeyStore::AddWatchOnly(dest);
 }
 
 bool CWallet::Unlock(const SecureString &strWalletPassphrase,
                      bool accept_no_keys) {
     CCrypter crypter;
     CKeyingMaterial _vMasterKey;
 
     {
         LOCK(cs_wallet);
         for (const MasterKeyMap::value_type &pMasterKey : mapMasterKeys) {
             if (!crypter.SetKeyFromPassphrase(
                     strWalletPassphrase, pMasterKey.second.vchSalt,
                     pMasterKey.second.nDeriveIterations,
                     pMasterKey.second.nDerivationMethod)) {
                 return false;
             }
             if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey,
                                  _vMasterKey)) {
                 // try another master key
                 continue;
             }
             if (CCryptoKeyStore::Unlock(_vMasterKey, accept_no_keys)) {
                 // Now that we've unlocked, upgrade the key metadata
                 UpgradeKeyMetadata();
                 return true;
             }
         }
     }
 
     return false;
 }
 
 bool CWallet::ChangeWalletPassphrase(
     const SecureString &strOldWalletPassphrase,
     const SecureString &strNewWalletPassphrase) {
     bool fWasLocked = IsLocked();
 
     LOCK(cs_wallet);
     Lock();
 
     CCrypter crypter;
     CKeyingMaterial _vMasterKey;
     for (MasterKeyMap::value_type &pMasterKey : mapMasterKeys) {
         if (!crypter.SetKeyFromPassphrase(
                 strOldWalletPassphrase, pMasterKey.second.vchSalt,
                 pMasterKey.second.nDeriveIterations,
                 pMasterKey.second.nDerivationMethod)) {
             return false;
         }
 
         if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, _vMasterKey)) {
             return false;
         }
 
         if (CCryptoKeyStore::Unlock(_vMasterKey)) {
             int64_t nStartTime = GetTimeMillis();
             crypter.SetKeyFromPassphrase(strNewWalletPassphrase,
                                          pMasterKey.second.vchSalt,
                                          pMasterKey.second.nDeriveIterations,
                                          pMasterKey.second.nDerivationMethod);
             pMasterKey.second.nDeriveIterations = static_cast<unsigned int>(
                 pMasterKey.second.nDeriveIterations *
                 (100 / ((double)(GetTimeMillis() - nStartTime))));
 
             nStartTime = GetTimeMillis();
             crypter.SetKeyFromPassphrase(strNewWalletPassphrase,
                                          pMasterKey.second.vchSalt,
                                          pMasterKey.second.nDeriveIterations,
                                          pMasterKey.second.nDerivationMethod);
             pMasterKey.second.nDeriveIterations =
                 (pMasterKey.second.nDeriveIterations +
                  static_cast<unsigned int>(
                      pMasterKey.second.nDeriveIterations * 100 /
                      double(GetTimeMillis() - nStartTime))) /
                 2;
 
             if (pMasterKey.second.nDeriveIterations < 25000) {
                 pMasterKey.second.nDeriveIterations = 25000;
             }
 
             WalletLogPrintf(
                 "Wallet passphrase changed to an nDeriveIterations of %i\n",
                 pMasterKey.second.nDeriveIterations);
 
             if (!crypter.SetKeyFromPassphrase(
                     strNewWalletPassphrase, pMasterKey.second.vchSalt,
                     pMasterKey.second.nDeriveIterations,
                     pMasterKey.second.nDerivationMethod)) {
                 return false;
             }
 
             if (!crypter.Encrypt(_vMasterKey,
                                  pMasterKey.second.vchCryptedKey)) {
                 return false;
             }
 
             WalletBatch(*database).WriteMasterKey(pMasterKey.first,
                                                   pMasterKey.second);
             if (fWasLocked) {
                 Lock();
             }
 
             return true;
         }
     }
 
     return false;
 }
 
 void CWallet::ChainStateFlushed(const CBlockLocator &loc) {
     WalletBatch batch(*database);
     batch.WriteBestBlock(loc);
 }
 
 void CWallet::SetMinVersion(enum WalletFeature nVersion, WalletBatch *batch_in,
                             bool fExplicit) {
     // nWalletVersion
     LOCK(cs_wallet);
     if (nWalletVersion >= nVersion) {
         return;
     }
 
     // When doing an explicit upgrade, if we pass the max version permitted,
     // upgrade all the way.
     if (fExplicit && nVersion > nWalletMaxVersion) {
         nVersion = FEATURE_LATEST;
     }
 
     nWalletVersion = nVersion;
 
     if (nVersion > nWalletMaxVersion) {
         nWalletMaxVersion = nVersion;
     }
 
     WalletBatch *batch = batch_in ? batch_in : new WalletBatch(*database);
     if (nWalletVersion > 40000) {
         batch->WriteMinVersion(nWalletVersion);
     }
     if (!batch_in) {
         delete batch;
     }
 }
 
 bool CWallet::SetMaxVersion(int nVersion) {
     // nWalletVersion, nWalletMaxVersion
     LOCK(cs_wallet);
 
     // Cannot downgrade below current version
     if (nWalletVersion > nVersion) {
         return false;
     }
 
     nWalletMaxVersion = nVersion;
 
     return true;
 }
 
 std::set<TxId> CWallet::GetConflicts(const TxId &txid) const {
     std::set<TxId> result;
     AssertLockHeld(cs_wallet);
 
     std::map<TxId, CWalletTx>::const_iterator it = mapWallet.find(txid);
     if (it == mapWallet.end()) {
         return result;
     }
 
     const CWalletTx &wtx = it->second;
 
     std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
 
     for (const CTxIn &txin : wtx.tx->vin) {
         if (mapTxSpends.count(txin.prevout) <= 1) {
             // No conflict if zero or one spends.
             continue;
         }
 
         range = mapTxSpends.equal_range(txin.prevout);
         for (TxSpends::const_iterator _it = range.first; _it != range.second;
              ++_it) {
             result.insert(_it->second);
         }
     }
 
     return result;
 }
 
 bool CWallet::HasWalletSpend(const TxId &txid) const {
     AssertLockHeld(cs_wallet);
     auto iter = mapTxSpends.lower_bound(COutPoint(txid, 0));
     return (iter != mapTxSpends.end() && iter->first.GetTxId() == txid);
 }
 
 void CWallet::Flush(bool shutdown) {
     database->Flush(shutdown);
 }
 
 void CWallet::SyncMetaData(
     std::pair<TxSpends::iterator, TxSpends::iterator> range) {
     // We want all the wallet transactions in range to have the same metadata as
     // the oldest (smallest nOrderPos).
     // So: find smallest nOrderPos:
 
     int nMinOrderPos = std::numeric_limits<int>::max();
     const CWalletTx *copyFrom = nullptr;
     for (TxSpends::iterator it = range.first; it != range.second; ++it) {
         const CWalletTx *wtx = &mapWallet.at(it->second);
         if (wtx->nOrderPos < nMinOrderPos) {
             nMinOrderPos = wtx->nOrderPos;
             copyFrom = wtx;
         }
     }
 
     if (!copyFrom) {
         return;
     }
 
     // Now copy data from copyFrom to rest:
     for (TxSpends::iterator it = range.first; it != range.second; ++it) {
         const TxId &txid = it->second;
         CWalletTx *copyTo = &mapWallet.at(txid);
         if (copyFrom == copyTo) {
             continue;
         }
 
         assert(
             copyFrom &&
             "Oldest wallet transaction in range assumed to have been found.");
 
         if (!copyFrom->IsEquivalentTo(*copyTo)) {
             continue;
         }
 
         copyTo->mapValue = copyFrom->mapValue;
         copyTo->vOrderForm = copyFrom->vOrderForm;
         // fTimeReceivedIsTxTime not copied on purpose nTimeReceived not copied
         // on purpose.
         copyTo->nTimeSmart = copyFrom->nTimeSmart;
         copyTo->fFromMe = copyFrom->fFromMe;
         // nOrderPos not copied on purpose cached members not copied on purpose.
     }
 }
 
 /**
  * Outpoint is spent if any non-conflicted transaction, spends it:
  */
 bool CWallet::IsSpent(interfaces::Chain::Lock &locked_chain,
                       const COutPoint &outpoint) const {
     std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range =
         mapTxSpends.equal_range(outpoint);
 
     for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
         const TxId &wtxid = it->second;
         std::map<TxId, CWalletTx>::const_iterator mit = mapWallet.find(wtxid);
         if (mit != mapWallet.end()) {
             int depth = mit->second.GetDepthInMainChain(locked_chain);
             if (depth > 0 || (depth == 0 && !mit->second.isAbandoned())) {
                 // Spent
                 return true;
             }
         }
     }
 
     return false;
 }
 
 void CWallet::AddToSpends(const COutPoint &outpoint, const TxId &wtxid) {
     mapTxSpends.insert(std::make_pair(outpoint, wtxid));
 
     setLockedCoins.erase(outpoint);
 
     std::pair<TxSpends::iterator, TxSpends::iterator> range;
     range = mapTxSpends.equal_range(outpoint);
     SyncMetaData(range);
 }
 
 void CWallet::AddToSpends(const TxId &wtxid) {
     auto it = mapWallet.find(wtxid);
     assert(it != mapWallet.end());
     CWalletTx &thisTx = it->second;
     // Coinbases don't spend anything!
     if (thisTx.IsCoinBase()) {
         return;
     }
 
     for (const CTxIn &txin : thisTx.tx->vin) {
         AddToSpends(txin.prevout, wtxid);
     }
 }
 
 bool CWallet::EncryptWallet(const SecureString &strWalletPassphrase) {
     if (IsCrypted()) {
         return false;
     }
 
     CKeyingMaterial _vMasterKey;
 
     _vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
     GetStrongRandBytes(&_vMasterKey[0], WALLET_CRYPTO_KEY_SIZE);
 
     CMasterKey kMasterKey;
 
     kMasterKey.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
     GetStrongRandBytes(&kMasterKey.vchSalt[0], WALLET_CRYPTO_SALT_SIZE);
 
     CCrypter crypter;
     int64_t nStartTime = GetTimeMillis();
     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000,
                                  kMasterKey.nDerivationMethod);
     kMasterKey.nDeriveIterations = static_cast<unsigned int>(
         2500000 / double(GetTimeMillis() - nStartTime));
 
     nStartTime = GetTimeMillis();
     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt,
                                  kMasterKey.nDeriveIterations,
                                  kMasterKey.nDerivationMethod);
     kMasterKey.nDeriveIterations =
         (kMasterKey.nDeriveIterations +
          static_cast<unsigned int>(kMasterKey.nDeriveIterations * 100 /
                                    double(GetTimeMillis() - nStartTime))) /
         2;
 
     if (kMasterKey.nDeriveIterations < 25000) {
         kMasterKey.nDeriveIterations = 25000;
     }
 
     WalletLogPrintf("Encrypting Wallet with an nDeriveIterations of %i\n",
                     kMasterKey.nDeriveIterations);
 
     if (!crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt,
                                       kMasterKey.nDeriveIterations,
                                       kMasterKey.nDerivationMethod)) {
         return false;
     }
 
     if (!crypter.Encrypt(_vMasterKey, kMasterKey.vchCryptedKey)) {
         return false;
     }
 
     {
         LOCK(cs_wallet);
         mapMasterKeys[++nMasterKeyMaxID] = kMasterKey;
         assert(!encrypted_batch);
         encrypted_batch = new WalletBatch(*database);
         if (!encrypted_batch->TxnBegin()) {
             delete encrypted_batch;
             encrypted_batch = nullptr;
             return false;
         }
         encrypted_batch->WriteMasterKey(nMasterKeyMaxID, kMasterKey);
 
         if (!EncryptKeys(_vMasterKey)) {
             encrypted_batch->TxnAbort();
             delete encrypted_batch;
             // We now probably have half of our keys encrypted in memory, and
             // half not... die and let the user reload the unencrypted wallet.
             assert(false);
         }
 
         // Encryption was introduced in version 0.4.0
         SetMinVersion(FEATURE_WALLETCRYPT, encrypted_batch, true);
 
         if (!encrypted_batch->TxnCommit()) {
             delete encrypted_batch;
             // We now have keys encrypted in memory, but not on disk...
             // die to avoid confusion and let the user reload the unencrypted
             // wallet.
             assert(false);
         }
 
         delete encrypted_batch;
         encrypted_batch = nullptr;
 
         Lock();
         Unlock(strWalletPassphrase);
 
         // If we are using HD, replace the HD seed with a new one
         if (IsHDEnabled()) {
             SetHDSeed(GenerateNewSeed());
         }
 
         NewKeyPool();
         Lock();
 
         // Need to completely rewrite the wallet file; if we don't, bdb might
         // keep bits of the unencrypted private key in slack space in the
         // database file.
         database->Rewrite();
 
         // BDB seems to have a bad habit of writing old data into
         // slack space in .dat files; that is bad if the old data is
         // unencrypted private keys. So:
         database->ReloadDbEnv();
     }
 
     NotifyStatusChanged(this);
     return true;
 }
 
 DBErrors CWallet::ReorderTransactions() {
     LOCK(cs_wallet);
     WalletBatch batch(*database);
 
     // Old wallets didn't have any defined order for transactions. Probably a
     // bad idea to change the output of this.
 
     // First: get all CWalletTx into a sorted-by-time
     // multimap.
     TxItems txByTime;
 
     for (auto &entry : mapWallet) {
         CWalletTx *wtx = &entry.second;
         txByTime.insert(std::make_pair(wtx->nTimeReceived, wtx));
     }
 
     nOrderPosNext = 0;
     std::vector<int64_t> nOrderPosOffsets;
     for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it) {
         CWalletTx *const pwtx = (*it).second;
         int64_t &nOrderPos = pwtx->nOrderPos;
 
         if (nOrderPos == -1) {
             nOrderPos = nOrderPosNext++;
             nOrderPosOffsets.push_back(nOrderPos);
 
             if (!batch.WriteTx(*pwtx)) {
                 return DBErrors::LOAD_FAIL;
             }
         } else {
             int64_t nOrderPosOff = 0;
             for (const int64_t &nOffsetStart : nOrderPosOffsets) {
                 if (nOrderPos >= nOffsetStart) {
                     ++nOrderPosOff;
                 }
             }
 
             nOrderPos += nOrderPosOff;
             nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1);
 
             if (!nOrderPosOff) {
                 continue;
             }
 
             // Since we're changing the order, write it back.
             if (!batch.WriteTx(*pwtx)) {
                 return DBErrors::LOAD_FAIL;
             }
         }
     }
 
     batch.WriteOrderPosNext(nOrderPosNext);
 
     return DBErrors::LOAD_OK;
 }
 
 int64_t CWallet::IncOrderPosNext(WalletBatch *batch) {
     // nOrderPosNext
     AssertLockHeld(cs_wallet);
     int64_t nRet = nOrderPosNext++;
     if (batch) {
         batch->WriteOrderPosNext(nOrderPosNext);
     } else {
         WalletBatch(*database).WriteOrderPosNext(nOrderPosNext);
     }
 
     return nRet;
 }
 
 void CWallet::MarkDirty() {
     LOCK(cs_wallet);
     for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
         item.second.MarkDirty();
     }
 }
 
 bool CWallet::AddToWallet(const CWalletTx &wtxIn, bool fFlushOnClose) {
     LOCK(cs_wallet);
 
     WalletBatch batch(*database, "r+", fFlushOnClose);
 
     const TxId &txid = wtxIn.GetId();
 
     // Inserts only if not already there, returns tx inserted or tx found.
     std::pair<std::map<TxId, CWalletTx>::iterator, bool> ret =
         mapWallet.insert(std::make_pair(txid, wtxIn));
     CWalletTx &wtx = (*ret.first).second;
     wtx.BindWallet(this);
     bool fInsertedNew = ret.second;
     if (fInsertedNew) {
         wtx.nTimeReceived = chain().getAdjustedTime();
         wtx.nOrderPos = IncOrderPosNext(&batch);
         wtx.m_it_wtxOrdered =
             wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
         wtx.nTimeSmart = ComputeTimeSmart(wtx);
         AddToSpends(txid);
     }
 
     bool fUpdated = false;
     if (!fInsertedNew) {
         // Merge
         if (!wtxIn.hashUnset() && wtxIn.hashBlock != wtx.hashBlock) {
             wtx.hashBlock = wtxIn.hashBlock;
             fUpdated = true;
         }
 
         // If no longer abandoned, update
         if (wtxIn.hashBlock.IsNull() && wtx.isAbandoned()) {
             wtx.hashBlock = wtxIn.hashBlock;
             fUpdated = true;
         }
 
         if (wtxIn.nIndex != -1 && (wtxIn.nIndex != wtx.nIndex)) {
             wtx.nIndex = wtxIn.nIndex;
             fUpdated = true;
         }
 
         if (wtxIn.fFromMe && wtxIn.fFromMe != wtx.fFromMe) {
             wtx.fFromMe = wtxIn.fFromMe;
             fUpdated = true;
         }
     }
 
     //// debug print
     WalletLogPrintf("AddToWallet %s  %s%s\n", wtxIn.GetId().ToString(),
                     (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));
 
     // Write to disk
     if ((fInsertedNew || fUpdated) && !batch.WriteTx(wtx)) {
         return false;
     }
 
     // Break debit/credit balance caches:
     wtx.MarkDirty();
 
     // Notify UI of new or updated transaction.
     NotifyTransactionChanged(this, txid, fInsertedNew ? CT_NEW : CT_UPDATED);
 
     // Notify an external script when a wallet transaction comes in or is
     // updated.
     std::string strCmd = gArgs.GetArg("-walletnotify", "");
 
     if (!strCmd.empty()) {
         boost::replace_all(strCmd, "%s", wtxIn.GetId().GetHex());
         std::thread t(runCommand, strCmd);
         // Thread runs free.
         t.detach();
     }
 
     return true;
 }
 
 void CWallet::LoadToWallet(const CWalletTx &wtxIn) {
     const TxId &txid = wtxIn.GetId();
     const auto &ins = mapWallet.emplace(txid, wtxIn);
     CWalletTx &wtx = ins.first->second;
     wtx.BindWallet(this);
     if (/* insertion took place */ ins.second) {
         wtx.m_it_wtxOrdered =
             wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
     }
     AddToSpends(txid);
     for (const CTxIn &txin : wtx.tx->vin) {
         auto it = mapWallet.find(txin.prevout.GetTxId());
         if (it != mapWallet.end()) {
             CWalletTx &prevtx = it->second;
             if (prevtx.nIndex == -1 && !prevtx.hashUnset()) {
                 MarkConflicted(prevtx.hashBlock, wtx.GetId());
             }
         }
     }
 }
 
 bool CWallet::AddToWalletIfInvolvingMe(const CTransactionRef &ptx,
                                        const BlockHash &block_hash,
                                        int posInBlock, bool fUpdate) {
     const CTransaction &tx = *ptx;
     AssertLockHeld(cs_wallet);
 
     if (!block_hash.IsNull()) {
         for (const CTxIn &txin : tx.vin) {
             std::pair<TxSpends::const_iterator, TxSpends::const_iterator>
                 range = mapTxSpends.equal_range(txin.prevout);
             while (range.first != range.second) {
                 if (range.first->second != tx.GetId()) {
                     WalletLogPrintf(
                         "Transaction %s (in block %s) conflicts with wallet "
                         "transaction %s (both spend %s:%i)\n",
                         tx.GetId().ToString(), block_hash.ToString(),
                         range.first->second.ToString(),
                         range.first->first.GetTxId().ToString(),
                         range.first->first.GetN());
                     MarkConflicted(block_hash, range.first->second);
                 }
                 range.first++;
             }
         }
     }
 
     bool fExisted = mapWallet.count(tx.GetId()) != 0;
     if (fExisted && !fUpdate) {
         return false;
     }
     if (fExisted || IsMine(tx) || IsFromMe(tx)) {
         /**
          * Check if any keys in the wallet keypool that were supposed to be
          * unused have appeared in a new transaction. If so, remove those keys
          * from the keypool. This can happen when restoring an old wallet backup
          * that does not contain the mostly recently created transactions from
          * newer versions of the wallet.
          */
 
         // loop though all outputs
         for (const CTxOut &txout : tx.vout) {
             // extract addresses and check if they match with an unused keypool
             // key
             for (const auto &keyid :
                  GetAffectedKeys(txout.scriptPubKey, *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 (!TopUpKeyPool()) {
                         WalletLogPrintf(
                             "%s: Topping up keypool failed (locked wallet)\n",
                             __func__);
                     }
                 }
             }
         }
 
         CWalletTx wtx(this, ptx);
 
         // Get merkle branch if transaction was found in a block
         if (!block_hash.IsNull()) {
             wtx.SetMerkleBranch(block_hash, posInBlock);
         }
 
         return AddToWallet(wtx, false);
     }
 
     return false;
 }
 
 bool CWallet::TransactionCanBeAbandoned(const TxId &txid) const {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
     const CWalletTx *wtx = GetWalletTx(txid);
     return wtx && !wtx->isAbandoned() &&
            wtx->GetDepthInMainChain(*locked_chain) == 0 && !wtx->InMempool();
 }
 
 void CWallet::MarkInputsDirty(const CTransactionRef &tx) {
     for (const CTxIn &txin : tx->vin) {
         auto it = mapWallet.find(txin.prevout.GetTxId());
         if (it != mapWallet.end()) {
             it->second.MarkDirty();
         }
     }
 }
 
 bool CWallet::AbandonTransaction(interfaces::Chain::Lock &locked_chain,
                                  const TxId &txid) {
     // Temporary. Removed in upcoming lock cleanup
     auto locked_chain_recursive = chain().lock();
     LOCK(cs_wallet);
 
     WalletBatch batch(*database, "r+");
 
     std::set<TxId> todo;
     std::set<TxId> done;
 
     // Can't mark abandoned if confirmed or in mempool
     auto it = mapWallet.find(txid);
     assert(it != mapWallet.end());
     CWalletTx &origtx = it->second;
     if (origtx.GetDepthInMainChain(locked_chain) != 0 || origtx.InMempool()) {
         return false;
     }
 
     todo.insert(txid);
 
     while (!todo.empty()) {
         const TxId now = *todo.begin();
         todo.erase(now);
         done.insert(now);
         it = mapWallet.find(now);
         assert(it != mapWallet.end());
         CWalletTx &wtx = it->second;
         int currentconfirm = wtx.GetDepthInMainChain(locked_chain);
         // If the orig tx was not in block, none of its spends can be.
         assert(currentconfirm <= 0);
         // If (currentconfirm < 0) {Tx and spends are already conflicted, no
         // need to abandon}
         if (currentconfirm == 0 && !wtx.isAbandoned()) {
             // If the orig tx was not in block/mempool, none of its spends can
             // be in mempool.
             assert(!wtx.InMempool());
             wtx.nIndex = -1;
             wtx.setAbandoned();
             wtx.MarkDirty();
             batch.WriteTx(wtx);
             NotifyTransactionChanged(this, wtx.GetId(), CT_UPDATED);
             // Iterate over all its outputs, and mark transactions in the wallet
             // that spend them abandoned too.
             TxSpends::const_iterator iter =
                 mapTxSpends.lower_bound(COutPoint(now, 0));
             while (iter != mapTxSpends.end() && iter->first.GetTxId() == now) {
                 if (!done.count(iter->second)) {
                     todo.insert(iter->second);
                 }
                 iter++;
             }
 
             // If a transaction changes 'conflicted' state, that changes the
             // balance available of the outputs it spends. So force those to be
             // recomputed.
             MarkInputsDirty(wtx.tx);
         }
     }
 
     return true;
 }
 
 void CWallet::MarkConflicted(const BlockHash &hashBlock, const TxId &txid) {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     int conflictconfirms = -locked_chain->getBlockDepth(hashBlock);
 
     // If number of conflict confirms cannot be determined, this means that the
     // block is still unknown or not yet part of the main chain, for example
     // when loading the wallet during a reindex. Do nothing in that case.
     if (conflictconfirms >= 0) {
         return;
     }
 
     // Do not flush the wallet here for performance reasons.
     WalletBatch batch(*database, "r+", false);
 
     std::set<TxId> todo;
     std::set<TxId> done;
 
     todo.insert(txid);
 
     while (!todo.empty()) {
         const TxId now = *todo.begin();
         todo.erase(now);
         done.insert(now);
         auto it = mapWallet.find(now);
         assert(it != mapWallet.end());
         CWalletTx &wtx = it->second;
         int currentconfirm = wtx.GetDepthInMainChain(*locked_chain);
         if (conflictconfirms < currentconfirm) {
             // Block is 'more conflicted' than current confirm; update.
             // Mark transaction as conflicted with this block.
             wtx.nIndex = -1;
             wtx.hashBlock = hashBlock;
             wtx.MarkDirty();
             batch.WriteTx(wtx);
             // Iterate over all its outputs, and mark transactions in the wallet
             // that spend them conflicted too.
             TxSpends::const_iterator iter =
                 mapTxSpends.lower_bound(COutPoint(now, 0));
             while (iter != mapTxSpends.end() && iter->first.GetTxId() == now) {
                 if (!done.count(iter->second)) {
                     todo.insert(iter->second);
                 }
                 iter++;
             }
             // If a transaction changes 'conflicted' state, that changes the
             // balance available of the outputs it spends. So force those to be
             // recomputed.
             MarkInputsDirty(wtx.tx);
         }
     }
 }
 
 void CWallet::SyncTransaction(const CTransactionRef &ptx,
                               const BlockHash &block_hash, int posInBlock,
                               bool update_tx) {
     if (!AddToWalletIfInvolvingMe(ptx, block_hash, posInBlock, update_tx)) {
         // Not one of ours
         return;
     }
 
     // If a transaction changes 'conflicted' state, that changes the balance
     // available of the outputs it spends. So force those to be
     // recomputed, also:
     MarkInputsDirty(ptx);
 }
 
 void CWallet::TransactionAddedToMempool(const CTransactionRef &ptx) {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
     SyncTransaction(ptx, BlockHash(), 0 /* position in block */);
 
     auto it = mapWallet.find(ptx->GetId());
     if (it != mapWallet.end()) {
         it->second.fInMempool = true;
     }
 }
 
 void CWallet::TransactionRemovedFromMempool(const CTransactionRef &ptx) {
     LOCK(cs_wallet);
     auto it = mapWallet.find(ptx->GetId());
     if (it != mapWallet.end()) {
         it->second.fInMempool = false;
     }
 }
 
 void CWallet::BlockConnected(
     const CBlock &block, const std::vector<CTransactionRef> &vtxConflicted) {
     const BlockHash &block_hash = block.GetHash();
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     // TODO: Temporarily ensure that mempool removals are notified before
     // connected transactions. This shouldn't matter, but the abandoned state of
     // transactions in our wallet is currently cleared when we receive another
     // notification and there is a race condition where notification of a
     // connected conflict might cause an outside process to abandon a
     // transaction and then have it inadvertently cleared by the notification
     // that the conflicted transaction was evicted.
     for (const CTransactionRef &ptx : vtxConflicted) {
         SyncTransaction(ptx, BlockHash(), 0 /* position in block */);
         TransactionRemovedFromMempool(ptx);
     }
 
     for (size_t i = 0; i < block.vtx.size(); i++) {
         SyncTransaction(block.vtx[i], block_hash, i);
         TransactionRemovedFromMempool(block.vtx[i]);
     }
 
     m_last_block_processed = block_hash;
 }
 
 void CWallet::BlockDisconnected(const CBlock &block) {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     for (const CTransactionRef &ptx : block.vtx) {
         SyncTransaction(ptx, BlockHash(), 0 /* position in block */);
     }
 }
 
 void CWallet::UpdatedBlockTip() {
     m_best_block_time = GetTime();
 }
 
 void CWallet::BlockUntilSyncedToCurrentChain() {
     AssertLockNotHeld(cs_wallet);
     // Skip the queue-draining stuff if we know we're caught up with
     // chainActive.Tip(), otherwise put a callback in the validation interface
     // queue and wait for the queue to drain enough to execute it (indicating we
     // are caught up at least with the time we entered this function).
     const BlockHash last_block_hash =
         WITH_LOCK(cs_wallet, return m_last_block_processed);
     chain().waitForNotificationsIfNewBlocksConnected(last_block_hash);
 }
 
 isminetype CWallet::IsMine(const CTxIn &txin) const {
     LOCK(cs_wallet);
     std::map<TxId, CWalletTx>::const_iterator mi =
         mapWallet.find(txin.prevout.GetTxId());
     if (mi != mapWallet.end()) {
         const CWalletTx &prev = (*mi).second;
         if (txin.prevout.GetN() < prev.tx->vout.size()) {
             return IsMine(prev.tx->vout[txin.prevout.GetN()]);
         }
     }
 
     return ISMINE_NO;
 }
 
 // Note that this function doesn't distinguish between a 0-valued input, and a
 // not-"is mine" (according to the filter) input.
 Amount CWallet::GetDebit(const CTxIn &txin, const isminefilter &filter) const {
     LOCK(cs_wallet);
     std::map<TxId, CWalletTx>::const_iterator mi =
         mapWallet.find(txin.prevout.GetTxId());
     if (mi != mapWallet.end()) {
         const CWalletTx &prev = (*mi).second;
         if (txin.prevout.GetN() < prev.tx->vout.size()) {
             if (IsMine(prev.tx->vout[txin.prevout.GetN()]) & filter) {
                 return prev.tx->vout[txin.prevout.GetN()].nValue;
             }
         }
     }
 
     return Amount::zero();
 }
 
 isminetype CWallet::IsMine(const CTxOut &txout) const {
     return ::IsMine(*this, txout.scriptPubKey);
 }
 
 Amount CWallet::GetCredit(const CTxOut &txout,
                           const isminefilter &filter) const {
     if (!MoneyRange(txout.nValue)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": value out of range");
     }
 
     return (IsMine(txout) & filter) ? txout.nValue : Amount::zero();
 }
 
 bool CWallet::IsChange(const CTxOut &txout) const {
     return IsChange(txout.scriptPubKey);
 }
 
 bool CWallet::IsChange(const CScript &script) const {
     // TODO: fix handling of 'change' outputs. The assumption is that any
     // payment to a script that is ours, but is not in the address book is
     // change. That assumption is likely to break when we implement
     // multisignature wallets that return change back into a
     // multi-signature-protected address; a better way of identifying which
     // outputs are 'the send' and which are 'the change' will need to be
     // implemented (maybe extend CWalletTx to remember which output, if any, was
     // change).
     if (::IsMine(*this, script)) {
         CTxDestination address;
         if (!ExtractDestination(script, address)) {
             return true;
         }
 
         LOCK(cs_wallet);
         if (!mapAddressBook.count(address)) {
             return true;
         }
     }
 
     return false;
 }
 
 Amount CWallet::GetChange(const CTxOut &txout) const {
     if (!MoneyRange(txout.nValue)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": value out of range");
     }
 
     return (IsChange(txout) ? txout.nValue : Amount::zero());
 }
 
 bool CWallet::IsMine(const CTransaction &tx) const {
     for (const CTxOut &txout : tx.vout) {
         if (IsMine(txout)) {
             return true;
         }
     }
 
     return false;
 }
 
 bool CWallet::IsFromMe(const CTransaction &tx) const {
     return GetDebit(tx, ISMINE_ALL) > Amount::zero();
 }
 
 Amount CWallet::GetDebit(const CTransaction &tx,
                          const isminefilter &filter) const {
     Amount nDebit = Amount::zero();
     for (const CTxIn &txin : tx.vin) {
         nDebit += GetDebit(txin, filter);
         if (!MoneyRange(nDebit)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": value out of range");
         }
     }
 
     return nDebit;
 }
 
 bool CWallet::IsAllFromMe(const CTransaction &tx,
                           const isminefilter &filter) const {
     LOCK(cs_wallet);
 
     for (const CTxIn &txin : tx.vin) {
         auto mi = mapWallet.find(txin.prevout.GetTxId());
         if (mi == mapWallet.end()) {
             // Any unknown inputs can't be from us.
             return false;
         }
 
         const CWalletTx &prev = (*mi).second;
 
         if (txin.prevout.GetN() >= prev.tx->vout.size()) {
             // Invalid input!
             return false;
         }
 
         if (!(IsMine(prev.tx->vout[txin.prevout.GetN()]) & filter)) {
             return false;
         }
     }
 
     return true;
 }
 
 Amount CWallet::GetCredit(const CTransaction &tx,
                           const isminefilter &filter) const {
     Amount nCredit = Amount::zero();
     for (const CTxOut &txout : tx.vout) {
         nCredit += GetCredit(txout, filter);
         if (!MoneyRange(nCredit)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": value out of range");
         }
     }
 
     return nCredit;
 }
 
 Amount CWallet::GetChange(const CTransaction &tx) const {
     Amount nChange = Amount::zero();
     for (const CTxOut &txout : tx.vout) {
         nChange += GetChange(txout);
         if (!MoneyRange(nChange)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": value out of range");
         }
     }
 
     return nChange;
 }
 
 CPubKey CWallet::GenerateNewSeed() {
     assert(!IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
     CKey key;
     key.MakeNewKey(true);
     return DeriveNewSeed(key);
 }
 
 CPubKey CWallet::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_wallet);
 
     // 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 CWallet::SetHDSeed(const CPubKey &seed) {
     LOCK(cs_wallet);
 
     // Store the keyid (hash160) together with the child index counter in the
     // database as a hdchain object.
     CHDChain newHdChain;
     newHdChain.nVersion = CanSupportFeature(FEATURE_HD_SPLIT)
                               ? CHDChain::VERSION_HD_CHAIN_SPLIT
                               : CHDChain::VERSION_HD_BASE;
     newHdChain.seed_id = seed.GetID();
     SetHDChain(newHdChain, false);
     NotifyCanGetAddressesChanged();
     UnsetWalletFlag(WALLET_FLAG_BLANK_WALLET);
 }
 
 void CWallet::SetHDChain(const CHDChain &chain, bool memonly) {
     LOCK(cs_wallet);
     if (!memonly && !WalletBatch(*database).WriteHDChain(chain)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing chain failed");
     }
 
     hdChain = chain;
 }
 
 bool CWallet::IsHDEnabled() const {
     return !hdChain.seed_id.IsNull();
 }
 
 bool CWallet::CanGenerateKeys() {
     // A wallet can generate keys if it has an HD seed (IsHDEnabled) or it is a
     // non-HD wallet (pre FEATURE_HD)
     LOCK(cs_wallet);
     return IsHDEnabled() || !CanSupportFeature(FEATURE_HD);
 }
 
 bool CWallet::CanGetAddresses(bool internal) {
     LOCK(cs_wallet);
     // Check if the keypool has keys
     bool keypool_has_keys;
     if (internal && 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;
 }
 
 void CWallet::SetWalletFlag(uint64_t flags) {
     LOCK(cs_wallet);
     m_wallet_flags |= flags;
     if (!WalletBatch(*database).WriteWalletFlags(m_wallet_flags)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing wallet flags failed");
     }
 }
 
 void CWallet::UnsetWalletFlag(uint64_t flag) {
     WalletBatch batch(*database);
     UnsetWalletFlagWithDB(batch, flag);
 }
 
 void CWallet::UnsetWalletFlagWithDB(WalletBatch &batch, uint64_t flag) {
     LOCK(cs_wallet);
     m_wallet_flags &= ~flag;
     if (!batch.WriteWalletFlags(m_wallet_flags)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing wallet flags failed");
     }
 }
 
 bool CWallet::IsWalletFlagSet(uint64_t flag) const {
     return (m_wallet_flags & flag);
 }
 
 bool CWallet::SetWalletFlags(uint64_t overwriteFlags, bool memonly) {
     LOCK(cs_wallet);
     m_wallet_flags = overwriteFlags;
     if (((overwriteFlags & KNOWN_WALLET_FLAGS) >> 32) ^
         (overwriteFlags >> 32)) {
         // contains unknown non-tolerable wallet flags
         return false;
     }
     if (!memonly && !WalletBatch(*database).WriteWalletFlags(m_wallet_flags)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing wallet flags failed");
     }
 
     return true;
 }
 
 int64_t CWalletTx::GetTxTime() const {
     int64_t n = nTimeSmart;
     return n ? n : nTimeReceived;
 }
 
 // Helper for producing a max-sized low-S low-R signature (eg 71 bytes)
 // or a max-sized low-S signature (e.g. 72 bytes) if use_max_sig is true
 bool CWallet::DummySignInput(CTxIn &tx_in, const CTxOut &txout,
                              bool use_max_sig) const {
     // Fill in dummy signatures for fee calculation.
     const CScript &scriptPubKey = txout.scriptPubKey;
     SignatureData sigdata;
 
     if (!ProduceSignature(*this,
                           use_max_sig ? DUMMY_MAXIMUM_SIGNATURE_CREATOR
                                       : DUMMY_SIGNATURE_CREATOR,
                           scriptPubKey, sigdata)) {
         return false;
     }
 
     UpdateInput(tx_in, sigdata);
     return true;
 }
 
 // Helper for producing a bunch of max-sized low-S low-R signatures (eg 71
 // bytes)
 bool CWallet::DummySignTx(CMutableTransaction &txNew,
                           const std::vector<CTxOut> &txouts,
                           bool use_max_sig) const {
     // Fill in dummy signatures for fee calculation.
     int nIn = 0;
     for (const auto &txout : txouts) {
         if (!DummySignInput(txNew.vin[nIn], txout, use_max_sig)) {
             return false;
         }
 
         nIn++;
     }
     return true;
 }
 
 bool CWallet::ImportScripts(const std::set<CScript> scripts) {
     WalletBatch batch(*database);
     for (const auto &entry : scripts) {
         if (!HaveCScript(CScriptID(entry)) && !AddCScriptWithDB(batch, entry)) {
             return false;
         }
     }
     return true;
 }
 
 bool CWallet::ImportPrivKeys(const std::map<CKeyID, CKey> &privkey_map,
                              const int64_t timestamp) {
     WalletBatch batch(*database);
     for (const auto &entry : privkey_map) {
         const CKey &key = entry.second;
         CPubKey pubkey = key.GetPubKey();
         const CKeyID &id = entry.first;
         assert(key.VerifyPubKey(pubkey));
         mapKeyMetadata[id].nCreateTime = timestamp;
         // If the private key is not present in the wallet, insert it.
         if (!HaveKey(id) && !AddKeyPubKeyWithDB(batch, key, pubkey)) {
             return false;
         }
         UpdateTimeFirstKey(timestamp);
     }
     return true;
 }
 
 bool CWallet::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(*database);
     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) &&
             !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 CWallet::ImportScriptPubKeys(const std::string &label,
                                   const std::set<CScript> &script_pub_keys,
                                   const bool have_solving_data,
                                   const bool internal,
                                   const int64_t timestamp) {
     WalletBatch batch(*database);
     for (const CScript &script : script_pub_keys) {
         if (!have_solving_data || !::IsMine(*this, script)) {
             // Always call AddWatchOnly for non-solvable watch-only, so that
             // watch timestamp gets updated
             if (!AddWatchOnlyWithDB(batch, script, timestamp)) {
                 return false;
             }
         }
         CTxDestination dest;
         ExtractDestination(script, dest);
         if (!internal && IsValidDestination(dest)) {
             SetAddressBookWithDB(batch, dest, label, "receive");
         }
     }
     return true;
 }
 
 int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
                                      const CWallet *wallet, bool use_max_sig) {
     std::vector<CTxOut> txouts;
     // Look up the inputs.  We should have already checked that this transaction
     // IsAllFromMe(ISMINE_SPENDABLE), so every input should already be in our
     // wallet, with a valid index into the vout array, and the ability to sign.
     for (auto &input : tx.vin) {
         const auto mi = wallet->mapWallet.find(input.prevout.GetTxId());
         if (mi == wallet->mapWallet.end()) {
             return -1;
         }
         assert(input.prevout.GetN() < mi->second.tx->vout.size());
         txouts.emplace_back(mi->second.tx->vout[input.prevout.GetN()]);
     }
     return CalculateMaximumSignedTxSize(tx, wallet, txouts, use_max_sig);
 }
 
 // txouts needs to be in the order of tx.vin
 int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
                                      const CWallet *wallet,
                                      const std::vector<CTxOut> &txouts,
                                      bool use_max_sig) {
     CMutableTransaction txNew(tx);
     if (!wallet->DummySignTx(txNew, txouts, use_max_sig)) {
         // This should never happen, because IsAllFromMe(ISMINE_SPENDABLE)
         // implies that we can sign for every input.
         return -1;
     }
     return GetSerializeSize(txNew, PROTOCOL_VERSION);
 }
 
 int CalculateMaximumSignedInputSize(const CTxOut &txout, const CWallet *wallet,
                                     bool use_max_sig) {
     CMutableTransaction txn;
     txn.vin.push_back(CTxIn(COutPoint()));
     if (!wallet->DummySignInput(txn.vin[0], txout, use_max_sig)) {
         // This should never happen, because IsAllFromMe(ISMINE_SPENDABLE)
         // implies that we can sign for every input.
         return -1;
     }
     return GetSerializeSize(txn.vin[0], PROTOCOL_VERSION);
 }
 
 void CWalletTx::GetAmounts(std::list<COutputEntry> &listReceived,
                            std::list<COutputEntry> &listSent, Amount &nFee,
                            const isminefilter &filter) const {
     nFee = Amount::zero();
     listReceived.clear();
     listSent.clear();
 
     // Compute fee:
     Amount nDebit = GetDebit(filter);
     // debit>0 means we signed/sent this transaction.
     if (nDebit > Amount::zero()) {
         Amount nValueOut = tx->GetValueOut();
         nFee = (nDebit - nValueOut);
     }
 
     // Sent/received.
     for (unsigned int i = 0; i < tx->vout.size(); ++i) {
         const CTxOut &txout = tx->vout[i];
         isminetype fIsMine = pwallet->IsMine(txout);
         // Only need to handle txouts if AT LEAST one of these is true:
         //   1) they debit from us (sent)
         //   2) the output is to us (received)
         if (nDebit > Amount::zero()) {
             // Don't report 'change' txouts
             if (pwallet->IsChange(txout)) {
                 continue;
             }
         } else if (!(fIsMine & filter)) {
             continue;
         }
 
         // In either case, we need to get the destination address.
         CTxDestination address;
 
         if (!ExtractDestination(txout.scriptPubKey, address) &&
             !txout.scriptPubKey.IsUnspendable()) {
             pwallet->WalletLogPrintf("CWalletTx::GetAmounts: Unknown "
                                      "transaction type found, txid %s\n",
                                      this->GetId().ToString());
             address = CNoDestination();
         }
 
         COutputEntry output = {address, txout.nValue, (int)i};
 
         // If we are debited by the transaction, add the output as a "sent"
         // entry.
         if (nDebit > Amount::zero()) {
             listSent.push_back(output);
         }
 
         // If we are receiving the output, add it as a "received" entry.
         if (fIsMine & filter) {
             listReceived.push_back(output);
         }
     }
 }
 
 /**
  * Scan active chain for relevant transactions after importing keys. This should
  * be called whenever new keys are added to the wallet, with the oldest key
  * creation time.
  *
  * @return Earliest timestamp that could be successfully scanned from. Timestamp
  * returned will be higher than startTime if relevant blocks could not be read.
  */
 int64_t CWallet::RescanFromTime(int64_t startTime,
                                 const WalletRescanReserver &reserver,
                                 bool update) {
     // Find starting block. May be null if nCreateTime is greater than the
     // highest blockchain timestamp, in which case there is nothing that needs
     // to be scanned.
     BlockHash start_block;
     {
         auto locked_chain = chain().lock();
         const Optional<int> start_height =
             locked_chain->findFirstBlockWithTimeAndHeight(
                 startTime - TIMESTAMP_WINDOW, 0, &start_block);
         const Optional<int> tip_height = locked_chain->getHeight();
         WalletLogPrintf(
             "%s: Rescanning last %i blocks\n", __func__,
             tip_height && start_height ? *tip_height - *start_height + 1 : 0);
     }
 
     if (!start_block.IsNull()) {
         // TODO: this should take into account failure by ScanResult::USER_ABORT
         ScanResult result = ScanForWalletTransactions(start_block, BlockHash(),
                                                       reserver, update);
         if (result.status == ScanResult::FAILURE) {
             int64_t time_max;
             if (!chain().findBlock(result.last_failed_block,
                                    nullptr /* block */, nullptr /* time */,
                                    &time_max)) {
                 throw std::logic_error(
                     "ScanForWalletTransactions returned invalid block hash");
             }
             return time_max + TIMESTAMP_WINDOW + 1;
         }
     }
     return startTime;
 }
 
 /**
  * Scan the block chain (starting in start_block) for transactions from or to
  * us. If fUpdate is true, found transactions that already exist in the wallet
  * will be updated.
  *
  * @param[in] start_block Scan starting block. If block is not on the active
  *                        chain, the scan will return SUCCESS immediately.
  * @param[in] stop_block  Scan ending block. If block is not on the active
  *                        chain, the scan will continue until it reaches the
  *                        chain tip.
  *
  * @return ScanResult returning scan information and indicating success or
  *         failure. Return status will be set to SUCCESS if scan was
  *         successful. FAILURE if a complete rescan was not possible (due to
  *         pruning or corruption). USER_ABORT if the rescan was aborted before
  *         it could complete.
  *
  * @pre Caller needs to make sure start_block (and the optional stop_block) are
  * on the main chain after to the addition of any new keys you want to detect
  * transactions for.
  */
 CWallet::ScanResult CWallet::ScanForWalletTransactions(
     const BlockHash &start_block, const BlockHash &stop_block,
     const WalletRescanReserver &reserver, bool fUpdate) {
     int64_t nNow = GetTime();
 
     assert(reserver.isReserved());
 
     BlockHash block_hash = start_block;
     ScanResult result;
 
     WalletLogPrintf("Rescan started from block %s...\n",
                     start_block.ToString());
 
     {
         fAbortRescan = false;
 
         // Show rescan progress in GUI as dialog or on splashscreen, if -rescan
         // on startup.
         ShowProgress(
             strprintf("%s " + _("Rescanning...").translated, GetDisplayName()),
             0);
         BlockHash tip_hash;
         // The way the 'block_height' is initialized is just a workaround for
         // the gcc bug #47679 since version 4.6.0.
         Optional<int> block_height = MakeOptional(false, int());
         double progress_begin;
         double progress_end;
         {
             auto locked_chain = chain().lock();
             if (Optional<int> tip_height = locked_chain->getHeight()) {
                 tip_hash = locked_chain->getBlockHash(*tip_height);
             }
             block_height = locked_chain->getBlockHeight(block_hash);
             progress_begin = chain().guessVerificationProgress(block_hash);
             progress_end = chain().guessVerificationProgress(
                 stop_block.IsNull() ? tip_hash : stop_block);
         }
         double progress_current = progress_begin;
         while (block_height && !fAbortRescan && !chain().shutdownRequested()) {
             if (*block_height % 100 == 0 &&
                 progress_end - progress_begin > 0.0) {
                 ShowProgress(
                     strprintf("%s " + _("Rescanning...").translated,
                               GetDisplayName()),
                     std::max(
                         1,
                         std::min(99, (int)((progress_current - progress_begin) /
                                            (progress_end - progress_begin) *
                                            100))));
             }
             if (GetTime() >= nNow + 60) {
                 nNow = GetTime();
                 WalletLogPrintf("Still rescanning. At block %d. Progress=%f\n",
                                 *block_height, progress_current);
             }
 
             CBlock block;
             if (chain().findBlock(block_hash, &block) && !block.IsNull()) {
                 auto locked_chain = chain().lock();
                 LOCK(cs_wallet);
                 if (!locked_chain->getBlockHeight(block_hash)) {
                     // Abort scan if current block is no longer active, to
                     // prevent marking transactions as coming from the wrong
                     // block.
                     // TODO: This should return success instead of failure, see
                     // https://github.com/bitcoin/bitcoin/pull/14711#issuecomment-458342518
                     result.last_failed_block = block_hash;
                     result.status = ScanResult::FAILURE;
                     break;
                 }
                 for (size_t posInBlock = 0; posInBlock < block.vtx.size();
                      ++posInBlock) {
                     SyncTransaction(block.vtx[posInBlock], block_hash,
                                     posInBlock, fUpdate);
                 }
                 // scan succeeded, record block as most recent successfully
                 // scanned
                 result.last_scanned_block = block_hash;
                 result.last_scanned_height = *block_height;
             } else {
                 // could not scan block, keep scanning but record this block as
                 // the most recent failure
                 result.last_failed_block = block_hash;
                 result.status = ScanResult::FAILURE;
             }
             if (block_hash == stop_block) {
                 break;
             }
             {
                 auto locked_chain = chain().lock();
                 Optional<int> tip_height = locked_chain->getHeight();
                 if (!tip_height || *tip_height <= block_height ||
                     !locked_chain->getBlockHeight(block_hash)) {
                     // break successfully when rescan has reached the tip, or
                     // previous block is no longer on the chain due to a reorg
                     break;
                 }
 
                 // increment block and verification progress
                 block_hash = locked_chain->getBlockHash(++*block_height);
                 progress_current =
                     chain().guessVerificationProgress(block_hash);
 
                 // handle updated tip hash
                 const BlockHash prev_tip_hash = tip_hash;
                 tip_hash = locked_chain->getBlockHash(*tip_height);
                 if (stop_block.IsNull() && prev_tip_hash != tip_hash) {
                     // in case the tip has changed, update progress max
                     progress_end = chain().guessVerificationProgress(tip_hash);
                 }
             }
         }
 
         // Hide progress dialog in GUI.
         ShowProgress(
             strprintf("%s " + _("Rescanning...").translated, GetDisplayName()),
             100);
         if (block_height && fAbortRescan) {
             WalletLogPrintf("Rescan aborted at block %d. Progress=%f\n",
                             *block_height, progress_current);
             result.status = ScanResult::USER_ABORT;
         } else if (block_height && chain().shutdownRequested()) {
             WalletLogPrintf("Rescan interrupted by shutdown request at block "
                             "%d. Progress=%f\n",
                             *block_height, progress_current);
             result.status = ScanResult::USER_ABORT;
         }
     }
 
     return result;
 }
 
 void CWallet::ReacceptWalletTransactions(
     interfaces::Chain::Lock &locked_chain) {
     // If transactions aren't being broadcasted, don't let them into local
     // mempool either.
     if (!fBroadcastTransactions) {
         return;
     }
 
     std::map<int64_t, CWalletTx *> mapSorted;
 
     // Sort pending wallet transactions based on their initial wallet insertion
     // order.
     for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
         const TxId &wtxid = item.first;
         CWalletTx &wtx = item.second;
         assert(wtx.GetId() == wtxid);
 
         int nDepth = wtx.GetDepthInMainChain(locked_chain);
 
         if (!wtx.IsCoinBase() && (nDepth == 0 && !wtx.isAbandoned())) {
             mapSorted.insert(std::make_pair(wtx.nOrderPos, &wtx));
         }
     }
 
     // Try to add wallet transactions to memory pool.
     for (const std::pair<const int64_t, CWalletTx *> &item : mapSorted) {
         CWalletTx &wtx = *(item.second);
         CValidationState state;
         wtx.AcceptToMemoryPool(locked_chain, state);
     }
 }
 
 bool CWalletTx::RelayWalletTransaction(interfaces::Chain::Lock &locked_chain) {
     assert(pwallet->GetBroadcastTransactions());
     if (IsCoinBase() || isAbandoned() ||
         GetDepthInMainChain(locked_chain) != 0) {
         return false;
     }
 
     CValidationState state;
     // GetDepthInMainChain already catches known conflicts.
     if (InMempool() || AcceptToMemoryPool(locked_chain, state)) {
         pwallet->WalletLogPrintf("Relaying wtx %s\n", GetId().ToString());
         if (pwallet->chain().p2pEnabled()) {
             pwallet->chain().relayTransaction(GetId());
             return true;
         }
     }
 
     return false;
 }
 
 std::set<TxId> CWalletTx::GetConflicts() const {
     std::set<TxId> result;
     if (pwallet != nullptr) {
         const TxId &txid = GetId();
         result = pwallet->GetConflicts(txid);
         result.erase(txid);
     }
 
     return result;
 }
 
 Amount CWalletTx::GetCachableAmount(AmountType type, const isminefilter &filter,
                                     bool recalculate) const {
     auto &amount = m_amounts[type];
     if (recalculate || !amount.m_cached[filter]) {
         amount.Set(filter, type == DEBIT ? pwallet->GetDebit(*tx, filter)
                                          : pwallet->GetCredit(*tx, filter));
     }
     return amount.m_value[filter];
 }
 
 Amount CWalletTx::GetDebit(const isminefilter &filter) const {
     if (tx->vin.empty()) {
         return Amount::zero();
     }
 
     Amount debit = Amount::zero();
     if (filter & ISMINE_SPENDABLE) {
         debit += GetCachableAmount(DEBIT, ISMINE_SPENDABLE);
     }
     if (filter & ISMINE_WATCH_ONLY) {
         debit += GetCachableAmount(DEBIT, ISMINE_WATCH_ONLY);
     }
 
     return debit;
 }
 
 Amount CWalletTx::GetCredit(interfaces::Chain::Lock &locked_chain,
                             const isminefilter &filter) const {
     // Must wait until coinbase is safely deep enough in the chain before
     // valuing it.
     if (IsImmatureCoinBase(locked_chain)) {
         return Amount::zero();
     }
 
     Amount credit = Amount::zero();
     if (filter & ISMINE_SPENDABLE) {
         // GetBalance can assume transactions in mapWallet won't change.
         credit += GetCachableAmount(CREDIT, ISMINE_SPENDABLE);
     }
 
     if (filter & ISMINE_WATCH_ONLY) {
         credit += GetCachableAmount(CREDIT, ISMINE_WATCH_ONLY);
     }
 
     return credit;
 }
 
 Amount CWalletTx::GetImmatureCredit(interfaces::Chain::Lock &locked_chain,
                                     bool fUseCache) const {
     if (IsImmatureCoinBase(locked_chain) && IsInMainChain(locked_chain)) {
         return GetCachableAmount(IMMATURE_CREDIT, ISMINE_SPENDABLE, !fUseCache);
     }
 
     return Amount::zero();
 }
 
 Amount CWalletTx::GetAvailableCredit(interfaces::Chain::Lock &locked_chain,
                                      bool fUseCache,
                                      const isminefilter &filter) const {
     if (pwallet == nullptr) {
         return Amount::zero();
     }
 
     // Avoid caching ismine for NO or ALL cases (could remove this check and
     // simplify in the future).
     bool allow_cache =
         filter == ISMINE_SPENDABLE || filter == ISMINE_WATCH_ONLY;
 
     // Must wait until coinbase is safely deep enough in the chain before
     // valuing it.
     if (IsImmatureCoinBase(locked_chain)) {
         return Amount::zero();
     }
 
     if (fUseCache && allow_cache &&
         m_amounts[AVAILABLE_CREDIT].m_cached[filter]) {
         return m_amounts[AVAILABLE_CREDIT].m_value[filter];
     }
 
     Amount nCredit = Amount::zero();
     const TxId &txid = GetId();
     for (uint32_t i = 0; i < tx->vout.size(); i++) {
         if (!pwallet->IsSpent(locked_chain, COutPoint(txid, i))) {
             const CTxOut &txout = tx->vout[i];
             nCredit += pwallet->GetCredit(txout, filter);
             if (!MoneyRange(nCredit)) {
                 throw std::runtime_error(std::string(__func__) +
                                          " : value out of range");
             }
         }
     }
 
     if (allow_cache) {
         m_amounts[AVAILABLE_CREDIT].Set(filter, nCredit);
     }
 
     return nCredit;
 }
 
 Amount
 CWalletTx::GetImmatureWatchOnlyCredit(interfaces::Chain::Lock &locked_chain,
                                       const bool fUseCache) const {
     if (IsImmatureCoinBase(locked_chain) && IsInMainChain(locked_chain)) {
         return GetCachableAmount(IMMATURE_CREDIT, ISMINE_WATCH_ONLY,
                                  !fUseCache);
     }
 
     return Amount::zero();
 }
 
 Amount CWalletTx::GetChange() const {
     if (fChangeCached) {
         return nChangeCached;
     }
 
     nChangeCached = pwallet->GetChange(*tx);
     fChangeCached = true;
     return nChangeCached;
 }
 
 bool CWalletTx::InMempool() const {
     return fInMempool;
 }
 
 bool CWalletTx::IsTrusted(interfaces::Chain::Lock &locked_chain) const {
     // Quick answer in most cases
     CValidationState state;
     if (!locked_chain.contextualCheckTransactionForCurrentBlock(
             Params().GetConsensus(), *tx, state)) {
         return false;
     }
 
     int nDepth = GetDepthInMainChain(locked_chain);
     if (nDepth >= 1) {
         return true;
     }
 
     if (nDepth < 0) {
         return false;
     }
 
     // using wtx's cached debit
     if (!pwallet->m_spend_zero_conf_change || !IsFromMe(ISMINE_ALL)) {
         return false;
     }
 
     // Don't trust unconfirmed transactions from us unless they are in the
     // mempool.
     if (!InMempool()) {
         return false;
     }
 
     // Trusted if all inputs are from us and are in the mempool:
     for (const CTxIn &txin : tx->vin) {
         // Transactions not sent by us: not trusted
         const CWalletTx *parent = pwallet->GetWalletTx(txin.prevout.GetTxId());
         if (parent == nullptr) {
             return false;
         }
 
         const CTxOut &parentOut = parent->tx->vout[txin.prevout.GetN()];
         if (pwallet->IsMine(parentOut) != ISMINE_SPENDABLE) {
             return false;
         }
     }
 
     return true;
 }
 
 bool CWalletTx::IsEquivalentTo(const CWalletTx &_tx) const {
     CMutableTransaction tx1{*this->tx};
     CMutableTransaction tx2{*_tx.tx};
     for (auto &txin : tx1.vin) {
         txin.scriptSig = CScript();
     }
 
     for (auto &txin : tx2.vin) {
         txin.scriptSig = CScript();
     }
 
     return CTransaction(tx1) == CTransaction(tx2);
 }
 
 // Rebroadcast transactions from the wallet. We do this on a random timer
 // to slightly obfuscate which transactions come from our wallet.
 //
 // Ideally, we'd only resend transactions that we think should have been
 // mined in the most recent block. Any transaction that wasn't in the top
 // blockweight of transactions in the mempool shouldn't have been mined,
 // and so is probably just sitting in the mempool waiting to be confirmed.
 // Rebroadcasting does nothing to speed up confirmation and only damages
 // privacy.
 void CWallet::ResendWalletTransactions() {
     // During reindex, importing and IBD, old wallet transactions become
     // unconfirmed. Don't resend them as that would spam other nodes.
     if (!chain().isReadyToBroadcast()) {
         return;
     }
 
     // Do this infrequently and randomly to avoid giving away that these are our
     // transactions.
     if (GetTime() < nNextResend || !fBroadcastTransactions) {
         return;
     }
 
     bool fFirst = (nNextResend == 0);
     nNextResend = GetTime() + GetRand(30 * 60);
     if (fFirst) {
         return;
     }
 
     // Only do it if there's been a new block since last time
     if (m_best_block_time < nLastResend) {
         return;
     }
 
     nLastResend = GetTime();
 
     int relayed_tx_count = 0;
 
     { // locked_chain and cs_wallet scope
         auto locked_chain = chain().lock();
         LOCK(cs_wallet);
 
         // Relay transactions
         for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
             CWalletTx &wtx = item.second;
             // only rebroadcast unconfirmed txes older than 5 minutes before the
             // last block was found
             if (wtx.nTimeReceived > m_best_block_time - 5 * 60) {
                 continue;
             }
             if (wtx.RelayWalletTransaction(*locked_chain)) {
                 ++relayed_tx_count;
             }
         }
     } // locked_chain and cs_wallet
 
     if (relayed_tx_count > 0) {
         WalletLogPrintf("%s: rebroadcast %u unconfirmed transactions\n",
                         __func__, relayed_tx_count);
     }
 }
 
 /** @} */ // end of mapWallet
 
 void MaybeResendWalletTxs() {
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         pwallet->ResendWalletTransactions();
     }
 }
 
 /**
  * @defgroup Actions
  *
  * @{
  */
 CWallet::Balance CWallet::GetBalance(const int min_depth) const {
     Balance ret;
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
     for (const auto &entry : mapWallet) {
         const CWalletTx &wtx = entry.second;
         const bool is_trusted{wtx.IsTrusted(*locked_chain)};
         const int tx_depth{wtx.GetDepthInMainChain(*locked_chain)};
         const Amount tx_credit_mine{wtx.GetAvailableCredit(
             *locked_chain, /* fUseCache */ true, ISMINE_SPENDABLE)};
         const Amount tx_credit_watchonly{wtx.GetAvailableCredit(
             *locked_chain, /* fUseCache */ true, ISMINE_WATCH_ONLY)};
         if (is_trusted && tx_depth >= min_depth) {
             ret.m_mine_trusted += tx_credit_mine;
             ret.m_watchonly_trusted += tx_credit_watchonly;
         }
         if (!is_trusted && tx_depth == 0 && wtx.InMempool()) {
             ret.m_mine_untrusted_pending += tx_credit_mine;
             ret.m_watchonly_untrusted_pending += tx_credit_watchonly;
         }
         ret.m_mine_immature += wtx.GetImmatureCredit(*locked_chain);
         ret.m_watchonly_immature +=
             wtx.GetImmatureWatchOnlyCredit(*locked_chain);
     }
     return ret;
 }
 
 Amount CWallet::GetAvailableBalance(const CCoinControl *coinControl) const {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     Amount balance = Amount::zero();
     std::vector<COutput> vCoins;
     AvailableCoins(*locked_chain, vCoins, true, coinControl);
     for (const COutput &out : vCoins) {
         if (out.fSpendable) {
             balance += out.tx->tx->vout[out.i].nValue;
         }
     }
     return balance;
 }
 
 void CWallet::AvailableCoins(interfaces::Chain::Lock &locked_chain,
                              std::vector<COutput> &vCoins, bool fOnlySafe,
                              const CCoinControl *coinControl,
                              const Amount nMinimumAmount,
                              const Amount nMaximumAmount,
                              const Amount nMinimumSumAmount,
                              const uint64_t nMaximumCount, const int nMinDepth,
                              const int nMaxDepth) const {
     AssertLockHeld(cs_wallet);
 
     vCoins.clear();
     Amount nTotal = Amount::zero();
 
     const Consensus::Params params = Params().GetConsensus();
 
     for (const auto &entry : mapWallet) {
         const TxId &wtxid = entry.first;
         const CWalletTx &wtx = entry.second;
 
         CValidationState state;
         if (!locked_chain.contextualCheckTransactionForCurrentBlock(
                 params, *wtx.tx, state)) {
             continue;
         }
 
         if (wtx.IsImmatureCoinBase(locked_chain)) {
             continue;
         }
 
         int nDepth = wtx.GetDepthInMainChain(locked_chain);
         if (nDepth < 0) {
             continue;
         }
 
         // We should not consider coins which aren't at least in our mempool.
         // It's possible for these to be conflicted via ancestors which we may
         // never be able to detect.
         if (nDepth == 0 && !wtx.InMempool()) {
             continue;
         }
 
         bool safeTx = wtx.IsTrusted(locked_chain);
 
         // Bitcoin-ABC: Removed check that prevents consideration of coins from
         // transactions that are replacing other transactions. This check based
         // on wtx.mapValue.count("replaces_txid") which was not being set
         // anywhere.
 
         // Similarly, we should not consider coins from transactions that have
         // been replaced. In the example above, we would want to prevent
         // creation of a transaction A' spending an output of A, because if
         // transaction B were initially confirmed, conflicting with A and A', we
         // wouldn't want to the user to create a transaction D intending to
         // replace A', but potentially resulting in a scenario where A, A', and
         // D could all be accepted (instead of just B and D, or just A and A'
         // like the user would want).
 
         // Bitcoin-ABC: retained this check as 'replaced_by_txid' is still set
         // in the wallet code.
         if (nDepth == 0 && wtx.mapValue.count("replaced_by_txid")) {
             safeTx = false;
         }
 
         if (fOnlySafe && !safeTx) {
             continue;
         }
 
         if (nDepth < nMinDepth || nDepth > nMaxDepth) {
             continue;
         }
 
         for (uint32_t i = 0; i < wtx.tx->vout.size(); i++) {
             if (wtx.tx->vout[i].nValue < nMinimumAmount ||
                 wtx.tx->vout[i].nValue > nMaximumAmount) {
                 continue;
             }
 
             const COutPoint outpoint(wtxid, i);
 
             if (coinControl && coinControl->HasSelected() &&
                 !coinControl->fAllowOtherInputs &&
                 !coinControl->IsSelected(outpoint)) {
                 continue;
             }
 
             if (IsLockedCoin(outpoint)) {
                 continue;
             }
 
             if (IsSpent(locked_chain, outpoint)) {
                 continue;
             }
 
             isminetype mine = IsMine(wtx.tx->vout[i]);
 
             if (mine == ISMINE_NO) {
                 continue;
             }
 
             bool solvable = IsSolvable(*this, wtx.tx->vout[i].scriptPubKey);
             bool spendable =
                 ((mine & ISMINE_SPENDABLE) != ISMINE_NO) ||
                 (((mine & ISMINE_WATCH_ONLY) != ISMINE_NO) &&
                  (coinControl && coinControl->fAllowWatchOnly && solvable));
 
             vCoins.push_back(
                 COutput(&wtx, i, nDepth, spendable, solvable, safeTx,
                         (coinControl && coinControl->fAllowWatchOnly)));
 
             // Checks the sum amount of all UTXO's.
             if (nMinimumSumAmount != MAX_MONEY) {
                 nTotal += wtx.tx->vout[i].nValue;
 
                 if (nTotal >= nMinimumSumAmount) {
                     return;
                 }
             }
 
             // Checks the maximum number of UTXO's.
             if (nMaximumCount > 0 && vCoins.size() >= nMaximumCount) {
                 return;
             }
         }
     }
 }
 
 std::map<CTxDestination, std::vector<COutput>>
 CWallet::ListCoins(interfaces::Chain::Lock &locked_chain) const {
     AssertLockHeld(cs_wallet);
 
     std::map<CTxDestination, std::vector<COutput>> result;
     std::vector<COutput> availableCoins;
 
     AvailableCoins(locked_chain, availableCoins);
 
     for (const auto &coin : availableCoins) {
         CTxDestination address;
         if (coin.fSpendable &&
             ExtractDestination(
                 FindNonChangeParentOutput(*coin.tx->tx, coin.i).scriptPubKey,
                 address)) {
             result[address].emplace_back(std::move(coin));
         }
     }
 
     std::vector<COutPoint> lockedCoins;
     ListLockedCoins(lockedCoins);
     for (const auto &output : lockedCoins) {
         auto it = mapWallet.find(output.GetTxId());
         if (it != mapWallet.end()) {
             int depth = it->second.GetDepthInMainChain(locked_chain);
             if (depth >= 0 && output.GetN() < it->second.tx->vout.size() &&
                 IsMine(it->second.tx->vout[output.GetN()]) ==
                     ISMINE_SPENDABLE) {
                 CTxDestination address;
                 if (ExtractDestination(
                         FindNonChangeParentOutput(*it->second.tx, output.GetN())
                             .scriptPubKey,
                         address)) {
                     result[address].emplace_back(
                         &it->second, output.GetN(), depth, true /* spendable */,
                         true /* solvable */, false /* safe */);
                 }
             }
         }
     }
 
     return result;
 }
 
 const CTxOut &CWallet::FindNonChangeParentOutput(const CTransaction &tx,
                                                  int output) const {
     const CTransaction *ptx = &tx;
     int n = output;
     while (IsChange(ptx->vout[n]) && ptx->vin.size() > 0) {
         const COutPoint &prevout = ptx->vin[0].prevout;
         auto it = mapWallet.find(prevout.GetTxId());
         if (it == mapWallet.end() ||
             it->second.tx->vout.size() <= prevout.GetN() ||
             !IsMine(it->second.tx->vout[prevout.GetN()])) {
             break;
         }
         ptx = it->second.tx.get();
         n = prevout.GetN();
     }
     return ptx->vout[n];
 }
 
 bool CWallet::SelectCoinsMinConf(
     const Amount nTargetValue, const CoinEligibilityFilter &eligibility_filter,
     std::vector<OutputGroup> groups, std::set<CInputCoin> &setCoinsRet,
     Amount &nValueRet, const CoinSelectionParams &coin_selection_params,
     bool &bnb_used) const {
     setCoinsRet.clear();
     nValueRet = Amount::zero();
 
     std::vector<OutputGroup> utxo_pool;
     if (coin_selection_params.use_bnb) {
         // Get long term estimate
         CCoinControl temp;
         temp.m_confirm_target = 1008;
         CFeeRate long_term_feerate = GetMinimumFeeRate(*this, temp);
 
         // Calculate cost of change
         Amount cost_of_change =
             dustRelayFee.GetFee(coin_selection_params.change_spend_size) +
             coin_selection_params.effective_fee.GetFee(
                 coin_selection_params.change_output_size);
 
         // Filter by the min conf specs and add to utxo_pool and calculate
         // effective value
         for (OutputGroup &group : groups) {
             if (!group.EligibleForSpending(eligibility_filter)) {
                 continue;
             }
 
             group.fee = Amount::zero();
             group.long_term_fee = Amount::zero();
             group.effective_value = Amount::zero();
             for (auto it = group.m_outputs.begin();
                  it != group.m_outputs.end();) {
                 const CInputCoin &coin = *it;
                 Amount effective_value =
                     coin.txout.nValue -
                     (coin.m_input_bytes < 0
                          ? Amount::zero()
                          : coin_selection_params.effective_fee.GetFee(
                                coin.m_input_bytes));
                 // Only include outputs that are positive effective value (i.e.
                 // not dust)
                 if (effective_value > Amount::zero()) {
                     group.fee +=
                         coin.m_input_bytes < 0
                             ? Amount::zero()
                             : coin_selection_params.effective_fee.GetFee(
                                   coin.m_input_bytes);
                     group.long_term_fee +=
                         coin.m_input_bytes < 0
                             ? Amount::zero()
                             : long_term_feerate.GetFee(coin.m_input_bytes);
                     group.effective_value += effective_value;
                     ++it;
                 } else {
                     it = group.Discard(coin);
                 }
             }
             if (group.effective_value > Amount::zero()) {
                 utxo_pool.push_back(group);
             }
         }
         // Calculate the fees for things that aren't inputs
         Amount not_input_fees = coin_selection_params.effective_fee.GetFee(
             coin_selection_params.tx_noinputs_size);
         bnb_used = true;
         return SelectCoinsBnB(utxo_pool, nTargetValue, cost_of_change,
                               setCoinsRet, nValueRet, not_input_fees);
     } else {
         // Filter by the min conf specs and add to utxo_pool
         for (const OutputGroup &group : groups) {
             if (!group.EligibleForSpending(eligibility_filter)) {
                 continue;
             }
             utxo_pool.push_back(group);
         }
         bnb_used = false;
         return KnapsackSolver(nTargetValue, utxo_pool, setCoinsRet, nValueRet);
     }
 }
 
 bool CWallet::SelectCoins(const std::vector<COutput> &vAvailableCoins,
                           const Amount nTargetValue,
                           std::set<CInputCoin> &setCoinsRet, Amount &nValueRet,
                           const CCoinControl &coin_control,
                           CoinSelectionParams &coin_selection_params,
                           bool &bnb_used) const {
     std::vector<COutput> vCoins(vAvailableCoins);
 
     // coin control -> return all selected outputs (we want all selected to go
     // into the transaction for sure)
     if (coin_control.HasSelected() && !coin_control.fAllowOtherInputs) {
         // We didn't use BnB here, so set it to false.
         bnb_used = false;
 
         for (const COutput &out : vCoins) {
             if (!out.fSpendable) {
                 continue;
             }
 
             nValueRet += out.tx->tx->vout[out.i].nValue;
             setCoinsRet.insert(out.GetInputCoin());
         }
 
         return (nValueRet >= nTargetValue);
     }
 
     // Calculate value from preset inputs and store them.
     std::set<CInputCoin> setPresetCoins;
     Amount nValueFromPresetInputs = Amount::zero();
 
     std::vector<COutPoint> vPresetInputs;
     coin_control.ListSelected(vPresetInputs);
 
     for (const COutPoint &outpoint : vPresetInputs) {
         // For now, don't use BnB if preset inputs are selected. TODO: Enable
         // this later
         bnb_used = false;
         coin_selection_params.use_bnb = false;
 
         std::map<TxId, CWalletTx>::const_iterator it =
             mapWallet.find(outpoint.GetTxId());
         if (it == mapWallet.end()) {
             // TODO: Allow non-wallet inputs
             return false;
         }
 
         const CWalletTx &wtx = it->second;
         // Clearly invalid input, fail.
         if (wtx.tx->vout.size() <= outpoint.GetN()) {
             return false;
         }
 
         // Just to calculate the marginal byte size
         nValueFromPresetInputs += wtx.tx->vout[outpoint.GetN()].nValue;
         setPresetCoins.insert(CInputCoin(wtx.tx, outpoint.GetN()));
     }
 
     // Remove preset inputs from vCoins
     for (std::vector<COutput>::iterator it = vCoins.begin();
          it != vCoins.end() && coin_control.HasSelected();) {
         if (setPresetCoins.count(it->GetInputCoin())) {
             it = vCoins.erase(it);
         } else {
             ++it;
         }
     }
 
     // form groups from remaining coins; note that preset coins will not
     // automatically have their associated (same address) coins included
     if (coin_control.m_avoid_partial_spends &&
         vCoins.size() > OUTPUT_GROUP_MAX_ENTRIES) {
         // Cases where we have 11+ outputs all pointing to the same destination
         // may result in privacy leaks as they will potentially be
         // deterministically sorted. We solve that by explicitly shuffling the
         // outputs before processing
         Shuffle(vCoins.begin(), vCoins.end(), FastRandomContext());
     }
     std::vector<OutputGroup> groups =
         GroupOutputs(vCoins, !coin_control.m_avoid_partial_spends);
 
     size_t max_ancestors = std::max<size_t>(
         1, gArgs.GetArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT));
     size_t max_descendants = std::max<size_t>(
         1, gArgs.GetArg("-limitdescendantcount", DEFAULT_DESCENDANT_LIMIT));
     bool fRejectLongChains = gArgs.GetBoolArg(
         "-walletrejectlongchains", DEFAULT_WALLET_REJECT_LONG_CHAINS);
 
     bool res =
         nTargetValue <= nValueFromPresetInputs ||
         SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs,
                            CoinEligibilityFilter(1, 6, 0), groups, setCoinsRet,
                            nValueRet, coin_selection_params, bnb_used) ||
         SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs,
                            CoinEligibilityFilter(1, 1, 0), groups, setCoinsRet,
                            nValueRet, coin_selection_params, bnb_used) ||
         (m_spend_zero_conf_change &&
          SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs,
                             CoinEligibilityFilter(0, 1, 2), groups, setCoinsRet,
                             nValueRet, coin_selection_params, bnb_used)) ||
         (m_spend_zero_conf_change &&
          SelectCoinsMinConf(
              nTargetValue - nValueFromPresetInputs,
              CoinEligibilityFilter(0, 1, std::min<size_t>(4, max_ancestors / 3),
                                    std::min<size_t>(4, max_descendants / 3)),
              groups, setCoinsRet, nValueRet, coin_selection_params,
              bnb_used)) ||
         (m_spend_zero_conf_change &&
          SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs,
                             CoinEligibilityFilter(0, 1, max_ancestors / 2,
                                                   max_descendants / 2),
                             groups, setCoinsRet, nValueRet,
                             coin_selection_params, bnb_used)) ||
         (m_spend_zero_conf_change &&
          SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs,
                             CoinEligibilityFilter(0, 1, max_ancestors - 1,
                                                   max_descendants - 1),
                             groups, setCoinsRet, nValueRet,
                             coin_selection_params, bnb_used)) ||
         (m_spend_zero_conf_change && !fRejectLongChains &&
          SelectCoinsMinConf(
              nTargetValue - nValueFromPresetInputs,
              CoinEligibilityFilter(0, 1, std::numeric_limits<uint64_t>::max()),
              groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used));
 
     // Because SelectCoinsMinConf clears the setCoinsRet, we now add the
     // possible inputs to the coinset.
     util::insert(setCoinsRet, setPresetCoins);
 
     // Add preset inputs to the total value selected.
     nValueRet += nValueFromPresetInputs;
 
     return res;
 }
 
 bool CWallet::SignTransaction(CMutableTransaction &tx) {
     // sign the new tx
     int nIn = 0;
     for (CTxIn &input : tx.vin) {
         auto mi = mapWallet.find(input.prevout.GetTxId());
         if (mi == mapWallet.end() ||
             input.prevout.GetN() >= mi->second.tx->vout.size()) {
             return false;
         }
         const CScript &scriptPubKey =
             mi->second.tx->vout[input.prevout.GetN()].scriptPubKey;
         const Amount amount = mi->second.tx->vout[input.prevout.GetN()].nValue;
         SignatureData sigdata;
         SigHashType sigHashType = SigHashType().withForkId();
         if (!ProduceSignature(*this,
                               MutableTransactionSignatureCreator(
                                   &tx, nIn, amount, sigHashType),
                               scriptPubKey, sigdata)) {
             return false;
         }
         UpdateInput(input, sigdata);
         nIn++;
     }
     return true;
 }
 
 bool CWallet::FundTransaction(CMutableTransaction &tx, Amount &nFeeRet,
                               int &nChangePosInOut, std::string &strFailReason,
                               bool lockUnspents,
                               const std::set<int> &setSubtractFeeFromOutputs,
                               CCoinControl coinControl) {
     std::vector<CRecipient> vecSend;
 
     // Turn the txout set into a CRecipient vector.
     for (size_t idx = 0; idx < tx.vout.size(); idx++) {
         const CTxOut &txOut = tx.vout[idx];
         CRecipient recipient = {txOut.scriptPubKey, txOut.nValue,
                                 setSubtractFeeFromOutputs.count(idx) == 1};
         vecSend.push_back(recipient);
     }
 
     coinControl.fAllowOtherInputs = true;
 
     for (const CTxIn &txin : tx.vin) {
         coinControl.Select(txin.prevout);
     }
 
     // Acquire the locks to prevent races to the new locked unspents between the
     // CreateTransaction call and LockCoin calls (when lockUnspents is true).
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     CReserveKey reservekey(this);
     CTransactionRef tx_new;
     if (!CreateTransaction(*locked_chain, vecSend, tx_new, reservekey, nFeeRet,
                            nChangePosInOut, strFailReason, coinControl,
                            false)) {
         return false;
     }
 
     if (nChangePosInOut != -1) {
         tx.vout.insert(tx.vout.begin() + nChangePosInOut,
                        tx_new->vout[nChangePosInOut]);
         // We don't have the normal Create/Commit cycle, and don't want to
         // risk reusing change, so just remove the key from the keypool
         // here.
         reservekey.KeepKey();
     }
 
     // Copy output sizes from new transaction; they may have had the fee
     // subtracted from them.
     for (size_t idx = 0; idx < tx.vout.size(); idx++) {
         tx.vout[idx].nValue = tx_new->vout[idx].nValue;
     }
 
     // Add new txins (keeping original txin scriptSig/order)
     for (const CTxIn &txin : tx_new->vin) {
         if (!coinControl.IsSelected(txin.prevout)) {
             tx.vin.push_back(txin);
 
             if (lockUnspents) {
                 LockCoin(txin.prevout);
             }
         }
     }
 
     if (nFeeRet > this->m_default_max_tx_fee) {
         strFailReason =
             TransactionErrorString(TransactionError::MAX_FEE_EXCEEDED);
         return false;
     }
 
     return true;
 }
 
 static bool IsCurrentForAntiFeeSniping(interfaces::Chain &chain,
                                        interfaces::Chain::Lock &locked_chain) {
     if (chain.isInitialBlockDownload()) {
         return false;
     }
 
     // in seconds
     constexpr int64_t MAX_ANTI_FEE_SNIPING_TIP_AGE = 8 * 60 * 60;
     if (locked_chain.getBlockTime(*locked_chain.getHeight()) <
         (GetTime() - MAX_ANTI_FEE_SNIPING_TIP_AGE)) {
         return false;
     }
     return true;
 }
 
 /**
  * Return a height-based locktime for new transactions (uses the height of the
  * current chain tip unless we are not synced with the current chain
  */
 static uint32_t
 GetLocktimeForNewTransaction(interfaces::Chain &chain,
                              interfaces::Chain::Lock &locked_chain) {
     uint32_t const height = locked_chain.getHeight().value_or(-1);
     uint32_t locktime;
     // Discourage fee sniping.
     //
     // For a large miner the value of the transactions in the best block and
     // the mempool can exceed the cost of deliberately attempting to mine two
     // blocks to orphan the current best block. By setting nLockTime such that
     // only the next block can include the transaction, we discourage this
     // practice as the height restricted and limited blocksize gives miners
     // considering fee sniping fewer options for pulling off this attack.
     //
     // A simple way to think about this is from the wallet's point of view we
     // always want the blockchain to move forward. By setting nLockTime this
     // way we're basically making the statement that we only want this
     // transaction to appear in the next block; we don't want to potentially
     // encourage reorgs by allowing transactions to appear at lower heights
     // than the next block in forks of the best chain.
     //
     // Of course, the subsidy is high enough, and transaction volume low
     // enough, that fee sniping isn't a problem yet, but by implementing a fix
     // now we ensure code won't be written that makes assumptions about
     // nLockTime that preclude a fix later.
     if (IsCurrentForAntiFeeSniping(chain, locked_chain)) {
         locktime = height;
 
         // Secondly occasionally randomly pick a nLockTime even further back, so
         // that transactions that are delayed after signing for whatever reason,
         // e.g. high-latency mix networks and some CoinJoin implementations,
         // have better privacy.
         if (GetRandInt(10) == 0) {
             locktime = std::max(0, int(locktime) - GetRandInt(100));
         }
     } else {
         // If our chain is lagging behind, we can't discourage fee sniping nor
         // help the privacy of high-latency transactions. To avoid leaking a
         // potentially unique "nLockTime fingerprint", set nLockTime to a
         // constant.
         locktime = 0;
     }
     assert(locktime <= height);
     assert(locktime < LOCKTIME_THRESHOLD);
     return locktime;
 }
 
 OutputType
 CWallet::TransactionChangeType(OutputType change_type,
                                const std::vector<CRecipient> &vecSend) {
     // If -changetype is specified, always use that change type.
     if (change_type != OutputType::CHANGE_AUTO) {
         return change_type;
     }
 
     // if m_default_address_type is legacy, use legacy address as change.
     if (m_default_address_type == OutputType::LEGACY) {
         return OutputType::LEGACY;
     }
 
     // else use m_default_address_type for change
     return m_default_address_type;
 }
 
 bool CWallet::CreateTransaction(interfaces::Chain::Lock &locked_chainIn,
                                 const std::vector<CRecipient> &vecSend,
                                 CTransactionRef &tx, CReserveKey &reservekey,
                                 Amount &nFeeRet, int &nChangePosInOut,
                                 std::string &strFailReason,
                                 const CCoinControl &coinControl, bool sign) {
     Amount nValue = Amount::zero();
     int nChangePosRequest = nChangePosInOut;
     unsigned int nSubtractFeeFromAmount = 0;
     for (const auto &recipient : vecSend) {
         if (nValue < Amount::zero() || recipient.nAmount < Amount::zero()) {
             strFailReason =
                 _("Transaction amounts must not be negative").translated;
             return false;
         }
 
         nValue += recipient.nAmount;
 
         if (recipient.fSubtractFeeFromAmount) {
             nSubtractFeeFromAmount++;
         }
     }
 
     if (vecSend.empty()) {
         strFailReason =
             _("Transaction must have at least one recipient").translated;
         return false;
     }
 
     CMutableTransaction txNew;
 
     txNew.nLockTime = GetLocktimeForNewTransaction(chain(), locked_chainIn);
 
     {
         std::set<CInputCoin> setCoins;
         auto locked_chain = chain().lock();
         LOCK(cs_wallet);
 
         std::vector<COutput> vAvailableCoins;
         AvailableCoins(*locked_chain, vAvailableCoins, true, &coinControl);
         // Parameters for coin selection, init with dummy
         CoinSelectionParams coin_selection_params;
 
         // Create change script that will be used if we need change
         // TODO: pass in scriptChange instead of reservekey so
         // change transaction isn't always pay-to-bitcoin-address
         CScript scriptChange;
 
         // coin control: send change to custom address
         if (!boost::get<CNoDestination>(&coinControl.destChange)) {
             scriptChange = GetScriptForDestination(coinControl.destChange);
 
             // no coin control: send change to newly generated address
         } else {
             // Note: We use a new key here to keep it from being obvious
             // which side is the change.
             //  The drawback is that by not reusing a previous key, the
             //  change may be lost if a backup is restored, if the backup
             //  doesn't have the new private key for the change. If we
             //  reused the old key, it would be possible to add code to look
             //  for and rediscover unknown transactions that were written
             //  with keys of ours to recover post-backup change.
 
             // Reserve a new key pair from key pool
             if (!CanGetAddresses(true)) {
                 strFailReason =
                     _("Can't generate a change-address key. No keys in the "
                       "internal keypool and can't generate any keys.")
                         .translated;
                 return false;
             }
             CPubKey vchPubKey;
             bool ret;
             ret = reservekey.GetReservedKey(vchPubKey, true);
             if (!ret) {
                 strFailReason =
                     _("Keypool ran out, please call keypoolrefill first")
                         .translated;
                 return false;
             }
 
             const OutputType change_type = TransactionChangeType(
                 coinControl.m_change_type ? *coinControl.m_change_type
                                           : m_default_change_type,
                 vecSend);
 
             LearnRelatedScripts(vchPubKey, change_type);
             scriptChange = GetScriptForDestination(
                 GetDestinationForKey(vchPubKey, change_type));
         }
         CTxOut change_prototype_txout(Amount::zero(), scriptChange);
         coin_selection_params.change_output_size =
             GetSerializeSize(change_prototype_txout);
 
         // Get the fee rate to use effective values in coin selection
         CFeeRate nFeeRateNeeded = GetMinimumFeeRate(*this, coinControl);
 
         nFeeRet = Amount::zero();
         bool pick_new_inputs = true;
         Amount nValueIn = Amount::zero();
 
         // BnB selector is the only selector used when this is true.
         // That should only happen on the first pass through the loop.
         // If we are doing subtract fee from recipient, then don't use BnB
         coin_selection_params.use_bnb = nSubtractFeeFromAmount == 0;
         // Start with no fee and loop until there is enough fee
         while (true) {
             nChangePosInOut = nChangePosRequest;
             txNew.vin.clear();
             txNew.vout.clear();
             bool fFirst = true;
 
             Amount nValueToSelect = nValue;
             if (nSubtractFeeFromAmount == 0) {
                 nValueToSelect += nFeeRet;
             }
 
             // Static size overhead + outputs vsize. 4 nVersion, 4 nLocktime, 1
             // input count, 1 output count
             coin_selection_params.tx_noinputs_size = 10;
             // vouts to the payees
             for (const auto &recipient : vecSend) {
                 CTxOut txout(recipient.nAmount, recipient.scriptPubKey);
 
                 if (recipient.fSubtractFeeFromAmount) {
                     assert(nSubtractFeeFromAmount != 0);
                     // Subtract fee equally from each selected recipient.
                     txout.nValue -= nFeeRet / int(nSubtractFeeFromAmount);
 
                     // First receiver pays the remainder not divisible by output
                     // count.
                     if (fFirst) {
                         fFirst = false;
                         txout.nValue -= nFeeRet % int(nSubtractFeeFromAmount);
                     }
                 }
 
                 // Include the fee cost for outputs. Note this is only used for
                 // BnB right now
                 coin_selection_params.tx_noinputs_size +=
                     ::GetSerializeSize(txout, PROTOCOL_VERSION);
 
                 if (IsDust(txout, chain().relayDustFee())) {
                     if (recipient.fSubtractFeeFromAmount &&
                         nFeeRet > Amount::zero()) {
                         if (txout.nValue < Amount::zero()) {
                             strFailReason = _("The transaction amount is too "
                                               "small to pay the fee")
                                                 .translated;
                         } else {
                             strFailReason =
                                 _("The transaction amount is too small to "
                                   "send after the fee has been deducted")
                                     .translated;
                         }
                     } else {
                         strFailReason =
                             _("Transaction amount too small").translated;
                     }
 
                     return false;
                 }
 
                 txNew.vout.push_back(txout);
             }
 
             // Choose coins to use
             bool bnb_used;
             if (pick_new_inputs) {
                 nValueIn = Amount::zero();
                 setCoins.clear();
                 coin_selection_params.change_spend_size =
                     CalculateMaximumSignedInputSize(change_prototype_txout,
                                                     this);
                 coin_selection_params.effective_fee = nFeeRateNeeded;
                 if (!SelectCoins(vAvailableCoins, nValueToSelect, setCoins,
                                  nValueIn, coinControl, coin_selection_params,
                                  bnb_used)) {
                     // If BnB was used, it was the first pass. No longer the
                     // first pass and continue loop with knapsack.
                     if (bnb_used) {
                         coin_selection_params.use_bnb = false;
                         continue;
                     } else {
                         strFailReason = _("Insufficient funds").translated;
                         return false;
                     }
                 }
             }
 
             const Amount nChange = nValueIn - nValueToSelect;
             if (nChange > Amount::zero()) {
                 // Fill a vout to ourself.
                 CTxOut newTxOut(nChange, scriptChange);
 
                 // Never create dust outputs; if we would, just add the dust to
                 // the fee.
                 // The nChange when BnB is used is always going to go to fees.
                 if (IsDust(newTxOut, dustRelayFee) || bnb_used) {
                     nChangePosInOut = -1;
                     nFeeRet += nChange;
                 } else {
                     if (nChangePosInOut == -1) {
                         // Insert change txn at random position:
                         nChangePosInOut = GetRandInt(txNew.vout.size() + 1);
                     } else if ((unsigned int)nChangePosInOut >
                                txNew.vout.size()) {
                         strFailReason =
                             _("Change index out of range").translated;
                         return false;
                     }
 
                     std::vector<CTxOut>::iterator position =
                         txNew.vout.begin() + nChangePosInOut;
                     txNew.vout.insert(position, newTxOut);
                 }
             } else {
                 nChangePosInOut = -1;
             }
 
             // Dummy fill vin for maximum size estimation
             //
             for (const auto &coin : setCoins) {
                 txNew.vin.push_back(CTxIn(coin.outpoint, CScript()));
             }
 
             CTransaction txNewConst(txNew);
             int nBytes = CalculateMaximumSignedTxSize(
                 txNewConst, this, coinControl.fAllowWatchOnly);
             if (nBytes < 0) {
                 strFailReason = _("Signing transaction failed").translated;
                 return false;
             }
 
             Amount nFeeNeeded = GetMinimumFee(*this, nBytes, coinControl);
 
             // If we made it here and we aren't even able to meet the relay fee
             // on the next pass, give up because we must be at the maximum
             // allowed fee.
             if (nFeeNeeded < chain().relayMinFee().GetFee(nBytes)) {
                 strFailReason =
                     _("Transaction too large for fee policy").translated;
                 return false;
             }
 
             if (nFeeRet >= nFeeNeeded) {
                 // Reduce fee to only the needed amount if possible. This
                 // prevents potential overpayment in fees if the coins selected
                 // to meet nFeeNeeded result in a transaction that requires less
                 // fee than the prior iteration.
 
                 // If we have no change and a big enough excess fee, then try to
                 // construct transaction again only without picking new inputs.
                 // We now know we only need the smaller fee (because of reduced
                 // tx size) and so we should add a change output. Only try this
                 // once.
                 if (nChangePosInOut == -1 && nSubtractFeeFromAmount == 0 &&
                     pick_new_inputs) {
                     // Add 2 as a buffer in case increasing # of outputs changes
                     // compact size
                     unsigned int tx_size_with_change =
                         nBytes + coin_selection_params.change_output_size + 2;
                     Amount fee_needed_with_change =
                         GetMinimumFee(*this, tx_size_with_change, coinControl);
                     Amount minimum_value_for_change =
                         GetDustThreshold(change_prototype_txout, dustRelayFee);
                     if (nFeeRet >=
                         fee_needed_with_change + minimum_value_for_change) {
                         pick_new_inputs = false;
                         nFeeRet = fee_needed_with_change;
                         continue;
                     }
                 }
 
                 // If we have change output already, just increase it
                 if (nFeeRet > nFeeNeeded && nChangePosInOut != -1 &&
                     nSubtractFeeFromAmount == 0) {
                     Amount extraFeePaid = nFeeRet - nFeeNeeded;
                     std::vector<CTxOut>::iterator change_position =
                         txNew.vout.begin() + nChangePosInOut;
                     change_position->nValue += extraFeePaid;
                     nFeeRet -= extraFeePaid;
                 }
 
                 // Done, enough fee included.
                 break;
             } else if (!pick_new_inputs) {
                 // This shouldn't happen, we should have had enough excess fee
                 // to pay for the new output and still meet nFeeNeeded.
                 // Or we should have just subtracted fee from recipients and
                 // nFeeNeeded should not have changed.
                 strFailReason =
                     _("Transaction fee and change calculation failed")
                         .translated;
                 return false;
             }
 
             // Try to reduce change to include necessary fee.
             if (nChangePosInOut != -1 && nSubtractFeeFromAmount == 0) {
                 Amount additionalFeeNeeded = nFeeNeeded - nFeeRet;
                 std::vector<CTxOut>::iterator change_position =
                     txNew.vout.begin() + nChangePosInOut;
                 // Only reduce change if remaining amount is still a large
                 // enough output.
                 if (change_position->nValue >=
                     MIN_FINAL_CHANGE + additionalFeeNeeded) {
                     change_position->nValue -= additionalFeeNeeded;
                     nFeeRet += additionalFeeNeeded;
                     // Done, able to increase fee from change.
                     break;
                 }
             }
 
             // If subtracting fee from recipients, we now know what fee we
             // need to subtract, we have no reason to reselect inputs.
             if (nSubtractFeeFromAmount > 0) {
                 pick_new_inputs = false;
             }
 
             // Include more fee and try again.
             nFeeRet = nFeeNeeded;
             coin_selection_params.use_bnb = false;
             continue;
         }
 
         if (nChangePosInOut == -1) {
             // Return any reserved key if we don't have change
             reservekey.ReturnKey();
         }
 
         // Shuffle selected coins and fill in final vin
         txNew.vin.clear();
         std::vector<CInputCoin> selected_coins(setCoins.begin(),
                                                setCoins.end());
         Shuffle(selected_coins.begin(), selected_coins.end(),
                 FastRandomContext());
 
         // Note how the sequence number is set to non-maxint so that
         // the nLockTime set above actually works.
         for (const auto &coin : selected_coins) {
             txNew.vin.push_back(
                 CTxIn(coin.outpoint, CScript(),
                       std::numeric_limits<uint32_t>::max() - 1));
         }
 
         if (sign) {
             SigHashType sigHashType = SigHashType().withForkId();
 
             int nIn = 0;
             for (const auto &coin : selected_coins) {
                 const CScript &scriptPubKey = coin.txout.scriptPubKey;
                 SignatureData sigdata;
 
                 if (!ProduceSignature(
                         *this,
                         MutableTransactionSignatureCreator(
                             &txNew, nIn, coin.txout.nValue, sigHashType),
                         scriptPubKey, sigdata)) {
                     strFailReason = _("Signing transaction failed").translated;
                     return false;
                 }
 
                 UpdateInput(txNew.vin.at(nIn), sigdata);
                 nIn++;
             }
         }
 
         // Return the constructed transaction data.
         tx = MakeTransactionRef(std::move(txNew));
 
         // Limit size.
         if (tx->GetTotalSize() >= MAX_STANDARD_TX_SIZE) {
             strFailReason = _("Transaction too large").translated;
             return false;
         }
     }
 
     if (gArgs.GetBoolArg("-walletrejectlongchains",
                          DEFAULT_WALLET_REJECT_LONG_CHAINS)) {
         // Lastly, ensure this tx will pass the mempool's chain limits
         if (!chain().checkChainLimits(tx)) {
             strFailReason =
                 _("Transaction has too long of a mempool chain").translated;
             return false;
         }
     }
 
     return true;
 }
 
 /**
  * Call after CreateTransaction unless you want to abort
  */
 bool CWallet::CommitTransaction(
     CTransactionRef tx, mapValue_t mapValue,
     std::vector<std::pair<std::string, std::string>> orderForm,
     CReserveKey &reservekey, CValidationState &state) {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     CWalletTx wtxNew(this, std::move(tx));
     wtxNew.mapValue = std::move(mapValue);
     wtxNew.vOrderForm = std::move(orderForm);
     wtxNew.fTimeReceivedIsTxTime = true;
     wtxNew.fFromMe = true;
 
     WalletLogPrintfToBeContinued("CommitTransaction:\n%s",
                                  wtxNew.tx->ToString());
 
     // Take key pair from key pool so it won't be used again.
     reservekey.KeepKey();
 
     // Add tx to wallet, because if it has change it's also ours, otherwise just
     // for transaction history.
     AddToWallet(wtxNew);
 
     // Notify that old coins are spent.
     for (const CTxIn &txin : wtxNew.tx->vin) {
         CWalletTx &coin = mapWallet.at(txin.prevout.GetTxId());
         coin.BindWallet(this);
         NotifyTransactionChanged(this, coin.GetId(), CT_UPDATED);
     }
 
     // Get the inserted-CWalletTx from mapWallet so that the
     // fInMempool flag is cached properly
     CWalletTx &wtx = mapWallet.at(wtxNew.GetId());
 
     if (fBroadcastTransactions) {
         // Broadcast
         if (!wtx.AcceptToMemoryPool(*locked_chain, state)) {
             WalletLogPrintf("CommitTransaction(): Transaction cannot be "
                             "broadcast immediately, %s\n",
                             FormatStateMessage(state));
             // TODO: if we expect the failure to be long term or permanent,
             // instead delete wtx from the wallet and return failure.
         } else {
             wtx.RelayWalletTransaction(*locked_chain);
         }
     }
 
     return true;
 }
 
 DBErrors CWallet::LoadWallet(bool &fFirstRunRet) {
     LOCK(cs_wallet);
 
     fFirstRunRet = false;
     DBErrors nLoadWalletRet = WalletBatch(*database, "cr+").LoadWallet(this);
     if (nLoadWalletRet == DBErrors::NEED_REWRITE) {
         if (database->Rewrite("\x04pool")) {
             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.
         }
     }
 
     {
         LOCK(cs_KeyStore);
         // This wallet is in its first run if all of these are empty
         fFirstRunRet = mapKeys.empty() && mapCryptedKeys.empty() &&
                        mapWatchKeys.empty() && setWatchOnly.empty() &&
                        mapScripts.empty() &&
                        !IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
                        !IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET);
     }
 
     if (nLoadWalletRet != DBErrors::LOAD_OK) {
         return nLoadWalletRet;
     }
 
     return DBErrors::LOAD_OK;
 }
 
 DBErrors CWallet::ZapSelectTx(std::vector<TxId> &txIdsIn,
                               std::vector<TxId> &txIdsOut) {
     // mapWallet
     AssertLockHeld(cs_wallet);
     DBErrors nZapSelectTxRet =
         WalletBatch(*database, "cr+").ZapSelectTx(txIdsIn, txIdsOut);
     for (const TxId &txid : txIdsOut) {
         const auto &it = mapWallet.find(txid);
         wtxOrdered.erase(it->second.m_it_wtxOrdered);
         mapWallet.erase(it);
     }
 
     if (nZapSelectTxRet == DBErrors::NEED_REWRITE) {
         if (database->Rewrite("\x04pool")) {
             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.
         }
     }
 
     if (nZapSelectTxRet != DBErrors::LOAD_OK) {
         return nZapSelectTxRet;
     }
 
     MarkDirty();
 
     return DBErrors::LOAD_OK;
 }
 
 DBErrors CWallet::ZapWalletTx(std::vector<CWalletTx> &vWtx) {
     DBErrors nZapWalletTxRet = WalletBatch(*database, "cr+").ZapWalletTx(vWtx);
     if (nZapWalletTxRet == DBErrors::NEED_REWRITE) {
         if (database->Rewrite("\x04pool")) {
             LOCK(cs_wallet);
             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.
         }
     }
 
     if (nZapWalletTxRet != DBErrors::LOAD_OK) {
         return nZapWalletTxRet;
     }
 
     return DBErrors::LOAD_OK;
 }
 
 bool CWallet::SetAddressBookWithDB(WalletBatch &batch,
                                    const CTxDestination &address,
                                    const std::string &strName,
                                    const std::string &strPurpose) {
     bool fUpdated = false;
     {
         LOCK(cs_wallet);
         std::map<CTxDestination, CAddressBookData>::iterator mi =
             mapAddressBook.find(address);
         fUpdated = mi != mapAddressBook.end();
         mapAddressBook[address].name = strName;
         // Update purpose only if requested.
         if (!strPurpose.empty()) {
             mapAddressBook[address].purpose = strPurpose;
         }
     }
 
     NotifyAddressBookChanged(this, address, strName,
                              ::IsMine(*this, address) != ISMINE_NO, strPurpose,
                              (fUpdated ? CT_UPDATED : CT_NEW));
     if (!strPurpose.empty() && !batch.WritePurpose(address, strPurpose)) {
         return false;
     }
     return batch.WriteName(address, strName);
 }
 
 bool CWallet::SetAddressBook(const CTxDestination &address,
                              const std::string &strName,
                              const std::string &strPurpose) {
     WalletBatch batch(*database);
     return SetAddressBookWithDB(batch, address, strName, strPurpose);
 }
 
 bool CWallet::DelAddressBook(const CTxDestination &address) {
     {
         LOCK(cs_wallet);
 
         // Delete destdata tuples associated with address.
         for (const std::pair<const std::string, std::string> &item :
              mapAddressBook[address].destdata) {
             WalletBatch(*database).EraseDestData(address, item.first);
         }
 
         mapAddressBook.erase(address);
     }
 
     NotifyAddressBookChanged(this, address, "",
                              ::IsMine(*this, address) != ISMINE_NO, "",
                              CT_DELETED);
 
     WalletBatch(*database).ErasePurpose(address);
     return WalletBatch(*database).EraseName(address);
 }
 
 const std::string &CWallet::GetLabelName(const CScript &scriptPubKey) const {
     CTxDestination address;
     if (ExtractDestination(scriptPubKey, address) &&
         !scriptPubKey.IsUnspendable()) {
         auto mi = mapAddressBook.find(address);
         if (mi != mapAddressBook.end()) {
             return mi->second.name;
         }
     }
     // A scriptPubKey that doesn't have an entry in the address book is
     // associated with the default label ("").
     const static std::string DEFAULT_LABEL_NAME;
     return DEFAULT_LABEL_NAME;
 }
 
 /**
  * Mark old keypool keys as used, and generate all new keys.
  */
 bool CWallet::NewKeyPool() {
     if (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         return false;
     }
     LOCK(cs_wallet);
     WalletBatch batch(*database);
 
     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 (!TopUpKeyPool()) {
         return false;
     }
 
     WalletLogPrintf("CWallet::NewKeyPool rewrote keypool\n");
     return true;
 }
 
 size_t CWallet::KeypoolCountExternalKeys() {
     // setExternalKeyPool
     AssertLockHeld(cs_wallet);
     return setExternalKeyPool.size() + set_pre_split_keypool.size();
 }
 
 void CWallet::LoadKeyPool(int64_t nIndex, const CKeyPool &keypool) {
     AssertLockHeld(cs_wallet);
     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 CWallet::TopUpKeyPool(unsigned int kpSize) {
     if (!CanGenerateKeys()) {
         return false;
     }
     {
         LOCK(cs_wallet);
 
         if (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() || !CanSupportFeature(FEATURE_HD_SPLIT)) {
             // don't create extra internal keys
             missingInternal = 0;
         }
         bool internal = false;
         WalletBatch batch(*database);
         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 CWallet::AddKeypoolPubkeyWithDB(const CPubKey &pubkey, const bool internal,
                                      WalletBatch &batch) {
     LOCK(cs_wallet);
     // 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;
 }
 
 bool CWallet::ReserveKeyFromKeyPool(int64_t &nIndex, CKeyPool &keypool,
                                     bool fRequestedInternal) {
     nIndex = -1;
     keypool.vchPubKey = CPubKey();
     {
         LOCK(cs_wallet);
 
         if (!IsLocked()) {
             TopUpKeyPool();
         }
 
         bool fReturningInternal = fRequestedInternal;
         fReturningInternal &=
             (IsHDEnabled() && CanSupportFeature(FEATURE_HD_SPLIT)) ||
             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(*database);
 
         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");
         }
 
         m_pool_key_to_index.erase(keypool.vchPubKey.GetID());
         WalletLogPrintf("keypool reserve %d\n", nIndex);
     }
     NotifyCanGetAddressesChanged();
     return true;
 }
 
 void CWallet::KeepKey(int64_t nIndex) {
     // Remove from key pool.
     WalletBatch batch(*database);
     batch.ErasePool(nIndex);
     WalletLogPrintf("keypool keep %d\n", nIndex);
 }
 
 void CWallet::ReturnKey(int64_t nIndex, bool fInternal, const CPubKey &pubkey) {
     // Return to key pool
     {
         LOCK(cs_wallet);
         if (fInternal) {
             setInternalKeyPool.insert(nIndex);
         } else if (!set_pre_split_keypool.empty()) {
             set_pre_split_keypool.insert(nIndex);
         } else {
             setExternalKeyPool.insert(nIndex);
         }
         m_pool_key_to_index[pubkey.GetID()] = nIndex;
         NotifyCanGetAddressesChanged();
     }
 
     WalletLogPrintf("keypool return %d\n", nIndex);
 }
 
 bool CWallet::GetKeyFromPool(CPubKey &result, bool internal) {
     if (!CanGetAddresses(internal)) {
         return false;
     }
 
     CKeyPool keypool;
     LOCK(cs_wallet);
     int64_t nIndex;
     if (!ReserveKeyFromKeyPool(nIndex, keypool, internal) &&
         !IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         if (IsLocked()) {
             return false;
         }
         WalletBatch batch(*database);
         result = GenerateNewKey(batch, internal);
         return true;
     }
 
     KeepKey(nIndex);
     result = keypool.vchPubKey;
 
     return true;
 }
 
 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 CWallet::GetOldestKeyPoolTime() {
     LOCK(cs_wallet);
 
     WalletBatch batch(*database);
 
     // load oldest key from keypool, get time and return
     int64_t oldestKey = GetOldestKeyTimeInPool(setExternalKeyPool, batch);
     if (IsHDEnabled() && 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;
 }
 
 std::map<CTxDestination, Amount>
 CWallet::GetAddressBalances(interfaces::Chain::Lock &locked_chain) {
     std::map<CTxDestination, Amount> balances;
 
     LOCK(cs_wallet);
     for (const auto &walletEntry : mapWallet) {
         const CWalletTx &wtx = walletEntry.second;
 
         if (!wtx.IsTrusted(locked_chain)) {
             continue;
         }
 
         if (wtx.IsImmatureCoinBase(locked_chain)) {
             continue;
         }
 
         int nDepth = wtx.GetDepthInMainChain(locked_chain);
         if (nDepth < (wtx.IsFromMe(ISMINE_ALL) ? 0 : 1)) {
             continue;
         }
 
         for (uint32_t i = 0; i < wtx.tx->vout.size(); i++) {
             CTxDestination addr;
             if (!IsMine(wtx.tx->vout[i])) {
                 continue;
             }
 
             if (!ExtractDestination(wtx.tx->vout[i].scriptPubKey, addr)) {
                 continue;
             }
 
             Amount n = IsSpent(locked_chain, COutPoint(walletEntry.first, i))
                            ? Amount::zero()
                            : wtx.tx->vout[i].nValue;
 
             if (!balances.count(addr)) {
                 balances[addr] = Amount::zero();
             }
             balances[addr] += n;
         }
     }
 
     return balances;
 }
 
 std::set<std::set<CTxDestination>> CWallet::GetAddressGroupings() {
     // mapWallet
     AssertLockHeld(cs_wallet);
     std::set<std::set<CTxDestination>> groupings;
     std::set<CTxDestination> grouping;
 
     for (const auto &walletEntry : mapWallet) {
         const CWalletTx &wtx = walletEntry.second;
 
         if (wtx.tx->vin.size() > 0) {
             bool any_mine = false;
             // Group all input addresses with each other.
             for (const auto &txin : wtx.tx->vin) {
                 CTxDestination address;
                 // If this input isn't mine, ignore it.
                 if (!IsMine(txin)) {
                     continue;
                 }
 
                 if (!ExtractDestination(mapWallet.at(txin.prevout.GetTxId())
                                             .tx->vout[txin.prevout.GetN()]
                                             .scriptPubKey,
                                         address)) {
                     continue;
                 }
 
                 grouping.insert(address);
                 any_mine = true;
             }
 
             // Group change with input addresses.
             if (any_mine) {
                 for (const auto &txout : wtx.tx->vout) {
                     if (IsChange(txout)) {
                         CTxDestination txoutAddr;
                         if (!ExtractDestination(txout.scriptPubKey,
                                                 txoutAddr)) {
                             continue;
                         }
 
                         grouping.insert(txoutAddr);
                     }
                 }
             }
 
             if (grouping.size() > 0) {
                 groupings.insert(grouping);
                 grouping.clear();
             }
         }
 
         // Group lone addrs by themselves.
         for (const auto &txout : wtx.tx->vout) {
             if (IsMine(txout)) {
                 CTxDestination address;
                 if (!ExtractDestination(txout.scriptPubKey, address)) {
                     continue;
                 }
 
                 grouping.insert(address);
                 groupings.insert(grouping);
                 grouping.clear();
             }
         }
     }
 
     // A set of pointers to groups of addresses.
     std::set<std::set<CTxDestination> *> uniqueGroupings;
     // Map addresses to the unique group containing it.
     std::map<CTxDestination, std::set<CTxDestination> *> setmap;
     for (std::set<CTxDestination> _grouping : groupings) {
         // Make a set of all the groups hit by this new group.
         std::set<std::set<CTxDestination> *> hits;
         std::map<CTxDestination, std::set<CTxDestination> *>::iterator it;
         for (const CTxDestination &address : _grouping) {
             if ((it = setmap.find(address)) != setmap.end()) {
                 hits.insert((*it).second);
             }
         }
 
         // Merge all hit groups into a new single group and delete old groups.
         std::set<CTxDestination> *merged =
             new std::set<CTxDestination>(_grouping);
         for (std::set<CTxDestination> *hit : hits) {
             merged->insert(hit->begin(), hit->end());
             uniqueGroupings.erase(hit);
             delete hit;
         }
         uniqueGroupings.insert(merged);
 
         // Update setmap.
         for (const CTxDestination &element : *merged) {
             setmap[element] = merged;
         }
     }
 
     std::set<std::set<CTxDestination>> ret;
     for (const std::set<CTxDestination> *uniqueGrouping : uniqueGroupings) {
         ret.insert(*uniqueGrouping);
         delete uniqueGrouping;
     }
 
     return ret;
 }
 
 std::set<CTxDestination>
 CWallet::GetLabelAddresses(const std::string &label) const {
     LOCK(cs_wallet);
     std::set<CTxDestination> result;
     for (const std::pair<const CTxDestination, CAddressBookData> &item :
          mapAddressBook) {
         const CTxDestination &address = item.first;
         const std::string &strName = item.second.name;
         if (strName == label) {
             result.insert(address);
         }
     }
 
     return result;
 }
 
 bool CReserveKey::GetReservedKey(CPubKey &pubkey, bool internal) {
     if (!pwallet->CanGetAddresses(internal)) {
         return false;
     }
 
     if (nIndex == -1) {
         CKeyPool keypool;
         if (!pwallet->ReserveKeyFromKeyPool(nIndex, keypool, internal)) {
             return false;
         }
 
         vchPubKey = keypool.vchPubKey;
         fInternal = keypool.fInternal;
     }
 
     assert(vchPubKey.IsValid());
     pubkey = vchPubKey;
     return true;
 }
 
 void CReserveKey::KeepKey() {
     if (nIndex != -1) {
         pwallet->KeepKey(nIndex);
     }
 
     nIndex = -1;
     vchPubKey = CPubKey();
 }
 
 void CReserveKey::ReturnKey() {
     if (nIndex != -1) {
         pwallet->ReturnKey(nIndex, fInternal, vchPubKey);
     }
     nIndex = -1;
     vchPubKey = CPubKey();
 }
 
 void CWallet::MarkReserveKeysAsUsed(int64_t keypool_id) {
     AssertLockHeld(cs_wallet);
     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(*database);
     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);
     }
 }
 
 void CWallet::GetScriptForMining(std::shared_ptr<CReserveScript> &script) {
     std::shared_ptr<CReserveKey> rKey = std::make_shared<CReserveKey>(this);
     CPubKey pubkey;
     if (!rKey->GetReservedKey(pubkey)) {
         return;
     }
 
     script = rKey;
     script->reserveScript = CScript() << ToByteVector(pubkey) << OP_CHECKSIG;
 }
 
 void CWallet::LockCoin(const COutPoint &output) {
     // setLockedCoins
     AssertLockHeld(cs_wallet);
     setLockedCoins.insert(output);
 }
 
 void CWallet::UnlockCoin(const COutPoint &output) {
     // setLockedCoins
     AssertLockHeld(cs_wallet);
     setLockedCoins.erase(output);
 }
 
 void CWallet::UnlockAllCoins() {
     // setLockedCoins
     AssertLockHeld(cs_wallet);
     setLockedCoins.clear();
 }
 
 bool CWallet::IsLockedCoin(const COutPoint &outpoint) const {
     // setLockedCoins
     AssertLockHeld(cs_wallet);
 
     return setLockedCoins.count(outpoint) > 0;
 }
 
 void CWallet::ListLockedCoins(std::vector<COutPoint> &vOutpts) const {
     // setLockedCoins
     AssertLockHeld(cs_wallet);
     for (COutPoint outpoint : setLockedCoins) {
         vOutpts.push_back(outpoint);
     }
 }
 
 /** @} */ // end of Actions
 
 void CWallet::GetKeyBirthTimes(
     interfaces::Chain::Lock &locked_chain,
     std::map<CTxDestination, int64_t> &mapKeyBirth) const {
     // mapKeyMetadata
     AssertLockHeld(cs_wallet);
     mapKeyBirth.clear();
 
     // Get birth times for keys with metadata.
     for (const auto &entry : mapKeyMetadata) {
         if (entry.second.nCreateTime) {
-            mapKeyBirth[entry.first] = entry.second.nCreateTime;
+            mapKeyBirth[PKHash(entry.first)] = entry.second.nCreateTime;
         }
     }
 
     // Map in which we'll infer heights of other keys
     const Optional<int> tip_height = locked_chain.getHeight();
     // the tip can be reorganized; use a 144-block safety margin
     const int max_height =
         tip_height && *tip_height > 144 ? *tip_height - 144 : 0;
     std::map<CKeyID, int> mapKeyFirstBlock;
     for (const CKeyID &keyid : GetKeys()) {
-        if (mapKeyBirth.count(keyid) == 0) {
+        if (mapKeyBirth.count(PKHash(keyid)) == 0) {
             mapKeyFirstBlock[keyid] = max_height;
         }
     }
 
     // If there are no such keys, we're done.
     if (mapKeyFirstBlock.empty()) {
         return;
     }
 
     // Find first block that affects those keys, if there are any left.
     for (const auto &entry : mapWallet) {
         // iterate over all wallet transactions...
         const CWalletTx &wtx = entry.second;
         if (Optional<int> height = locked_chain.getBlockHeight(wtx.hashBlock)) {
             // ... which are already in a block
             for (const CTxOut &txout : wtx.tx->vout) {
                 // Iterate over all their outputs...
                 for (const auto &keyid :
                      GetAffectedKeys(txout.scriptPubKey, *this)) {
                     // ... and all their affected keys.
                     std::map<CKeyID, int>::iterator rit =
                         mapKeyFirstBlock.find(keyid);
                     if (rit != mapKeyFirstBlock.end() &&
                         *height < rit->second) {
                         rit->second = *height;
                     }
                 }
             }
         }
     }
 
     // Extract block timestamps for those keys.
     for (const auto &entry : mapKeyFirstBlock) {
         // block times can be 2h off
-        mapKeyBirth[entry.first] =
+        mapKeyBirth[PKHash(entry.first)] =
             locked_chain.getBlockTime(entry.second) - TIMESTAMP_WINDOW;
     }
 }
 
 /**
  * Compute smart timestamp for a transaction being added to the wallet.
  *
  * Logic:
  * - If sending a transaction, assign its timestamp to the current time.
  * - If receiving a transaction outside a block, assign its timestamp to the
  *   current time.
  * - If receiving a block with a future timestamp, assign all its (not already
  *   known) transactions' timestamps to the current time.
  * - If receiving a block with a past timestamp, before the most recent known
  *   transaction (that we care about), assign all its (not already known)
  *   transactions' timestamps to the same timestamp as that most-recent-known
  *   transaction.
  * - If receiving a block with a past timestamp, but after the most recent known
  *   transaction, assign all its (not already known) transactions' timestamps to
  *   the block time.
  *
  * For more information see CWalletTx::nTimeSmart,
  * https://bitcointalk.org/?topic=54527, or
  * https://github.com/bitcoin/bitcoin/pull/1393.
  */
 unsigned int CWallet::ComputeTimeSmart(const CWalletTx &wtx) const {
     unsigned int nTimeSmart = wtx.nTimeReceived;
     if (!wtx.hashUnset()) {
         int64_t blocktime;
         if (chain().findBlock(wtx.hashBlock, nullptr /* block */, &blocktime)) {
             int64_t latestNow = wtx.nTimeReceived;
             int64_t latestEntry = 0;
 
             // Tolerate times up to the last timestamp in the wallet not more
             // than 5 minutes into the future
             int64_t latestTolerated = latestNow + 300;
             const TxItems &txOrdered = wtxOrdered;
             for (auto it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) {
                 CWalletTx *const pwtx = it->second;
                 if (pwtx == &wtx) {
                     continue;
                 }
                 int64_t nSmartTime;
                 nSmartTime = pwtx->nTimeSmart;
                 if (!nSmartTime) {
                     nSmartTime = pwtx->nTimeReceived;
                 }
                 if (nSmartTime <= latestTolerated) {
                     latestEntry = nSmartTime;
                     if (nSmartTime > latestNow) {
                         latestNow = nSmartTime;
                     }
                     break;
                 }
             }
 
             nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
         } else {
             WalletLogPrintf("%s: found %s in block %s not in index\n", __func__,
                             wtx.GetId().ToString(), wtx.hashBlock.ToString());
         }
     }
     return nTimeSmart;
 }
 
 bool CWallet::AddDestData(const CTxDestination &dest, const std::string &key,
                           const std::string &value) {
     if (boost::get<CNoDestination>(&dest)) {
         return false;
     }
 
     mapAddressBook[dest].destdata.insert(std::make_pair(key, value));
     return WalletBatch(*database).WriteDestData(dest, key, value);
 }
 
 bool CWallet::EraseDestData(const CTxDestination &dest,
                             const std::string &key) {
     if (!mapAddressBook[dest].destdata.erase(key)) {
         return false;
     }
 
     return WalletBatch(*database).EraseDestData(dest, key);
 }
 
 void CWallet::LoadDestData(const CTxDestination &dest, const std::string &key,
                            const std::string &value) {
     mapAddressBook[dest].destdata.insert(std::make_pair(key, value));
 }
 
 bool CWallet::GetDestData(const CTxDestination &dest, const std::string &key,
                           std::string *value) const {
     std::map<CTxDestination, CAddressBookData>::const_iterator i =
         mapAddressBook.find(dest);
     if (i != mapAddressBook.end()) {
         CAddressBookData::StringMap::const_iterator j =
             i->second.destdata.find(key);
         if (j != i->second.destdata.end()) {
             if (value) {
                 *value = j->second;
             }
 
             return true;
         }
     }
     return false;
 }
 
 std::vector<std::string>
 CWallet::GetDestValues(const std::string &prefix) const {
     std::vector<std::string> values;
     for (const auto &address : mapAddressBook) {
         for (const auto &data : address.second.destdata) {
             if (!data.first.compare(0, prefix.size(), prefix)) {
                 values.emplace_back(data.second);
             }
         }
     }
     return values;
 }
 
 bool CWallet::Verify(const CChainParams &chainParams, interfaces::Chain &chain,
                      const WalletLocation &location, bool salvage_wallet,
                      std::string &error_string, std::string &warning_string) {
     // Do some checking on wallet path. It should be either a:
     //
     // 1. Path where a directory can be created.
     // 2. Path to an existing directory.
     // 3. Path to a symlink to a directory.
     // 4. For backwards compatibility, the name of a data file in -walletdir.
     LOCK(cs_wallets);
     const fs::path &wallet_path = location.GetPath();
     fs::file_type path_type = fs::symlink_status(wallet_path).type();
     if (!(path_type == fs::file_not_found || path_type == fs::directory_file ||
           (path_type == fs::symlink_file && fs::is_directory(wallet_path)) ||
           (path_type == fs::regular_file &&
            fs::path(location.GetName()).filename() == location.GetName()))) {
         error_string =
             strprintf("Invalid -wallet path '%s'. -wallet path should point to "
                       "a directory where wallet.dat and "
                       "database/log.?????????? files can be stored, a location "
                       "where such a directory could be created, "
                       "or (for backwards compatibility) the name of an "
                       "existing data file in -walletdir (%s)",
                       location.GetName(), GetWalletDir());
         return false;
     }
 
     // Make sure that the wallet path doesn't clash with an existing wallet path
     if (IsWalletLoaded(wallet_path)) {
         error_string = strprintf(
             "Error loading wallet %s. Duplicate -wallet filename specified.",
             location.GetName());
         return false;
     }
 
     // Keep same database environment instance across Verify/Recover calls
     // below.
     std::unique_ptr<WalletDatabase> database =
         WalletDatabase::Create(wallet_path);
 
     try {
         if (!WalletBatch::VerifyEnvironment(wallet_path, error_string)) {
             return false;
         }
     } catch (const fs::filesystem_error &e) {
         error_string =
             strprintf("Error loading wallet %s. %s", location.GetName(),
                       fsbridge::get_filesystem_error_message(e));
         return false;
     }
 
     if (salvage_wallet) {
         // Recover readable keypairs:
         CWallet dummyWallet(chainParams, &chain, WalletLocation(),
                             WalletDatabase::CreateDummy());
         std::string backup_filename;
         if (!WalletBatch::Recover(
                 wallet_path, static_cast<void *>(&dummyWallet),
                 WalletBatch::RecoverKeysOnlyFilter, backup_filename)) {
             return false;
         }
     }
 
     return WalletBatch::VerifyDatabaseFile(wallet_path, warning_string,
                                            error_string);
 }
 
 void CWallet::MarkPreSplitKeys() {
     WalletBatch batch(*database);
     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);
     }
 }
 
 std::shared_ptr<CWallet> CWallet::CreateWalletFromFile(
     const CChainParams &chainParams, interfaces::Chain &chain,
     const WalletLocation &location, uint64_t wallet_creation_flags) {
     const std::string &walletFile = location.GetName();
 
     // Needed to restore wallet transaction meta data after -zapwallettxes
     std::vector<CWalletTx> vWtx;
 
     if (gArgs.GetBoolArg("-zapwallettxes", false)) {
         chain.initMessage(
             _("Zapping all transactions from wallet...").translated);
 
         std::unique_ptr<CWallet> tempWallet = std::make_unique<CWallet>(
             chainParams, &chain, location,
             WalletDatabase::Create(location.GetPath()));
         DBErrors nZapWalletRet = tempWallet->ZapWalletTx(vWtx);
         if (nZapWalletRet != DBErrors::LOAD_OK) {
             chain.initError(
                 strprintf(_("Error loading %s: Wallet corrupted").translated,
                           walletFile));
             return nullptr;
         }
     }
 
     chain.initMessage(_("Loading wallet...").translated);
 
     int64_t nStart = GetTimeMillis();
     bool fFirstRun = true;
     // TODO: Can't use std::make_shared because we need a custom deleter but
     // should be possible to use std::allocate_shared.
     std::shared_ptr<CWallet> walletInstance(
         new CWallet(chainParams, &chain, location,
                     WalletDatabase::Create(location.GetPath())),
         ReleaseWallet);
     DBErrors nLoadWalletRet = walletInstance->LoadWallet(fFirstRun);
     if (nLoadWalletRet != DBErrors::LOAD_OK) {
         if (nLoadWalletRet == DBErrors::CORRUPT) {
             chain.initError(
                 strprintf(_("Error loading %s: Wallet corrupted").translated,
                           walletFile));
             return nullptr;
         }
 
         if (nLoadWalletRet == DBErrors::NONCRITICAL_ERROR) {
             chain.initError(strprintf(
                 _("Error reading %s! All keys read correctly, but transaction "
                   "data or address book entries might be missing or incorrect.")
                     .translated,
                 walletFile));
         } else if (nLoadWalletRet == DBErrors::TOO_NEW) {
             chain.initError(strprintf(
                 _("Error loading %s: Wallet requires newer version of %s")
                     .translated,
                 walletFile, PACKAGE_NAME));
             return nullptr;
         } else if (nLoadWalletRet == DBErrors::NEED_REWRITE) {
             chain.initError(strprintf(
                 _("Wallet needed to be rewritten: restart %s to complete")
                     .translated,
                 PACKAGE_NAME));
             return nullptr;
         } else {
             chain.initError(
                 strprintf(_("Error loading %s").translated, walletFile));
             return nullptr;
         }
     }
 
     int prev_version = walletInstance->nWalletVersion;
     if (gArgs.GetBoolArg("-upgradewallet", fFirstRun)) {
         int nMaxVersion = gArgs.GetArg("-upgradewallet", 0);
         // The -upgradewallet without argument case
         if (nMaxVersion == 0) {
             walletInstance->WalletLogPrintf("Performing wallet upgrade to %i\n",
                                             FEATURE_LATEST);
             nMaxVersion = FEATURE_LATEST;
             // permanently upgrade the wallet immediately
             walletInstance->SetMinVersion(FEATURE_LATEST);
         } else {
             walletInstance->WalletLogPrintf(
                 "Allowing wallet upgrade up to %i\n", nMaxVersion);
         }
 
         if (nMaxVersion < walletInstance->GetVersion()) {
             chain.initError(_("Cannot downgrade wallet").translated);
             return nullptr;
         }
 
         walletInstance->SetMaxVersion(nMaxVersion);
     }
 
     // Upgrade to HD if explicit upgrade
     if (gArgs.GetBoolArg("-upgradewallet", false)) {
         LOCK(walletInstance->cs_wallet);
 
         // Do not upgrade versions to any version between HD_SPLIT and
         // FEATURE_PRE_SPLIT_KEYPOOL unless already supporting HD_SPLIT
         int max_version = walletInstance->nWalletVersion;
         if (!walletInstance->CanSupportFeature(FEATURE_HD_SPLIT) &&
             max_version >= FEATURE_HD_SPLIT &&
             max_version < FEATURE_PRE_SPLIT_KEYPOOL) {
             chain.initError(
                 _("Cannot upgrade a non HD split wallet without upgrading to "
                   "support pre split keypool. Please use -upgradewallet=200300 "
                   "or -upgradewallet with no version specified.")
                     .translated);
             return nullptr;
         }
 
         bool hd_upgrade = false;
         bool split_upgrade = false;
         if (walletInstance->CanSupportFeature(FEATURE_HD) &&
             !walletInstance->IsHDEnabled()) {
             walletInstance->WalletLogPrintf("Upgrading wallet to HD\n");
             walletInstance->SetMinVersion(FEATURE_HD);
 
             // generate a new master key
             CPubKey masterPubKey = walletInstance->GenerateNewSeed();
             walletInstance->SetHDSeed(masterPubKey);
             hd_upgrade = true;
         }
         // Upgrade to HD chain split if necessary
         if (walletInstance->CanSupportFeature(FEATURE_HD_SPLIT)) {
             walletInstance->WalletLogPrintf(
                 "Upgrading wallet to use HD chain split\n");
             walletInstance->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) {
             walletInstance->MarkPreSplitKeys();
         }
         // Regenerate the keypool if upgraded to HD
         if (hd_upgrade) {
             if (!walletInstance->TopUpKeyPool()) {
                 chain.initError(_("Unable to generate keys").translated);
                 return nullptr;
             }
         }
     }
 
     if (fFirstRun) {
         // Ensure this wallet.dat can only be opened by clients supporting
         // HD with chain split and expects no default key.
         walletInstance->SetMinVersion(FEATURE_LATEST);
 
         if ((wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
             // selective allow to set flags
             walletInstance->SetWalletFlag(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
         } else if (wallet_creation_flags & WALLET_FLAG_BLANK_WALLET) {
             walletInstance->SetWalletFlag(WALLET_FLAG_BLANK_WALLET);
         } else {
             // generate a new seed
             CPubKey seed = walletInstance->GenerateNewSeed();
             walletInstance->SetHDSeed(seed);
         } // Otherwise, do not generate a new seed
 
         // Top up the keypool
         if (walletInstance->CanGenerateKeys() &&
             !walletInstance->TopUpKeyPool()) {
             chain.initError(_("Unable to generate initial keys").translated);
             return nullptr;
         }
 
         auto locked_chain = chain.lock();
         walletInstance->ChainStateFlushed(locked_chain->getTipLocator());
     } else if (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS) {
         // Make it impossible to disable private keys after creation
         chain.initError(
             strprintf(_("Error loading %s: Private keys can only be "
                         "disabled during creation")
                           .translated,
                       walletFile));
         return nullptr;
     } else if (walletInstance->IsWalletFlagSet(
                    WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         LOCK(walletInstance->cs_KeyStore);
         if (!walletInstance->mapKeys.empty() ||
             !walletInstance->mapCryptedKeys.empty()) {
             chain.initWarning(
                 strprintf(_("Warning: Private keys detected in wallet "
                             "{%s} with disabled private keys")
                               .translated,
                           walletFile));
         }
     }
 
     if (gArgs.IsArgSet("-mintxfee")) {
         Amount n = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-mintxfee", ""), n) ||
             n == Amount::zero()) {
             chain.initError(
                 AmountErrMsg("mintxfee", gArgs.GetArg("-mintxfee", "")));
             return nullptr;
         }
         if (n > HIGH_TX_FEE_PER_KB) {
             chain.initWarning(
                 AmountHighWarn("-mintxfee") + " " +
                 _("This is the minimum transaction fee you pay on "
                   "every transaction.")
                     .translated);
         }
         walletInstance->m_min_fee = CFeeRate(n);
     }
 
     if (gArgs.IsArgSet("-fallbackfee")) {
         Amount nFeePerK = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-fallbackfee", ""), nFeePerK)) {
             chain.initError(strprintf(
                 _("Invalid amount for -fallbackfee=<amount>: '%s'").translated,
                 gArgs.GetArg("-fallbackfee", "")));
             return nullptr;
         }
         if (nFeePerK > HIGH_TX_FEE_PER_KB) {
             chain.initWarning(
                 AmountHighWarn("-fallbackfee") + " " +
                 _("This is the transaction fee you may pay when fee "
                   "estimates are not available.")
                     .translated);
         }
         walletInstance->m_fallback_fee = CFeeRate(nFeePerK);
         // disable fallback fee in case value was set to 0, enable if non-null
         // value
         walletInstance->m_allow_fallback_fee = (nFeePerK != Amount::zero());
     }
     if (gArgs.IsArgSet("-paytxfee")) {
         Amount nFeePerK = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-paytxfee", ""), nFeePerK)) {
             chain.initError(
                 AmountErrMsg("paytxfee", gArgs.GetArg("-paytxfee", "")));
             return nullptr;
         }
         if (nFeePerK > HIGH_TX_FEE_PER_KB) {
             chain.initWarning(
                 AmountHighWarn("-paytxfee") + " " +
                 _("This is the transaction fee you will pay if you "
                   "send a transaction.")
                     .translated);
         }
         walletInstance->m_pay_tx_fee = CFeeRate(nFeePerK, 1000);
         if (walletInstance->m_pay_tx_fee < chain.relayMinFee()) {
             chain.initError(strprintf(
                 _("Invalid amount for -paytxfee=<amount>: '%s' "
                   "(must be at least %s)")
                     .translated,
                 gArgs.GetArg("-paytxfee", ""), chain.relayMinFee().ToString()));
             return nullptr;
         }
     }
 
     if (gArgs.IsArgSet("-maxtxfee")) {
         Amount nMaxFee = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-maxtxfee", ""), nMaxFee)) {
             chain.initError(
                 AmountErrMsg("maxtxfee", gArgs.GetArg("-maxtxfee", "")));
             return nullptr;
         }
         if (nMaxFee > HIGH_MAX_TX_FEE) {
             chain.initWarning(_("-maxtxfee is set very high! Fees this large "
                                 "could be paid on a single transaction.")
                                   .translated);
         }
         if (CFeeRate(nMaxFee, 1000) < chain.relayMinFee()) {
             chain.initError(strprintf(
                 _("Invalid amount for -maxtxfee=<amount>: '%s' (must be at "
                   "least the minrelay fee of %s to prevent stuck transactions)")
                     .translated,
                 gArgs.GetArg("-maxtxfee", ""), chain.relayMinFee().ToString()));
             return nullptr;
         }
         walletInstance->m_default_max_tx_fee = nMaxFee;
     }
 
     if (chain.relayMinFee().GetFeePerK() > HIGH_TX_FEE_PER_KB) {
         chain.initWarning(
             AmountHighWarn("-minrelaytxfee") + " " +
             _("The wallet will avoid paying less than the minimum relay fee.")
                 .translated);
     }
 
     walletInstance->m_spend_zero_conf_change =
         gArgs.GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE);
 
     walletInstance->m_default_address_type = DEFAULT_ADDRESS_TYPE;
     walletInstance->m_default_change_type = DEFAULT_CHANGE_TYPE;
 
     walletInstance->WalletLogPrintf("Wallet completed loading in %15dms\n",
                                     GetTimeMillis() - nStart);
 
     // Try to top up keypool. No-op if the wallet is locked.
     walletInstance->TopUpKeyPool();
 
     auto locked_chain = chain.lock();
     LOCK(walletInstance->cs_wallet);
 
     int rescan_height = 0;
     if (!gArgs.GetBoolArg("-rescan", false)) {
         WalletBatch batch(*walletInstance->database);
         CBlockLocator locator;
         if (batch.ReadBestBlock(locator)) {
             if (const Optional<int> fork_height =
                     locked_chain->findLocatorFork(locator)) {
                 rescan_height = *fork_height;
             }
         }
     }
 
     const Optional<int> tip_height = locked_chain->getHeight();
     if (tip_height) {
         walletInstance->m_last_block_processed =
             locked_chain->getBlockHash(*tip_height);
     } else {
         walletInstance->m_last_block_processed.SetNull();
     }
 
     if (tip_height && *tip_height != rescan_height) {
         // We can't rescan beyond non-pruned blocks, stop and throw an error.
         // This might happen if a user uses an old wallet within a pruned node
         // or if he ran -disablewallet for a longer time, then decided to
         // re-enable.
         if (chain.getPruneMode()) {
             int block_height = *tip_height;
             while (block_height > 0 &&
                    locked_chain->haveBlockOnDisk(block_height - 1) &&
                    rescan_height != block_height) {
                 --block_height;
             }
 
             if (rescan_height != block_height) {
                 chain.initError(
                     _("Prune: last wallet synchronisation goes beyond "
                       "pruned data. You need to -reindex (download the "
                       "whole blockchain again in case of pruned node)")
                         .translated);
                 return nullptr;
             }
         }
 
         chain.initMessage(_("Rescanning...").translated);
         walletInstance->WalletLogPrintf(
             "Rescanning last %i blocks (from block %i)...\n",
             *tip_height - rescan_height, rescan_height);
 
         // No need to read and scan block if block was created before our wallet
         // birthday (as adjusted for block time variability)
         if (walletInstance->nTimeFirstKey) {
             if (Optional<int> first_block =
                     locked_chain->findFirstBlockWithTimeAndHeight(
                         walletInstance->nTimeFirstKey - TIMESTAMP_WINDOW,
                         rescan_height, nullptr)) {
                 rescan_height = *first_block;
             }
         }
 
         nStart = GetTimeMillis();
         {
             WalletRescanReserver reserver(walletInstance.get());
             if (!reserver.reserve() ||
                 (ScanResult::SUCCESS !=
                  walletInstance
                      ->ScanForWalletTransactions(
                          locked_chain->getBlockHash(rescan_height), BlockHash(),
                          reserver, true /* update */)
                      .status)) {
                 chain.initError(
                     _("Failed to rescan the wallet during initialization")
                         .translated);
                 return nullptr;
             }
         }
         walletInstance->WalletLogPrintf("Rescan completed in %15dms\n",
                                         GetTimeMillis() - nStart);
         walletInstance->ChainStateFlushed(locked_chain->getTipLocator());
         walletInstance->database->IncrementUpdateCounter();
 
         // Restore wallet transaction metadata after -zapwallettxes=1
         if (gArgs.GetBoolArg("-zapwallettxes", false) &&
             gArgs.GetArg("-zapwallettxes", "1") != "2") {
             WalletBatch batch(*walletInstance->database);
 
             for (const CWalletTx &wtxOld : vWtx) {
                 const TxId txid = wtxOld.GetId();
                 std::map<TxId, CWalletTx>::iterator mi =
                     walletInstance->mapWallet.find(txid);
                 if (mi != walletInstance->mapWallet.end()) {
                     const CWalletTx *copyFrom = &wtxOld;
                     CWalletTx *copyTo = &mi->second;
                     copyTo->mapValue = copyFrom->mapValue;
                     copyTo->vOrderForm = copyFrom->vOrderForm;
                     copyTo->nTimeReceived = copyFrom->nTimeReceived;
                     copyTo->nTimeSmart = copyFrom->nTimeSmart;
                     copyTo->fFromMe = copyFrom->fFromMe;
                     copyTo->nOrderPos = copyFrom->nOrderPos;
                     batch.WriteTx(*copyTo);
                 }
             }
         }
     }
 
     chain.loadWallet(interfaces::MakeWallet(walletInstance));
 
     // Register with the validation interface. It's ok to do this after rescan
     // since we're still holding locked_chain.
     walletInstance->handleNotifications();
 
     walletInstance->SetBroadcastTransactions(
         gArgs.GetBoolArg("-walletbroadcast", DEFAULT_WALLETBROADCAST));
 
     walletInstance->WalletLogPrintf("setKeyPool.size() = %u\n",
                                     walletInstance->GetKeyPoolSize());
     walletInstance->WalletLogPrintf("mapWallet.size() = %u\n",
                                     walletInstance->mapWallet.size());
     walletInstance->WalletLogPrintf("mapAddressBook.size() = %u\n",
                                     walletInstance->mapAddressBook.size());
 
     return walletInstance;
 }
 
 void CWallet::handleNotifications() {
     m_chain_notifications_handler = m_chain->handleNotifications(*this);
 }
 
 void CWallet::postInitProcess() {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     // Add wallet transactions that aren't already in a block to mempool.
     // Do this here as mempool requires genesis block to be loaded.
     ReacceptWalletTransactions(*locked_chain);
 
     // Update wallet transactions with current mempool transactions.
     chain().requestMempoolTransactions(*this);
 }
 
 bool CWallet::BackupWallet(const std::string &strDest) {
     return database->Backup(strDest);
 }
 
 CKeyPool::CKeyPool() {
     nTime = GetTime();
     fInternal = false;
     m_pre_split = false;
 }
 
 CKeyPool::CKeyPool(const CPubKey &vchPubKeyIn, bool internalIn) {
     nTime = GetTime();
     vchPubKey = vchPubKeyIn;
     fInternal = internalIn;
     m_pre_split = false;
 }
 
 CWalletKey::CWalletKey(int64_t nExpires) {
     nTimeCreated = (nExpires ? GetTime() : 0);
     nTimeExpires = nExpires;
 }
 
 void CMerkleTx::SetMerkleBranch(const BlockHash &block_hash, int posInBlock) {
     // Update the tx's hashBlock
     hashBlock = block_hash;
 
     // Set the position of the transaction in the block.
     nIndex = posInBlock;
 }
 
 int CMerkleTx::GetDepthInMainChain(
     interfaces::Chain::Lock &locked_chain) const {
     if (hashUnset()) {
         return 0;
     }
 
     return locked_chain.getBlockDepth(hashBlock) * (nIndex == -1 ? -1 : 1);
 }
 
 int CMerkleTx::GetBlocksToMaturity(
     interfaces::Chain::Lock &locked_chain) const {
     if (!IsCoinBase()) {
         return 0;
     }
 
     return std::max(0, (COINBASE_MATURITY + 1) -
                            GetDepthInMainChain(locked_chain));
 }
 
 bool CMerkleTx::IsImmatureCoinBase(
     interfaces::Chain::Lock &locked_chain) const {
     // note GetBlocksToMaturity is 0 for non-coinbase tx
     return GetBlocksToMaturity(locked_chain) > 0;
 }
 
 bool CWalletTx::AcceptToMemoryPool(interfaces::Chain::Lock &locked_chain,
                                    CValidationState &state) {
     // We must set fInMempool here - while it will be re-set to true by the
     // entered-mempool callback, if we did not there would be a race where a
     // user could call sendmoney in a loop and hit spurious out of funds errors
     // because we think that this newly generated transaction's change is
     // unavailable as we're not yet aware that it is in the mempool.
     bool ret = locked_chain.submitToMemoryPool(
         ::GetConfig(), tx, pwallet->m_default_max_tx_fee, state);
     fInMempool |= ret;
     return ret;
 }
 
 void CWallet::LearnRelatedScripts(const CPubKey &key, OutputType type) {
     // Nothing to do...
 }
 
 void CWallet::LearnAllRelatedScripts(const CPubKey &key) {
     // Nothing to do...
 }
 
 std::vector<OutputGroup>
 CWallet::GroupOutputs(const std::vector<COutput> &outputs,
                       bool single_coin) const {
     std::vector<OutputGroup> groups;
     std::map<CTxDestination, OutputGroup> gmap;
     CTxDestination dst;
     for (const auto &output : outputs) {
         if (output.fSpendable) {
             CInputCoin input_coin = output.GetInputCoin();
 
             size_t ancestors, descendants;
             chain().getTransactionAncestry(output.tx->GetId(), ancestors,
                                            descendants);
             if (!single_coin &&
                 ExtractDestination(output.tx->tx->vout[output.i].scriptPubKey,
                                    dst)) {
                 // Limit output groups to no more than 10 entries, to protect
                 // against inadvertently creating a too-large transaction
                 // when using -avoidpartialspends
                 if (gmap[dst].m_outputs.size() >= OUTPUT_GROUP_MAX_ENTRIES) {
                     groups.push_back(gmap[dst]);
                     gmap.erase(dst);
                 }
                 gmap[dst].Insert(input_coin, output.nDepth,
                                  output.tx->IsFromMe(ISMINE_ALL), ancestors,
                                  descendants);
             } else {
                 groups.emplace_back(input_coin, output.nDepth,
                                     output.tx->IsFromMe(ISMINE_ALL), ancestors,
                                     descendants);
             }
         }
     }
     if (!single_coin) {
         for (const auto &it : gmap) {
             groups.push_back(it.second);
         }
     }
     return groups;
 }
 
 bool CWallet::GetKeyOrigin(const CKeyID &keyID, KeyOriginInfo &info) const {
     CKeyMetadata meta;
     {
         LOCK(cs_wallet);
         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 CWallet::AddKeyOriginWithDB(WalletBatch &batch, const CPubKey &pubkey,
                                  const KeyOriginInfo &info) {
     LOCK(cs_wallet);
     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);
 }