diff --git a/src/amount.cpp b/src/amount.cpp
index 8bd041597..bde2f4d22 100644
--- a/src/amount.cpp
+++ b/src/amount.cpp
@@ -1,16 +1,26 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <amount.h>
 
 #include <network.h>
+#include <univalue.h>
 
 #include <tinyformat.h>
 
 std::string Amount::ToString() const {
     return strprintf("%d.%08d %s", *this / COIN, (*this % COIN) / SATOSHI,
                      CURRENCY_UNIT);
 }
+
+Amount::operator UniValue() const {
+    bool sign = *this < Amount::zero();
+    Amount n_abs(sign ? -amount : amount);
+    int64_t quotient = n_abs / COIN;
+    int64_t remainder = (n_abs % COIN) / SATOSHI;
+    return UniValue(UniValue::VNUM, strprintf("%s%d.%08d", sign ? "-" : "",
+                                              quotient, remainder));
+}
diff --git a/src/amount.h b/src/amount.h
index 4405e9aab..ec9451d0a 100644
--- a/src/amount.h
+++ b/src/amount.h
@@ -1,165 +1,172 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_AMOUNT_H
 #define BITCOIN_AMOUNT_H
 
 #include <serialize.h>
 
 #include <cstdlib>
 #include <ostream>
 #include <string>
 #include <type_traits>
 
+class UniValue;
+
 struct Amount {
 private:
     int64_t amount;
 
     explicit constexpr Amount(int64_t _amount) : amount(_amount) {}
 
 public:
     constexpr Amount() : amount(0) {}
     constexpr Amount(const Amount &other) : amount(other.amount) {}
 
+    /**
+     * Convenient implicit UniValue conversion operator
+     */
+    operator UniValue() const;
+
     /**
      * Assignement operator.
      */
     constexpr Amount &operator=(const Amount &other) {
         amount = other.amount;
         return *this;
     }
 
     static constexpr Amount zero() { return Amount(0); }
     static constexpr Amount satoshi() { return Amount(1); }
 
     /**
      * Implement standard operators
      */
     Amount &operator+=(const Amount a) {
         amount += a.amount;
         return *this;
     }
     Amount &operator-=(const Amount a) {
         amount -= a.amount;
         return *this;
     }
 
     /**
      * Equality
      */
     friend constexpr bool operator==(const Amount a, const Amount b) {
         return a.amount == b.amount;
     }
     friend constexpr bool operator!=(const Amount a, const Amount b) {
         return !(a == b);
     }
 
     /**
      * Comparison
      */
     friend constexpr bool operator<(const Amount a, const Amount b) {
         return a.amount < b.amount;
     }
     friend constexpr bool operator>(const Amount a, const Amount b) {
         return b < a;
     }
     friend constexpr bool operator<=(const Amount a, const Amount b) {
         return !(a > b);
     }
     friend constexpr bool operator>=(const Amount a, const Amount b) {
         return !(a < b);
     }
 
     /**
      * Unary minus
      */
     constexpr Amount operator-() const { return Amount(-amount); }
 
     /**
      * Addition and subtraction.
      */
     friend constexpr Amount operator+(const Amount a, const Amount b) {
         return Amount(a.amount + b.amount);
     }
     friend constexpr Amount operator-(const Amount a, const Amount b) {
         return a + -b;
     }
 
     /**
      * Multiplication
      */
     friend constexpr Amount operator*(const int64_t a, const Amount b) {
         return Amount(a * b.amount);
     }
     friend constexpr Amount operator*(const int a, const Amount b) {
         return Amount(a * b.amount);
     }
 
     /**
      * Division
      */
     constexpr int64_t operator/(const Amount b) const {
         return amount / b.amount;
     }
     constexpr Amount operator/(const int64_t b) const {
         return Amount(amount / b);
     }
     constexpr Amount operator/(const int b) const { return Amount(amount / b); }
     Amount &operator/=(const int64_t n) {
         amount /= n;
         return *this;
     }
 
     /**
      * Modulus
      */
     constexpr Amount operator%(const Amount b) const {
         return Amount(amount % b.amount);
     }
     constexpr Amount operator%(const int64_t b) const {
         return Amount(amount % b);
     }
     constexpr Amount operator%(const int b) const { return Amount(amount % b); }
 
     /**
      * Do not implement double ops to get an error with double and ensure
      * casting to integer is explicit.
      */
     friend constexpr Amount operator*(const double a, const Amount b) = delete;
     constexpr Amount operator/(const double b) const = delete;
     constexpr Amount operator%(const double b) const = delete;
 
     // ostream support
     friend std::ostream &operator<<(std::ostream &stream, const Amount &ca) {
         return stream << ca.amount;
     }
 
     std::string ToString() const;
 
     // serialization support
     SERIALIZE_METHODS(Amount, obj) { READWRITE(obj.amount); }
 };
 
 static constexpr Amount SATOSHI = Amount::satoshi();
 static constexpr Amount CASH = 100 * SATOSHI;
 static constexpr Amount COIN = 100000000 * SATOSHI;
 
 /**
  * No amount larger than this (in satoshi) is valid.
  *
  * Note that this constant is *not* the total money supply, which in Bitcoin
  * currently happens to be less than 21,000,000 BCH for various reasons, but
  * rather a sanity check. As this sanity check is used by consensus-critical
  * validation code, the exact value of the MAX_MONEY constant is consensus
  * critical; in unusual circumstances like a(nother) overflow bug that allowed
  * for the creation of coins out of thin air modification could lead to a fork.
  */
 static const Amount MAX_MONEY = 21000000 * COIN;
 inline bool MoneyRange(const Amount nValue) {
     return nValue >= Amount::zero() && nValue <= MAX_MONEY;
 }
 
 #endif // BITCOIN_AMOUNT_H
diff --git a/src/core_io.h b/src/core_io.h
index 3cda6b5f3..0ef0cd01c 100644
--- a/src/core_io.h
+++ b/src/core_io.h
@@ -1,55 +1,54 @@
 // 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_CORE_IO_H
 #define BITCOIN_CORE_IO_H
 
 #include <attributes.h>
 #include <script/sighashtype.h>
 
 #include <string>
 #include <vector>
 
 struct Amount;
 class CBlock;
 class CBlockHeader;
 class CMutableTransaction;
 class CScript;
 class CTransaction;
 class uint256;
 class UniValue;
 
 // core_read.cpp
 CScript ParseScript(const std::string &s);
 std::string ScriptToAsmStr(const CScript &script,
                            const bool fAttemptSighashDecode = false);
 NODISCARD bool DecodeHexTx(CMutableTransaction &tx,
                            const std::string &strHexTx);
 NODISCARD bool DecodeHexBlk(CBlock &, const std::string &strHexBlk);
 bool DecodeHexBlockHeader(CBlockHeader &, const std::string &hex_header);
 
 /**
  * Parse a hex string into 256 bits
  * @param[in] strHex a hex-formatted, 64-character string
  * @param[out] result the result of the parasing
  * @returns true if successful, false if not
  *
  * @see ParseHashV for an RPC-oriented version of this
  */
 bool ParseHashStr(const std::string &strHex, uint256 &result);
 std::vector<uint8_t> ParseHexUV(const UniValue &v, const std::string &strName);
 SigHashType ParseSighashString(const UniValue &sighash);
 
 // core_write.cpp
-UniValue ValueFromAmount(const Amount &amount);
 std::string FormatScript(const CScript &script);
 std::string EncodeHexTx(const CTransaction &tx, const int serializeFlags = 0);
 std::string SighashToStr(uint8_t sighash_type);
 void ScriptPubKeyToUniv(const CScript &scriptPubKey, UniValue &out,
                         bool fIncludeHex);
 void ScriptToUniv(const CScript &script, UniValue &out, bool include_address);
 void TxToUniv(const CTransaction &tx, const uint256 &hashBlock, UniValue &entry,
               bool include_hex = true, int serialize_flags = 0);
 
 #endif // BITCOIN_CORE_IO_H
diff --git a/src/core_write.cpp b/src/core_write.cpp
index e1c8047cd..fbb93e12a 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -1,279 +1,270 @@
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <core_io.h>
 
 #include <config.h>
 #include <key_io.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <script/sigencoding.h>
 #include <script/standard.h>
 #include <serialize.h>
 #include <streams.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 
 #include <univalue.h>
 
-UniValue ValueFromAmount(const Amount &amount) {
-    bool sign = amount < Amount::zero();
-    Amount n_abs(sign ? -amount : amount);
-    int64_t quotient = n_abs / COIN;
-    int64_t remainder = (n_abs % COIN) / SATOSHI;
-    return UniValue(UniValue::VNUM, strprintf("%s%d.%08d", sign ? "-" : "",
-                                              quotient, remainder));
-}
-
 std::string FormatScript(const CScript &script) {
     std::string ret;
     CScript::const_iterator it = script.begin();
     opcodetype op;
     while (it != script.end()) {
         CScript::const_iterator it2 = it;
         std::vector<uint8_t> vch;
         if (script.GetOp(it, op, vch)) {
             if (op == OP_0) {
                 ret += "0 ";
                 continue;
             }
 
             if ((op >= OP_1 && op <= OP_16) || op == OP_1NEGATE) {
                 ret += strprintf("%i ", op - OP_1NEGATE - 1);
                 continue;
             }
 
             if (op >= OP_NOP && op < FIRST_UNDEFINED_OP_VALUE) {
                 std::string str(GetOpName(op));
                 if (str.substr(0, 3) == std::string("OP_")) {
                     ret += str.substr(3, std::string::npos) + " ";
                     continue;
                 }
             }
 
             if (vch.size() > 0) {
                 ret += strprintf(
                     "0x%x 0x%x ",
                     HexStr(std::vector<uint8_t>(it2, it - vch.size())),
                     HexStr(std::vector<uint8_t>(it - vch.size(), it)));
             } else {
                 ret +=
                     strprintf("0x%x ", HexStr(std::vector<uint8_t>(it2, it)));
             }
 
             continue;
         }
 
         ret +=
             strprintf("0x%x ", HexStr(std::vector<uint8_t>(it2, script.end())));
         break;
     }
 
     return ret.substr(0, ret.size() - 1);
 }
 
 const std::map<uint8_t, std::string> mapSigHashTypes = {
     {SIGHASH_ALL, "ALL"},
     {SIGHASH_ALL | SIGHASH_ANYONECANPAY, "ALL|ANYONECANPAY"},
     {SIGHASH_ALL | SIGHASH_FORKID, "ALL|FORKID"},
     {SIGHASH_ALL | SIGHASH_FORKID | SIGHASH_ANYONECANPAY,
      "ALL|FORKID|ANYONECANPAY"},
     {SIGHASH_NONE, "NONE"},
     {SIGHASH_NONE | SIGHASH_ANYONECANPAY, "NONE|ANYONECANPAY"},
     {SIGHASH_NONE | SIGHASH_FORKID, "NONE|FORKID"},
     {SIGHASH_NONE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY,
      "NONE|FORKID|ANYONECANPAY"},
     {SIGHASH_SINGLE, "SINGLE"},
     {SIGHASH_SINGLE | SIGHASH_ANYONECANPAY, "SINGLE|ANYONECANPAY"},
     {SIGHASH_SINGLE | SIGHASH_FORKID, "SINGLE|FORKID"},
     {SIGHASH_SINGLE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY,
      "SINGLE|FORKID|ANYONECANPAY"},
 };
 
 std::string SighashToStr(uint8_t sighash_type) {
     const auto &it = mapSigHashTypes.find(sighash_type);
     if (it == mapSigHashTypes.end()) {
         return "";
     }
     return it->second;
 }
 
 /**
  * Create the assembly string representation of a CScript object.
  * @param[in] script    CScript object to convert into the asm string
  * representation.
  * @param[in] fAttemptSighashDecode    Whether to attempt to decode sighash
  * types on data within the script that matches the format of a signature. Only
  * pass true for scripts you believe could contain signatures. For example, pass
  * false, or omit the this argument (defaults to false), for scriptPubKeys.
  */
 std::string ScriptToAsmStr(const CScript &script,
                            const bool fAttemptSighashDecode) {
     std::string str;
     opcodetype opcode;
     std::vector<uint8_t> vch;
     CScript::const_iterator pc = script.begin();
     while (pc < script.end()) {
         if (!str.empty()) {
             str += " ";
         }
 
         if (!script.GetOp(pc, opcode, vch)) {
             str += "[error]";
             return str;
         }
 
         if (0 <= opcode && opcode <= OP_PUSHDATA4) {
             if (vch.size() <= static_cast<std::vector<uint8_t>::size_type>(4)) {
                 str += strprintf("%d", CScriptNum(vch, false).getint());
             } else {
                 // the IsUnspendable check makes sure not to try to decode
                 // OP_RETURN data that may match the format of a signature
                 if (fAttemptSighashDecode && !script.IsUnspendable()) {
                     std::string strSigHashDecode;
                     // goal: only attempt to decode a defined sighash type from
                     // data that looks like a signature within a scriptSig. This
                     // won't decode correctly formatted public keys in Pubkey or
                     // Multisig scripts due to the restrictions on the pubkey
                     // formats (see IsCompressedOrUncompressedPubKey) being
                     // incongruous with the checks in
                     // CheckTransactionSignatureEncoding.
                     uint32_t flags = SCRIPT_VERIFY_STRICTENC;
                     if (vch.back() & SIGHASH_FORKID) {
                         // If the transaction is using SIGHASH_FORKID, we need
                         // to set the appropriate flag.
                         // TODO: Remove after the Hard Fork.
                         flags |= SCRIPT_ENABLE_SIGHASH_FORKID;
                     }
                     if (CheckTransactionSignatureEncoding(vch, flags,
                                                           nullptr)) {
                         const uint8_t chSigHashType = vch.back();
                         if (mapSigHashTypes.count(chSigHashType)) {
                             strSigHashDecode =
                                 "[" +
                                 mapSigHashTypes.find(chSigHashType)->second +
                                 "]";
                             // remove the sighash type byte. it will be replaced
                             // by the decode.
                             vch.pop_back();
                         }
                     }
 
                     str += HexStr(vch) + strSigHashDecode;
                 } else {
                     str += HexStr(vch);
                 }
             }
         } else {
             str += GetOpName(opcode);
         }
     }
 
     return str;
 }
 
 std::string EncodeHexTx(const CTransaction &tx, const int serializeFlags) {
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION | serializeFlags);
     ssTx << tx;
     return HexStr(ssTx);
 }
 
 void ScriptToUniv(const CScript &script, UniValue &out, bool include_address) {
     out.pushKV("asm", ScriptToAsmStr(script));
     out.pushKV("hex", HexStr(script));
 
     std::vector<std::vector<uint8_t>> solns;
     TxoutType type = Solver(script, solns);
     out.pushKV("type", GetTxnOutputType(type));
 
     CTxDestination address;
     if (include_address && ExtractDestination(script, address) &&
         type != TxoutType::PUBKEY) {
         out.pushKV("address", EncodeDestination(address, GetConfig()));
     }
 }
 
 void ScriptPubKeyToUniv(const CScript &scriptPubKey, UniValue &out,
                         bool fIncludeHex) {
     TxoutType type;
     std::vector<CTxDestination> addresses;
     int nRequired;
 
     out.pushKV("asm", ScriptToAsmStr(scriptPubKey));
     if (fIncludeHex) {
         out.pushKV("hex", HexStr(scriptPubKey));
     }
 
     if (!ExtractDestinations(scriptPubKey, type, addresses, nRequired) ||
         type == TxoutType::PUBKEY) {
         out.pushKV("type", GetTxnOutputType(type));
         return;
     }
 
     out.pushKV("reqSigs", nRequired);
     out.pushKV("type", GetTxnOutputType(type));
 
     UniValue a(UniValue::VARR);
     for (const CTxDestination &addr : addresses) {
         a.push_back(EncodeDestination(addr, GetConfig()));
     }
     out.pushKV("addresses", a);
 }
 
 void TxToUniv(const CTransaction &tx, const uint256 &hashBlock, UniValue &entry,
               bool include_hex, int serialize_flags) {
     entry.pushKV("txid", tx.GetId().GetHex());
     entry.pushKV("hash", tx.GetHash().GetHex());
     entry.pushKV("version", tx.nVersion);
     entry.pushKV("size", (int)::GetSerializeSize(tx, PROTOCOL_VERSION));
     entry.pushKV("locktime", (int64_t)tx.nLockTime);
 
     UniValue vin(UniValue::VARR);
     for (unsigned int i = 0; i < tx.vin.size(); i++) {
         const CTxIn &txin = tx.vin[i];
         UniValue in(UniValue::VOBJ);
         if (tx.IsCoinBase()) {
             in.pushKV("coinbase", HexStr(txin.scriptSig));
         } else {
             in.pushKV("txid", txin.prevout.GetTxId().GetHex());
             in.pushKV("vout", int64_t(txin.prevout.GetN()));
             UniValue o(UniValue::VOBJ);
             o.pushKV("asm", ScriptToAsmStr(txin.scriptSig, true));
             o.pushKV("hex", HexStr(txin.scriptSig));
             in.pushKV("scriptSig", o);
         }
 
         in.pushKV("sequence", (int64_t)txin.nSequence);
         vin.push_back(in);
     }
 
     entry.pushKV("vin", vin);
 
     UniValue vout(UniValue::VARR);
     for (unsigned int i = 0; i < tx.vout.size(); i++) {
         const CTxOut &txout = tx.vout[i];
 
         UniValue out(UniValue::VOBJ);
 
-        out.pushKV("value", ValueFromAmount(txout.nValue));
+        out.pushKV("value", txout.nValue);
         out.pushKV("n", int64_t(i));
 
         UniValue o(UniValue::VOBJ);
         ScriptPubKeyToUniv(txout.scriptPubKey, o, true);
         out.pushKV("scriptPubKey", o);
         vout.push_back(out);
     }
 
     entry.pushKV("vout", vout);
 
     if (!hashBlock.IsNull()) {
         entry.pushKV("blockhash", hashBlock.GetHex());
     }
 
     if (include_hex) {
         // The hex-encoded transaction. Used the name "hex" to be consistent
         // with the verbose output of "getrawtransaction".
         entry.pushKV("hex", EncodeHexTx(tx, serialize_flags));
     }
 }
diff --git a/src/rest.cpp b/src/rest.cpp
index 26aa0e7d4..67cb04161 100644
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -1,778 +1,778 @@
 // 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 <blockdb.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <core_io.h>
 #include <httpserver.h>
 #include <index/txindex.h>
 #include <node/context.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <rpc/blockchain.h>
 #include <rpc/protocol.h>
 #include <rpc/server.h>
 #include <streams.h>
 #include <sync.h>
 #include <txmempool.h>
 #include <util/ref.h>
 #include <util/strencodings.h>
 #include <validation.h>
 #include <version.h>
 
 #include <boost/algorithm/string.hpp>
 
 #include <univalue.h>
 
 // Allow a max of 15 outpoints to be queried at once.
 static const size_t MAX_GETUTXOS_OUTPOINTS = 15;
 
 enum class RetFormat {
     UNDEF,
     BINARY,
     HEX,
     JSON,
 };
 
 static const struct {
     RetFormat rf;
     const char *name;
 } rf_names[] = {
     {RetFormat::UNDEF, ""},
     {RetFormat::BINARY, "bin"},
     {RetFormat::HEX, "hex"},
     {RetFormat::JSON, "json"},
 };
 
 struct CCoin {
     uint32_t nHeight;
     CTxOut out;
 
     CCoin() : nHeight(0) {}
     explicit CCoin(Coin in)
         : nHeight(in.GetHeight()), out(std::move(in.GetTxOut())) {}
 
     SERIALIZE_METHODS(CCoin, obj) {
         uint32_t nTxVerDummy = 0;
         READWRITE(nTxVerDummy, obj.nHeight, obj.out);
     }
 };
 
 static bool RESTERR(HTTPRequest *req, enum HTTPStatusCode status,
                     std::string message) {
     req->WriteHeader("Content-Type", "text/plain");
     req->WriteReply(status, message + "\r\n");
     return false;
 }
 
 /**
  * Get the node context mempool.
  *
  * Set the HTTP error and return nullptr if node context
  * mempool is not found.
  *
  * @param[in]  req the HTTP request
  * return pointer to the mempool or nullptr if no mempool found
  */
 static CTxMemPool *GetMemPool(const util::Ref &context, HTTPRequest *req) {
     NodeContext *node =
         context.Has<NodeContext>() ? &context.Get<NodeContext>() : nullptr;
     if (!node || !node->mempool) {
         RESTERR(req, HTTP_NOT_FOUND, "Mempool disabled or instance not found");
         return nullptr;
     }
     return node->mempool;
 }
 
 static RetFormat ParseDataFormat(std::string &param,
                                  const std::string &strReq) {
     const std::string::size_type pos = strReq.rfind('.');
     if (pos == std::string::npos) {
         param = strReq;
         return rf_names[0].rf;
     }
 
     param = strReq.substr(0, pos);
     const std::string suff(strReq, pos + 1);
 
     for (size_t i = 0; i < ARRAYLEN(rf_names); i++) {
         if (suff == rf_names[i].name) {
             return rf_names[i].rf;
         }
     }
 
     /* If no suffix is found, return original string.  */
     param = strReq;
     return rf_names[0].rf;
 }
 
 static std::string AvailableDataFormatsString() {
     std::string formats;
     for (size_t i = 0; i < ARRAYLEN(rf_names); i++) {
         if (strlen(rf_names[i].name) > 0) {
             formats.append(".");
             formats.append(rf_names[i].name);
             formats.append(", ");
         }
     }
 
     if (formats.length() > 0) {
         return formats.substr(0, formats.length() - 2);
     }
 
     return formats;
 }
 
 static bool CheckWarmup(HTTPRequest *req) {
     std::string statusmessage;
     if (RPCIsInWarmup(&statusmessage)) {
         return RESTERR(req, HTTP_SERVICE_UNAVAILABLE,
                        "Service temporarily unavailable: " + statusmessage);
     }
 
     return true;
 }
 
 static bool rest_headers(Config &config, const util::Ref &context,
                          HTTPRequest *req, const std::string &strURIPart) {
     if (!CheckWarmup(req)) {
         return false;
     }
 
     std::string param;
     const RetFormat rf = ParseDataFormat(param, strURIPart);
     std::vector<std::string> path;
     boost::split(path, param, boost::is_any_of("/"));
 
     if (path.size() != 2) {
         return RESTERR(req, HTTP_BAD_REQUEST,
                        "No header count specified. Use "
                        "/rest/headers/<count>/<hash>.<ext>.");
     }
 
     long count = strtol(path[0].c_str(), nullptr, 10);
     if (count < 1 || count > 2000) {
         return RESTERR(req, HTTP_BAD_REQUEST,
                        "Header count out of range: " + path[0]);
     }
 
     std::string hashStr = path[1];
     uint256 rawHash;
     if (!ParseHashStr(hashStr, rawHash)) {
         return RESTERR(req, HTTP_BAD_REQUEST, "Invalid hash: " + hashStr);
     }
 
     const BlockHash hash(rawHash);
 
     const CBlockIndex *tip = nullptr;
     std::vector<const CBlockIndex *> headers;
     headers.reserve(count);
     {
         LOCK(cs_main);
         tip = ::ChainActive().Tip();
         const CBlockIndex *pindex = LookupBlockIndex(hash);
         while (pindex != nullptr && ::ChainActive().Contains(pindex)) {
             headers.push_back(pindex);
             if (headers.size() == size_t(count)) {
                 break;
             }
             pindex = ::ChainActive().Next(pindex);
         }
     }
 
     switch (rf) {
         case RetFormat::BINARY: {
             CDataStream ssHeader(SER_NETWORK, PROTOCOL_VERSION);
             for (const CBlockIndex *pindex : headers) {
                 ssHeader << pindex->GetBlockHeader();
             }
 
             std::string binaryHeader = ssHeader.str();
             req->WriteHeader("Content-Type", "application/octet-stream");
             req->WriteReply(HTTP_OK, binaryHeader);
             return true;
         }
 
         case RetFormat::HEX: {
             CDataStream ssHeader(SER_NETWORK, PROTOCOL_VERSION);
             for (const CBlockIndex *pindex : headers) {
                 ssHeader << pindex->GetBlockHeader();
             }
 
             std::string strHex = HexStr(ssHeader) + "\n";
             req->WriteHeader("Content-Type", "text/plain");
             req->WriteReply(HTTP_OK, strHex);
             return true;
         }
         case RetFormat::JSON: {
             UniValue jsonHeaders(UniValue::VARR);
             for (const CBlockIndex *pindex : headers) {
                 jsonHeaders.push_back(blockheaderToJSON(tip, pindex));
             }
             std::string strJSON = jsonHeaders.write() + "\n";
             req->WriteHeader("Content-Type", "application/json");
             req->WriteReply(HTTP_OK, strJSON);
             return true;
         }
         default: {
             return RESTERR(
                 req, HTTP_NOT_FOUND,
                 "output format not found (available: .bin, .hex, .json)");
         }
     }
 }
 
 static bool rest_block(const Config &config, HTTPRequest *req,
                        const std::string &strURIPart, bool showTxDetails) {
     if (!CheckWarmup(req)) {
         return false;
     }
 
     std::string hashStr;
     const RetFormat rf = ParseDataFormat(hashStr, strURIPart);
 
     uint256 rawHash;
     if (!ParseHashStr(hashStr, rawHash)) {
         return RESTERR(req, HTTP_BAD_REQUEST, "Invalid hash: " + hashStr);
     }
 
     const BlockHash hash(rawHash);
 
     CBlock block;
     CBlockIndex *pblockindex = nullptr;
     CBlockIndex *tip = nullptr;
     {
         LOCK(cs_main);
         tip = ::ChainActive().Tip();
         pblockindex = LookupBlockIndex(hash);
         if (!pblockindex) {
             return RESTERR(req, HTTP_NOT_FOUND, hashStr + " not found");
         }
 
         if (IsBlockPruned(pblockindex)) {
             return RESTERR(req, HTTP_NOT_FOUND,
                            hashStr + " not available (pruned data)");
         }
 
         if (!ReadBlockFromDisk(block, pblockindex,
                                config.GetChainParams().GetConsensus())) {
             return RESTERR(req, HTTP_NOT_FOUND, hashStr + " not found");
         }
     }
 
     switch (rf) {
         case RetFormat::BINARY: {
             CDataStream ssBlock(SER_NETWORK,
                                 PROTOCOL_VERSION | RPCSerializationFlags());
             ssBlock << block;
             std::string binaryBlock = ssBlock.str();
             req->WriteHeader("Content-Type", "application/octet-stream");
             req->WriteReply(HTTP_OK, binaryBlock);
             return true;
         }
 
         case RetFormat::HEX: {
             CDataStream ssBlock(SER_NETWORK,
                                 PROTOCOL_VERSION | RPCSerializationFlags());
             ssBlock << block;
             std::string strHex = HexStr(ssBlock) + "\n";
             req->WriteHeader("Content-Type", "text/plain");
             req->WriteReply(HTTP_OK, strHex);
             return true;
         }
 
         case RetFormat::JSON: {
             UniValue objBlock =
                 blockToJSON(block, tip, pblockindex, showTxDetails);
             std::string strJSON = objBlock.write() + "\n";
             req->WriteHeader("Content-Type", "application/json");
             req->WriteReply(HTTP_OK, strJSON);
             return true;
         }
 
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: " +
                                AvailableDataFormatsString() + ")");
         }
     }
 }
 
 static bool rest_block_extended(Config &config, const util::Ref &context,
                                 HTTPRequest *req,
                                 const std::string &strURIPart) {
     return rest_block(config, req, strURIPart, true);
 }
 
 static bool rest_block_notxdetails(Config &config, const util::Ref &context,
                                    HTTPRequest *req,
                                    const std::string &strURIPart) {
     return rest_block(config, req, strURIPart, false);
 }
 
 static bool rest_chaininfo(Config &config, const util::Ref &context,
                            HTTPRequest *req, const std::string &strURIPart) {
     if (!CheckWarmup(req)) {
         return false;
     }
 
     std::string param;
     const RetFormat rf = ParseDataFormat(param, strURIPart);
 
     switch (rf) {
         case RetFormat::JSON: {
             JSONRPCRequest jsonRequest(context);
             jsonRequest.params = UniValue(UniValue::VARR);
             UniValue chainInfoObject = getblockchaininfo(config, jsonRequest);
             std::string strJSON = chainInfoObject.write() + "\n";
             req->WriteHeader("Content-Type", "application/json");
             req->WriteReply(HTTP_OK, strJSON);
             return true;
         }
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: json)");
         }
     }
 }
 
 static bool rest_mempool_info(Config &config, const util::Ref &context,
                               HTTPRequest *req, const std::string &strURIPart) {
     if (!CheckWarmup(req)) {
         return false;
     }
 
     const CTxMemPool *mempool = GetMemPool(context, req);
     if (!mempool) {
         return false;
     }
 
     std::string param;
     const RetFormat rf = ParseDataFormat(param, strURIPart);
 
     switch (rf) {
         case RetFormat::JSON: {
             UniValue mempoolInfoObject = MempoolInfoToJSON(*mempool);
 
             std::string strJSON = mempoolInfoObject.write() + "\n";
             req->WriteHeader("Content-Type", "application/json");
             req->WriteReply(HTTP_OK, strJSON);
             return true;
         }
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: json)");
         }
     }
 }
 
 static bool rest_mempool_contents(Config &config, const util::Ref &context,
                                   HTTPRequest *req,
                                   const std::string &strURIPart) {
     if (!CheckWarmup(req)) {
         return false;
     }
 
     const CTxMemPool *mempool = GetMemPool(context, req);
     if (!mempool) {
         return false;
     }
 
     std::string param;
     const RetFormat rf = ParseDataFormat(param, strURIPart);
 
     switch (rf) {
         case RetFormat::JSON: {
             UniValue mempoolObject = MempoolToJSON(*mempool, true);
 
             std::string strJSON = mempoolObject.write() + "\n";
             req->WriteHeader("Content-Type", "application/json");
             req->WriteReply(HTTP_OK, strJSON);
             return true;
         }
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: json)");
         }
     }
 }
 
 static bool rest_tx(Config &config, const util::Ref &context, HTTPRequest *req,
                     const std::string &strURIPart) {
     if (!CheckWarmup(req)) {
         return false;
     }
 
     std::string hashStr;
     const RetFormat rf = ParseDataFormat(hashStr, strURIPart);
 
     uint256 hash;
     if (!ParseHashStr(hashStr, hash)) {
         return RESTERR(req, HTTP_BAD_REQUEST, "Invalid hash: " + hashStr);
     }
 
     const TxId txid(hash);
 
     if (g_txindex) {
         g_txindex->BlockUntilSyncedToCurrentChain();
     }
 
     CTransactionRef tx;
     BlockHash hashBlock;
     if (!GetTransaction(txid, tx, config.GetChainParams().GetConsensus(),
                         hashBlock)) {
         return RESTERR(req, HTTP_NOT_FOUND, hashStr + " not found");
     }
 
     switch (rf) {
         case RetFormat::BINARY: {
             CDataStream ssTx(SER_NETWORK,
                              PROTOCOL_VERSION | RPCSerializationFlags());
             ssTx << tx;
 
             std::string binaryTx = ssTx.str();
             req->WriteHeader("Content-Type", "application/octet-stream");
             req->WriteReply(HTTP_OK, binaryTx);
             return true;
         }
 
         case RetFormat::HEX: {
             CDataStream ssTx(SER_NETWORK,
                              PROTOCOL_VERSION | RPCSerializationFlags());
             ssTx << tx;
 
             std::string strHex = HexStr(ssTx) + "\n";
             req->WriteHeader("Content-Type", "text/plain");
             req->WriteReply(HTTP_OK, strHex);
             return true;
         }
 
         case RetFormat::JSON: {
             UniValue objTx(UniValue::VOBJ);
             TxToUniv(*tx, hashBlock, objTx);
             std::string strJSON = objTx.write() + "\n";
             req->WriteHeader("Content-Type", "application/json");
             req->WriteReply(HTTP_OK, strJSON);
             return true;
         }
 
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: " +
                                AvailableDataFormatsString() + ")");
         }
     }
 }
 
 static bool rest_getutxos(Config &config, const util::Ref &context,
                           HTTPRequest *req, const std::string &strURIPart) {
     if (!CheckWarmup(req)) {
         return false;
     }
 
     std::string param;
     const RetFormat rf = ParseDataFormat(param, strURIPart);
 
     std::vector<std::string> uriParts;
     if (param.length() > 1) {
         std::string strUriParams = param.substr(1);
         boost::split(uriParts, strUriParams, boost::is_any_of("/"));
     }
 
     // throw exception in case of an empty request
     std::string strRequestMutable = req->ReadBody();
     if (strRequestMutable.length() == 0 && uriParts.size() == 0) {
         return RESTERR(req, HTTP_BAD_REQUEST, "Error: empty request");
     }
 
     bool fInputParsed = false;
     bool fCheckMemPool = false;
     std::vector<COutPoint> vOutPoints;
 
     // parse/deserialize input
     // input-format = output-format, rest/getutxos/bin requires binary input,
     // gives binary output, ...
 
     if (uriParts.size() > 0) {
         // inputs is sent over URI scheme
         // (/rest/getutxos/checkmempool/txid1-n/txid2-n/...)
         if (uriParts[0] == "checkmempool") {
             fCheckMemPool = true;
         }
 
         for (size_t i = (fCheckMemPool) ? 1 : 0; i < uriParts.size(); i++) {
             int32_t nOutput;
             std::string strTxid = uriParts[i].substr(0, uriParts[i].find('-'));
             std::string strOutput =
                 uriParts[i].substr(uriParts[i].find('-') + 1);
 
             if (!ParseInt32(strOutput, &nOutput) || !IsHex(strTxid)) {
                 return RESTERR(req, HTTP_BAD_REQUEST, "Parse error");
             }
 
             TxId txid;
             txid.SetHex(strTxid);
             vOutPoints.push_back(COutPoint(txid, uint32_t(nOutput)));
         }
 
         if (vOutPoints.size() > 0) {
             fInputParsed = true;
         } else {
             return RESTERR(req, HTTP_BAD_REQUEST, "Error: empty request");
         }
     }
 
     switch (rf) {
         case RetFormat::HEX: {
             // convert hex to bin, continue then with bin part
             std::vector<uint8_t> strRequestV = ParseHex(strRequestMutable);
             strRequestMutable.assign(strRequestV.begin(), strRequestV.end());
         }
         // FALLTHROUGH
         case RetFormat::BINARY: {
             try {
                 // deserialize only if user sent a request
                 if (strRequestMutable.size() > 0) {
                     // don't allow sending input over URI and HTTP RAW DATA
                     if (fInputParsed) {
                         return RESTERR(req, HTTP_BAD_REQUEST,
                                        "Combination of URI scheme inputs and "
                                        "raw post data is not allowed");
                     }
 
                     CDataStream oss(SER_NETWORK, PROTOCOL_VERSION);
                     oss << strRequestMutable;
                     oss >> fCheckMemPool;
                     oss >> vOutPoints;
                 }
             } catch (const std::ios_base::failure &) {
                 // abort in case of unreadable binary data
                 return RESTERR(req, HTTP_BAD_REQUEST, "Parse error");
             }
             break;
         }
 
         case RetFormat::JSON: {
             if (!fInputParsed) {
                 return RESTERR(req, HTTP_BAD_REQUEST, "Error: empty request");
             }
             break;
         }
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: " +
                                AvailableDataFormatsString() + ")");
         }
     }
 
     // limit max outpoints
     if (vOutPoints.size() > MAX_GETUTXOS_OUTPOINTS) {
         return RESTERR(
             req, HTTP_BAD_REQUEST,
             strprintf("Error: max outpoints exceeded (max: %d, tried: %d)",
                       MAX_GETUTXOS_OUTPOINTS, vOutPoints.size()));
     }
 
     // check spentness and form a bitmap (as well as a JSON capable
     // human-readable string representation)
     std::vector<uint8_t> bitmap;
     std::vector<CCoin> outs;
     std::string bitmapStringRepresentation;
     std::vector<bool> hits;
     bitmap.resize((vOutPoints.size() + 7) / 8);
     {
         auto process_utxos = [&vOutPoints, &outs,
                               &hits](const CCoinsView &view,
                                      const CTxMemPool &mempool) {
             for (const COutPoint &vOutPoint : vOutPoints) {
                 Coin coin;
                 bool hit = !mempool.isSpent(vOutPoint) &&
                            view.GetCoin(vOutPoint, coin);
                 hits.push_back(hit);
                 if (hit) {
                     outs.emplace_back(std::move(coin));
                 }
             }
         };
 
         if (fCheckMemPool) {
             const CTxMemPool *mempool = GetMemPool(context, req);
             if (!mempool) {
                 return false;
             }
 
             // use db+mempool as cache backend in case user likes to query
             // mempool
             LOCK2(cs_main, mempool->cs);
             CCoinsViewCache &viewChain = ::ChainstateActive().CoinsTip();
             CCoinsViewMemPool viewMempool(&viewChain, *mempool);
             process_utxos(viewMempool, *mempool);
         } else {
             // no need to lock mempool!
             LOCK(cs_main);
             process_utxos(::ChainstateActive().CoinsTip(), CTxMemPool());
         }
 
         for (size_t i = 0; i < hits.size(); ++i) {
             const bool hit = hits[i];
             // form a binary string representation (human-readable for json
             // output)
             bitmapStringRepresentation.append(hit ? "1" : "0");
             bitmap[i / 8] |= ((uint8_t)hit) << (i % 8);
         }
     }
 
     switch (rf) {
         case RetFormat::BINARY: {
             // serialize data
             // use exact same output as mentioned in Bip64
             CDataStream ssGetUTXOResponse(SER_NETWORK, PROTOCOL_VERSION);
             ssGetUTXOResponse << ::ChainActive().Height()
                               << ::ChainActive().Tip()->GetBlockHash() << bitmap
                               << outs;
             std::string ssGetUTXOResponseString = ssGetUTXOResponse.str();
 
             req->WriteHeader("Content-Type", "application/octet-stream");
             req->WriteReply(HTTP_OK, ssGetUTXOResponseString);
             return true;
         }
 
         case RetFormat::HEX: {
             CDataStream ssGetUTXOResponse(SER_NETWORK, PROTOCOL_VERSION);
             ssGetUTXOResponse << ::ChainActive().Height()
                               << ::ChainActive().Tip()->GetBlockHash() << bitmap
                               << outs;
             std::string strHex = HexStr(ssGetUTXOResponse) + "\n";
 
             req->WriteHeader("Content-Type", "text/plain");
             req->WriteReply(HTTP_OK, strHex);
             return true;
         }
 
         case RetFormat::JSON: {
             UniValue objGetUTXOResponse(UniValue::VOBJ);
 
             // pack in some essentials
             // use more or less the same output as mentioned in Bip64
             objGetUTXOResponse.pushKV("chainHeight", ::ChainActive().Height());
             objGetUTXOResponse.pushKV(
                 "chaintipHash", ::ChainActive().Tip()->GetBlockHash().GetHex());
             objGetUTXOResponse.pushKV("bitmap", bitmapStringRepresentation);
 
             UniValue utxos(UniValue::VARR);
             for (const CCoin &coin : outs) {
                 UniValue utxo(UniValue::VOBJ);
                 utxo.pushKV("height", int32_t(coin.nHeight));
-                utxo.pushKV("value", ValueFromAmount(coin.out.nValue));
+                utxo.pushKV("value", coin.out.nValue);
 
                 // include the script in a json output
                 UniValue o(UniValue::VOBJ);
                 ScriptPubKeyToUniv(coin.out.scriptPubKey, o, true);
                 utxo.pushKV("scriptPubKey", o);
                 utxos.push_back(utxo);
             }
             objGetUTXOResponse.pushKV("utxos", utxos);
 
             // return json string
             std::string strJSON = objGetUTXOResponse.write() + "\n";
             req->WriteHeader("Content-Type", "application/json");
             req->WriteReply(HTTP_OK, strJSON);
             return true;
         }
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: " +
                                AvailableDataFormatsString() + ")");
         }
     }
 }
 
 static bool rest_blockhash_by_height(Config &config, const util::Ref &context,
                                      HTTPRequest *req,
                                      const std::string &str_uri_part) {
     if (!CheckWarmup(req)) {
         return false;
     }
     std::string height_str;
     const RetFormat rf = ParseDataFormat(height_str, str_uri_part);
 
     int32_t blockheight;
     if (!ParseInt32(height_str, &blockheight) || blockheight < 0) {
         return RESTERR(req, HTTP_BAD_REQUEST,
                        "Invalid height: " + SanitizeString(height_str));
     }
 
     CBlockIndex *pblockindex = nullptr;
     {
         LOCK(cs_main);
         if (blockheight > ::ChainActive().Height()) {
             return RESTERR(req, HTTP_NOT_FOUND, "Block height out of range");
         }
         pblockindex = ::ChainActive()[blockheight];
     }
     switch (rf) {
         case RetFormat::BINARY: {
             CDataStream ss_blockhash(SER_NETWORK, PROTOCOL_VERSION);
             ss_blockhash << pblockindex->GetBlockHash();
             req->WriteHeader("Content-Type", "application/octet-stream");
             req->WriteReply(HTTP_OK, ss_blockhash.str());
             return true;
         }
         case RetFormat::HEX: {
             req->WriteHeader("Content-Type", "text/plain");
             req->WriteReply(HTTP_OK,
                             pblockindex->GetBlockHash().GetHex() + "\n");
             return true;
         }
         case RetFormat::JSON: {
             req->WriteHeader("Content-Type", "application/json");
             UniValue resp = UniValue(UniValue::VOBJ);
             resp.pushKV("blockhash", pblockindex->GetBlockHash().GetHex());
             req->WriteReply(HTTP_OK, resp.write() + "\n");
             return true;
         }
         default: {
             return RESTERR(req, HTTP_NOT_FOUND,
                            "output format not found (available: " +
                                AvailableDataFormatsString() + ")");
         }
     }
 }
 
 static const struct {
     const char *prefix;
     bool (*handler)(Config &config, const util::Ref &context, HTTPRequest *req,
                     const std::string &strReq);
 } uri_prefixes[] = {
     {"/rest/tx/", rest_tx},
     {"/rest/block/notxdetails/", rest_block_notxdetails},
     {"/rest/block/", rest_block_extended},
     {"/rest/chaininfo", rest_chaininfo},
     {"/rest/mempool/info", rest_mempool_info},
     {"/rest/mempool/contents", rest_mempool_contents},
     {"/rest/headers/", rest_headers},
     {"/rest/getutxos", rest_getutxos},
     {"/rest/blockhashbyheight/", rest_blockhash_by_height},
 };
 
 void StartREST(const util::Ref &context) {
     for (const auto &up : uri_prefixes) {
         auto handler = [&context, up](Config &config, HTTPRequest *req,
                                       const std::string &prefix) {
             return up.handler(config, context, req, prefix);
         };
         RegisterHTTPHandler(up.prefix, false, handler);
     }
 }
 
 void InterruptREST() {}
 
 void StopREST() {
     for (size_t i = 0; i < ARRAYLEN(uri_prefixes); i++) {
         UnregisterHTTPHandler(uri_prefixes[i].prefix, false);
     }
 }
diff --git a/src/rpc/avalanche.cpp b/src/rpc/avalanche.cpp
index f3675e17b..1be482d94 100644
--- a/src/rpc/avalanche.cpp
+++ b/src/rpc/avalanche.cpp
@@ -1,503 +1,503 @@
 // Copyright (c) 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 <avalanche/delegation.h>
 #include <avalanche/delegationbuilder.h>
 #include <avalanche/peermanager.h>
 #include <avalanche/processor.h>
 #include <avalanche/proof.h>
 #include <avalanche/proofbuilder.h>
 #include <avalanche/validation.h>
 #include <config.h>
 #include <core_io.h>
 #include <key_io.h>
 #include <node/context.h>
 #include <rpc/blockchain.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <util/strencodings.h>
 
 #include <univalue.h>
 
 static UniValue getavalanchekey(const Config &config,
                                 const JSONRPCRequest &request) {
     RPCHelpMan{
         "getavalanchekey",
         "Returns the key used to sign avalanche messages.\n",
         {},
         RPCResult{RPCResult::Type::STR_HEX, "", ""},
         RPCExamples{HelpExampleRpc("getavalanchekey", "")},
     }
         .Check(request);
 
     if (!g_avalanche) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Avalanche is not initialized");
     }
 
     return HexStr(g_avalanche->getSessionPubKey());
 }
 
 static CPubKey ParsePubKey(const UniValue &param) {
     const std::string keyHex = param.get_str();
     if ((keyHex.length() != 2 * CPubKey::COMPRESSED_SIZE &&
          keyHex.length() != 2 * CPubKey::SIZE) ||
         !IsHex(keyHex)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            strprintf("Invalid public key: %s\n", keyHex));
     }
 
     return HexToPubKey(keyHex);
 }
 
 static UniValue addavalanchenode(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "addavalanchenode",
         "Add a node in the set of peers to poll for avalanche.\n",
         {
             {"nodeid", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "Node to be added to avalanche."},
             {"publickey", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The public key of the node."},
             {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "Proof that the node is not a sybil."},
         },
         RPCResult{RPCResult::Type::BOOL, "success",
                   "Whether the addition succeeded or not."},
         RPCExamples{
             HelpExampleRpc("addavalanchenode", "5, \"<pubkey>\", \"<proof>\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params,
                  {UniValue::VNUM, UniValue::VSTR, UniValue::VSTR});
 
     if (!g_avalanche) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Avalanche is not initialized");
     }
 
     const NodeId nodeid = request.params[0].get_int64();
     const CPubKey key = ParsePubKey(request.params[1]);
 
     avalanche::Proof proof;
     bilingual_str error;
     if (!avalanche::Proof::FromHex(proof, request.params[2].get_str(), error)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, error.original);
     }
 
     if (key != proof.getMaster()) {
         // TODO: we want to provide a proper delegation.
         return false;
     }
 
     return g_avalanche->addNode(nodeid, proof,
                                 avalanche::DelegationBuilder(proof).build());
 }
 
 static UniValue buildavalancheproof(const Config &config,
                                     const JSONRPCRequest &request) {
     RPCHelpMan{
         "buildavalancheproof",
         "Build a proof for avalanche's sybil resistance.\n",
         {
             {"sequence", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The proof's sequence"},
             {"expiration", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "A timestamp indicating when the proof expire"},
             {"master", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The master public key"},
             {
                 "stakes",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The stakes to be signed and associated private keys",
                 {
                     {
                         "stake",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::NO,
                         "A stake to be attached to this proof",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                             {"amount", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO, "The amount in this UTXO"},
                             {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The height at which this UTXO was mined"},
                             {"iscoinbase", RPCArg::Type::BOOL,
                              /* default */ "false",
                              "Indicate wether the UTXO is a coinbase"},
                             {"privatekey", RPCArg::Type::STR,
                              RPCArg::Optional::NO,
                              "private key in base58-encoding"},
                         },
                     },
                 },
             },
         },
         RPCResult{RPCResult::Type::STR_HEX, "proof",
                   "A string that is a serialized, hex-encoded proof data."},
         RPCExamples{HelpExampleRpc("buildavalancheproof",
                                    "0 1234567800 \"<master>\" []")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VNUM, UniValue::VNUM,
                                   UniValue::VSTR, UniValue::VARR});
 
     const uint64_t sequence = request.params[0].get_int64();
     const int64_t expiration = request.params[1].get_int64();
     avalanche::ProofBuilder pb(sequence, expiration,
                                ParsePubKey(request.params[2]));
 
     const UniValue &stakes = request.params[3].get_array();
     for (size_t i = 0; i < stakes.size(); i++) {
         const UniValue &stake = stakes[i];
         RPCTypeCheckObj(stake,
                         {
                             {"txid", UniValue::VSTR},
                             {"vout", UniValue::VNUM},
                             // "amount" is also required but check is done below
                             // due to UniValue::VNUM erroneously not accepting
                             // quoted numerics (which are valid JSON)
                             {"height", UniValue::VNUM},
                             {"privatekey", UniValue::VSTR},
                         });
 
         int nOut = find_value(stake, "vout").get_int();
         if (nOut < 0) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                "vout must be positive");
         }
 
         const int height = find_value(stake, "height").get_int();
         if (height < 1) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                "height must be positive");
         }
 
         const TxId txid(ParseHashO(stake, "txid"));
         const COutPoint utxo(txid, nOut);
 
         if (!stake.exists("amount")) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Missing amount");
         }
 
         const Amount amount = AmountFromValue(find_value(stake, "amount"));
 
         const UniValue &iscbparam = find_value(stake, "iscoinbase");
         const bool iscoinbase =
             iscbparam.isNull() ? false : iscbparam.get_bool();
         CKey key = DecodeSecret(find_value(stake, "privatekey").get_str());
 
         if (!pb.addUTXO(utxo, amount, uint32_t(height), iscoinbase,
                         std::move(key))) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid private key");
         }
     }
 
     const avalanche::Proof proof = pb.build();
 
     CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
     ss << proof;
     return HexStr(ss);
 }
 
 static UniValue decodeavalancheproof(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "decodeavalancheproof",
         "Convert a serialized, hex-encoded proof, into JSON object. "
         "The validity of the proof is not verified.\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The proof hex string"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "sequence",
                  "The proof's sequential number"},
                 {RPCResult::Type::NUM, "expiration",
                  "A timestamp indicating when the proof expires"},
                 {RPCResult::Type::STR_HEX, "master", "The master public key"},
                 {RPCResult::Type::STR_HEX, "limitedid",
                  "A hash of the proof data excluding the master key."},
                 {RPCResult::Type::STR_HEX, "proofid",
                  "A hash of the limitedid and master key."},
                 {RPCResult::Type::ARR,
                  "stakes",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "txid",
                            "The transaction id"},
                           {RPCResult::Type::NUM, "vout", "The output number"},
                           {RPCResult::Type::STR_AMOUNT, "amount",
                            "The amount in this UTXO"},
                           {RPCResult::Type::NUM, "height",
                            "The height at which this UTXO was mined"},
                           {RPCResult::Type::BOOL, "iscoinbase",
                            "Indicate whether the UTXO is a coinbase"},
                           {RPCResult::Type::STR_HEX, "pubkey",
                            "This UTXO's public key"},
                           {RPCResult::Type::STR, "signature",
                            "Signature of the proofid with this UTXO's private "
                            "key (base64 encoded)"},
                       }},
                  }},
             }},
         RPCExamples{HelpExampleCli("decodeavalancheproof", "\"<hex proof>\"") +
                     HelpExampleRpc("decodeavalancheproof", "\"<hex proof>\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     avalanche::Proof proof;
     bilingual_str error;
     if (!avalanche::Proof::FromHex(proof, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, error.original);
     }
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("sequence", proof.getSequence());
     result.pushKV("expiration", proof.getExpirationTime());
     result.pushKV("master", HexStr(proof.getMaster()));
     result.pushKV("limitedid", proof.getLimitedId().ToString());
     result.pushKV("proofid", proof.getId().ToString());
 
     UniValue stakes(UniValue::VARR);
     for (const avalanche::SignedStake &s : proof.getStakes()) {
         const COutPoint &utxo = s.getStake().getUTXO();
         UniValue stake(UniValue::VOBJ);
         stake.pushKV("txid", utxo.GetTxId().ToString());
         stake.pushKV("vout", uint64_t(utxo.GetN()));
-        stake.pushKV("amount", ValueFromAmount(s.getStake().getAmount()));
+        stake.pushKV("amount", s.getStake().getAmount());
         stake.pushKV("height", uint64_t(s.getStake().getHeight()));
         stake.pushKV("iscoinbase", s.getStake().isCoinbase());
         stake.pushKV("pubkey", HexStr(s.getStake().getPubkey()));
         stake.pushKV("signature", EncodeBase64(s.getSignature()));
         stakes.push_back(stake);
     }
     result.pushKV("stakes", stakes);
 
     return result;
 }
 
 static UniValue delegateavalancheproof(const Config &config,
                                        const JSONRPCRequest &request) {
     RPCHelpMan{
         "delegateavalancheproof",
         "Delegate the avalanche proof to another public key.\n",
         {
             {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The proof to be delegated."},
             {"privatekey", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The private key in base58-encoding. Must match the proof master "
              "public key or the upper level parent delegation public key if "
              " supplied."},
             {"publickey", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The public key to delegate the proof to."},
             {"delegation", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED,
              "A string that is the serialized, hex-encoded delegation for the "
              "proof and which is a parent for the delegation to build."},
         },
         RPCResult{RPCResult::Type::STR_HEX, "delegation",
                   "A string that is a serialized, hex-encoded delegation."},
         RPCExamples{HelpExampleRpc("delegateavalancheproof",
                                    "\"<proof>\" \"<privkey>\" \"<pubkey>\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params,
                  {UniValue::VSTR, UniValue::VSTR, UniValue::VSTR});
 
     if (!g_avalanche) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Avalanche is not initialized");
     }
 
     avalanche::Proof proof;
     bilingual_str error;
     if (!avalanche::Proof::FromHex(proof, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, error.original);
     }
 
     avalanche::ProofValidationState proofState;
     if (!proof.verify(proofState)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "The proof is invalid");
     }
 
     const CKey privkey = DecodeSecret(request.params[1].get_str());
     if (!privkey.IsValid()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "The private key is invalid");
     }
 
     const CPubKey pubkey = ParsePubKey(request.params[2]);
 
     avalanche::DelegationBuilder dgb(proof);
     CPubKey auth;
     if (request.params.size() >= 4 && !request.params[3].isNull()) {
         avalanche::Delegation dg;
         CDataStream ss(ParseHexV(request.params[3], "delegation"), SER_NETWORK,
                        PROTOCOL_VERSION);
         ss >> dg;
 
         avalanche::DelegationState dgState;
         if (!dg.verify(dgState, proof, auth)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "The supplied delegation is not valid");
         }
 
         if (!dgb.importDelegation(dg)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Failed to import the delegation");
         }
 
     } else {
         auth = proof.getMaster();
     }
 
     if (privkey.GetPubKey() != auth) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "The private key does not match the proof or the delegation");
     }
 
     if (!dgb.addLevel(privkey, pubkey)) {
         throw JSONRPCError(RPC_MISC_ERROR, "Unable to build the delegation");
     }
 
     CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
     ss << dgb.build();
     return HexStr(ss);
 }
 
 static UniValue getavalanchepeerinfo(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "getavalanchepeerinfo",
         "Returns data about each connected avalanche peer as a json array of "
         "objects.\n",
         {},
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {{
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {{
                     {RPCResult::Type::NUM, "peerid", "The peer id"},
                     {RPCResult::Type::STR_HEX, "proof",
                      "The avalanche proof used by this peer"},
                     {RPCResult::Type::ARR,
                      "nodes",
                      "",
                      {
                          {RPCResult::Type::NUM, "nodeid",
                           "Node id, as returned by getpeerinfo"},
                      }},
                 }},
             }},
         },
         RPCExamples{HelpExampleCli("getavalanchepeerinfo", "") +
                     HelpExampleRpc("getavalanchepeerinfo", "")},
     }
         .Check(request);
 
     if (!g_avalanche) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Avalanche is not initialized");
     }
 
     UniValue ret(UniValue::VARR);
 
     for (const auto &peer : g_avalanche->getPeers()) {
         UniValue obj(UniValue::VOBJ);
 
         CDataStream serproof(SER_NETWORK, PROTOCOL_VERSION);
         serproof << peer.proof;
 
         obj.pushKV("peerid", uint64_t(peer.peerid));
         obj.pushKV("proof", HexStr(serproof));
 
         UniValue nodes(UniValue::VARR);
         for (const auto &id : g_avalanche->getNodeIdsForPeer(peer.peerid)) {
             nodes.push_back(id);
         }
         obj.pushKV("nodes", nodes);
         obj.pushKV("nodecount", uint64_t(peer.node_count));
 
         ret.push_back(obj);
     }
 
     return ret;
 }
 
 static UniValue verifyavalancheproof(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "verifyavalancheproof",
         "Verify an avalanche proof is valid and return the error otherwise.\n",
         {
             {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "Proof to verify."},
         },
         RPCResult{RPCResult::Type::BOOL, "success",
                   "Whether the proof is valid or not."},
         RPCExamples{HelpExampleRpc("verifyavalancheproof", "\"<proof>\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     avalanche::Proof proof;
     bilingual_str error;
     if (!avalanche::Proof::FromHex(proof, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, error.original);
     }
 
     NodeContext &node = EnsureNodeContext(request.context);
 
     avalanche::ProofValidationState state;
     {
         LOCK(cs_main);
         if (!proof.verify(state,
                           node.chainman->ActiveChainstate().CoinsTip())) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "The proof is invalid: " + state.ToString());
         }
     }
 
     return true;
 }
 
 void RegisterAvalancheRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            name                      actor (function)        argNames
         //  ------------------- ------------------------  ----------------------  ----------
         { "avalanche",          "getavalanchekey",        getavalanchekey,        {}},
         { "avalanche",          "addavalanchenode",       addavalanchenode,       {"nodeid"}},
         { "avalanche",          "buildavalancheproof",    buildavalancheproof,    {"sequence", "expiration", "master", "stakes"}},
         { "avalanche",          "decodeavalancheproof",   decodeavalancheproof,   {"proof"}},
         { "avalanche",          "delegateavalancheproof", delegateavalancheproof, {"proof", "privatekey", "publickey", "delegation"}},
         { "avalanche",          "getavalanchepeerinfo",   getavalanchepeerinfo,   {}},
         { "avalanche",          "verifyavalancheproof",   verifyavalancheproof,   {"proof"}},
     };
     // clang-format on
 
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 70b370153..c10401830 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1,2986 +1,2978 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <rpc/blockchain.h>
 
 #include <amount.h>
 #include <blockdb.h>
 #include <blockfilter.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <checkpoints.h>
 #include <coins.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <hash.h>
 #include <index/blockfilterindex.h>
 #include <network.h>
 #include <node/coinstats.h>
 #include <node/context.h>
 #include <node/utxo_snapshot.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <streams.h>
 #include <txdb.h>
 #include <txmempool.h>
 #include <undo.h>
 #include <util/ref.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <versionbitsinfo.h> // For VersionBitsDeploymentInfo
 #include <warnings.h>
 
 #include <condition_variable>
 #include <cstdint>
 #include <memory>
 #include <mutex>
 
 struct CUpdatedBlock {
     BlockHash hash;
     int height;
 };
 
 static Mutex cs_blockchange;
 static std::condition_variable cond_blockchange;
 static CUpdatedBlock latestblock GUARDED_BY(cs_blockchange);
 
 NodeContext &EnsureNodeContext(const util::Ref &context) {
     if (!context.Has<NodeContext>()) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Node context not found");
     }
     return context.Get<NodeContext>();
 }
 
 CTxMemPool &EnsureMemPool(const util::Ref &context) {
     NodeContext &node = EnsureNodeContext(context);
     if (!node.mempool) {
         throw JSONRPCError(RPC_CLIENT_MEMPOOL_DISABLED,
                            "Mempool disabled or instance not found");
     }
     return *node.mempool;
 }
 
 ChainstateManager &EnsureChainman(const util::Ref &context) {
     NodeContext &node = EnsureNodeContext(context);
     if (!node.chainman) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Node chainman not found");
     }
     return *node.chainman;
 }
 
 /**
  * Calculate the difficulty for a given block index.
  */
 double GetDifficulty(const CBlockIndex *blockindex) {
     CHECK_NONFATAL(blockindex);
 
     int nShift = (blockindex->nBits >> 24) & 0xff;
     double dDiff = double(0x0000ffff) / double(blockindex->nBits & 0x00ffffff);
 
     while (nShift < 29) {
         dDiff *= 256.0;
         nShift++;
     }
     while (nShift > 29) {
         dDiff /= 256.0;
         nShift--;
     }
 
     return dDiff;
 }
 
 static int ComputeNextBlockAndDepth(const CBlockIndex *tip,
                                     const CBlockIndex *blockindex,
                                     const CBlockIndex *&next) {
     next = tip->GetAncestor(blockindex->nHeight + 1);
     if (next && next->pprev == blockindex) {
         return tip->nHeight - blockindex->nHeight + 1;
     }
     next = nullptr;
     return blockindex == tip ? 1 : -1;
 }
 
 UniValue blockheaderToJSON(const CBlockIndex *tip,
                            const CBlockIndex *blockindex) {
     // Serialize passed information without accessing chain state of the active
     // chain!
     // For performance reasons
     AssertLockNotHeld(cs_main);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("hash", blockindex->GetBlockHash().GetHex());
     const CBlockIndex *pnext;
     int confirmations = ComputeNextBlockAndDepth(tip, blockindex, pnext);
     result.pushKV("confirmations", confirmations);
     result.pushKV("height", blockindex->nHeight);
     result.pushKV("version", blockindex->nVersion);
     result.pushKV("versionHex", strprintf("%08x", blockindex->nVersion));
     result.pushKV("merkleroot", blockindex->hashMerkleRoot.GetHex());
     result.pushKV("time", int64_t(blockindex->nTime));
     result.pushKV("mediantime", int64_t(blockindex->GetMedianTimePast()));
     result.pushKV("nonce", uint64_t(blockindex->nNonce));
     result.pushKV("bits", strprintf("%08x", blockindex->nBits));
     result.pushKV("difficulty", GetDifficulty(blockindex));
     result.pushKV("chainwork", blockindex->nChainWork.GetHex());
     result.pushKV("nTx", uint64_t(blockindex->nTx));
 
     if (blockindex->pprev) {
         result.pushKV("previousblockhash",
                       blockindex->pprev->GetBlockHash().GetHex());
     }
     if (pnext) {
         result.pushKV("nextblockhash", pnext->GetBlockHash().GetHex());
     }
     return result;
 }
 
 UniValue blockToJSON(const CBlock &block, const CBlockIndex *tip,
                      const CBlockIndex *blockindex, bool txDetails) {
     // Serialize passed information without accessing chain state of the active
     // chain!
     // For performance reasons
     AssertLockNotHeld(cs_main);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("hash", blockindex->GetBlockHash().GetHex());
     const CBlockIndex *pnext;
     int confirmations = ComputeNextBlockAndDepth(tip, blockindex, pnext);
     result.pushKV("confirmations", confirmations);
     result.pushKV("size", (int)::GetSerializeSize(block, PROTOCOL_VERSION));
     result.pushKV("height", blockindex->nHeight);
     result.pushKV("version", block.nVersion);
     result.pushKV("versionHex", strprintf("%08x", block.nVersion));
     result.pushKV("merkleroot", block.hashMerkleRoot.GetHex());
     UniValue txs(UniValue::VARR);
     for (const auto &tx : block.vtx) {
         if (txDetails) {
             UniValue objTx(UniValue::VOBJ);
             TxToUniv(*tx, uint256(), objTx, true, RPCSerializationFlags());
             txs.push_back(objTx);
         } else {
             txs.push_back(tx->GetId().GetHex());
         }
     }
     result.pushKV("tx", txs);
     result.pushKV("time", block.GetBlockTime());
     result.pushKV("mediantime", int64_t(blockindex->GetMedianTimePast()));
     result.pushKV("nonce", uint64_t(block.nNonce));
     result.pushKV("bits", strprintf("%08x", block.nBits));
     result.pushKV("difficulty", GetDifficulty(blockindex));
     result.pushKV("chainwork", blockindex->nChainWork.GetHex());
     result.pushKV("nTx", uint64_t(blockindex->nTx));
 
     if (blockindex->pprev) {
         result.pushKV("previousblockhash",
                       blockindex->pprev->GetBlockHash().GetHex());
     }
     if (pnext) {
         result.pushKV("nextblockhash", pnext->GetBlockHash().GetHex());
     }
     return result;
 }
 
 static UniValue getblockcount(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "getblockcount",
         "\nReturns the height of the most-work fully-validated chain.\n"
         "The genesis block has height 0.\n",
         {},
         RPCResult{RPCResult::Type::NUM, "", "The current block count"},
         RPCExamples{HelpExampleCli("getblockcount", "") +
                     HelpExampleRpc("getblockcount", "")},
     }
         .Check(request);
 
     LOCK(cs_main);
     return ::ChainActive().Height();
 }
 
 static UniValue getbestblockhash(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "getbestblockhash",
         "Returns the hash of the best (tip) block in the "
         "most-work fully-validated chain.\n",
         {},
         RPCResult{RPCResult::Type::STR_HEX, "", "the block hash, hex-encoded"},
         RPCExamples{HelpExampleCli("getbestblockhash", "") +
                     HelpExampleRpc("getbestblockhash", "")},
     }
         .Check(request);
 
     LOCK(cs_main);
     return ::ChainActive().Tip()->GetBlockHash().GetHex();
 }
 
 UniValue getfinalizedblockhash(const Config &config,
                                const JSONRPCRequest &request) {
     RPCHelpMan{
         "getfinalizedblockhash",
         "Returns the hash of the currently finalized block\n",
         {},
         RPCResult{RPCResult::Type::STR_HEX, "", "the block hash, hex-encoded"},
         RPCExamples{HelpExampleCli("getfinalizedblockhash", "") +
                     HelpExampleRpc("getfinalizedblockhash", "")},
     }
         .Check(request);
 
     LOCK(cs_main);
     const CBlockIndex *blockIndexFinalized =
         ::ChainstateActive().GetFinalizedBlock();
     if (blockIndexFinalized) {
         return blockIndexFinalized->GetBlockHash().GetHex();
     }
     return UniValue(UniValue::VSTR);
 }
 
 void RPCNotifyBlockChange(const CBlockIndex *pindex) {
     if (pindex) {
         LOCK(cs_blockchange);
         latestblock.hash = pindex->GetBlockHash();
         latestblock.height = pindex->nHeight;
     }
     cond_blockchange.notify_all();
 }
 
 static UniValue waitfornewblock(const Config &config,
                                 const JSONRPCRequest &request) {
     RPCHelpMan{
         "waitfornewblock",
         "Waits for a specific new block and returns useful info about it.\n"
         "\nReturns the current block on timeout or exit.\n",
         {
             {"timeout", RPCArg::Type::NUM, /* default */ "0",
              "Time in milliseconds to wait for a response. 0 indicates no "
              "timeout."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
                       {RPCResult::Type::NUM, "height", "Block height"},
                   }},
         RPCExamples{HelpExampleCli("waitfornewblock", "1000") +
                     HelpExampleRpc("waitfornewblock", "1000")},
     }
         .Check(request);
 
     int timeout = 0;
     if (!request.params[0].isNull()) {
         timeout = request.params[0].get_int();
     }
 
     CUpdatedBlock block;
     {
         WAIT_LOCK(cs_blockchange, lock);
         block = latestblock;
         if (timeout) {
             cond_blockchange.wait_for(
                 lock, std::chrono::milliseconds(timeout),
                 [&block]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                     return latestblock.height != block.height ||
                            latestblock.hash != block.hash || !IsRPCRunning();
                 });
         } else {
             cond_blockchange.wait(
                 lock, [&block]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                     return latestblock.height != block.height ||
                            latestblock.hash != block.hash || !IsRPCRunning();
                 });
         }
         block = latestblock;
     }
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("hash", block.hash.GetHex());
     ret.pushKV("height", block.height);
     return ret;
 }
 
 static UniValue waitforblock(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "waitforblock",
         "Waits for a specific new block and returns useful info about it.\n"
         "\nReturns the current block on timeout or exit.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "Block hash to wait for."},
             {"timeout", RPCArg::Type::NUM, /* default */ "0",
              "Time in milliseconds to wait for a response. 0 indicates no "
              "timeout."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
                       {RPCResult::Type::NUM, "height", "Block height"},
                   }},
         RPCExamples{HelpExampleCli("waitforblock",
                                    "\"0000000000079f8ef3d2c688c244eb7a4570b24c9"
                                    "ed7b4a8c619eb02596f8862\" 1000") +
                     HelpExampleRpc("waitforblock",
                                    "\"0000000000079f8ef3d2c688c244eb7a4570b24c9"
                                    "ed7b4a8c619eb02596f8862\", 1000")},
     }
         .Check(request);
 
     int timeout = 0;
 
     BlockHash hash(ParseHashV(request.params[0], "blockhash"));
 
     if (!request.params[1].isNull()) {
         timeout = request.params[1].get_int();
     }
 
     CUpdatedBlock block;
     {
         WAIT_LOCK(cs_blockchange, lock);
         if (timeout) {
             cond_blockchange.wait_for(
                 lock, std::chrono::milliseconds(timeout),
                 [&hash]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                     return latestblock.hash == hash || !IsRPCRunning();
                 });
         } else {
             cond_blockchange.wait(
                 lock, [&hash]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                     return latestblock.hash == hash || !IsRPCRunning();
                 });
         }
         block = latestblock;
     }
 
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("hash", block.hash.GetHex());
     ret.pushKV("height", block.height);
     return ret;
 }
 
 static UniValue waitforblockheight(const Config &config,
                                    const JSONRPCRequest &request) {
     RPCHelpMan{
         "waitforblockheight",
         "Waits for (at least) block height and returns the height and "
         "hash\nof the current tip.\n"
         "\nReturns the current block on timeout or exit.\n",
         {
             {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "Block height to wait for."},
             {"timeout", RPCArg::Type::NUM, /* default */ "0",
              "Time in milliseconds to wait for a response. 0 indicates no "
              "timeout."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
                       {RPCResult::Type::NUM, "height", "Block height"},
                   }},
         RPCExamples{HelpExampleCli("waitforblockheight", "100 1000") +
                     HelpExampleRpc("waitforblockheight", "100, 1000")},
     }
         .Check(request);
 
     int timeout = 0;
 
     int height = request.params[0].get_int();
 
     if (!request.params[1].isNull()) {
         timeout = request.params[1].get_int();
     }
 
     CUpdatedBlock block;
     {
         WAIT_LOCK(cs_blockchange, lock);
         if (timeout) {
             cond_blockchange.wait_for(
                 lock, std::chrono::milliseconds(timeout),
                 [&height]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                     return latestblock.height >= height || !IsRPCRunning();
                 });
         } else {
             cond_blockchange.wait(
                 lock, [&height]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {
                     return latestblock.height >= height || !IsRPCRunning();
                 });
         }
         block = latestblock;
     }
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("hash", block.hash.GetHex());
     ret.pushKV("height", block.height);
     return ret;
 }
 
 static UniValue
 syncwithvalidationinterfacequeue(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "syncwithvalidationinterfacequeue",
         "Waits for the validation interface queue to catch up on everything "
         "that was there when we entered this function.\n",
         {},
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("syncwithvalidationinterfacequeue", "") +
                     HelpExampleRpc("syncwithvalidationinterfacequeue", "")},
     }
         .Check(request);
 
     SyncWithValidationInterfaceQueue();
     return NullUniValue;
 }
 
 static UniValue getdifficulty(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "getdifficulty",
         "Returns the proof-of-work difficulty as a multiple of the minimum "
         "difficulty.\n",
         {},
         RPCResult{RPCResult::Type::NUM, "",
                   "the proof-of-work difficulty as a multiple of the minimum "
                   "difficulty."},
         RPCExamples{HelpExampleCli("getdifficulty", "") +
                     HelpExampleRpc("getdifficulty", "")},
     }
         .Check(request);
 
     LOCK(cs_main);
     return GetDifficulty(::ChainActive().Tip());
 }
 
 static std::vector<RPCResult> MempoolEntryDescription() {
     return {
         RPCResult{RPCResult::Type::NUM, "size", "transaction size."},
         RPCResult{RPCResult::Type::STR_AMOUNT, "fee",
                   "transaction fee in " + CURRENCY_UNIT + " (DEPRECATED)"},
         RPCResult{RPCResult::Type::STR_AMOUNT, "modifiedfee",
                   "transaction fee with fee deltas used for mining priority "
                   "(DEPRECATED)"},
         RPCResult{RPCResult::Type::NUM_TIME, "time",
                   "local time transaction entered pool in seconds since 1 Jan "
                   "1970 GMT"},
         RPCResult{RPCResult::Type::NUM, "height",
                   "block height when transaction entered pool"},
         RPCResult{RPCResult::Type::NUM, "descendantcount",
                   "number of in-mempool descendant transactions (including "
                   "this one)"},
         RPCResult{RPCResult::Type::NUM, "descendantsize",
                   "transaction size of in-mempool descendants "
                   "(including this one)"},
         RPCResult{RPCResult::Type::STR_AMOUNT, "descendantfees",
                   "modified fees (see above) of in-mempool descendants "
                   "(including this one) (DEPRECATED)"},
         RPCResult{
             RPCResult::Type::NUM, "ancestorcount",
             "number of in-mempool ancestor transactions (including this one)"},
         RPCResult{
             RPCResult::Type::NUM, "ancestorsize",
             "transaction size of in-mempool ancestors (including this one)"},
         RPCResult{RPCResult::Type::STR_AMOUNT, "ancestorfees",
                   "modified fees (see above) of in-mempool ancestors "
                   "(including this one) (DEPRECATED)"},
         RPCResult{RPCResult::Type::OBJ,
                   "fees",
                   "",
                   {
                       RPCResult{RPCResult::Type::STR_AMOUNT, "base",
                                 "transaction fee in " + CURRENCY_UNIT},
                       RPCResult{RPCResult::Type::STR_AMOUNT, "modified",
                                 "transaction fee with fee deltas used for "
                                 "mining priority in " +
                                     CURRENCY_UNIT},
                       RPCResult{RPCResult::Type::STR_AMOUNT, "ancestor",
                                 "modified fees (see above) of in-mempool "
                                 "ancestors (including this one) in " +
                                     CURRENCY_UNIT},
                       RPCResult{RPCResult::Type::STR_AMOUNT, "descendant",
                                 "modified fees (see above) of in-mempool "
                                 "descendants (including this one) in " +
                                     CURRENCY_UNIT},
                   }},
         RPCResult{
             RPCResult::Type::ARR,
             "depends",
             "unconfirmed transactions used as inputs for this transaction",
             {RPCResult{RPCResult::Type::STR_HEX, "transactionid",
                        "parent transaction id"}}},
         RPCResult{
             RPCResult::Type::ARR,
             "spentby",
             "unconfirmed transactions spending outputs from this transaction",
             {RPCResult{RPCResult::Type::STR_HEX, "transactionid",
                        "child transaction id"}}},
         RPCResult{RPCResult::Type::BOOL, "unbroadcast",
                   "Whether this transaction is currently unbroadcast (initial "
                   "broadcast not yet acknowledged by any peers)"},
     };
 }
 
 static void entryToJSON(const CTxMemPool &pool, UniValue &info,
                         const CTxMemPoolEntry &e)
     EXCLUSIVE_LOCKS_REQUIRED(pool.cs) {
     AssertLockHeld(pool.cs);
 
     UniValue fees(UniValue::VOBJ);
-    fees.pushKV("base", ValueFromAmount(e.GetFee()));
-    fees.pushKV("modified", ValueFromAmount(e.GetModifiedFee()));
-    fees.pushKV("ancestor", ValueFromAmount(e.GetModFeesWithAncestors()));
-    fees.pushKV("descendant", ValueFromAmount(e.GetModFeesWithDescendants()));
+    fees.pushKV("base", e.GetFee());
+    fees.pushKV("modified", e.GetModifiedFee());
+    fees.pushKV("ancestor", e.GetModFeesWithAncestors());
+    fees.pushKV("descendant", e.GetModFeesWithDescendants());
     info.pushKV("fees", fees);
 
     info.pushKV("size", (int)e.GetTxSize());
-    info.pushKV("fee", ValueFromAmount(e.GetFee()));
-    info.pushKV("modifiedfee", ValueFromAmount(e.GetModifiedFee()));
+    info.pushKV("fee", e.GetFee());
+    info.pushKV("modifiedfee", e.GetModifiedFee());
     info.pushKV("time", count_seconds(e.GetTime()));
     info.pushKV("height", (int)e.GetHeight());
     info.pushKV("descendantcount", e.GetCountWithDescendants());
     info.pushKV("descendantsize", e.GetSizeWithDescendants());
     info.pushKV("descendantfees", e.GetModFeesWithDescendants() / SATOSHI);
     info.pushKV("ancestorcount", e.GetCountWithAncestors());
     info.pushKV("ancestorsize", e.GetSizeWithAncestors());
     info.pushKV("ancestorfees", e.GetModFeesWithAncestors() / SATOSHI);
     const CTransaction &tx = e.GetTx();
     std::set<std::string> setDepends;
     for (const CTxIn &txin : tx.vin) {
         if (pool.exists(txin.prevout.GetTxId())) {
             setDepends.insert(txin.prevout.GetTxId().ToString());
         }
     }
 
     UniValue depends(UniValue::VARR);
     for (const std::string &dep : setDepends) {
         depends.push_back(dep);
     }
 
     info.pushKV("depends", depends);
 
     UniValue spent(UniValue::VARR);
     const CTxMemPool::txiter &it = pool.mapTx.find(tx.GetId());
     const CTxMemPool::setEntries &setChildren = pool.GetMemPoolChildren(it);
     for (CTxMemPool::txiter childiter : setChildren) {
         spent.push_back(childiter->GetTx().GetId().ToString());
     }
 
     info.pushKV("spentby", spent);
     info.pushKV("unbroadcast", pool.IsUnbroadcastTx(tx.GetId()));
 }
 
 UniValue MempoolToJSON(const CTxMemPool &pool, bool verbose) {
     if (verbose) {
         LOCK(pool.cs);
         UniValue o(UniValue::VOBJ);
         for (const CTxMemPoolEntry &e : pool.mapTx) {
             const uint256 &txid = e.GetTx().GetId();
             UniValue info(UniValue::VOBJ);
             entryToJSON(pool, info, e);
             // Mempool has unique entries so there is no advantage in using
             // UniValue::pushKV, which checks if the key already exists in O(N).
             // UniValue::__pushKV is used instead which currently is O(1).
             o.__pushKV(txid.ToString(), info);
         }
         return o;
     } else {
         std::vector<uint256> vtxids;
         pool.queryHashes(vtxids);
 
         UniValue a(UniValue::VARR);
         for (const uint256 &txid : vtxids) {
             a.push_back(txid.ToString());
         }
 
         return a;
     }
 }
 
 static UniValue getrawmempool(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "getrawmempool",
         "Returns all transaction ids in memory pool as a json array of "
         "string transaction ids.\n"
         "\nHint: use getmempoolentry to fetch a specific transaction from the "
         "mempool.\n",
         {
             {"verbose", RPCArg::Type::BOOL, /* default */ "false",
              "True for a json object, false for array of transaction ids"},
         },
         {
             RPCResult{"for verbose = false",
                       RPCResult::Type::ARR,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "", "The transaction id"},
                       }},
             RPCResult{"for verbose = true",
                       RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::OBJ_DYN, "transactionid", "",
                            MempoolEntryDescription()},
                       }},
         },
         RPCExamples{HelpExampleCli("getrawmempool", "true") +
                     HelpExampleRpc("getrawmempool", "true")},
     }
         .Check(request);
 
     bool fVerbose = false;
     if (!request.params[0].isNull()) {
         fVerbose = request.params[0].get_bool();
     }
 
     return MempoolToJSON(EnsureMemPool(request.context), fVerbose);
 }
 
 static UniValue getmempoolancestors(const Config &config,
                                     const JSONRPCRequest &request) {
     RPCHelpMan{
         "getmempoolancestors",
         "If txid is in the mempool, returns all in-mempool ancestors.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id (must be in mempool)"},
             {"verbose", RPCArg::Type::BOOL, /* default */ "false",
              "True for a json object, false for array of transaction ids"},
         },
         {
             RPCResult{
                 "for verbose = false",
                 RPCResult::Type::ARR,
                 "",
                 "",
                 {{RPCResult::Type::STR_HEX, "",
                   "The transaction id of an in-mempool ancestor transaction"}}},
             RPCResult{"for verbose = true", RPCResult::Type::OBJ_DYN,
                       "transactionid", "", MempoolEntryDescription()},
         },
         RPCExamples{HelpExampleCli("getmempoolancestors", "\"mytxid\"") +
                     HelpExampleRpc("getmempoolancestors", "\"mytxid\"")},
     }
         .Check(request);
 
     bool fVerbose = false;
     if (!request.params[1].isNull()) {
         fVerbose = request.params[1].get_bool();
     }
 
     TxId txid(ParseHashV(request.params[0], "parameter 1"));
 
     const CTxMemPool &mempool = EnsureMemPool(request.context);
     LOCK(mempool.cs);
 
     CTxMemPool::txiter it = mempool.mapTx.find(txid);
     if (it == mempool.mapTx.end()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Transaction not in mempool");
     }
 
     CTxMemPool::setEntries setAncestors;
     uint64_t noLimit = std::numeric_limits<uint64_t>::max();
     std::string dummy;
     mempool.CalculateMemPoolAncestors(*it, setAncestors, noLimit, noLimit,
                                       noLimit, noLimit, dummy, false);
 
     if (!fVerbose) {
         UniValue o(UniValue::VARR);
         for (CTxMemPool::txiter ancestorIt : setAncestors) {
             o.push_back(ancestorIt->GetTx().GetId().ToString());
         }
 
         return o;
     } else {
         UniValue o(UniValue::VOBJ);
         for (CTxMemPool::txiter ancestorIt : setAncestors) {
             const CTxMemPoolEntry &e = *ancestorIt;
             const TxId &_txid = e.GetTx().GetId();
             UniValue info(UniValue::VOBJ);
             entryToJSON(mempool, info, e);
             o.pushKV(_txid.ToString(), info);
         }
         return o;
     }
 }
 
 static UniValue getmempooldescendants(const Config &config,
                                       const JSONRPCRequest &request) {
     RPCHelpMan{
         "getmempooldescendants",
         "If txid is in the mempool, returns all in-mempool descendants.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id (must be in mempool)"},
             {"verbose", RPCArg::Type::BOOL, /* default */ "false",
              "True for a json object, false for array of transaction ids"},
         },
         {
             RPCResult{"for verbose = false",
                       RPCResult::Type::ARR,
                       "",
                       "",
                       {{RPCResult::Type::STR_HEX, "",
                         "The transaction id of an in-mempool descendant "
                         "transaction"}}},
             RPCResult{"for verbose = true",
                       RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::OBJ_DYN, "transactionid", "",
                            MempoolEntryDescription()},
                       }},
         },
         RPCExamples{HelpExampleCli("getmempooldescendants", "\"mytxid\"") +
                     HelpExampleRpc("getmempooldescendants", "\"mytxid\"")},
     }
         .Check(request);
 
     bool fVerbose = false;
     if (!request.params[1].isNull()) {
         fVerbose = request.params[1].get_bool();
     }
 
     TxId txid(ParseHashV(request.params[0], "parameter 1"));
 
     const CTxMemPool &mempool = EnsureMemPool(request.context);
     LOCK(mempool.cs);
 
     CTxMemPool::txiter it = mempool.mapTx.find(txid);
     if (it == mempool.mapTx.end()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Transaction not in mempool");
     }
 
     CTxMemPool::setEntries setDescendants;
     mempool.CalculateDescendants(it, setDescendants);
     // CTxMemPool::CalculateDescendants will include the given tx
     setDescendants.erase(it);
 
     if (!fVerbose) {
         UniValue o(UniValue::VARR);
         for (CTxMemPool::txiter descendantIt : setDescendants) {
             o.push_back(descendantIt->GetTx().GetId().ToString());
         }
 
         return o;
     } else {
         UniValue o(UniValue::VOBJ);
         for (CTxMemPool::txiter descendantIt : setDescendants) {
             const CTxMemPoolEntry &e = *descendantIt;
             const TxId &_txid = e.GetTx().GetId();
             UniValue info(UniValue::VOBJ);
             entryToJSON(mempool, info, e);
             o.pushKV(_txid.ToString(), info);
         }
         return o;
     }
 }
 
 static UniValue getmempoolentry(const Config &config,
                                 const JSONRPCRequest &request) {
     RPCHelpMan{
         "getmempoolentry",
         "Returns mempool data for given transaction\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id (must be in mempool)"},
         },
         RPCResult{RPCResult::Type::OBJ_DYN, "", "", MempoolEntryDescription()},
         RPCExamples{HelpExampleCli("getmempoolentry", "\"mytxid\"") +
                     HelpExampleRpc("getmempoolentry", "\"mytxid\"")},
     }
         .Check(request);
 
     TxId txid(ParseHashV(request.params[0], "parameter 1"));
 
     const CTxMemPool &mempool = EnsureMemPool(request.context);
     LOCK(mempool.cs);
 
     CTxMemPool::txiter it = mempool.mapTx.find(txid);
     if (it == mempool.mapTx.end()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Transaction not in mempool");
     }
 
     const CTxMemPoolEntry &e = *it;
     UniValue info(UniValue::VOBJ);
     entryToJSON(mempool, info, e);
     return info;
 }
 
 static UniValue getblockhash(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "getblockhash",
         "Returns hash of block in best-block-chain at height provided.\n",
         {
             {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The height index"},
         },
         RPCResult{RPCResult::Type::STR_HEX, "", "The block hash"},
         RPCExamples{HelpExampleCli("getblockhash", "1000") +
                     HelpExampleRpc("getblockhash", "1000")},
     }
         .Check(request);
 
     LOCK(cs_main);
 
     int nHeight = request.params[0].get_int();
     if (nHeight < 0 || nHeight > ::ChainActive().Height()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Block height out of range");
     }
 
     CBlockIndex *pblockindex = ::ChainActive()[nHeight];
     return pblockindex->GetBlockHash().GetHex();
 }
 
 static UniValue getblockheader(const Config &config,
                                const JSONRPCRequest &request) {
     RPCHelpMan{
         "getblockheader",
         "If verbose is false, returns a string that is serialized, hex-encoded "
         "data for blockheader 'hash'.\n"
         "If verbose is true, returns an Object with information about "
         "blockheader <hash>.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The block hash"},
             {"verbose", RPCArg::Type::BOOL, /* default */ "true",
              "true for a json object, false for the hex-encoded data"},
         },
         {
             RPCResult{
                 "for verbose = true",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::STR_HEX, "hash",
                      "the block hash (same as provided)"},
                     {RPCResult::Type::NUM, "confirmations",
                      "The number of confirmations, or -1 if the block is not "
                      "on the main chain"},
                     {RPCResult::Type::NUM, "height",
                      "The block height or index"},
                     {RPCResult::Type::NUM, "version", "The block version"},
                     {RPCResult::Type::STR_HEX, "versionHex",
                      "The block version formatted in hexadecimal"},
                     {RPCResult::Type::STR_HEX, "merkleroot", "The merkle root"},
                     {RPCResult::Type::NUM_TIME, "time",
                      "The block time expressed in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::NUM_TIME, "mediantime",
                      "The median block time expressed in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::NUM, "nonce", "The nonce"},
                     {RPCResult::Type::STR_HEX, "bits", "The bits"},
                     {RPCResult::Type::NUM, "difficulty", "The difficulty"},
                     {RPCResult::Type::STR_HEX, "chainwork",
                      "Expected number of hashes required to produce the "
                      "current chain"},
                     {RPCResult::Type::NUM, "nTx",
                      "The number of transactions in the block"},
                     {RPCResult::Type::STR_HEX, "previousblockhash",
                      "The hash of the previous block"},
                     {RPCResult::Type::STR_HEX, "nextblockhash",
                      "The hash of the next block"},
                 }},
             RPCResult{"for verbose=false", RPCResult::Type::STR_HEX, "",
                       "A string that is serialized, hex-encoded data for block "
                       "'hash'"},
         },
         RPCExamples{HelpExampleCli("getblockheader",
                                    "\"00000000c937983704a73af28acdec37b049d214a"
                                    "dbda81d7e2a3dd146f6ed09\"") +
                     HelpExampleRpc("getblockheader",
                                    "\"00000000c937983704a73af28acdec37b049d214a"
                                    "dbda81d7e2a3dd146f6ed09\"")},
     }
         .Check(request);
 
     BlockHash hash(ParseHashV(request.params[0], "hash"));
 
     bool fVerbose = true;
     if (!request.params[1].isNull()) {
         fVerbose = request.params[1].get_bool();
     }
 
     const CBlockIndex *pblockindex;
     const CBlockIndex *tip;
     {
         LOCK(cs_main);
         pblockindex = LookupBlockIndex(hash);
         tip = ::ChainActive().Tip();
     }
 
     if (!pblockindex) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
     }
 
     if (!fVerbose) {
         CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);
         ssBlock << pblockindex->GetBlockHeader();
         std::string strHex = HexStr(ssBlock);
         return strHex;
     }
 
     return blockheaderToJSON(tip, pblockindex);
 }
 
 static CBlock GetBlockChecked(const Config &config,
                               const CBlockIndex *pblockindex) {
     CBlock block;
     if (IsBlockPruned(pblockindex)) {
         throw JSONRPCError(RPC_MISC_ERROR, "Block not available (pruned data)");
     }
 
     if (!ReadBlockFromDisk(block, pblockindex,
                            config.GetChainParams().GetConsensus())) {
         // Block not found on disk. This could be because we have the block
         // header in our index but don't have the block (for example if a
         // non-whitelisted node sends us an unrequested long chain of valid
         // blocks, we add the headers to our index, but don't accept the block).
         throw JSONRPCError(RPC_MISC_ERROR, "Block not found on disk");
     }
 
     return block;
 }
 
 static CBlockUndo GetUndoChecked(const CBlockIndex *pblockindex) {
     CBlockUndo blockUndo;
     if (IsBlockPruned(pblockindex)) {
         throw JSONRPCError(RPC_MISC_ERROR,
                            "Undo data not available (pruned data)");
     }
 
     if (!UndoReadFromDisk(blockUndo, pblockindex)) {
         throw JSONRPCError(RPC_MISC_ERROR, "Can't read undo data from disk");
     }
 
     return blockUndo;
 }
 
 static UniValue getblock(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "getblock",
         "If verbosity is 0 or false, returns a string that is serialized, "
         "hex-encoded data for block 'hash'.\n"
         "If verbosity is 1 or true, returns an Object with information about "
         "block <hash>.\n"
         "If verbosity is 2, returns an Object with information about block "
         "<hash> and information about each transaction.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The block hash"},
             {"verbosity|verbose", RPCArg::Type::NUM, /* default */ "1",
              "0 for hex-encoded data, 1 for a json object, and 2 for json "
              "object with transaction data"},
         },
         {
             RPCResult{"for verbosity = 0", RPCResult::Type::STR_HEX, "",
                       "A string that is serialized, hex-encoded data for block "
                       "'hash'"},
             RPCResult{
                 "for verbosity = 1",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::STR_HEX, "hash",
                      "the block hash (same as provided)"},
                     {RPCResult::Type::NUM, "confirmations",
                      "The number of confirmations, or -1 if the block is not "
                      "on the main chain"},
                     {RPCResult::Type::NUM, "size", "The block size"},
                     {RPCResult::Type::NUM, "height",
                      "The block height or index"},
                     {RPCResult::Type::NUM, "version", "The block version"},
                     {RPCResult::Type::STR_HEX, "versionHex",
                      "The block version formatted in hexadecimal"},
                     {RPCResult::Type::STR_HEX, "merkleroot", "The merkle root"},
                     {RPCResult::Type::ARR,
                      "tx",
                      "The transaction ids",
                      {{RPCResult::Type::STR_HEX, "", "The transaction id"}}},
                     {RPCResult::Type::NUM_TIME, "time",
                      "The block time expressed in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::NUM_TIME, "mediantime",
                      "The median block time expressed in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::NUM, "nonce", "The nonce"},
                     {RPCResult::Type::STR_HEX, "bits", "The bits"},
                     {RPCResult::Type::NUM, "difficulty", "The difficulty"},
                     {RPCResult::Type::STR_HEX, "chainwork",
                      "Expected number of hashes required to produce the chain "
                      "up to this block (in hex)"},
                     {RPCResult::Type::NUM, "nTx",
                      "The number of transactions in the block"},
                     {RPCResult::Type::STR_HEX, "previousblockhash",
                      "The hash of the previous block"},
                     {RPCResult::Type::STR_HEX, "nextblockhash",
                      "The hash of the next block"},
                 }},
             RPCResult{"for verbosity = 2",
                       RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::ELISION, "",
                            "Same output as verbosity = 1"},
                           {RPCResult::Type::ARR,
                            "tx",
                            "",
                            {
                                {RPCResult::Type::OBJ,
                                 "",
                                 "",
                                 {
                                     {RPCResult::Type::ELISION, "",
                                      "The transactions in the format of the "
                                      "getrawtransaction RPC. Different from "
                                      "verbosity = 1 \"tx\" result"},
                                 }},
                            }},
                           {RPCResult::Type::ELISION, "",
                            "Same output as verbosity = 1"},
                       }},
         },
         RPCExamples{
             HelpExampleCli("getblock", "\"00000000c937983704a73af28acdec37b049d"
                                        "214adbda81d7e2a3dd146f6ed09\"") +
             HelpExampleRpc("getblock", "\"00000000c937983704a73af28acdec37b049d"
                                        "214adbda81d7e2a3dd146f6ed09\"")},
     }
         .Check(request);
 
     BlockHash hash(ParseHashV(request.params[0], "blockhash"));
 
     int verbosity = 1;
     if (!request.params[1].isNull()) {
         if (request.params[1].isNum()) {
             verbosity = request.params[1].get_int();
         } else {
             verbosity = request.params[1].get_bool() ? 1 : 0;
         }
     }
 
     CBlock block;
     const CBlockIndex *pblockindex;
     const CBlockIndex *tip;
     {
         LOCK(cs_main);
         pblockindex = LookupBlockIndex(hash);
         tip = ::ChainActive().Tip();
 
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
 
         block = GetBlockChecked(config, pblockindex);
     }
 
     if (verbosity <= 0) {
         CDataStream ssBlock(SER_NETWORK,
                             PROTOCOL_VERSION | RPCSerializationFlags());
         ssBlock << block;
         std::string strHex = HexStr(ssBlock);
         return strHex;
     }
 
     return blockToJSON(block, tip, pblockindex, verbosity >= 2);
 }
 
 static UniValue pruneblockchain(const Config &config,
                                 const JSONRPCRequest &request) {
     RPCHelpMan{
         "pruneblockchain",
         "",
         {
             {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The block height to prune up to. May be set to a discrete "
              "height, or to a " +
                  UNIX_EPOCH_TIME +
                  "\n"
                  "                  to prune blocks whose block time is at "
                  "least 2 hours older than the provided timestamp."},
         },
         RPCResult{RPCResult::Type::NUM, "", "Height of the last block pruned"},
         RPCExamples{HelpExampleCli("pruneblockchain", "1000") +
                     HelpExampleRpc("pruneblockchain", "1000")},
     }
         .Check(request);
 
     if (!fPruneMode) {
         throw JSONRPCError(
             RPC_MISC_ERROR,
             "Cannot prune blocks because node is not in prune mode.");
     }
 
     LOCK(cs_main);
 
     int heightParam = request.params[0].get_int();
     if (heightParam < 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative block height.");
     }
 
     // Height value more than a billion is too high to be a block height, and
     // too low to be a block time (corresponds to timestamp from Sep 2001).
     if (heightParam > 1000000000) {
         // Add a 2 hour buffer to include blocks which might have had old
         // timestamps
         CBlockIndex *pindex = ::ChainActive().FindEarliestAtLeast(
             heightParam - TIMESTAMP_WINDOW, 0);
         if (!pindex) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Could not find block with at least the specified timestamp.");
         }
         heightParam = pindex->nHeight;
     }
 
     unsigned int height = (unsigned int)heightParam;
     unsigned int chainHeight = (unsigned int)::ChainActive().Height();
     if (chainHeight < config.GetChainParams().PruneAfterHeight()) {
         throw JSONRPCError(RPC_MISC_ERROR,
                            "Blockchain is too short for pruning.");
     } else if (height > chainHeight) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "Blockchain is shorter than the attempted prune height.");
     } else if (height > chainHeight - MIN_BLOCKS_TO_KEEP) {
         LogPrint(BCLog::RPC, "Attempt to prune blocks close to the tip. "
                              "Retaining the minimum number of blocks.\n");
         height = chainHeight - MIN_BLOCKS_TO_KEEP;
     }
 
     PruneBlockFilesManual(height);
     const CBlockIndex *block = ::ChainActive().Tip();
     CHECK_NONFATAL(block);
     while (block->pprev && (block->pprev->nStatus.hasData())) {
         block = block->pprev;
     }
     return uint64_t(block->nHeight);
 }
 
 static UniValue gettxoutsetinfo(const Config &config,
                                 const JSONRPCRequest &request) {
     RPCHelpMan{
         "gettxoutsetinfo",
         "Returns statistics about the unspent transaction output set.\n"
         "Note this call may take some time.\n",
         {},
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::NUM, "height",
                        "The current block height (index)"},
                       {RPCResult::Type::STR_HEX, "bestblock",
                        "The hash of the block at the tip of the chain"},
                       {RPCResult::Type::NUM, "transactions",
                        "The number of transactions with unspent outputs"},
                       {RPCResult::Type::NUM, "txouts",
                        "The number of unspent transaction outputs"},
                       {RPCResult::Type::NUM, "bogosize",
                        "A meaningless metric for UTXO set size"},
                       {RPCResult::Type::STR_HEX, "hash_serialized",
                        "The serialized hash"},
                       {RPCResult::Type::NUM, "disk_size",
                        "The estimated size of the chainstate on disk"},
                       {RPCResult::Type::STR_AMOUNT, "total_amount",
                        "The total amount"},
                   }},
         RPCExamples{HelpExampleCli("gettxoutsetinfo", "") +
                     HelpExampleRpc("gettxoutsetinfo", "")},
     }
         .Check(request);
 
     UniValue ret(UniValue::VOBJ);
 
     CCoinsStats stats;
     ::ChainstateActive().ForceFlushStateToDisk();
 
     CCoinsView *coins_view =
         WITH_LOCK(cs_main, return &ChainstateActive().CoinsDB());
     NodeContext &node = EnsureNodeContext(request.context);
     if (GetUTXOStats(coins_view, stats, node.rpc_interruption_point)) {
         ret.pushKV("height", int64_t(stats.nHeight));
         ret.pushKV("bestblock", stats.hashBlock.GetHex());
         ret.pushKV("transactions", int64_t(stats.nTransactions));
         ret.pushKV("txouts", int64_t(stats.nTransactionOutputs));
         ret.pushKV("bogosize", int64_t(stats.nBogoSize));
         ret.pushKV("hash_serialized", stats.hashSerialized.GetHex());
         ret.pushKV("disk_size", stats.nDiskSize);
-        ret.pushKV("total_amount", ValueFromAmount(stats.nTotalAmount));
+        ret.pushKV("total_amount", stats.nTotalAmount);
     } else {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Unable to read UTXO set");
     }
     return ret;
 }
 
 UniValue gettxout(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "gettxout",
         "Returns details about an unspent transaction output.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id"},
             {"n", RPCArg::Type::NUM, RPCArg::Optional::NO, "vout number"},
             {"include_mempool", RPCArg::Type::BOOL, /* default */ "true",
              "Whether to include the mempool. Note that an unspent output that "
              "is spent in the mempool won't appear."},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR_HEX, "bestblock",
                  "The hash of the block at the tip of the chain"},
                 {RPCResult::Type::NUM, "confirmations",
                  "The number of confirmations"},
                 {RPCResult::Type::STR_AMOUNT, "value",
                  "The transaction value in " + CURRENCY_UNIT},
                 {RPCResult::Type::OBJ,
                  "scriptPubKey",
                  "",
                  {
                      {RPCResult::Type::STR_HEX, "asm", ""},
                      {RPCResult::Type::STR_HEX, "hex", ""},
                      {RPCResult::Type::NUM, "reqSigs",
                       "Number of required signatures"},
                      {RPCResult::Type::STR_HEX, "type",
                       "The type, eg pubkeyhash"},
                      {RPCResult::Type::ARR,
                       "addresses",
                       "array of bitcoin addresses",
                       {{RPCResult::Type::STR, "address", "bitcoin address"}}},
                  }},
                 {RPCResult::Type::BOOL, "coinbase", "Coinbase or not"},
             }},
         RPCExamples{"\nGet unspent transactions\n" +
                     HelpExampleCli("listunspent", "") + "\nView the details\n" +
                     HelpExampleCli("gettxout", "\"txid\" 1") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc("gettxout", "\"txid\", 1")},
     }
         .Check(request);
 
     LOCK(cs_main);
 
     UniValue ret(UniValue::VOBJ);
 
     TxId txid(ParseHashV(request.params[0], "txid"));
     int n = request.params[1].get_int();
     COutPoint out(txid, n);
     bool fMempool = true;
     if (!request.params[2].isNull()) {
         fMempool = request.params[2].get_bool();
     }
 
     Coin coin;
     CCoinsViewCache *coins_view = &::ChainstateActive().CoinsTip();
 
     if (fMempool) {
         const CTxMemPool &mempool = EnsureMemPool(request.context);
         LOCK(mempool.cs);
         CCoinsViewMemPool view(coins_view, mempool);
         if (!view.GetCoin(out, coin) || mempool.isSpent(out)) {
             return NullUniValue;
         }
     } else {
         if (!coins_view->GetCoin(out, coin)) {
             return NullUniValue;
         }
     }
 
     const CBlockIndex *pindex = LookupBlockIndex(coins_view->GetBestBlock());
     ret.pushKV("bestblock", pindex->GetBlockHash().GetHex());
     if (coin.GetHeight() == MEMPOOL_HEIGHT) {
         ret.pushKV("confirmations", 0);
     } else {
         ret.pushKV("confirmations",
                    int64_t(pindex->nHeight - coin.GetHeight() + 1));
     }
-    ret.pushKV("value", ValueFromAmount(coin.GetTxOut().nValue));
+    ret.pushKV("value", coin.GetTxOut().nValue);
     UniValue o(UniValue::VOBJ);
     ScriptPubKeyToUniv(coin.GetTxOut().scriptPubKey, o, true);
     ret.pushKV("scriptPubKey", o);
     ret.pushKV("coinbase", coin.IsCoinBase());
 
     return ret;
 }
 
 static UniValue verifychain(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "verifychain",
         "Verifies blockchain database.\n",
         {
             {"checklevel", RPCArg::Type::NUM,
              /* default */ strprintf("%d, range=0-4", DEFAULT_CHECKLEVEL),
              strprintf("How thorough the block verification is:\n - %s",
                        Join(CHECKLEVEL_DOC, "\n- "))},
             {"nblocks", RPCArg::Type::NUM,
              /* default */ strprintf("%d, 0=all", DEFAULT_CHECKBLOCKS),
              "The number of blocks to check."},
         },
         RPCResult{RPCResult::Type::BOOL, "", "Verified or not"},
         RPCExamples{HelpExampleCli("verifychain", "") +
                     HelpExampleRpc("verifychain", "")},
     }
         .Check(request);
 
     const int check_level(request.params[0].isNull()
                               ? DEFAULT_CHECKLEVEL
                               : request.params[0].get_int());
     const int check_depth{request.params[1].isNull()
                               ? DEFAULT_CHECKBLOCKS
                               : request.params[1].get_int()};
 
     LOCK(cs_main);
 
     return CVerifyDB().VerifyDB(config, &::ChainstateActive().CoinsTip(),
                                 check_level, check_depth);
 }
 
 static void BIP9SoftForkDescPushBack(UniValue &softforks,
                                      const Consensus::Params &consensusParams,
                                      Consensus::DeploymentPos id)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     // For BIP9 deployments.
     // Deployments (e.g. testdummy) with timeout value before Jan 1, 2009 are
     // hidden. A timeout value of 0 guarantees a softfork will never be
     // activated. This is used when merging logic to implement a proposed
     // softfork without a specified deployment schedule.
     if (consensusParams.vDeployments[id].nTimeout <= 1230768000) {
         return;
     }
 
     UniValue bip9(UniValue::VOBJ);
     const ThresholdState thresholdState =
         VersionBitsTipState(consensusParams, id);
     switch (thresholdState) {
         case ThresholdState::DEFINED:
             bip9.pushKV("status", "defined");
             break;
         case ThresholdState::STARTED:
             bip9.pushKV("status", "started");
             break;
         case ThresholdState::LOCKED_IN:
             bip9.pushKV("status", "locked_in");
             break;
         case ThresholdState::ACTIVE:
             bip9.pushKV("status", "active");
             break;
         case ThresholdState::FAILED:
             bip9.pushKV("status", "failed");
             break;
     }
     if (ThresholdState::STARTED == thresholdState) {
         bip9.pushKV("bit", consensusParams.vDeployments[id].bit);
     }
     bip9.pushKV("start_time", consensusParams.vDeployments[id].nStartTime);
     bip9.pushKV("timeout", consensusParams.vDeployments[id].nTimeout);
     int64_t since_height = VersionBitsTipStateSinceHeight(consensusParams, id);
     bip9.pushKV("since", since_height);
     if (ThresholdState::STARTED == thresholdState) {
         UniValue statsUV(UniValue::VOBJ);
         BIP9Stats statsStruct = VersionBitsTipStatistics(consensusParams, id);
         statsUV.pushKV("period", statsStruct.period);
         statsUV.pushKV("threshold", statsStruct.threshold);
         statsUV.pushKV("elapsed", statsStruct.elapsed);
         statsUV.pushKV("count", statsStruct.count);
         statsUV.pushKV("possible", statsStruct.possible);
         bip9.pushKV("statistics", statsUV);
     }
 
     UniValue rv(UniValue::VOBJ);
     rv.pushKV("type", "bip9");
     rv.pushKV("bip9", bip9);
     if (ThresholdState::ACTIVE == thresholdState) {
         rv.pushKV("height", since_height);
     }
     rv.pushKV("active", ThresholdState::ACTIVE == thresholdState);
 
     softforks.pushKV(VersionBitsDeploymentInfo[id].name, rv);
 }
 
 UniValue getblockchaininfo(const Config &config,
                            const JSONRPCRequest &request) {
     RPCHelpMan{
         "getblockchaininfo",
         "Returns an object containing various state info regarding blockchain "
         "processing.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR, "chain",
                  "current network name (main, test, regtest)"},
                 {RPCResult::Type::NUM, "blocks",
                  "the height of the most-work fully-validated chain. The "
                  "genesis block has height 0"},
                 {RPCResult::Type::NUM, "headers",
                  "the current number of headers we have validated"},
                 {RPCResult::Type::STR, "bestblockhash",
                  "the hash of the currently best block"},
                 {RPCResult::Type::NUM, "difficulty", "the current difficulty"},
                 {RPCResult::Type::NUM, "mediantime",
                  "median time for the current best block"},
                 {RPCResult::Type::NUM, "verificationprogress",
                  "estimate of verification progress [0..1]"},
                 {RPCResult::Type::BOOL, "initialblockdownload",
                  "(debug information) estimate of whether this node is in "
                  "Initial Block Download mode"},
                 {RPCResult::Type::STR_HEX, "chainwork",
                  "total amount of work in active chain, in hexadecimal"},
                 {RPCResult::Type::NUM, "size_on_disk",
                  "the estimated size of the block and undo files on disk"},
                 {RPCResult::Type::BOOL, "pruned",
                  "if the blocks are subject to pruning"},
                 {RPCResult::Type::NUM, "pruneheight",
                  "lowest-height complete block stored (only present if pruning "
                  "is enabled)"},
                 {RPCResult::Type::BOOL, "automatic_pruning",
                  "whether automatic pruning is enabled (only present if "
                  "pruning is enabled)"},
                 {RPCResult::Type::NUM, "prune_target_size",
                  "the target size used by pruning (only present if automatic "
                  "pruning is enabled)"},
                 {RPCResult::Type::OBJ_DYN,
                  "softforks",
                  "status of softforks",
                  {
                      {RPCResult::Type::OBJ,
                       "xxxx",
                       "name of the softfork",
                       {
                           {RPCResult::Type::STR, "type",
                            "one of \"buried\", \"bip9\""},
                           {RPCResult::Type::OBJ,
                            "bip9",
                            "status of bip9 softforks (only for \"bip9\" type)",
                            {
                                {RPCResult::Type::STR, "status",
                                 "one of \"defined\", \"started\", "
                                 "\"locked_in\", \"active\", \"failed\""},
                                {RPCResult::Type::NUM, "bit",
                                 "the bit (0-28) in the block version field "
                                 "used to signal this softfork (only for "
                                 "\"started\" status)"},
                                {RPCResult::Type::NUM_TIME, "start_time",
                                 "the minimum median time past of a block at "
                                 "which the bit gains its meaning"},
                                {RPCResult::Type::NUM_TIME, "timeout",
                                 "the median time past of a block at which the "
                                 "deployment is considered failed if not yet "
                                 "locked in"},
                                {RPCResult::Type::NUM, "since",
                                 "height of the first block to which the status "
                                 "applies"},
                                {RPCResult::Type::OBJ,
                                 "statistics",
                                 "numeric statistics about BIP9 signalling for "
                                 "a softfork",
                                 {
                                     {RPCResult::Type::NUM, "period",
                                      "the length in blocks of the BIP9 "
                                      "signalling period"},
                                     {RPCResult::Type::NUM, "threshold",
                                      "the number of blocks with the version "
                                      "bit set required to activate the "
                                      "feature"},
                                     {RPCResult::Type::NUM, "elapsed",
                                      "the number of blocks elapsed since the "
                                      "beginning of the current period"},
                                     {RPCResult::Type::NUM, "count",
                                      "the number of blocks with the version "
                                      "bit set in the current period"},
                                     {RPCResult::Type::BOOL, "possible",
                                      "returns false if there are not enough "
                                      "blocks left in this period to pass "
                                      "activation threshold"},
                                 }},
                            }},
                           {RPCResult::Type::NUM, "height",
                            "height of the first block which the rules are or "
                            "will be enforced (only for \"buried\" type, or "
                            "\"bip9\" type with \"active\" status)"},
                           {RPCResult::Type::BOOL, "active",
                            "true if the rules are enforced for the mempool and "
                            "the next block"},
                       }},
                  }},
                 {RPCResult::Type::STR, "warnings",
                  "any network and blockchain warnings"},
             }},
         RPCExamples{HelpExampleCli("getblockchaininfo", "") +
                     HelpExampleRpc("getblockchaininfo", "")},
     }
         .Check(request);
 
     LOCK(cs_main);
 
     const CChainParams &chainparams = config.GetChainParams();
 
     const CBlockIndex *tip = ::ChainActive().Tip();
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("chain", chainparams.NetworkIDString());
     obj.pushKV("blocks", int(::ChainActive().Height()));
     obj.pushKV("headers", pindexBestHeader ? pindexBestHeader->nHeight : -1);
     obj.pushKV("bestblockhash", tip->GetBlockHash().GetHex());
     obj.pushKV("difficulty", double(GetDifficulty(tip)));
     obj.pushKV("mediantime", int64_t(tip->GetMedianTimePast()));
     obj.pushKV("verificationprogress",
                GuessVerificationProgress(Params().TxData(), tip));
     obj.pushKV("initialblockdownload",
                ::ChainstateActive().IsInitialBlockDownload());
     obj.pushKV("chainwork", tip->nChainWork.GetHex());
     obj.pushKV("size_on_disk", CalculateCurrentUsage());
     obj.pushKV("pruned", fPruneMode);
 
     if (fPruneMode) {
         const CBlockIndex *block = tip;
         CHECK_NONFATAL(block);
         while (block->pprev && (block->pprev->nStatus.hasData())) {
             block = block->pprev;
         }
 
         obj.pushKV("pruneheight", block->nHeight);
 
         // if 0, execution bypasses the whole if block.
         bool automatic_pruning = (gArgs.GetArg("-prune", 0) != 1);
         obj.pushKV("automatic_pruning", automatic_pruning);
         if (automatic_pruning) {
             obj.pushKV("prune_target_size", nPruneTarget);
         }
     }
 
     UniValue softforks(UniValue::VOBJ);
     for (int i = 0; i < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; i++) {
         BIP9SoftForkDescPushBack(softforks, chainparams.GetConsensus(),
                                  Consensus::DeploymentPos(i));
     }
     obj.pushKV("softforks", softforks);
 
     obj.pushKV("warnings", GetWarnings(false));
     return obj;
 }
 
 /** Comparison function for sorting the getchaintips heads.  */
 struct CompareBlocksByHeight {
     bool operator()(const CBlockIndex *a, const CBlockIndex *b) const {
         // Make sure that unequal blocks with the same height do not compare
         // equal. Use the pointers themselves to make a distinction.
         if (a->nHeight != b->nHeight) {
             return (a->nHeight > b->nHeight);
         }
 
         return a < b;
     }
 };
 
 static UniValue getchaintips(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "getchaintips",
         "Return information about all known tips in the block tree, including "
         "the main chain as well as orphaned branches.\n",
         {},
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {{RPCResult::Type::OBJ,
               "",
               "",
               {
                   {RPCResult::Type::NUM, "height", "height of the chain tip"},
                   {RPCResult::Type::STR_HEX, "hash", "block hash of the tip"},
                   {RPCResult::Type::NUM, "branchlen",
                    "zero for main chain, otherwise length of branch connecting "
                    "the tip to the main chain"},
                   {RPCResult::Type::STR, "status",
                    "status of the chain, \"active\" for the main chain\n"
                    "Possible values for status:\n"
                    "1.  \"invalid\"               This branch contains at "
                    "least one invalid block\n"
                    "2.  \"parked\"                This branch contains at "
                    "least one parked block\n"
                    "3.  \"headers-only\"          Not all blocks for this "
                    "branch are available, but the headers are valid\n"
                    "4.  \"valid-headers\"         All blocks are available for "
                    "this branch, but they were never fully validated\n"
                    "5.  \"valid-fork\"            This branch is not part of "
                    "the active chain, but is fully validated\n"
                    "6.  \"active\"                This is the tip of the "
                    "active main chain, which is certainly valid"},
               }}}},
         RPCExamples{HelpExampleCli("getchaintips", "") +
                     HelpExampleRpc("getchaintips", "")},
     }
         .Check(request);
 
     ChainstateManager &chainman = EnsureChainman(request.context);
     LOCK(cs_main);
 
     /**
      * Idea: The set of chain tips is the active chain tip, plus orphan blocks
      * which do not have another orphan building off of them. Algorithm:
      *  - Make one pass through BlockIndex(), picking out the orphan
      * blocks, and also storing a set of the orphan block's pprev pointers.
      *  - Iterate through the orphan blocks. If the block isn't pointed to by
      * another orphan, it is a chain tip.
      *  - Add the active chain tip
      */
     std::set<const CBlockIndex *, CompareBlocksByHeight> setTips;
     std::set<const CBlockIndex *> setOrphans;
     std::set<const CBlockIndex *> setPrevs;
 
     for (const std::pair<const BlockHash, CBlockIndex *> &item :
          chainman.BlockIndex()) {
         if (!chainman.ActiveChain().Contains(item.second)) {
             setOrphans.insert(item.second);
             setPrevs.insert(item.second->pprev);
         }
     }
 
     for (std::set<const CBlockIndex *>::iterator it = setOrphans.begin();
          it != setOrphans.end(); ++it) {
         if (setPrevs.erase(*it) == 0) {
             setTips.insert(*it);
         }
     }
 
     // Always report the currently active tip.
     setTips.insert(chainman.ActiveChain().Tip());
 
     /* Construct the output array.  */
     UniValue res(UniValue::VARR);
     for (const CBlockIndex *block : setTips) {
         UniValue obj(UniValue::VOBJ);
         obj.pushKV("height", block->nHeight);
         obj.pushKV("hash", block->phashBlock->GetHex());
 
         const int branchLen =
             block->nHeight - chainman.ActiveChain().FindFork(block)->nHeight;
         obj.pushKV("branchlen", branchLen);
 
         std::string status;
         if (chainman.ActiveChain().Contains(block)) {
             // This block is part of the currently active chain.
             status = "active";
         } else if (block->nStatus.isInvalid()) {
             // This block or one of its ancestors is invalid.
             status = "invalid";
         } else if (block->nStatus.isOnParkedChain()) {
             // This block or one of its ancestors is parked.
             status = "parked";
         } else if (!block->HaveTxsDownloaded()) {
             // This block cannot be connected because full block data for it or
             // one of its parents is missing.
             status = "headers-only";
         } else if (block->IsValid(BlockValidity::SCRIPTS)) {
             // This block is fully validated, but no longer part of the active
             // chain. It was probably the active block once, but was
             // reorganized.
             status = "valid-fork";
         } else if (block->IsValid(BlockValidity::TREE)) {
             // The headers for this block are valid, but it has not been
             // validated. It was probably never part of the most-work chain.
             status = "valid-headers";
         } else {
             // No clue.
             status = "unknown";
         }
         obj.pushKV("status", status);
 
         res.push_back(obj);
     }
 
     return res;
 }
 
 UniValue MempoolInfoToJSON(const CTxMemPool &pool) {
     // Make sure this call is atomic in the pool.
     LOCK(pool.cs);
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("loaded", pool.IsLoaded());
     ret.pushKV("size", (int64_t)pool.size());
     ret.pushKV("bytes", (int64_t)pool.GetTotalTxSize());
     ret.pushKV("usage", (int64_t)pool.DynamicMemoryUsage());
     size_t maxmempool =
         gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
     ret.pushKV("maxmempool", (int64_t)maxmempool);
     ret.pushKV(
         "mempoolminfee",
-        ValueFromAmount(std::max(pool.GetMinFee(maxmempool), ::minRelayTxFee)
-                            .GetFeePerK()));
-    ret.pushKV("minrelaytxfee", ValueFromAmount(::minRelayTxFee.GetFeePerK()));
+        std::max(pool.GetMinFee(maxmempool), ::minRelayTxFee).GetFeePerK());
+    ret.pushKV("minrelaytxfee", ::minRelayTxFee.GetFeePerK());
     ret.pushKV("unbroadcastcount", uint64_t{pool.GetUnbroadcastTxs().size()});
     return ret;
 }
 
 static UniValue getmempoolinfo(const Config &config,
                                const JSONRPCRequest &request) {
     RPCHelpMan{
         "getmempoolinfo",
         "Returns details on the active state of the TX memory pool.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::BOOL, "loaded",
                  "True if the mempool is fully loaded"},
                 {RPCResult::Type::NUM, "size", "Current tx count"},
                 {RPCResult::Type::NUM, "bytes", "Sum of all transaction sizes"},
                 {RPCResult::Type::NUM, "usage",
                  "Total memory usage for the mempool"},
                 {RPCResult::Type::NUM, "maxmempool",
                  "Maximum memory usage for the mempool"},
                 {RPCResult::Type::STR_AMOUNT, "mempoolminfee",
                  "Minimum fee rate in " + CURRENCY_UNIT +
                      "/kB for tx to be accepted. Is the maximum of "
                      "minrelaytxfee and minimum mempool fee"},
                 {RPCResult::Type::STR_AMOUNT, "minrelaytxfee",
                  "Current minimum relay fee for transactions"},
                 {RPCResult::Type::NUM, "unbroadcastcount",
                  "Current number of transactions that haven't passed initial "
                  "broadcast yet"},
             }},
         RPCExamples{HelpExampleCli("getmempoolinfo", "") +
                     HelpExampleRpc("getmempoolinfo", "")},
     }
         .Check(request);
 
     return MempoolInfoToJSON(EnsureMemPool(request.context));
 }
 
 static UniValue preciousblock(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "preciousblock",
         "Treats a block as if it were received before others with the same "
         "work.\n"
         "\nA later preciousblock call can override the effect of an earlier "
         "one.\n"
         "\nThe effects of preciousblock are not retained across restarts.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to mark as precious"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("preciousblock", "\"blockhash\"") +
                     HelpExampleRpc("preciousblock", "\"blockhash\"")},
     }
         .Check(request);
 
     BlockHash hash(ParseHashV(request.params[0], "blockhash"));
     CBlockIndex *pblockindex;
 
     {
         LOCK(cs_main);
         pblockindex = LookupBlockIndex(hash);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
     }
 
     BlockValidationState state;
     PreciousBlock(config, state, pblockindex);
 
     if (!state.IsValid()) {
         throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
     }
 
     return NullUniValue;
 }
 
 UniValue finalizeblock(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "finalizeblock",
         "Treats a block as final. It cannot be reorged. Any chain\n"
         "that does not contain this block is invalid. Used on a less\n"
         "work chain, it can effectively PUT YOU OUT OF CONSENSUS.\n"
         "USE WITH CAUTION!\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to mark as invalid"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("finalizeblock", "\"blockhash\"") +
                     HelpExampleRpc("finalizeblock", "\"blockhash\"")},
     }
         .Check(request);
 
     std::string strHash = request.params[0].get_str();
     BlockHash hash(uint256S(strHash));
     BlockValidationState state;
 
     CBlockIndex *pblockindex = nullptr;
     {
         LOCK(cs_main);
         pblockindex = LookupBlockIndex(hash);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
     } // end of locked cs_main scope
 
     ::ChainstateActive().FinalizeBlock(config, state, pblockindex);
 
     if (state.IsValid()) {
         ActivateBestChain(config, state);
     }
 
     if (!state.IsValid()) {
         throw JSONRPCError(RPC_DATABASE_ERROR, state.ToString());
     }
 
     return NullUniValue;
 }
 
 static UniValue invalidateblock(const Config &config,
                                 const JSONRPCRequest &request) {
     RPCHelpMan{
         "invalidateblock",
         "Permanently marks a block as invalid, as if it violated a consensus "
         "rule.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to mark as invalid"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("invalidateblock", "\"blockhash\"") +
                     HelpExampleRpc("invalidateblock", "\"blockhash\"")},
     }
         .Check(request);
 
     const BlockHash hash(ParseHashV(request.params[0], "blockhash"));
     BlockValidationState state;
 
     CBlockIndex *pblockindex;
     {
         LOCK(cs_main);
         pblockindex = LookupBlockIndex(hash);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
     }
     ::ChainstateActive().InvalidateBlock(config, state, pblockindex);
 
     if (state.IsValid()) {
         ActivateBestChain(config, state);
     }
 
     if (!state.IsValid()) {
         throw JSONRPCError(RPC_DATABASE_ERROR, state.ToString());
     }
 
     return NullUniValue;
 }
 
 UniValue parkblock(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "parkblock",
         "Marks a block as parked.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to park"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("parkblock", "\"blockhash\"") +
                     HelpExampleRpc("parkblock", "\"blockhash\"")},
     }
         .Check(request);
 
     const std::string strHash = request.params[0].get_str();
     const BlockHash hash(uint256S(strHash));
     BlockValidationState state;
 
     CBlockIndex *pblockindex = nullptr;
     {
         LOCK(cs_main);
         pblockindex = LookupBlockIndex(hash);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
     }
     ::ChainstateActive().ParkBlock(config, state, pblockindex);
 
     if (state.IsValid()) {
         ActivateBestChain(config, state);
     }
 
     if (!state.IsValid()) {
         throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
     }
 
     return NullUniValue;
 }
 
 static UniValue reconsiderblock(const Config &config,
                                 const JSONRPCRequest &request) {
     RPCHelpMan{
         "reconsiderblock",
         "Removes invalidity status of a block, its ancestors and its"
         "descendants, reconsider them for activation.\n"
         "This can be used to undo the effects of invalidateblock.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to reconsider"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("reconsiderblock", "\"blockhash\"") +
                     HelpExampleRpc("reconsiderblock", "\"blockhash\"")},
     }
         .Check(request);
 
     const BlockHash hash(ParseHashV(request.params[0], "blockhash"));
 
     {
         LOCK(cs_main);
         CBlockIndex *pblockindex = LookupBlockIndex(hash);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
 
         ResetBlockFailureFlags(pblockindex);
     }
 
     BlockValidationState state;
     ActivateBestChain(config, state);
 
     if (!state.IsValid()) {
         throw JSONRPCError(RPC_DATABASE_ERROR, state.ToString());
     }
 
     return NullUniValue;
 }
 
 UniValue unparkblock(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "unparkblock",
         "Removes parked status of a block and its descendants, reconsider "
         "them for activation.\n"
         "This can be used to undo the effects of parkblock.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hash of the block to unpark"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("unparkblock", "\"blockhash\"") +
                     HelpExampleRpc("unparkblock", "\"blockhash\"")},
     }
         .Check(request);
 
     const std::string strHash = request.params[0].get_str();
     const BlockHash hash(uint256S(strHash));
 
     {
         LOCK(cs_main);
 
         CBlockIndex *pblockindex = LookupBlockIndex(hash);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
 
         UnparkBlockAndChildren(pblockindex);
     }
 
     BlockValidationState state;
     ActivateBestChain(config, state);
 
     if (!state.IsValid()) {
         throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
     }
 
     return NullUniValue;
 }
 
 static UniValue getchaintxstats(const Config &config,
                                 const JSONRPCRequest &request) {
     RPCHelpMan{
         "getchaintxstats",
         "Compute statistics about the total number and rate of transactions "
         "in the chain.\n",
         {
             {"nblocks", RPCArg::Type::NUM, /* default */ "one month",
              "Size of the window in number of blocks"},
             {"blockhash", RPCArg::Type::STR_HEX, /* default */ "chain tip",
              "The hash of the block that ends the window."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::NUM_TIME, "time",
                        "The timestamp for the final block in the window, "
                        "expressed in " +
                            UNIX_EPOCH_TIME},
                       {RPCResult::Type::NUM, "txcount",
                        "The total number of transactions in the chain up to "
                        "that point"},
                       {RPCResult::Type::STR_HEX, "window_final_block_hash",
                        "The hash of the final block in the window"},
                       {RPCResult::Type::NUM, "window_final_block_height",
                        "The height of the final block in the window."},
                       {RPCResult::Type::NUM, "window_block_count",
                        "Size of the window in number of blocks"},
                       {RPCResult::Type::NUM, "window_tx_count",
                        "The number of transactions in the window. Only "
                        "returned if \"window_block_count\" is > 0"},
                       {RPCResult::Type::NUM, "window_interval",
                        "The elapsed time in the window in seconds. Only "
                        "returned if \"window_block_count\" is > 0"},
                       {RPCResult::Type::NUM, "txrate",
                        "The average rate of transactions per second in the "
                        "window. Only returned if \"window_interval\" is > 0"},
                   }},
         RPCExamples{HelpExampleCli("getchaintxstats", "") +
                     HelpExampleRpc("getchaintxstats", "2016")},
     }
         .Check(request);
 
     const CBlockIndex *pindex;
 
     // By default: 1 month
     int blockcount = 30 * 24 * 60 * 60 /
                      config.GetChainParams().GetConsensus().nPowTargetSpacing;
 
     if (request.params[1].isNull()) {
         LOCK(cs_main);
         pindex = ::ChainActive().Tip();
     } else {
         BlockHash hash(ParseHashV(request.params[1], "blockhash"));
         LOCK(cs_main);
         pindex = LookupBlockIndex(hash);
         if (!pindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
         if (!::ChainActive().Contains(pindex)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Block is not in main chain");
         }
     }
 
     CHECK_NONFATAL(pindex != nullptr);
 
     if (request.params[0].isNull()) {
         blockcount = std::max(0, std::min(blockcount, pindex->nHeight - 1));
     } else {
         blockcount = request.params[0].get_int();
 
         if (blockcount < 0 ||
             (blockcount > 0 && blockcount >= pindex->nHeight)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid block count: "
                                                       "should be between 0 and "
                                                       "the block's height - 1");
         }
     }
 
     const CBlockIndex *pindexPast =
         pindex->GetAncestor(pindex->nHeight - blockcount);
     int nTimeDiff =
         pindex->GetMedianTimePast() - pindexPast->GetMedianTimePast();
     int nTxDiff = pindex->GetChainTxCount() - pindexPast->GetChainTxCount();
 
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("time", pindex->GetBlockTime());
     ret.pushKV("txcount", pindex->GetChainTxCount());
     ret.pushKV("window_final_block_hash", pindex->GetBlockHash().GetHex());
     ret.pushKV("window_final_block_height", pindex->nHeight);
     ret.pushKV("window_block_count", blockcount);
     if (blockcount > 0) {
         ret.pushKV("window_tx_count", nTxDiff);
         ret.pushKV("window_interval", nTimeDiff);
         if (nTimeDiff > 0) {
             ret.pushKV("txrate", double(nTxDiff) / nTimeDiff);
         }
     }
 
     return ret;
 }
 
 template <typename T>
 static T CalculateTruncatedMedian(std::vector<T> &scores) {
     size_t size = scores.size();
     if (size == 0) {
         return T();
     }
 
     std::sort(scores.begin(), scores.end());
     if (size % 2 == 0) {
         return (scores[size / 2 - 1] + scores[size / 2]) / 2;
     } else {
         return scores[size / 2];
     }
 }
 
 template <typename T> static inline bool SetHasKeys(const std::set<T> &set) {
     return false;
 }
 template <typename T, typename Tk, typename... Args>
 static inline bool SetHasKeys(const std::set<T> &set, const Tk &key,
                               const Args &... args) {
     return (set.count(key) != 0) || SetHasKeys(set, args...);
 }
 
 // outpoint (needed for the utxo index) + nHeight + fCoinBase
 static constexpr size_t PER_UTXO_OVERHEAD =
     sizeof(COutPoint) + sizeof(uint32_t) + sizeof(bool);
 
 static UniValue getblockstats(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "getblockstats",
         "Compute per block statistics for a given window. All amounts are "
         "in " +
             CURRENCY_UNIT +
             ".\n"
             "It won't work for some heights with pruning.\n",
         {
             {"hash_or_height",
              RPCArg::Type::NUM,
              RPCArg::Optional::NO,
              "The block hash or height of the target block",
              "",
              {"", "string or numeric"}},
             {"stats",
              RPCArg::Type::ARR,
              /* default */ "all values",
              "Values to plot (see result below)",
              {
                  {"height", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                   "Selected statistic"},
                  {"time", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                   "Selected statistic"},
              },
              "stats"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "avgfee", "Average fee in the block"},
                 {RPCResult::Type::NUM, "avgfeerate",
                  "Average feerate (in satoshis per virtual byte)"},
                 {RPCResult::Type::NUM, "avgtxsize", "Average transaction size"},
                 {RPCResult::Type::STR_HEX, "blockhash",
                  "The block hash (to check for potential reorgs)"},
                 {RPCResult::Type::NUM, "height", "The height of the block"},
                 {RPCResult::Type::NUM, "ins",
                  "The number of inputs (excluding coinbase)"},
                 {RPCResult::Type::NUM, "maxfee", "Maximum fee in the block"},
                 {RPCResult::Type::NUM, "maxfeerate",
                  "Maximum feerate (in satoshis per virtual byte)"},
                 {RPCResult::Type::NUM, "maxtxsize", "Maximum transaction size"},
                 {RPCResult::Type::NUM, "medianfee",
                  "Truncated median fee in the block"},
                 {RPCResult::Type::NUM, "medianfeerate",
                  "Truncated median feerate (in " + CURRENCY_UNIT +
                      " per byte)"},
                 {RPCResult::Type::NUM, "mediantime",
                  "The block median time past"},
                 {RPCResult::Type::NUM, "mediantxsize",
                  "Truncated median transaction size"},
                 {RPCResult::Type::NUM, "minfee", "Minimum fee in the block"},
                 {RPCResult::Type::NUM, "minfeerate",
                  "Minimum feerate (in satoshis per virtual byte)"},
                 {RPCResult::Type::NUM, "mintxsize", "Minimum transaction size"},
                 {RPCResult::Type::NUM, "outs", "The number of outputs"},
                 {RPCResult::Type::NUM, "subsidy", "The block subsidy"},
                 {RPCResult::Type::NUM, "time", "The block time"},
                 {RPCResult::Type::NUM, "total_out",
                  "Total amount in all outputs (excluding coinbase and thus "
                  "reward [ie subsidy + totalfee])"},
                 {RPCResult::Type::NUM, "total_size",
                  "Total size of all non-coinbase transactions"},
                 {RPCResult::Type::NUM, "totalfee", "The fee total"},
                 {RPCResult::Type::NUM, "txs",
                  "The number of transactions (excluding coinbase)"},
                 {RPCResult::Type::NUM, "utxo_increase",
                  "The increase/decrease in the number of unspent outputs"},
                 {RPCResult::Type::NUM, "utxo_size_inc",
                  "The increase/decrease in size for the utxo index (not "
                  "discounting op_return and similar)"},
             }},
         RPCExamples{
             HelpExampleCli(
                 "getblockstats",
                 R"('"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09"' '["minfeerate","avgfeerate"]')") +
             HelpExampleCli("getblockstats",
                            R"(1000 '["minfeerate","avgfeerate"]')") +
             HelpExampleRpc(
                 "getblockstats",
                 R"("00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09", ["minfeerate","avgfeerate"])") +
             HelpExampleRpc("getblockstats",
                            R"(1000, ["minfeerate","avgfeerate"])")},
     }
         .Check(request);
 
     LOCK(cs_main);
 
     CBlockIndex *pindex;
     if (request.params[0].isNum()) {
         const int height = request.params[0].get_int();
         const int current_tip = ::ChainActive().Height();
         if (height < 0) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Target block height %d is negative", height));
         }
         if (height > current_tip) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Target block height %d after current tip %d", height,
                           current_tip));
         }
 
         pindex = ::ChainActive()[height];
     } else {
         const BlockHash hash(ParseHashV(request.params[0], "hash_or_height"));
         pindex = LookupBlockIndex(hash);
         if (!pindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
         if (!::ChainActive().Contains(pindex)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                strprintf("Block is not in chain %s",
                                          Params().NetworkIDString()));
         }
     }
 
     CHECK_NONFATAL(pindex != nullptr);
 
     std::set<std::string> stats;
     if (!request.params[1].isNull()) {
         const UniValue stats_univalue = request.params[1].get_array();
         for (unsigned int i = 0; i < stats_univalue.size(); i++) {
             const std::string stat = stats_univalue[i].get_str();
             stats.insert(stat);
         }
     }
 
     const CBlock block = GetBlockChecked(config, pindex);
     const CBlockUndo blockUndo = GetUndoChecked(pindex);
 
     // Calculate everything if nothing selected (default)
     const bool do_all = stats.size() == 0;
     const bool do_mediantxsize = do_all || stats.count("mediantxsize") != 0;
     const bool do_medianfee = do_all || stats.count("medianfee") != 0;
     const bool do_medianfeerate = do_all || stats.count("medianfeerate") != 0;
     const bool loop_inputs =
         do_all || do_medianfee || do_medianfeerate ||
         SetHasKeys(stats, "utxo_size_inc", "totalfee", "avgfee", "avgfeerate",
                    "minfee", "maxfee", "minfeerate", "maxfeerate");
     const bool loop_outputs = do_all || loop_inputs || stats.count("total_out");
     const bool do_calculate_size =
         do_mediantxsize || loop_inputs ||
         SetHasKeys(stats, "total_size", "avgtxsize", "mintxsize", "maxtxsize");
 
     const int64_t blockMaxSize = config.GetMaxBlockSize();
     Amount maxfee = Amount::zero();
     Amount maxfeerate = Amount::zero();
     Amount minfee = MAX_MONEY;
     Amount minfeerate = MAX_MONEY;
     Amount total_out = Amount::zero();
     Amount totalfee = Amount::zero();
     int64_t inputs = 0;
     int64_t maxtxsize = 0;
     int64_t mintxsize = blockMaxSize;
     int64_t outputs = 0;
     int64_t total_size = 0;
     int64_t utxo_size_inc = 0;
     std::vector<Amount> fee_array;
     std::vector<Amount> feerate_array;
     std::vector<int64_t> txsize_array;
 
     for (size_t i = 0; i < block.vtx.size(); ++i) {
         const auto &tx = block.vtx.at(i);
         outputs += tx->vout.size();
         Amount tx_total_out = Amount::zero();
         if (loop_outputs) {
             for (const CTxOut &out : tx->vout) {
                 tx_total_out += out.nValue;
                 utxo_size_inc +=
                     GetSerializeSize(out, PROTOCOL_VERSION) + PER_UTXO_OVERHEAD;
             }
         }
 
         if (tx->IsCoinBase()) {
             continue;
         }
 
         // Don't count coinbase's fake input
         inputs += tx->vin.size();
         // Don't count coinbase reward
         total_out += tx_total_out;
 
         int64_t tx_size = 0;
         if (do_calculate_size) {
             tx_size = tx->GetTotalSize();
             if (do_mediantxsize) {
                 txsize_array.push_back(tx_size);
             }
             maxtxsize = std::max(maxtxsize, tx_size);
             mintxsize = std::min(mintxsize, tx_size);
             total_size += tx_size;
         }
 
         if (loop_inputs) {
             Amount tx_total_in = Amount::zero();
             const auto &txundo = blockUndo.vtxundo.at(i - 1);
             for (const Coin &coin : txundo.vprevout) {
                 const CTxOut &prevoutput = coin.GetTxOut();
 
                 tx_total_in += prevoutput.nValue;
                 utxo_size_inc -=
                     GetSerializeSize(prevoutput, PROTOCOL_VERSION) +
                     PER_UTXO_OVERHEAD;
             }
 
             Amount txfee = tx_total_in - tx_total_out;
             CHECK_NONFATAL(MoneyRange(txfee));
             if (do_medianfee) {
                 fee_array.push_back(txfee);
             }
             maxfee = std::max(maxfee, txfee);
             minfee = std::min(minfee, txfee);
             totalfee += txfee;
 
             Amount feerate = txfee / tx_size;
             if (do_medianfeerate) {
                 feerate_array.push_back(feerate);
             }
             maxfeerate = std::max(maxfeerate, feerate);
             minfeerate = std::min(minfeerate, feerate);
         }
     }
 
     UniValue ret_all(UniValue::VOBJ);
-    ret_all.pushKV("avgfee",
-                   ValueFromAmount((block.vtx.size() > 1)
-                                       ? totalfee / int((block.vtx.size() - 1))
-                                       : Amount::zero()));
+    ret_all.pushKV("avgfee", block.vtx.size() > 1
+                                 ? (totalfee / int((block.vtx.size() - 1)))
+                                 : Amount::zero());
     ret_all.pushKV("avgfeerate",
-                   ValueFromAmount((total_size > 0) ? totalfee / total_size
-                                                    : Amount::zero()));
+                   total_size > 0 ? (totalfee / total_size) : Amount::zero());
     ret_all.pushKV("avgtxsize", (block.vtx.size() > 1)
                                     ? total_size / (block.vtx.size() - 1)
                                     : 0);
     ret_all.pushKV("blockhash", pindex->GetBlockHash().GetHex());
     ret_all.pushKV("height", (int64_t)pindex->nHeight);
     ret_all.pushKV("ins", inputs);
-    ret_all.pushKV("maxfee", ValueFromAmount(maxfee));
-    ret_all.pushKV("maxfeerate", ValueFromAmount(maxfeerate));
+    ret_all.pushKV("maxfee", maxfee);
+    ret_all.pushKV("maxfeerate", maxfeerate);
     ret_all.pushKV("maxtxsize", maxtxsize);
-    ret_all.pushKV("medianfee",
-                   ValueFromAmount(CalculateTruncatedMedian(fee_array)));
-    ret_all.pushKV("medianfeerate",
-                   ValueFromAmount(CalculateTruncatedMedian(feerate_array)));
+    ret_all.pushKV("medianfee", CalculateTruncatedMedian(fee_array));
+    ret_all.pushKV("medianfeerate", CalculateTruncatedMedian(feerate_array));
     ret_all.pushKV("mediantime", pindex->GetMedianTimePast());
     ret_all.pushKV("mediantxsize", CalculateTruncatedMedian(txsize_array));
-    ret_all.pushKV(
-        "minfee",
-        ValueFromAmount((minfee == MAX_MONEY) ? Amount::zero() : minfee));
+    ret_all.pushKV("minfee", minfee == MAX_MONEY ? Amount::zero() : minfee);
     ret_all.pushKV("minfeerate",
-                   ValueFromAmount((minfeerate == MAX_MONEY) ? Amount::zero()
-                                                             : minfeerate));
+                   minfeerate == MAX_MONEY ? Amount::zero() : minfeerate);
     ret_all.pushKV("mintxsize", mintxsize == blockMaxSize ? 0 : mintxsize);
     ret_all.pushKV("outs", outputs);
-    ret_all.pushKV("subsidy", ValueFromAmount(GetBlockSubsidy(
-                                  pindex->nHeight, Params().GetConsensus())));
+    ret_all.pushKV("subsidy",
+                   GetBlockSubsidy(pindex->nHeight, Params().GetConsensus()));
     ret_all.pushKV("time", pindex->GetBlockTime());
-    ret_all.pushKV("total_out", ValueFromAmount(total_out));
+    ret_all.pushKV("total_out", total_out);
     ret_all.pushKV("total_size", total_size);
-    ret_all.pushKV("totalfee", ValueFromAmount(totalfee));
+    ret_all.pushKV("totalfee", totalfee);
     ret_all.pushKV("txs", (int64_t)block.vtx.size());
     ret_all.pushKV("utxo_increase", outputs - inputs);
     ret_all.pushKV("utxo_size_inc", utxo_size_inc);
 
     if (do_all) {
         return ret_all;
     }
 
     UniValue ret(UniValue::VOBJ);
     for (const std::string &stat : stats) {
         const UniValue &value = ret_all[stat];
         if (value.isNull()) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Invalid selected statistic %s", stat));
         }
         ret.pushKV(stat, value);
     }
     return ret;
 }
 
 static UniValue savemempool(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "savemempool",
         "Dumps the mempool to disk. It will fail until the previous dump is "
         "fully loaded.\n",
         {},
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("savemempool", "") +
                     HelpExampleRpc("savemempool", "")},
     }
         .Check(request);
 
     const CTxMemPool &mempool = EnsureMemPool(request.context);
 
     if (!mempool.IsLoaded()) {
         throw JSONRPCError(RPC_MISC_ERROR, "The mempool was not loaded yet");
     }
 
     if (!DumpMempool(mempool)) {
         throw JSONRPCError(RPC_MISC_ERROR, "Unable to dump mempool to disk");
     }
 
     return NullUniValue;
 }
 
 namespace {
 //! Search for a given set of pubkey scripts
 static bool FindScriptPubKey(std::atomic<int> &scan_progress,
                              const std::atomic<bool> &should_abort,
                              int64_t &count, CCoinsViewCursor *cursor,
                              const std::set<CScript> &needles,
                              std::map<COutPoint, Coin> &out_results,
                              std::function<void()> &interruption_point) {
     scan_progress = 0;
     count = 0;
     while (cursor->Valid()) {
         COutPoint key;
         Coin coin;
         if (!cursor->GetKey(key) || !cursor->GetValue(coin)) {
             return false;
         }
         if (++count % 8192 == 0) {
             interruption_point();
             if (should_abort) {
                 // allow to abort the scan via the abort reference
                 return false;
             }
         }
         if (count % 256 == 0) {
             // update progress reference every 256 item
             const TxId &txid = key.GetTxId();
             uint32_t high = 0x100 * *txid.begin() + *(txid.begin() + 1);
             scan_progress = int(high * 100.0 / 65536.0 + 0.5);
         }
         if (needles.count(coin.GetTxOut().scriptPubKey)) {
             out_results.emplace(key, coin);
         }
         cursor->Next();
     }
     scan_progress = 100;
     return true;
 }
 } // namespace
 
 /** RAII object to prevent concurrency issue when scanning the txout set */
 static std::atomic<int> g_scan_progress;
 static std::atomic<bool> g_scan_in_progress;
 static std::atomic<bool> g_should_abort_scan;
 class CoinsViewScanReserver {
 private:
     bool m_could_reserve;
 
 public:
     explicit CoinsViewScanReserver() : m_could_reserve(false) {}
 
     bool reserve() {
         CHECK_NONFATAL(!m_could_reserve);
         if (g_scan_in_progress.exchange(true)) {
             return false;
         }
         m_could_reserve = true;
         return true;
     }
 
     ~CoinsViewScanReserver() {
         if (m_could_reserve) {
             g_scan_in_progress = false;
         }
     }
 };
 
 static UniValue scantxoutset(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "scantxoutset",
         "EXPERIMENTAL warning: this call may be removed or changed in future "
         "releases.\n"
         "\nScans the unspent transaction output set for entries that match "
         "certain output descriptors.\n"
         "Examples of output descriptors are:\n"
         "    addr(<address>)                      Outputs whose scriptPubKey "
         "corresponds to the specified address (does not include P2PK)\n"
         "    raw(<hex script>)                    Outputs whose scriptPubKey "
         "equals the specified hex scripts\n"
         "    combo(<pubkey>)                      P2PK and P2PKH outputs for "
         "the given pubkey\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"
         "\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 \"/\", and optionally ending in "
         "\"/*\" (unhardened), or \"/*'\" or \"/*h\" (hardened) to specify all\n"
         "unhardened or hardened child keys.\n"
         "In the latter case, a range needs to be specified by below if "
         "different from 1000.\n"
         "For more information on output descriptors, see the documentation in "
         "the doc/descriptors.md file.\n",
         {
             {"action", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The action to execute\n"
              "                                      \"start\" for starting a "
              "scan\n"
              "                                      \"abort\" for aborting the "
              "current scan (returns true when abort was successful)\n"
              "                                      \"status\" for "
              "progress report (in %) of the current scan"},
             {"scanobjects",
              RPCArg::Type::ARR,
              RPCArg::Optional::OMITTED,
              "Array of scan objects. Required for \"start\" action\n"
              "                                  Every scan object is either a "
              "string descriptor or an object:",
              {
                  {"descriptor", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                   "An output descriptor"},
                  {
                      "",
                      RPCArg::Type::OBJ,
                      RPCArg::Optional::OMITTED,
                      "An object with output descriptor and metadata",
                      {
                          {"desc", RPCArg::Type::STR, RPCArg::Optional::NO,
                           "An output descriptor"},
                          {"range", RPCArg::Type::RANGE, /* default */ "1000",
                           "The range of HD chain indexes to explore (either "
                           "end or [begin,end])"},
                      },
                  },
              },
              "[scanobjects,...]"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::BOOL, "success",
                  "Whether the scan was completed"},
                 {RPCResult::Type::NUM, "txouts",
                  "The number of unspent transaction outputs scanned"},
                 {RPCResult::Type::NUM, "height",
                  "The current block height (index)"},
                 {RPCResult::Type::STR_HEX, "bestblock",
                  "The hash of the block at the tip of the chain"},
                 {RPCResult::Type::ARR,
                  "unspents",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "txid",
                            "The transaction id"},
                           {RPCResult::Type::NUM, "vout", "The vout value"},
                           {RPCResult::Type::STR_HEX, "scriptPubKey",
                            "The script key"},
                           {RPCResult::Type::STR, "desc",
                            "A specialized descriptor for the matched "
                            "scriptPubKey"},
                           {RPCResult::Type::STR_AMOUNT, "amount",
                            "The total amount in " + CURRENCY_UNIT +
                                " of the unspent output"},
                           {RPCResult::Type::NUM, "height",
                            "Height of the unspent transaction output"},
                       }},
                  }},
                 {RPCResult::Type::STR_AMOUNT, "total_amount",
                  "The total amount of all found unspent outputs in " +
                      CURRENCY_UNIT},
             }},
         RPCExamples{""},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VARR});
 
     UniValue result(UniValue::VOBJ);
     if (request.params[0].get_str() == "status") {
         CoinsViewScanReserver reserver;
         if (reserver.reserve()) {
             // no scan in progress
             return NullUniValue;
         }
         result.pushKV("progress", g_scan_progress.load());
         return result;
     } else if (request.params[0].get_str() == "abort") {
         CoinsViewScanReserver reserver;
         if (reserver.reserve()) {
             // reserve was possible which means no scan was running
             return false;
         }
         // set the abort flag
         g_should_abort_scan = true;
         return true;
     } else if (request.params[0].get_str() == "start") {
         CoinsViewScanReserver reserver;
         if (!reserver.reserve()) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Scan already in progress, use action \"abort\" or \"status\"");
         }
 
         if (request.params.size() < 2) {
             throw JSONRPCError(
                 RPC_MISC_ERROR,
                 "scanobjects argument is required for the start action");
         }
 
         std::set<CScript> needles;
         std::map<CScript, std::string> descriptors;
         Amount total_in = Amount::zero();
 
         // loop through the scan objects
         for (const UniValue &scanobject :
              request.params[1].get_array().getValues()) {
             FlatSigningProvider provider;
             auto scripts = EvalDescriptorStringOrObject(scanobject, provider);
             for (const auto &script : scripts) {
                 std::string inferred =
                     InferDescriptor(script, provider)->ToString();
                 needles.emplace(script);
                 descriptors.emplace(std::move(script), std::move(inferred));
             }
         }
 
         // Scan the unspent transaction output set for inputs
         UniValue unspents(UniValue::VARR);
         std::vector<CTxOut> input_txos;
         std::map<COutPoint, Coin> coins;
         g_should_abort_scan = false;
         g_scan_progress = 0;
         int64_t count = 0;
         std::unique_ptr<CCoinsViewCursor> pcursor;
         CBlockIndex *tip;
         {
             LOCK(cs_main);
             ::ChainstateActive().ForceFlushStateToDisk();
             pcursor = std::unique_ptr<CCoinsViewCursor>(
                 ::ChainstateActive().CoinsDB().Cursor());
             CHECK_NONFATAL(pcursor);
             tip = ::ChainActive().Tip();
             CHECK_NONFATAL(tip);
         }
         NodeContext &node = EnsureNodeContext(request.context);
         bool res = FindScriptPubKey(g_scan_progress, g_should_abort_scan, count,
                                     pcursor.get(), needles, coins,
                                     node.rpc_interruption_point);
         result.pushKV("success", res);
         result.pushKV("txouts", count);
         result.pushKV("height", tip->nHeight);
         result.pushKV("bestblock", tip->GetBlockHash().GetHex());
 
         for (const auto &it : coins) {
             const COutPoint &outpoint = it.first;
             const Coin &coin = it.second;
             const CTxOut &txo = coin.GetTxOut();
             input_txos.push_back(txo);
             total_in += txo.nValue;
 
             UniValue unspent(UniValue::VOBJ);
             unspent.pushKV("txid", outpoint.GetTxId().GetHex());
             unspent.pushKV("vout", int32_t(outpoint.GetN()));
             unspent.pushKV("scriptPubKey", HexStr(txo.scriptPubKey));
             unspent.pushKV("desc", descriptors[txo.scriptPubKey]);
-            unspent.pushKV("amount", ValueFromAmount(txo.nValue));
+            unspent.pushKV("amount", txo.nValue);
             unspent.pushKV("height", int32_t(coin.GetHeight()));
 
             unspents.push_back(unspent);
         }
         result.pushKV("unspents", unspents);
-        result.pushKV("total_amount", ValueFromAmount(total_in));
+        result.pushKV("total_amount", total_in);
     } else {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid command");
     }
     return result;
 }
 
 static UniValue getblockfilter(const Config &config,
                                const JSONRPCRequest &request) {
     RPCHelpMan{
         "getblockfilter",
         "Retrieve a BIP 157 content filter for a particular block.\n",
         {
             {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hash of the block"},
             {"filtertype", RPCArg::Type::STR, /*default*/ "basic",
              "The type name of the filter"},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "filter",
                        "the hex-encoded filter data"},
                       {RPCResult::Type::STR_HEX, "header",
                        "the hex-encoded filter header"},
                   }},
         RPCExamples{
             HelpExampleCli("getblockfilter",
                            "\"00000000c937983704a73af28acdec37b049d214a"
                            "dbda81d7e2a3dd146f6ed09\" \"basic\"") +
             HelpExampleRpc("getblockfilter",
                            "\"00000000c937983704a73af28acdec37b049d214adbda81d7"
                            "e2a3dd146f6ed09\", \"basic\"")}}
         .Check(request);
 
     const BlockHash block_hash(ParseHashV(request.params[0], "blockhash"));
     std::string filtertype_name = "basic";
     if (!request.params[1].isNull()) {
         filtertype_name = request.params[1].get_str();
     }
 
     BlockFilterType filtertype;
     if (!BlockFilterTypeByName(filtertype_name, filtertype)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unknown filtertype");
     }
 
     BlockFilterIndex *index = GetBlockFilterIndex(filtertype);
     if (!index) {
         throw JSONRPCError(RPC_MISC_ERROR,
                            "Index is not enabled for filtertype " +
                                filtertype_name);
     }
 
     const CBlockIndex *block_index;
     bool block_was_connected;
     {
         LOCK(cs_main);
         block_index = LookupBlockIndex(block_hash);
         if (!block_index) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
         block_was_connected = block_index->IsValid(BlockValidity::SCRIPTS);
     }
 
     bool index_ready = index->BlockUntilSyncedToCurrentChain();
 
     BlockFilter filter;
     uint256 filter_header;
     if (!index->LookupFilter(block_index, filter) ||
         !index->LookupFilterHeader(block_index, filter_header)) {
         int err_code;
         std::string errmsg = "Filter not found.";
 
         if (!block_was_connected) {
             err_code = RPC_INVALID_ADDRESS_OR_KEY;
             errmsg += " Block was not connected to active chain.";
         } else if (!index_ready) {
             err_code = RPC_MISC_ERROR;
             errmsg +=
                 " Block filters are still in the process of being indexed.";
         } else {
             err_code = RPC_INTERNAL_ERROR;
             errmsg +=
                 " This error is unexpected and indicates index corruption.";
         }
 
         throw JSONRPCError(err_code, errmsg);
     }
 
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("filter", HexStr(filter.GetEncodedFilter()));
     ret.pushKV("header", filter_header.GetHex());
     return ret;
 }
 
 /**
  * Serialize the UTXO set to a file for loading elsewhere.
  *
  * @see SnapshotMetadata
  */
 static UniValue dumptxoutset(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "dumptxoutset",
         "\nWrite the serialized UTXO set to disk.\n",
         {
             {"path", RPCArg::Type::STR, RPCArg::Optional::NO,
              /* default_val */ "",
              "path to the output file. If relative, will be prefixed by "
              "datadir."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::NUM, "coins_written",
                        "the number of coins written in the snapshot"},
                       {RPCResult::Type::STR_HEX, "base_hash",
                        "the hash of the base of the snapshot"},
                       {RPCResult::Type::NUM, "base_height",
                        "the height of the base of the snapshot"},
                       {RPCResult::Type::STR, "path",
                        "the absolute path that the snapshot was written to"},
                   }},
         RPCExamples{HelpExampleCli("dumptxoutset", "utxo.dat")}}
         .Check(request);
 
     fs::path path = fs::absolute(request.params[0].get_str(), GetDataDir());
     // Write to a temporary path and then move into `path` on completion
     // to avoid confusion due to an interruption.
     fs::path temppath =
         fs::absolute(request.params[0].get_str() + ".incomplete", GetDataDir());
 
     if (fs::exists(path)) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             path.string() +
                 " already exists. If you are sure this is what you want, "
                 "move it out of the way first");
     }
 
     FILE *file{fsbridge::fopen(temppath, "wb")};
     CAutoFile afile{file, SER_DISK, CLIENT_VERSION};
     std::unique_ptr<CCoinsViewCursor> pcursor;
     CCoinsStats stats;
     CBlockIndex *tip;
     NodeContext &node = EnsureNodeContext(request.context);
 
     {
         // We need to lock cs_main to ensure that the coinsdb isn't written to
         // between (i) flushing coins cache to disk (coinsdb), (ii) getting
         // stats based upon the coinsdb, and (iii) constructing a cursor to the
         // coinsdb for use below this block.
         //
         // Cursors returned by leveldb iterate over snapshots, so the contents
         // of the pcursor will not be affected by simultaneous writes during
         // use below this block.
         //
         // See discussion here:
         //   https://github.com/bitcoin/bitcoin/pull/15606#discussion_r274479369
         //
         LOCK(::cs_main);
 
         ::ChainstateActive().ForceFlushStateToDisk();
 
         if (!GetUTXOStats(&::ChainstateActive().CoinsDB(), stats,
                           node.rpc_interruption_point)) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Unable to read UTXO set");
         }
 
         pcursor = std::unique_ptr<CCoinsViewCursor>(
             ::ChainstateActive().CoinsDB().Cursor());
         tip = LookupBlockIndex(stats.hashBlock);
         CHECK_NONFATAL(tip);
     }
 
     SnapshotMetadata metadata{tip->GetBlockHash(), stats.coins_count,
                               uint64_t(tip->GetChainTxCount())};
 
     afile << metadata;
 
     COutPoint key;
     Coin coin;
     unsigned int iter{0};
 
     while (pcursor->Valid()) {
         if (iter % 5000 == 0) {
             node.rpc_interruption_point();
         }
         ++iter;
         if (pcursor->GetKey(key) && pcursor->GetValue(coin)) {
             afile << key;
             afile << coin;
         }
 
         pcursor->Next();
     }
 
     afile.fclose();
     fs::rename(temppath, path);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("coins_written", stats.coins_count);
     result.pushKV("base_hash", tip->GetBlockHash().ToString());
     result.pushKV("base_height", tip->nHeight);
     result.pushKV("path", path.string());
     return result;
 }
 
 void RegisterBlockchainRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            name                      actor (function)        argNames
         //  ------------------- ------------------------  ----------------------  ----------
         { "blockchain",         "getbestblockhash",       getbestblockhash,       {} },
         { "blockchain",         "getblock",               getblock,               {"blockhash","verbosity|verbose"} },
         { "blockchain",         "getblockchaininfo",      getblockchaininfo,      {} },
         { "blockchain",         "getblockcount",          getblockcount,          {} },
         { "blockchain",         "getblockhash",           getblockhash,           {"height"} },
         { "blockchain",         "getblockheader",         getblockheader,         {"blockhash","verbose"} },
         { "blockchain",         "getblockstats",          getblockstats,          {"hash_or_height","stats"} },
         { "blockchain",         "getchaintips",           getchaintips,           {} },
         { "blockchain",         "getchaintxstats",        getchaintxstats,        {"nblocks", "blockhash"} },
         { "blockchain",         "getdifficulty",            getdifficulty,            {} },
         { "blockchain",         "getmempoolancestors",    getmempoolancestors,    {"txid","verbose"} },
         { "blockchain",         "getmempooldescendants",  getmempooldescendants,  {"txid","verbose"} },
         { "blockchain",         "getmempoolentry",        getmempoolentry,        {"txid"} },
         { "blockchain",         "getmempoolinfo",         getmempoolinfo,         {} },
         { "blockchain",         "getrawmempool",          getrawmempool,          {"verbose"} },
         { "blockchain",         "gettxout",               gettxout,               {"txid","n","include_mempool"} },
         { "blockchain",         "gettxoutsetinfo",        gettxoutsetinfo,        {} },
         { "blockchain",         "pruneblockchain",        pruneblockchain,        {"height"} },
         { "blockchain",         "savemempool",            savemempool,            {} },
         { "blockchain",         "verifychain",            verifychain,            {"checklevel","nblocks"} },
         { "blockchain",         "preciousblock",          preciousblock,          {"blockhash"} },
         { "blockchain",         "scantxoutset",           scantxoutset,           {"action", "scanobjects"} },
         { "blockchain",         "getblockfilter",          getblockfilter,          {"blockhash", "filtertype"} },
 
         /* Not shown in help */
         { "hidden",             "getfinalizedblockhash",             getfinalizedblockhash,             {} },
         { "hidden",             "finalizeblock",                     finalizeblock,                     {"blockhash"} },
         { "hidden",             "invalidateblock",                  invalidateblock,                  {"blockhash"} },
         { "hidden",             "parkblock",                        parkblock,                        {"blockhash"} },
         { "hidden",             "reconsiderblock",                  reconsiderblock,                  {"blockhash"} },
         { "hidden",             "syncwithvalidationinterfacequeue", syncwithvalidationinterfacequeue, {} },
         { "hidden",             "dumptxoutset",                     dumptxoutset,                     {"path"} },
         { "hidden",             "unparkblock",                      unparkblock,                      {"blockhash"} },
         { "hidden",             "waitfornewblock",                  waitfornewblock,                  {"timeout"} },
         { "hidden",             "waitforblock",                     waitforblock,                     {"blockhash","timeout"} },
         { "hidden",             "waitforblockheight",               waitforblockheight,               {"height","timeout"} },
     };
     // clang-format on
 
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 7ff371528..5df4ed239 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -1,1171 +1,1171 @@
 // 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 <blockvalidity.h>
 #include <cashaddrenc.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/activation.h>
 #include <consensus/consensus.h>
 #include <consensus/params.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <key_io.h>
 #include <miner.h>
 #include <minerfund.h>
 #include <net.h>
 #include <node/context.h>
 #include <policy/policy.h>
 #include <pow/pow.h>
 #include <rpc/blockchain.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <shutdown.h>
 #include <txmempool.h>
 #include <univalue.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <warnings.h>
 
 #include <cstdint>
 
 /**
  * Return average network hashes per second based on the last 'lookup' blocks,
  * or from the last difficulty change if 'lookup' is nonpositive. If 'height' is
  * nonnegative, compute the estimate at the time when a given block was found.
  */
 static UniValue GetNetworkHashPS(int lookup, int height) {
     CBlockIndex *pb = ::ChainActive().Tip();
 
     if (height >= 0 && height < ::ChainActive().Height()) {
         pb = ::ChainActive()[height];
     }
 
     if (pb == nullptr || !pb->nHeight) {
         return 0;
     }
 
     // If lookup is -1, then use blocks since last difficulty change.
     if (lookup <= 0) {
         lookup = pb->nHeight %
                      Params().GetConsensus().DifficultyAdjustmentInterval() +
                  1;
     }
 
     // If lookup is larger than chain, then set it to chain length.
     if (lookup > pb->nHeight) {
         lookup = pb->nHeight;
     }
 
     CBlockIndex *pb0 = pb;
     int64_t minTime = pb0->GetBlockTime();
     int64_t maxTime = minTime;
     for (int i = 0; i < lookup; i++) {
         pb0 = pb0->pprev;
         int64_t time = pb0->GetBlockTime();
         minTime = std::min(time, minTime);
         maxTime = std::max(time, maxTime);
     }
 
     // In case there's a situation where minTime == maxTime, we don't want a
     // divide by zero exception.
     if (minTime == maxTime) {
         return 0;
     }
 
     arith_uint256 workDiff = pb->nChainWork - pb0->nChainWork;
     int64_t timeDiff = maxTime - minTime;
 
     return workDiff.getdouble() / timeDiff;
 }
 
 static UniValue getnetworkhashps(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "getnetworkhashps",
         "Returns the estimated network hashes per second based on the last n "
         "blocks.\n"
         "Pass in [blocks] to override # of blocks, -1 specifies since last "
         "difficulty change.\n"
         "Pass in [height] to estimate the network speed at the time when a "
         "certain block was found.\n",
         {
             {"nblocks", RPCArg::Type::NUM, /* default */ "120",
              "The number of blocks, or -1 for blocks since last difficulty "
              "change."},
             {"height", RPCArg::Type::NUM, /* default */ "-1",
              "To estimate at the time of the given height."},
         },
         RPCResult{RPCResult::Type::NUM, "", "Hashes per second estimated"},
         RPCExamples{HelpExampleCli("getnetworkhashps", "") +
                     HelpExampleRpc("getnetworkhashps", "")},
     }
         .Check(request);
 
     LOCK(cs_main);
     return GetNetworkHashPS(
         !request.params[0].isNull() ? request.params[0].get_int() : 120,
         !request.params[1].isNull() ? request.params[1].get_int() : -1);
 }
 
 static bool GenerateBlock(const Config &config, ChainstateManager &chainman,
                           CBlock &block, uint64_t &max_tries,
                           unsigned int &extra_nonce, BlockHash &block_hash) {
     block_hash.SetNull();
     const uint64_t nExcessiveBlockSize = config.GetMaxBlockSize();
 
     {
         LOCK(cs_main);
         IncrementExtraNonce(&block, ::ChainActive().Tip(), nExcessiveBlockSize,
                             extra_nonce);
     }
 
     const Consensus::Params &params = config.GetChainParams().GetConsensus();
 
     while (max_tries > 0 &&
            block.nNonce < std::numeric_limits<uint32_t>::max() &&
            !CheckProofOfWork(block.GetHash(), block.nBits, params) &&
            !ShutdownRequested()) {
         ++block.nNonce;
         --max_tries;
     }
     if (max_tries == 0 || ShutdownRequested()) {
         return false;
     }
     if (block.nNonce == std::numeric_limits<uint32_t>::max()) {
         return true;
     }
 
     std::shared_ptr<const CBlock> shared_pblock =
         std::make_shared<const CBlock>(block);
     if (!chainman.ProcessNewBlock(config, shared_pblock, true, nullptr)) {
         throw JSONRPCError(RPC_INTERNAL_ERROR,
                            "ProcessNewBlock, block not accepted");
     }
 
     block_hash = block.GetHash();
     return true;
 }
 
 static UniValue generateBlocks(const Config &config,
                                ChainstateManager &chainman,
                                const CTxMemPool &mempool,
                                const CScript &coinbase_script, int nGenerate,
                                uint64_t nMaxTries) {
     int nHeightEnd = 0;
     int nHeight = 0;
 
     {
         // Don't keep cs_main locked.
         LOCK(cs_main);
         nHeight = ::ChainActive().Height();
         nHeightEnd = nHeight + nGenerate;
     }
 
     unsigned int nExtraNonce = 0;
     UniValue blockHashes(UniValue::VARR);
     while (nHeight < nHeightEnd && !ShutdownRequested()) {
         std::unique_ptr<CBlockTemplate> pblocktemplate(
             BlockAssembler(config, mempool).CreateNewBlock(coinbase_script));
 
         if (!pblocktemplate.get()) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
         }
 
         CBlock *pblock = &pblocktemplate->block;
 
         BlockHash block_hash;
         if (!GenerateBlock(config, chainman, *pblock, nMaxTries, nExtraNonce,
                            block_hash)) {
             break;
         }
 
         if (!block_hash.IsNull()) {
             ++nHeight;
             blockHashes.push_back(block_hash.GetHex());
         }
     }
     return blockHashes;
 }
 
 static bool getScriptFromDescriptor(const std::string &descriptor,
                                     CScript &script, std::string &error) {
     FlatSigningProvider key_provider;
     const auto desc =
         Parse(descriptor, key_provider, error, /* require_checksum = */ false);
     if (desc) {
         if (desc->IsRange()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Ranged descriptor not accepted. Maybe pass "
                                "through deriveaddresses first?");
         }
 
         FlatSigningProvider provider;
         std::vector<CScript> scripts;
         if (!desc->Expand(0, key_provider, scripts, provider)) {
             throw JSONRPCError(
                 RPC_INVALID_ADDRESS_OR_KEY,
                 strprintf("Cannot derive script without private keys"));
         }
 
         // Combo descriptors can have 2 scripts, so we can't just check
         // scripts.size() == 1
         CHECK_NONFATAL(scripts.size() > 0 && scripts.size() <= 2);
 
         if (scripts.size() == 1) {
             script = scripts.at(0);
         } else {
             // Else take the 2nd script, since it is p2pkh
             script = scripts.at(1);
         }
 
         return true;
     }
 
     return false;
 }
 
 static UniValue generatetodescriptor(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "generatetodescriptor",
         "\nMine blocks immediately to a specified descriptor (before the RPC "
         "call returns)\n",
         {
             {"num_blocks", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "How many blocks are generated immediately."},
             {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The descriptor to send the newly generated bitcoin to."},
             {"maxtries", RPCArg::Type::NUM, /* default */ "1000000",
              "How many iterations to try."},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "hashes of blocks generated",
                   {
                       {RPCResult::Type::STR_HEX, "", "blockhash"},
                   }},
         RPCExamples{"\nGenerate 11 blocks to mydesc\n" +
                     HelpExampleCli("generatetodescriptor", "11 \"mydesc\"")},
     }
         .Check(request);
 
     const int num_blocks{request.params[0].get_int()};
     const int64_t max_tries{
         request.params[2].isNull() ? 1000000 : request.params[2].get_int()};
 
     CScript coinbase_script;
     std::string error;
     if (!getScriptFromDescriptor(request.params[1].get_str(), coinbase_script,
                                  error)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
     }
 
     const CTxMemPool &mempool = EnsureMemPool(request.context);
     ChainstateManager &chainman = EnsureChainman(request.context);
 
     return generateBlocks(config, chainman, mempool, coinbase_script,
                           num_blocks, max_tries);
 }
 
 static UniValue generatetoaddress(const Config &config,
                                   const JSONRPCRequest &request) {
     RPCHelpMan{
         "generatetoaddress",
         "Mine blocks immediately to a specified address before the "
         "RPC call returns)\n",
         {
             {"nblocks", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "How many blocks are generated immediately."},
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The address to send the newly generated bitcoin to."},
             {"maxtries", RPCArg::Type::NUM, /* default */ "1000000",
              "How many iterations to try."},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "hashes of blocks generated",
                   {
                       {RPCResult::Type::STR_HEX, "", "blockhash"},
                   }},
         RPCExamples{
             "\nGenerate 11 blocks to myaddress\n" +
             HelpExampleCli("generatetoaddress", "11 \"myaddress\"") +
             "If you are running the Bitcoin ABC wallet, you can get a new "
             "address to send the newly generated bitcoin to with:\n" +
             HelpExampleCli("getnewaddress", "")},
     }
         .Check(request);
 
     int nGenerate = request.params[0].get_int();
     uint64_t nMaxTries = 1000000;
     if (!request.params[2].isNull()) {
         nMaxTries = request.params[2].get_int64();
     }
 
     CTxDestination destination =
         DecodeDestination(request.params[1].get_str(), config.GetChainParams());
     if (!IsValidDestination(destination)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Error: Invalid address");
     }
 
     const CTxMemPool &mempool = EnsureMemPool(request.context);
     ChainstateManager &chainman = EnsureChainman(request.context);
 
     CScript coinbase_script = GetScriptForDestination(destination);
 
     return generateBlocks(config, chainman, mempool, coinbase_script, nGenerate,
                           nMaxTries);
 }
 
 static UniValue generateblock(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "generateblock",
         "\nMine a block with a set of ordered transactions immediately to a "
         "specified address or descriptor (before the RPC call returns)\n",
         {
             {"output", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The address or descriptor to send the newly generated bitcoin "
              "to."},
             {
                 "transactions",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "An array of hex strings which are either txids or raw "
                 "transactions.\n"
                 "Txids must reference transactions currently in the mempool.\n"
                 "All transactions must be valid and in valid order, otherwise "
                 "the block will be rejected.",
                 {
                     {"rawtx/txid", RPCArg::Type::STR_HEX,
                      RPCArg::Optional::OMITTED, ""},
                 },
             },
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR_HEX, "hash", "hash of generated block"},
             }},
         RPCExamples{
             "\nGenerate a block to myaddress, with txs rawtx and "
             "mempool_txid\n" +
             HelpExampleCli("generateblock",
                            R"("myaddress" '["rawtx", "mempool_txid"]')")},
     }
         .Check(request);
 
     const auto address_or_descriptor = request.params[0].get_str();
     CScript coinbase_script;
     std::string error;
 
     const CChainParams &chainparams = config.GetChainParams();
 
     if (!getScriptFromDescriptor(address_or_descriptor, coinbase_script,
                                  error)) {
         const auto destination =
             DecodeDestination(address_or_descriptor, chainparams);
         if (!IsValidDestination(destination)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Error: Invalid address or descriptor");
         }
 
         coinbase_script = GetScriptForDestination(destination);
     }
 
     const CTxMemPool &mempool = EnsureMemPool(request.context);
 
     std::vector<CTransactionRef> txs;
     const auto raw_txs_or_txids = request.params[1].get_array();
     for (size_t i = 0; i < raw_txs_or_txids.size(); i++) {
         const auto str(raw_txs_or_txids[i].get_str());
 
         uint256 hash;
         CMutableTransaction mtx;
         if (ParseHashStr(str, hash)) {
             const auto tx = mempool.get(TxId(hash));
             if (!tx) {
                 throw JSONRPCError(
                     RPC_INVALID_ADDRESS_OR_KEY,
                     strprintf("Transaction %s not in mempool.", str));
             }
 
             txs.emplace_back(tx);
 
         } else if (DecodeHexTx(mtx, str)) {
             txs.push_back(MakeTransactionRef(std::move(mtx)));
 
         } else {
             throw JSONRPCError(
                 RPC_DESERIALIZATION_ERROR,
                 strprintf("Transaction decode failed for %s", str));
         }
     }
 
     CBlock block;
 
     {
         LOCK(cs_main);
 
         CTxMemPool empty_mempool;
         std::unique_ptr<CBlockTemplate> blocktemplate(
             BlockAssembler(config, empty_mempool)
                 .CreateNewBlock(coinbase_script));
         if (!blocktemplate) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
         }
         block = blocktemplate->block;
     }
 
     CHECK_NONFATAL(block.vtx.size() == 1);
 
     // Add transactions
     block.vtx.insert(block.vtx.end(), txs.begin(), txs.end());
 
     {
         LOCK(cs_main);
 
         BlockValidationState state;
         if (!TestBlockValidity(state, chainparams, block,
                                LookupBlockIndex(block.hashPrevBlock),
                                BlockValidationOptions(config)
                                    .withCheckPoW(false)
                                    .withCheckMerkleRoot(false))) {
             throw JSONRPCError(
                 RPC_VERIFY_ERROR,
                 strprintf("TestBlockValidity failed: %s", state.ToString()));
         }
     }
 
     BlockHash block_hash;
     uint64_t max_tries{1000000};
     unsigned int extra_nonce{0};
 
     if (!GenerateBlock(config, EnsureChainman(request.context), block,
                        max_tries, extra_nonce, block_hash) ||
         block_hash.IsNull()) {
         throw JSONRPCError(RPC_MISC_ERROR, "Failed to make block.");
     }
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("hash", block_hash.GetHex());
     return obj;
 }
 
 static UniValue getmininginfo(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "getmininginfo",
         "Returns a json object containing mining-related "
         "information.",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "blocks", "The current block"},
                 {RPCResult::Type::NUM, "currentblocksize", /* optional */ true,
                  "The block size of the last assembled block (only present if "
                  "a block was ever assembled)"},
                 {RPCResult::Type::NUM, "currentblocktx", /* optional */ true,
                  "The number of block transactions of the last assembled block "
                  "(only present if a block was ever assembled)"},
                 {RPCResult::Type::NUM, "difficulty", "The current difficulty"},
                 {RPCResult::Type::NUM, "networkhashps",
                  "The network hashes per second"},
                 {RPCResult::Type::NUM, "pooledtx", "The size of the mempool"},
                 {RPCResult::Type::STR, "chain",
                  "current network name (main, test, regtest)"},
                 {RPCResult::Type::STR, "warnings",
                  "any network and blockchain warnings"},
             }},
         RPCExamples{HelpExampleCli("getmininginfo", "") +
                     HelpExampleRpc("getmininginfo", "")},
     }
         .Check(request);
 
     LOCK(cs_main);
     const CTxMemPool &mempool = EnsureMemPool(request.context);
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("blocks", int(::ChainActive().Height()));
     if (BlockAssembler::m_last_block_size) {
         obj.pushKV("currentblocksize", *BlockAssembler::m_last_block_size);
     }
     if (BlockAssembler::m_last_block_num_txs) {
         obj.pushKV("currentblocktx", *BlockAssembler::m_last_block_num_txs);
     }
     obj.pushKV("difficulty", double(GetDifficulty(::ChainActive().Tip())));
     obj.pushKV("networkhashps", getnetworkhashps(config, request));
     obj.pushKV("pooledtx", uint64_t(mempool.size()));
     obj.pushKV("chain", config.GetChainParams().NetworkIDString());
     obj.pushKV("warnings", GetWarnings(false));
 
     return obj;
 }
 
 // NOTE: Unlike wallet RPC (which use BCH values), mining RPCs follow GBT (BIP
 // 22) in using satoshi amounts
 static UniValue prioritisetransaction(const Config &config,
                                       const JSONRPCRequest &request) {
     RPCHelpMan{
         "prioritisetransaction",
         "Accepts the transaction into mined blocks at a higher "
         "(or lower) priority\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id."},
             {"dummy", RPCArg::Type::NUM, RPCArg::Optional::OMITTED_NAMED_ARG,
              "API-Compatibility for previous API. Must be zero or null.\n"
              "                  DEPRECATED. For forward compatibility "
              "use named arguments and omit this parameter."},
             {"fee_delta", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The fee value (in satoshis) to add (or subtract, if negative).\n"
              "                        The fee is not actually paid, only the "
              "algorithm for selecting transactions into a block\n"
              "                  considers the transaction as it would "
              "have paid a higher (or lower) fee."},
         },
         RPCResult{RPCResult::Type::BOOL, "", "Returns true"},
         RPCExamples{
             HelpExampleCli("prioritisetransaction", "\"txid\" 0.0 10000") +
             HelpExampleRpc("prioritisetransaction", "\"txid\", 0.0, 10000")},
     }
         .Check(request);
 
     LOCK(cs_main);
 
     TxId txid(ParseHashV(request.params[0], "txid"));
     Amount nAmount = request.params[2].get_int64() * SATOSHI;
 
     if (!(request.params[1].isNull() || request.params[1].get_real() == 0)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Priority is no longer supported, dummy argument to "
                            "prioritisetransaction must be 0.");
     }
 
     EnsureMemPool(request.context).PrioritiseTransaction(txid, nAmount);
     return true;
 }
 
 // NOTE: Assumes a conclusive result; if result is inconclusive, it must be
 // handled by caller
 static UniValue BIP22ValidationResult(const Config &config,
                                       const BlockValidationState &state) {
     if (state.IsValid()) {
         return NullUniValue;
     }
 
     if (state.IsError()) {
         throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
     }
 
     if (state.IsInvalid()) {
         std::string strRejectReason = state.GetRejectReason();
         if (strRejectReason.empty()) {
             return "rejected";
         }
         return strRejectReason;
     }
 
     // Should be impossible.
     return "valid?";
 }
 
 static UniValue getblocktemplate(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "getblocktemplate",
         "If the request parameters include a 'mode' key, that is used to "
         "explicitly select between the default 'template' request or a "
         "'proposal'.\n"
         "It returns data needed to construct a block to work on.\n"
         "For full specification, see BIPs 22, 23, 9, and 145:\n"
         "    "
         "https://github.com/bitcoin/bips/blob/master/"
         "bip-0022.mediawiki\n"
         "    "
         "https://github.com/bitcoin/bips/blob/master/"
         "bip-0023.mediawiki\n"
         "    "
         "https://github.com/bitcoin/bips/blob/master/"
         "bip-0009.mediawiki#getblocktemplate_changes\n"
         "    ",
         {
             {"template_request",
              RPCArg::Type::OBJ,
              "{}",
              "Format of the template",
              {
                  {"mode", RPCArg::Type::STR, /* treat as named arg */
                   RPCArg::Optional::OMITTED_NAMED_ARG,
                   "This must be set to \"template\", \"proposal\" (see BIP "
                   "23), or omitted"},
                  {
                      "capabilities",
                      RPCArg::Type::ARR,
                      /* treat as named arg */
                      RPCArg::Optional::OMITTED_NAMED_ARG,
                      "A list of strings",
                      {
                          {"support", RPCArg::Type::STR,
                           RPCArg::Optional::OMITTED,
                           "client side supported feature, 'longpoll', "
                           "'coinbasetxn', 'coinbasevalue', 'proposal', "
                           "'serverlist', 'workid'"},
                      },
                  },
              },
              "\"template_request\""},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "version",
                  "The preferred block version"},
                 {RPCResult::Type::STR, "previousblockhash",
                  "The hash of current highest block"},
                 {RPCResult::Type::ARR,
                  "transactions",
                  "contents of non-coinbase transactions that should be "
                  "included in the next block",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "data",
                            "transaction data encoded in hexadecimal "
                            "(byte-for-byte)"},
                           {RPCResult::Type::STR_HEX, "txid",
                            "transaction id encoded in little-endian "
                            "hexadecimal"},
                           {RPCResult::Type::STR_HEX, "hash",
                            "hash encoded in little-endian hexadecimal"},
                           {RPCResult::Type::ARR,
                            "depends",
                            "array of numbers",
                            {
                                {RPCResult::Type::NUM, "",
                                 "transactions before this one (by 1-based "
                                 "index in 'transactions' list) that must be "
                                 "present in the final block if this one is"},
                            }},
                           {RPCResult::Type::NUM, "fee",
                            "difference in value between transaction inputs and "
                            "outputs (in satoshis); for coinbase transactions, "
                            "this is a negative Number of the total collected "
                            "block fees (ie, not including the block subsidy); "
                            "if key is not present, fee is unknown and clients "
                            "MUST NOT assume there isn't one"},
                           {RPCResult::Type::NUM, "sigops",
                            "total SigOps cost, as counted for purposes of "
                            "block limits; if key is not present, sigop cost is "
                            "unknown and clients MUST NOT assume it is zero"},
                       }},
                  }},
                 {RPCResult::Type::OBJ,
                  "coinbaseaux",
                  "data that should be included in the coinbase's scriptSig "
                  "content",
                  {
                      {RPCResult::Type::ELISION, "", ""},
                  }},
                 {RPCResult::Type::NUM, "coinbasevalue",
                  "maximum allowable input to coinbase transaction, including "
                  "the generation award and transaction fees (in satoshis)"},
                 {RPCResult::Type::OBJ,
                  "coinbasetxn",
                  "information for coinbase transaction",
                  {
                      {RPCResult::Type::OBJ,
                       "minerfund",
                       "information related to the coinbase miner fund",
                       {
 
                           {RPCResult::Type::ARR,
                            "addresses",
                            "List of valid addresses for the miner fund output",
                            {
                                {RPCResult::Type::ELISION, "", ""},
                            }},
 
                           {RPCResult::Type::STR_AMOUNT, "minimumvalue",
                            "The minimum value the miner fund output must pay"},
 
                       }},
                      {RPCResult::Type::ELISION, "", ""},
                  }},
                 {RPCResult::Type::STR, "target", "The hash target"},
                 {RPCResult::Type::NUM_TIME, "mintime",
                  "The minimum timestamp appropriate for the next block time, "
                  "expressed in " +
                      UNIX_EPOCH_TIME},
                 {RPCResult::Type::ARR,
                  "mutable",
                  "list of ways the block template may be changed",
                  {
                      {RPCResult::Type::STR, "value",
                       "A way the block template may be changed, e.g. 'time', "
                       "'transactions', 'prevblock'"},
                  }},
                 {RPCResult::Type::STR_HEX, "noncerange",
                  "A range of valid nonces"},
                 {RPCResult::Type::NUM, "sigoplimit",
                  "limit of sigops in blocks"},
                 {RPCResult::Type::NUM, "sizelimit", "limit of block size"},
                 {RPCResult::Type::NUM_TIME, "curtime",
                  "current timestamp in " + UNIX_EPOCH_TIME},
                 {RPCResult::Type::STR, "bits",
                  "compressed target of next block"},
                 {RPCResult::Type::NUM, "height",
                  "The height of the next block"},
             }},
         RPCExamples{HelpExampleCli("getblocktemplate", "") +
                     HelpExampleRpc("getblocktemplate", "")},
     }
         .Check(request);
 
     LOCK(cs_main);
     const CChainParams &chainparams = config.GetChainParams();
 
     std::string strMode = "template";
     UniValue lpval = NullUniValue;
     std::set<std::string> setClientRules;
     if (!request.params[0].isNull()) {
         const UniValue &oparam = request.params[0].get_obj();
         const UniValue &modeval = find_value(oparam, "mode");
         if (modeval.isStr()) {
             strMode = modeval.get_str();
         } else if (modeval.isNull()) {
             /* Do nothing */
         } else {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
         }
         lpval = find_value(oparam, "longpollid");
 
         if (strMode == "proposal") {
             const UniValue &dataval = find_value(oparam, "data");
             if (!dataval.isStr()) {
                 throw JSONRPCError(RPC_TYPE_ERROR,
                                    "Missing data String key for proposal");
             }
 
             CBlock block;
             if (!DecodeHexBlk(block, dataval.get_str())) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    "Block decode failed");
             }
 
             const BlockHash hash = block.GetHash();
             const CBlockIndex *pindex = LookupBlockIndex(hash);
             if (pindex) {
                 if (pindex->IsValid(BlockValidity::SCRIPTS)) {
                     return "duplicate";
                 }
                 if (pindex->nStatus.isInvalid()) {
                     return "duplicate-invalid";
                 }
                 return "duplicate-inconclusive";
             }
 
             CBlockIndex *const pindexPrev = ::ChainActive().Tip();
             // TestBlockValidity only supports blocks built on the current Tip
             if (block.hashPrevBlock != pindexPrev->GetBlockHash()) {
                 return "inconclusive-not-best-prevblk";
             }
             BlockValidationState state;
             TestBlockValidity(state, chainparams, block, pindexPrev,
                               BlockValidationOptions(config)
                                   .withCheckPoW(false)
                                   .withCheckMerkleRoot(true));
             return BIP22ValidationResult(config, state);
         }
     }
 
     if (strMode != "template") {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
     }
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     if (node.connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0) {
         throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED,
                            "Bitcoin is not connected!");
     }
 
     if (::ChainstateActive().IsInitialBlockDownload()) {
         throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, PACKAGE_NAME
                            " is in initial sync and waiting for blocks...");
     }
 
     static unsigned int nTransactionsUpdatedLast;
     const CTxMemPool &mempool = EnsureMemPool(request.context);
 
     if (!lpval.isNull()) {
         // Wait to respond until either the best block changes, OR a minute has
         // passed and there are more transactions
         uint256 hashWatchedChain;
         std::chrono::steady_clock::time_point checktxtime;
         unsigned int nTransactionsUpdatedLastLP;
 
         if (lpval.isStr()) {
             // Format: <hashBestChain><nTransactionsUpdatedLast>
             std::string lpstr = lpval.get_str();
 
             hashWatchedChain = ParseHashV(lpstr.substr(0, 64), "longpollid");
             nTransactionsUpdatedLastLP = atoi64(lpstr.substr(64));
         } else {
             // NOTE: Spec does not specify behaviour for non-string longpollid,
             // but this makes testing easier
             hashWatchedChain = ::ChainActive().Tip()->GetBlockHash();
             nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
         }
 
         // Release lock while waiting
         LEAVE_CRITICAL_SECTION(cs_main);
         {
             checktxtime =
                 std::chrono::steady_clock::now() + std::chrono::minutes(1);
 
             WAIT_LOCK(g_best_block_mutex, lock);
             while (g_best_block == hashWatchedChain && IsRPCRunning()) {
                 if (g_best_block_cv.wait_until(lock, checktxtime) ==
                     std::cv_status::timeout) {
                     // Timeout: Check transactions for update
                     // without holding the mempool look to avoid deadlocks
                     if (mempool.GetTransactionsUpdated() !=
                         nTransactionsUpdatedLastLP) {
                         break;
                     }
                     checktxtime += std::chrono::seconds(10);
                 }
             }
         }
         ENTER_CRITICAL_SECTION(cs_main);
 
         if (!IsRPCRunning()) {
             throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Shutting down");
         }
         // TODO: Maybe recheck connections/IBD and (if something wrong) send an
         // expires-immediately template to stop miners?
     }
 
     // Update block
     static CBlockIndex *pindexPrev;
     static int64_t nStart;
     static std::unique_ptr<CBlockTemplate> pblocktemplate;
     if (pindexPrev != ::ChainActive().Tip() ||
         (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast &&
          GetTime() - nStart > 5)) {
         // Clear pindexPrev so future calls make a new block, despite any
         // failures from here on
         pindexPrev = nullptr;
 
         // Store the pindexBest used before CreateNewBlock, to avoid races
         nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
         CBlockIndex *pindexPrevNew = ::ChainActive().Tip();
         nStart = GetTime();
 
         // Create new block
         CScript scriptDummy = CScript() << OP_TRUE;
         pblocktemplate =
             BlockAssembler(config, mempool).CreateNewBlock(scriptDummy);
         if (!pblocktemplate) {
             throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory");
         }
 
         // Need to update only after we know CreateNewBlock succeeded
         pindexPrev = pindexPrevNew;
     }
 
     CHECK_NONFATAL(pindexPrev);
     // pointer for convenience
     CBlock *pblock = &pblocktemplate->block;
 
     // Update nTime
     UpdateTime(pblock, chainparams, pindexPrev);
     pblock->nNonce = 0;
 
     UniValue aCaps(UniValue::VARR);
     aCaps.push_back("proposal");
 
     Amount coinbasevalue = Amount::zero();
 
     UniValue transactions(UniValue::VARR);
     transactions.reserve(pblock->vtx.size());
     int index_in_template = 0;
     for (const auto &it : pblock->vtx) {
         const CTransaction &tx = *it;
         const TxId txId = tx.GetId();
 
         if (tx.IsCoinBase()) {
             index_in_template++;
 
             for (const auto &o : pblock->vtx[0]->vout) {
                 coinbasevalue += o.nValue;
             }
 
             continue;
         }
 
         UniValue entry(UniValue::VOBJ);
         entry.reserve(5);
         entry.__pushKV("data", EncodeHexTx(tx));
         entry.__pushKV("txid", txId.GetHex());
         entry.__pushKV("hash", tx.GetHash().GetHex());
         entry.__pushKV("fee", pblocktemplate->entries[index_in_template].fees /
                                   SATOSHI);
         int64_t nTxSigOps =
             pblocktemplate->entries[index_in_template].sigOpCount;
         entry.__pushKV("sigops", nTxSigOps);
 
         transactions.push_back(entry);
         index_in_template++;
     }
 
     UniValue aux(UniValue::VOBJ);
 
     UniValue minerFundList(UniValue::VARR);
     const Consensus::Params &consensusParams = chainparams.GetConsensus();
     for (auto fundDestination :
          GetMinerFundWhitelist(consensusParams, pindexPrev)) {
         minerFundList.push_back(EncodeDestination(fundDestination, config));
     }
 
     int64_t minerFundMinValue = 0;
     if (IsAxionEnabled(consensusParams, pindexPrev)) {
         minerFundMinValue =
             int64_t(GetMinerFundAmount(coinbasevalue) / SATOSHI);
     }
 
     UniValue minerFund(UniValue::VOBJ);
     minerFund.pushKV("addresses", minerFundList);
     minerFund.pushKV("minimumvalue", minerFundMinValue);
 
     UniValue coinbasetxn(UniValue::VOBJ);
     coinbasetxn.pushKV("minerfund", minerFund);
 
     arith_uint256 hashTarget = arith_uint256().SetCompact(pblock->nBits);
 
     UniValue aMutable(UniValue::VARR);
     aMutable.push_back("time");
     aMutable.push_back("transactions");
     aMutable.push_back("prevblock");
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("capabilities", aCaps);
 
     result.pushKV("version", pblock->nVersion);
 
     result.pushKV("previousblockhash", pblock->hashPrevBlock.GetHex());
     result.pushKV("transactions", transactions);
     result.pushKV("coinbaseaux", aux);
     result.pushKV("coinbasetxn", coinbasetxn);
     result.pushKV("coinbasevalue", int64_t(coinbasevalue / SATOSHI));
     result.pushKV("longpollid", ::ChainActive().Tip()->GetBlockHash().GetHex() +
                                     ToString(nTransactionsUpdatedLast));
     result.pushKV("target", hashTarget.GetHex());
     result.pushKV("mintime", int64_t(pindexPrev->GetMedianTimePast()) + 1);
     result.pushKV("mutable", aMutable);
     result.pushKV("noncerange", "00000000ffffffff");
     result.pushKV("sigoplimit",
                   GetMaxBlockSigChecksCount(DEFAULT_MAX_BLOCK_SIZE));
     result.pushKV("sizelimit", DEFAULT_MAX_BLOCK_SIZE);
     result.pushKV("curtime", pblock->GetBlockTime());
     result.pushKV("bits", strprintf("%08x", pblock->nBits));
     result.pushKV("height", int64_t(pindexPrev->nHeight) + 1);
 
     return result;
 }
 
 class submitblock_StateCatcher final : public CValidationInterface {
 public:
     uint256 hash;
     bool found;
     BlockValidationState state;
 
     explicit submitblock_StateCatcher(const uint256 &hashIn)
         : hash(hashIn), found(false), state() {}
 
 protected:
     void BlockChecked(const CBlock &block,
                       const BlockValidationState &stateIn) override {
         if (block.GetHash() != hash) {
             return;
         }
 
         found = true;
         state = stateIn;
     }
 };
 
 static UniValue submitblock(const Config &config,
                             const JSONRPCRequest &request) {
     // We allow 2 arguments for compliance with BIP22. Argument 2 is ignored.
     RPCHelpMan{
         "submitblock",
         "Attempts to submit new block to network.\n"
         "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n",
         {
             {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hex-encoded block data to submit"},
             {"dummy", RPCArg::Type::STR, /* default */ "ignored",
              "dummy value, for compatibility with BIP22. This value is "
              "ignored."},
         },
         RPCResult{RPCResult::Type::NONE, "",
                   "Returns JSON Null when valid, a string according to BIP22 "
                   "otherwise"},
         RPCExamples{HelpExampleCli("submitblock", "\"mydata\"") +
                     HelpExampleRpc("submitblock", "\"mydata\"")},
     }
         .Check(request);
 
     std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
     CBlock &block = *blockptr;
     if (!DecodeHexBlk(block, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
     }
 
     if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            "Block does not start with a coinbase");
     }
 
     const BlockHash hash = block.GetHash();
     {
         LOCK(cs_main);
         const CBlockIndex *pindex = LookupBlockIndex(hash);
         if (pindex) {
             if (pindex->IsValid(BlockValidity::SCRIPTS)) {
                 return "duplicate";
             }
             if (pindex->nStatus.isInvalid()) {
                 return "duplicate-invalid";
             }
         }
     }
 
     bool new_block;
     auto sc = std::make_shared<submitblock_StateCatcher>(block.GetHash());
     RegisterSharedValidationInterface(sc);
     bool accepted =
         EnsureChainman(request.context)
             .ProcessNewBlock(config, blockptr, /* fForceProcessing */ true,
                              /* fNewBlock */ &new_block);
     UnregisterSharedValidationInterface(sc);
     if (!new_block && accepted) {
         return "duplicate";
     }
 
     if (!sc->found) {
         return "inconclusive";
     }
 
     return BIP22ValidationResult(config, sc->state);
 }
 
 static UniValue submitheader(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "submitheader",
         "Decode the given hexdata as a header and submit it as a candidate "
         "chain tip if valid."
         "\nThrows when the header is invalid.\n",
         {
             {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hex-encoded block header data"},
         },
         RPCResult{RPCResult::Type::NONE, "", "None"},
         RPCExamples{HelpExampleCli("submitheader", "\"aabbcc\"") +
                     HelpExampleRpc("submitheader", "\"aabbcc\"")},
     }
         .Check(request);
 
     CBlockHeader h;
     if (!DecodeHexBlockHeader(h, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            "Block header decode failed");
     }
     {
         LOCK(cs_main);
         if (!LookupBlockIndex(h.hashPrevBlock)) {
             throw JSONRPCError(RPC_VERIFY_ERROR,
                                "Must submit previous header (" +
                                    h.hashPrevBlock.GetHex() + ") first");
         }
     }
 
     BlockValidationState state;
     EnsureChainman(request.context).ProcessNewBlockHeaders(config, {h}, state);
     if (state.IsValid()) {
         return NullUniValue;
     }
     if (state.IsError()) {
         throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
     }
     throw JSONRPCError(RPC_VERIFY_ERROR, state.GetRejectReason());
 }
 
 static UniValue estimatefee(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "estimatefee",
         "Estimates the approximate fee per kilobyte needed for a "
         "transaction\n",
         {},
         RPCResult{RPCResult::Type::NUM, "", "estimated fee-per-kilobyte"},
         RPCExamples{HelpExampleCli("estimatefee", "")},
     }
         .Check(request);
 
     const CTxMemPool &mempool = EnsureMemPool(request.context);
-    return ValueFromAmount(mempool.estimateFee().GetFeePerK());
+    return mempool.estimateFee().GetFeePerK();
 }
 
 void RegisterMiningRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category   name                     actor (function)       argNames
         //  ---------- ------------------------ ---------------------- ----------
         {"mining",     "getnetworkhashps",      getnetworkhashps,      {"nblocks", "height"}},
         {"mining",     "getmininginfo",         getmininginfo,         {}},
         {"mining",     "prioritisetransaction", prioritisetransaction, {"txid", "dummy", "fee_delta"}},
         {"mining",     "getblocktemplate",      getblocktemplate,      {"template_request"}},
         {"mining",     "submitblock",           submitblock,           {"hexdata", "dummy"}},
         {"mining",     "submitheader",          submitheader,          {"hexdata"}},
 
         {"generating", "generatetoaddress",     generatetoaddress,     {"nblocks", "address", "maxtries"}},
         {"generating", "generatetodescriptor",  generatetodescriptor,  {"num_blocks","descriptor","maxtries"}},
         {"generating", "generateblock",         generateblock,         {"output","transactions"}},
 
         {"util",       "estimatefee",           estimatefee,           {"nblocks"}},
     };
     // clang-format on
 
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index 2b5abe653..3fb23898f 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -1,1007 +1,1006 @@
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <rpc/server.h>
 
 #include <banman.h>
 #include <clientversion.h>
 #include <config.h>
 #include <core_io.h>
 #include <net.h>
 #include <net_permissions.h>
 #include <net_processing.h>
 #include <net_types.h> // For banmap_t
 #include <netbase.h>
 #include <network.h>
 #include <node/context.h>
 #include <policy/settings.h>
 #include <rpc/blockchain.h>
 #include <rpc/protocol.h>
 #include <rpc/util.h>
 #include <sync.h>
 #include <timedata.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <validation.h>
 #include <version.h>
 #include <warnings.h>
 
 #include <univalue.h>
 
 static UniValue getconnectioncount(const Config &config,
                                    const JSONRPCRequest &request) {
     RPCHelpMan{
         "getconnectioncount",
         "Returns the number of connections to other nodes.\n",
         {},
         RPCResult{RPCResult::Type::NUM, "", "The connection count"},
         RPCExamples{HelpExampleCli("getconnectioncount", "") +
                     HelpExampleRpc("getconnectioncount", "")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     return int(node.connman->GetNodeCount(CConnman::CONNECTIONS_ALL));
 }
 
 static UniValue ping(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "ping",
         "Requests that a ping be sent to all other nodes, to measure ping "
         "time.\n"
         "Results provided in getpeerinfo, pingtime and pingwait fields are "
         "decimal seconds.\n"
         "Ping command is handled in queue with all other commands, so it "
         "measures processing backlog, not just network ping.\n",
         {},
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("ping", "") + HelpExampleRpc("ping", "")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     // Request that each node send a ping during next message processing pass
     node.connman->ForEachNode([](CNode *pnode) { pnode->fPingQueued = true; });
     return NullUniValue;
 }
 
 static UniValue getpeerinfo(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "getpeerinfo",
         "Returns data about each connected network node as a json array of "
         "objects.\n",
         {},
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {{
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {{
                     {RPCResult::Type::NUM, "id", "Peer index"},
                     {RPCResult::Type::STR, "addr",
                      "(host:port) The IP address and port of the peer"},
                     {RPCResult::Type::STR, "addrbind",
                      "(ip:port) Bind address of the connection to the peer"},
                     {RPCResult::Type::STR, "addrlocal",
                      "(ip:port) Local address as reported by the peer"},
                     {RPCResult::Type::NUM, "mapped_as",
                      "The AS in the BGP route to the peer used for "
                      "diversifying\n"
                      "peer selection (only available if the asmap config flag "
                      "is set)\n"},
                     {RPCResult::Type::STR_HEX, "services",
                      "The services offered"},
                     {RPCResult::Type::ARR,
                      "servicesnames",
                      "the services offered, in human-readable form",
                      {{RPCResult::Type::STR, "SERVICE_NAME",
                        "the service name if it is recognised"}}},
                     {RPCResult::Type::BOOL, "relaytxes",
                      "Whether peer has asked us to relay transactions to it"},
                     {RPCResult::Type::NUM_TIME, "lastsend",
                      "The " + UNIX_EPOCH_TIME + " of the last send"},
                     {RPCResult::Type::NUM_TIME, "lastrecv",
                      "The " + UNIX_EPOCH_TIME + " of the last receive"},
                     {RPCResult::Type::NUM_TIME, "last_transaction",
                      "The " + UNIX_EPOCH_TIME +
                          " of the last valid transaction received from this "
                          "peer"},
                     {RPCResult::Type::NUM_TIME, "last_block",
                      "The " + UNIX_EPOCH_TIME +
                          " of the last block received from this peer"},
                     {RPCResult::Type::NUM, "bytessent", "The total bytes sent"},
                     {RPCResult::Type::NUM, "bytesrecv",
                      "The total bytes received"},
                     {RPCResult::Type::NUM_TIME, "conntime",
                      "The " + UNIX_EPOCH_TIME + " of the connection"},
                     {RPCResult::Type::NUM, "timeoffset",
                      "The time offset in seconds"},
                     {RPCResult::Type::NUM, "pingtime",
                      "ping time (if available)"},
                     {RPCResult::Type::NUM, "minping",
                      "minimum observed ping time (if any at all)"},
                     {RPCResult::Type::NUM, "pingwait",
                      "ping wait (if non-zero)"},
                     {RPCResult::Type::NUM, "version",
                      "The peer version, such as 70001"},
                     {RPCResult::Type::STR, "subver", "The string version"},
                     {RPCResult::Type::BOOL, "inbound",
                      "Inbound (true) or Outbound (false)"},
                     {RPCResult::Type::BOOL, "addnode",
                      "Whether connection was due to addnode/-connect or if it "
                      "was an automatic/inbound connection"},
                     {RPCResult::Type::NUM, "startingheight",
                      "The starting height (block) of the peer"},
                     {RPCResult::Type::NUM, "banscore",
                      "The ban score (DEPRECATED, returned only if config "
                      "option -deprecatedrpc=banscore is passed)"},
                     {RPCResult::Type::NUM, "synced_headers",
                      "The last header we have in common with this peer"},
                     {RPCResult::Type::NUM, "synced_blocks",
                      "The last block we have in common with this peer"},
                     {RPCResult::Type::ARR,
                      "inflight",
                      "",
                      {
                          {RPCResult::Type::NUM, "n",
                           "The heights of blocks we're currently asking from "
                           "this peer"},
                      }},
                     {RPCResult::Type::BOOL, "whitelisted",
                      "Whether the peer is whitelisted"},
                     {RPCResult::Type::NUM, "minfeefilter",
                      "The minimum fee rate for transactions this peer accepts"},
                     {RPCResult::Type::OBJ_DYN,
                      "bytessent_per_msg",
                      "",
                      {{RPCResult::Type::NUM, "msg",
                        "The total bytes sent aggregated by message type\n"
                        "When a message type is not listed in this json object, "
                        "the bytes sent are 0.\n"
                        "Only known message types can appear as keys in the "
                        "object."}}},
                     {RPCResult::Type::OBJ,
                      "bytesrecv_per_msg",
                      "",
                      {{RPCResult::Type::NUM, "msg",
                        "The total bytes received aggregated by message type\n"
                        "When a message type is not listed in this json object, "
                        "the bytes received are 0.\n"
                        "Only known message types can appear as keys in the "
                        "object and all bytes received of unknown message types "
                        "are listed under '" +
                            NET_MESSAGE_COMMAND_OTHER + "'."}}},
                 }},
             }},
         },
         RPCExamples{HelpExampleCli("getpeerinfo", "") +
                     HelpExampleRpc("getpeerinfo", "")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     std::vector<CNodeStats> vstats;
     node.connman->GetNodeStats(vstats);
 
     UniValue ret(UniValue::VARR);
 
     for (const CNodeStats &stats : vstats) {
         UniValue obj(UniValue::VOBJ);
         CNodeStateStats statestats;
         bool fStateStats = GetNodeStateStats(stats.nodeid, statestats);
         obj.pushKV("id", stats.nodeid);
         obj.pushKV("addr", stats.addrName);
         if (!(stats.addrLocal.empty())) {
             obj.pushKV("addrlocal", stats.addrLocal);
         }
         if (stats.addrBind.IsValid()) {
             obj.pushKV("addrbind", stats.addrBind.ToString());
         }
         if (stats.m_mapped_as != 0) {
             obj.pushKV("mapped_as", uint64_t(stats.m_mapped_as));
         }
         obj.pushKV("services", strprintf("%016x", stats.nServices));
         obj.pushKV("servicesnames", GetServicesNames(stats.nServices));
         obj.pushKV("relaytxes", stats.fRelayTxes);
         obj.pushKV("lastsend", stats.nLastSend);
         obj.pushKV("lastrecv", stats.nLastRecv);
         obj.pushKV("last_transaction", stats.nLastTXTime);
         obj.pushKV("last_block", stats.nLastBlockTime);
         obj.pushKV("bytessent", stats.nSendBytes);
         obj.pushKV("bytesrecv", stats.nRecvBytes);
         obj.pushKV("conntime", stats.nTimeConnected);
         obj.pushKV("timeoffset", stats.nTimeOffset);
         if (stats.m_ping_usec > 0) {
             obj.pushKV("pingtime", double(stats.m_ping_usec) / 1e6);
         }
         if (stats.m_min_ping_usec < std::numeric_limits<int64_t>::max()) {
             obj.pushKV("minping", double(stats.m_min_ping_usec) / 1e6);
         }
         if (stats.m_ping_wait_usec > 0) {
             obj.pushKV("pingwait", double(stats.m_ping_wait_usec) / 1e6);
         }
         obj.pushKV("version", stats.nVersion);
         // Use the sanitized form of subver here, to avoid tricksy remote peers
         // from corrupting or modifying the JSON output by putting special
         // characters in their ver message.
         obj.pushKV("subver", stats.cleanSubVer);
         obj.pushKV("inbound", stats.fInbound);
         obj.pushKV("addnode", stats.m_manual_connection);
         obj.pushKV("startingheight", stats.nStartingHeight);
         if (fStateStats) {
             if (IsDeprecatedRPCEnabled(gArgs, "banscore")) {
                 // banscore is deprecated in v0.22.11 for removal in v0.23
                 obj.pushKV("banscore", statestats.m_misbehavior_score);
             }
             obj.pushKV("synced_headers", statestats.nSyncHeight);
             obj.pushKV("synced_blocks", statestats.nCommonHeight);
             UniValue heights(UniValue::VARR);
             for (const int height : statestats.vHeightInFlight) {
                 heights.push_back(height);
             }
             obj.pushKV("inflight", heights);
         }
         obj.pushKV("whitelisted", stats.m_legacyWhitelisted);
         UniValue permissions(UniValue::VARR);
         for (const auto &permission :
              NetPermissions::ToStrings(stats.m_permissionFlags)) {
             permissions.push_back(permission);
         }
         obj.pushKV("permissions", permissions);
-        obj.pushKV("minfeefilter", ValueFromAmount(stats.minFeeFilter));
+        obj.pushKV("minfeefilter", stats.minFeeFilter);
 
         UniValue sendPerMsgCmd(UniValue::VOBJ);
         for (const auto &i : stats.mapSendBytesPerMsgCmd) {
             if (i.second > 0) {
                 sendPerMsgCmd.pushKV(i.first, i.second);
             }
         }
         obj.pushKV("bytessent_per_msg", sendPerMsgCmd);
 
         UniValue recvPerMsgCmd(UniValue::VOBJ);
         for (const auto &i : stats.mapRecvBytesPerMsgCmd) {
             if (i.second > 0) {
                 recvPerMsgCmd.pushKV(i.first, i.second);
             }
         }
         obj.pushKV("bytesrecv_per_msg", recvPerMsgCmd);
 
         ret.push_back(obj);
     }
 
     return ret;
 }
 
 static UniValue addnode(const Config &config, const JSONRPCRequest &request) {
     std::string strCommand;
     if (!request.params[1].isNull()) {
         strCommand = request.params[1].get_str();
     }
 
     if (request.fHelp || request.params.size() != 2 ||
         (strCommand != "onetry" && strCommand != "add" &&
          strCommand != "remove")) {
         throw std::runtime_error(RPCHelpMan{
             "addnode",
             "Attempts to add or remove a node from the addnode list.\n"
             "Or try a connection to a node once.\n"
             "Nodes added using addnode (or -connect) are protected from "
             "DoS disconnection and are not required to be\n"
             "full nodes as other outbound peers are (though such peers "
             "will not be synced from).\n",
             {
                 {"node", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "The node (see getpeerinfo for nodes)"},
                 {"command", RPCArg::Type::STR, RPCArg::Optional::NO,
                  "'add' to add a node to the list, 'remove' to remove a "
                  "node from the list, 'onetry' to try a connection to the "
                  "node once"},
             },
             RPCResult{RPCResult::Type::NONE, "", ""},
             RPCExamples{
                 HelpExampleCli("addnode", "\"192.168.0.6:8333\" \"onetry\"") +
                 HelpExampleRpc("addnode", "\"192.168.0.6:8333\", \"onetry\"")},
         }
                                      .ToString());
     }
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     std::string strNode = request.params[0].get_str();
 
     if (strCommand == "onetry") {
         CAddress addr;
         node.connman->OpenNetworkConnection(
             addr, false, nullptr, strNode.c_str(), ConnectionType::MANUAL);
         return NullUniValue;
     }
 
     if ((strCommand == "add") && (!node.connman->AddNode(strNode))) {
         throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED,
                            "Error: Node already added");
     } else if ((strCommand == "remove") &&
                (!node.connman->RemoveAddedNode(strNode))) {
         throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED,
                            "Error: Node has not been added.");
     }
 
     return NullUniValue;
 }
 
 static UniValue disconnectnode(const Config &config,
                                const JSONRPCRequest &request) {
     RPCHelpMan{
         "disconnectnode",
         "Immediately disconnects from the specified peer node.\n"
         "\nStrictly one out of 'address' and 'nodeid' can be provided to "
         "identify the node.\n"
         "\nTo disconnect by nodeid, either set 'address' to the empty string, "
         "or call using the named 'nodeid' argument only.\n",
         {
             {"address", RPCArg::Type::STR,
              /* default */ "fallback to nodeid",
              "The IP address/port of the node"},
             {"nodeid", RPCArg::Type::NUM,
              /* default */ "fallback to address",
              "The node ID (see getpeerinfo for node IDs)"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("disconnectnode", "\"192.168.0.6:8333\"") +
                     HelpExampleCli("disconnectnode", "\"\" 1") +
                     HelpExampleRpc("disconnectnode", "\"192.168.0.6:8333\"") +
                     HelpExampleRpc("disconnectnode", "\"\", 1")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     bool success;
     const UniValue &address_arg = request.params[0];
     const UniValue &id_arg = request.params[1];
 
     if (!address_arg.isNull() && id_arg.isNull()) {
         /* handle disconnect-by-address */
         success = node.connman->DisconnectNode(address_arg.get_str());
     } else if (!id_arg.isNull() &&
                (address_arg.isNull() ||
                 (address_arg.isStr() && address_arg.get_str().empty()))) {
         /* handle disconnect-by-id */
         NodeId nodeid = (NodeId)id_arg.get_int64();
         success = node.connman->DisconnectNode(nodeid);
     } else {
         throw JSONRPCError(
             RPC_INVALID_PARAMS,
             "Only one of address and nodeid should be provided.");
     }
 
     if (!success) {
         throw JSONRPCError(RPC_CLIENT_NODE_NOT_CONNECTED,
                            "Node not found in connected nodes");
     }
 
     return NullUniValue;
 }
 
 static UniValue getaddednodeinfo(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "getaddednodeinfo",
         "Returns information about the given added node, or all added nodes\n"
         "(note that onetry addnodes are not listed here)\n",
         {
             {"node", RPCArg::Type::STR, /* default */ "all nodes",
              "If provided, return information about this specific node, "
              "otherwise all nodes are returned."},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "",
                  "",
                  {
                      {RPCResult::Type::STR, "addednode",
                       "The node IP address or name (as provided to addnode)"},
                      {RPCResult::Type::BOOL, "connected", "If connected"},
                      {RPCResult::Type::ARR,
                       "addresses",
                       "Only when connected = true",
                       {
                           {RPCResult::Type::OBJ,
                            "",
                            "",
                            {
                                {RPCResult::Type::STR, "address",
                                 "The bitcoin server IP and port we're "
                                 "connected to"},
                                {RPCResult::Type::STR, "connected",
                                 "connection, inbound or outbound"},
                            }},
                       }},
                  }},
             }},
         RPCExamples{HelpExampleCli("getaddednodeinfo", "\"192.168.0.201\"") +
                     HelpExampleRpc("getaddednodeinfo", "\"192.168.0.201\"")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     std::vector<AddedNodeInfo> vInfo = node.connman->GetAddedNodeInfo();
 
     if (!request.params[0].isNull()) {
         bool found = false;
         for (const AddedNodeInfo &info : vInfo) {
             if (info.strAddedNode == request.params[0].get_str()) {
                 vInfo.assign(1, info);
                 found = true;
                 break;
             }
         }
         if (!found) {
             throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED,
                                "Error: Node has not been added.");
         }
     }
 
     UniValue ret(UniValue::VARR);
 
     for (const AddedNodeInfo &info : vInfo) {
         UniValue obj(UniValue::VOBJ);
         obj.pushKV("addednode", info.strAddedNode);
         obj.pushKV("connected", info.fConnected);
         UniValue addresses(UniValue::VARR);
         if (info.fConnected) {
             UniValue address(UniValue::VOBJ);
             address.pushKV("address", info.resolvedAddress.ToString());
             address.pushKV("connected", info.fInbound ? "inbound" : "outbound");
             addresses.push_back(address);
         }
         obj.pushKV("addresses", addresses);
         ret.push_back(obj);
     }
 
     return ret;
 }
 
 static UniValue getnettotals(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "getnettotals",
         "Returns information about network traffic, including bytes in, "
         "bytes out,\n"
         "and current time.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "totalbytesrecv",
                  "Total bytes received"},
                 {RPCResult::Type::NUM, "totalbytessent", "Total bytes sent"},
                 {RPCResult::Type::NUM_TIME, "timemillis",
                  "Current UNIX time in milliseconds"},
                 {RPCResult::Type::OBJ,
                  "uploadtarget",
                  "",
                  {
                      {RPCResult::Type::NUM, "timeframe",
                       "Length of the measuring timeframe in seconds"},
                      {RPCResult::Type::NUM, "target", "Target in bytes"},
                      {RPCResult::Type::BOOL, "target_reached",
                       "True if target is reached"},
                      {RPCResult::Type::BOOL, "serve_historical_blocks",
                       "True if serving historical blocks"},
                      {RPCResult::Type::NUM, "bytes_left_in_cycle",
                       "Bytes left in current time cycle"},
                      {RPCResult::Type::NUM, "time_left_in_cycle",
                       "Seconds left in current time cycle"},
                  }},
             }},
         RPCExamples{HelpExampleCli("getnettotals", "") +
                     HelpExampleRpc("getnettotals", "")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("totalbytesrecv", node.connman->GetTotalBytesRecv());
     obj.pushKV("totalbytessent", node.connman->GetTotalBytesSent());
     obj.pushKV("timemillis", GetTimeMillis());
 
     UniValue outboundLimit(UniValue::VOBJ);
     outboundLimit.pushKV("timeframe", node.connman->GetMaxOutboundTimeframe());
     outboundLimit.pushKV("target", node.connman->GetMaxOutboundTarget());
     outboundLimit.pushKV("target_reached",
                          node.connman->OutboundTargetReached(false));
     outboundLimit.pushKV("serve_historical_blocks",
                          !node.connman->OutboundTargetReached(true));
     outboundLimit.pushKV("bytes_left_in_cycle",
                          node.connman->GetOutboundTargetBytesLeft());
     outboundLimit.pushKV("time_left_in_cycle",
                          node.connman->GetMaxOutboundTimeLeftInCycle());
     obj.pushKV("uploadtarget", outboundLimit);
     return obj;
 }
 
 static UniValue GetNetworksInfo() {
     UniValue networks(UniValue::VARR);
     for (int n = 0; n < NET_MAX; ++n) {
         enum Network network = static_cast<enum Network>(n);
         if (network == NET_UNROUTABLE || network == NET_INTERNAL) {
             continue;
         }
         proxyType proxy;
         UniValue obj(UniValue::VOBJ);
         GetProxy(network, proxy);
         obj.pushKV("name", GetNetworkName(network));
         obj.pushKV("limited", !IsReachable(network));
         obj.pushKV("reachable", IsReachable(network));
         obj.pushKV("proxy", proxy.IsValid() ? proxy.proxy.ToStringIPPort()
                                             : std::string());
         obj.pushKV("proxy_randomize_credentials", proxy.randomize_credentials);
         networks.push_back(obj);
     }
     return networks;
 }
 
 static UniValue getnetworkinfo(const Config &config,
                                const JSONRPCRequest &request) {
     RPCHelpMan{
         "getnetworkinfo",
         "Returns an object containing various state info regarding P2P "
         "networking.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "version", "the server version"},
                 {RPCResult::Type::STR, "subversion",
                  "the server subversion string"},
                 {RPCResult::Type::NUM, "protocolversion",
                  "the protocol version"},
                 {RPCResult::Type::STR_HEX, "localservices",
                  "the services we offer to the network"},
                 {RPCResult::Type::ARR,
                  "localservicesnames",
                  "the services we offer to the network, in human-readable form",
                  {
                      {RPCResult::Type::STR, "SERVICE_NAME", "the service name"},
                  }},
                 {RPCResult::Type::BOOL, "localrelay",
                  "true if transaction relay is requested from peers"},
                 {RPCResult::Type::NUM, "timeoffset", "the time offset"},
                 {RPCResult::Type::NUM, "connections",
                  "the number of connections"},
                 {RPCResult::Type::BOOL, "networkactive",
                  "whether p2p networking is enabled"},
                 {RPCResult::Type::ARR,
                  "networks",
                  "information per network",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR, "name",
                            "network (ipv4, ipv6 or onion)"},
                           {RPCResult::Type::BOOL, "limited",
                            "is the network limited using -onlynet?"},
                           {RPCResult::Type::BOOL, "reachable",
                            "is the network reachable?"},
                           {RPCResult::Type::STR, "proxy",
                            "(\"host:port\") the proxy that is used for this "
                            "network, or empty if none"},
                           {RPCResult::Type::BOOL, "proxy_randomize_credentials",
                            "Whether randomized credentials are used"},
                       }},
                  }},
                 {RPCResult::Type::NUM, "relayfee",
                  "minimum relay fee for transactions in " + CURRENCY_UNIT +
                      "/kB"},
                 {RPCResult::Type::NUM, "excessutxocharge",
                  "minimum charge for excess utxos in " + CURRENCY_UNIT},
                 {RPCResult::Type::ARR,
                  "localaddresses",
                  "list of local addresses",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR, "address", "network address"},
                           {RPCResult::Type::NUM, "port", "network port"},
                           {RPCResult::Type::NUM, "score", "relative score"},
                       }},
                  }},
                 {RPCResult::Type::STR, "warnings",
                  "any network and blockchain warnings"},
             }},
         RPCExamples{HelpExampleCli("getnetworkinfo", "") +
                     HelpExampleRpc("getnetworkinfo", "")},
     }
         .Check(request);
 
     LOCK(cs_main);
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("version", CLIENT_VERSION);
     obj.pushKV("subversion", userAgent(config));
     obj.pushKV("protocolversion", PROTOCOL_VERSION);
     NodeContext &node = EnsureNodeContext(request.context);
     if (node.connman) {
         ServiceFlags services = node.connman->GetLocalServices();
         obj.pushKV("localservices", strprintf("%016x", services));
         obj.pushKV("localservicesnames", GetServicesNames(services));
     }
     obj.pushKV("localrelay", g_relay_txes);
     obj.pushKV("timeoffset", GetTimeOffset());
     if (node.connman) {
         obj.pushKV("networkactive", node.connman->GetNetworkActive());
         obj.pushKV("connections",
                    int(node.connman->GetNodeCount(CConnman::CONNECTIONS_ALL)));
     }
     obj.pushKV("networks", GetNetworksInfo());
-    obj.pushKV("relayfee", ValueFromAmount(::minRelayTxFee.GetFeePerK()));
-    obj.pushKV("excessutxocharge",
-               ValueFromAmount(config.GetExcessUTXOCharge()));
+    obj.pushKV("relayfee", ::minRelayTxFee.GetFeePerK());
+    obj.pushKV("excessutxocharge", config.GetExcessUTXOCharge());
     UniValue localAddresses(UniValue::VARR);
     {
         LOCK(cs_mapLocalHost);
         for (const std::pair<const CNetAddr, LocalServiceInfo> &item :
              mapLocalHost) {
             UniValue rec(UniValue::VOBJ);
             rec.pushKV("address", item.first.ToString());
             rec.pushKV("port", item.second.nPort);
             rec.pushKV("score", item.second.nScore);
             localAddresses.push_back(rec);
         }
     }
     obj.pushKV("localaddresses", localAddresses);
     obj.pushKV("warnings", GetWarnings(false));
     return obj;
 }
 
 static UniValue setban(const Config &config, const JSONRPCRequest &request) {
     const RPCHelpMan help{
         "setban",
         "Attempts to add or remove an IP/Subnet from the banned list.\n",
         {
             {"subnet", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The IP/Subnet (see getpeerinfo for nodes IP) with an optional "
              "netmask (default is /32 = single IP)"},
             {"command", RPCArg::Type::STR, RPCArg::Optional::NO,
              "'add' to add an IP/Subnet to the list, 'remove' to remove an "
              "IP/Subnet from the list"},
             {"bantime", RPCArg::Type::NUM, /* default */ "0",
              "time in seconds how long (or until when if [absolute] is set) "
              "the IP is banned (0 or empty means using the default time of 24h "
              "which can also be overwritten by the -bantime startup argument)"},
             {"absolute", RPCArg::Type::BOOL, /* default */ "false",
              "If set, the bantime must be an absolute timestamp expressed in " +
                  UNIX_EPOCH_TIME},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{
             HelpExampleCli("setban", "\"192.168.0.6\" \"add\" 86400") +
             HelpExampleCli("setban", "\"192.168.0.0/24\" \"add\"") +
             HelpExampleRpc("setban", "\"192.168.0.6\", \"add\", 86400")},
     };
 
     std::string strCommand;
     if (!request.params[1].isNull()) {
         strCommand = request.params[1].get_str();
     }
 
     if (request.fHelp || !help.IsValidNumArgs(request.params.size()) ||
         (strCommand != "add" && strCommand != "remove")) {
         throw std::runtime_error(help.ToString());
     }
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.banman) {
         throw JSONRPCError(RPC_DATABASE_ERROR,
                            "Error: Ban database not loaded");
     }
 
     CSubNet subNet;
     CNetAddr netAddr;
     bool isSubnet = false;
 
     if (request.params[0].get_str().find('/') != std::string::npos) {
         isSubnet = true;
     }
 
     if (!isSubnet) {
         CNetAddr resolved;
         LookupHost(request.params[0].get_str(), resolved, false);
         netAddr = resolved;
     } else {
         LookupSubNet(request.params[0].get_str(), subNet);
     }
 
     if (!(isSubnet ? subNet.IsValid() : netAddr.IsValid())) {
         throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET,
                            "Error: Invalid IP/Subnet");
     }
 
     if (strCommand == "add") {
         if (isSubnet ? node.banman->IsBanned(subNet)
                      : node.banman->IsBanned(netAddr)) {
             throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED,
                                "Error: IP/Subnet already banned");
         }
 
         // Use standard bantime if not specified.
         int64_t banTime = 0;
         if (!request.params[2].isNull()) {
             banTime = request.params[2].get_int64();
         }
 
         bool absolute = false;
         if (request.params[3].isTrue()) {
             absolute = true;
         }
 
         if (isSubnet) {
             node.banman->Ban(subNet, banTime, absolute);
             if (node.connman) {
                 node.connman->DisconnectNode(subNet);
             }
         } else {
             node.banman->Ban(netAddr, banTime, absolute);
             if (node.connman) {
                 node.connman->DisconnectNode(netAddr);
             }
         }
     } else if (strCommand == "remove") {
         if (!(isSubnet ? node.banman->Unban(subNet)
                        : node.banman->Unban(netAddr))) {
             throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET,
                                "Error: Unban failed. Requested address/subnet "
                                "was not previously manually banned.");
         }
     }
     return NullUniValue;
 }
 
 static UniValue listbanned(const Config &config,
                            const JSONRPCRequest &request) {
     RPCHelpMan{
         "listbanned",
         "List all manually banned IPs/Subnets.\n",
         {},
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::OBJ,
                        "",
                        "",
                        {
                            {RPCResult::Type::STR, "address", ""},
                            {RPCResult::Type::NUM_TIME, "banned_until", ""},
                            {RPCResult::Type::NUM_TIME, "ban_created", ""},
                            {RPCResult::Type::STR, "ban_reason", ""},
                        }},
                   }},
         RPCExamples{HelpExampleCli("listbanned", "") +
                     HelpExampleRpc("listbanned", "")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.banman) {
         throw JSONRPCError(RPC_DATABASE_ERROR,
                            "Error: Ban database not loaded");
     }
 
     banmap_t banMap;
     node.banman->GetBanned(banMap);
 
     UniValue bannedAddresses(UniValue::VARR);
     for (const auto &entry : banMap) {
         const CBanEntry &banEntry = entry.second;
         UniValue rec(UniValue::VOBJ);
         rec.pushKV("address", entry.first.ToString());
         rec.pushKV("banned_until", banEntry.nBanUntil);
         rec.pushKV("ban_created", banEntry.nCreateTime);
 
         bannedAddresses.push_back(rec);
     }
 
     return bannedAddresses;
 }
 
 static UniValue clearbanned(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "clearbanned",
         "Clear all banned IPs.\n",
         {},
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("clearbanned", "") +
                     HelpExampleRpc("clearbanned", "")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.banman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     node.banman->ClearBanned();
 
     return NullUniValue;
 }
 
 static UniValue setnetworkactive(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "setnetworkactive",
         "Disable/enable all p2p network activity.\n",
         {
             {"state", RPCArg::Type::BOOL, RPCArg::Optional::NO,
              "true to enable networking, false to disable"},
         },
         RPCResult{RPCResult::Type::BOOL, "", "The value that was passed in"},
         RPCExamples{""},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.banman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     node.connman->SetNetworkActive(request.params[0].get_bool());
 
     return node.connman->GetNetworkActive();
 }
 
 static UniValue getnodeaddresses(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "getnodeaddresses",
         "Return known addresses which can potentially be used to find new "
         "nodes in the network\n",
         {
             {"count", RPCArg::Type::NUM, /* default */ "1",
              "How many addresses to return. Limited to the smaller of " +
                  ToString(ADDRMAN_GETADDR_MAX) + " or " +
                  ToString(ADDRMAN_GETADDR_MAX_PCT) +
                  "% of all known addresses."},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "",
                  "",
                  {
                      {RPCResult::Type::NUM_TIME, "time",
                       "The " + UNIX_EPOCH_TIME +
                           " of when the node was last seen"},
                      {RPCResult::Type::NUM, "services", "The services offered"},
                      {RPCResult::Type::STR, "address",
                       "The address of the node"},
                      {RPCResult::Type::NUM, "port", "The port of the node"},
                  }},
             }},
         RPCExamples{HelpExampleCli("getnodeaddresses", "8") +
                     HelpExampleRpc("getnodeaddresses", "8")},
     }
         .Check(request);
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.banman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     int count = 1;
     if (!request.params[0].isNull()) {
         count = request.params[0].get_int();
         if (count <= 0) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Address count out of range");
         }
     }
     // returns a shuffled list of CAddress
     std::vector<CAddress> vAddr = node.connman->GetAddresses();
     UniValue ret(UniValue::VARR);
 
     int address_return_count = std::min<int>(count, vAddr.size());
     for (int i = 0; i < address_return_count; ++i) {
         UniValue obj(UniValue::VOBJ);
         const CAddress &addr = vAddr[i];
         obj.pushKV("time", int(addr.nTime));
         obj.pushKV("services", uint64_t(addr.nServices));
         obj.pushKV("address", addr.ToStringIP());
         obj.pushKV("port", addr.GetPort());
         ret.push_back(obj);
     }
     return ret;
 }
 
 void RegisterNetRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            name                      actor (function)        argNames
         //  ------------------- ------------------------  ----------------------  ----------
         { "network",            "getconnectioncount",     getconnectioncount,     {} },
         { "network",            "ping",                   ping,                   {} },
         { "network",            "getpeerinfo",            getpeerinfo,            {} },
         { "network",            "addnode",                addnode,                {"node","command"} },
         { "network",            "disconnectnode",         disconnectnode,         {"address", "nodeid"} },
         { "network",            "getaddednodeinfo",       getaddednodeinfo,       {"node"} },
         { "network",            "getnettotals",           getnettotals,           {} },
         { "network",            "getnetworkinfo",         getnetworkinfo,         {} },
         { "network",            "setban",                 setban,                 {"subnet", "command", "bantime", "absolute"} },
         { "network",            "listbanned",             listbanned,             {} },
         { "network",            "clearbanned",            clearbanned,            {} },
         { "network",            "setnetworkactive",       setnetworkactive,       {"state"} },
         { "network",            "getnodeaddresses",       getnodeaddresses,       {"count"} },
     };
     // clang-format on
 
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 2b46a17a7..b290178b2 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -1,2178 +1,2178 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <blockdb.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <coins.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <index/txindex.h>
 #include <key_io.h>
 #include <merkleblock.h>
 #include <network.h>
 #include <node/coin.h>
 #include <node/context.h>
 #include <node/psbt.h>
 #include <node/transaction.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <psbt.h>
 #include <random.h>
 #include <rpc/blockchain.h>
 #include <rpc/rawtransaction_util.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/script.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
 #include <script/standard.h>
 #include <txmempool.h>
 #include <uint256.h>
 #include <util/error.h>
 #include <util/moneystr.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <validation.h>
 #include <validationinterface.h>
 
 #include <cstdint>
 #include <numeric>
 
 #include <univalue.h>
 
 static void TxToJSON(const CTransaction &tx, const BlockHash &hashBlock,
                      UniValue &entry) {
     // Call into TxToUniv() in bitcoin-common to decode the transaction hex.
     //
     // Blockchain contextual information (confirmations and blocktime) is not
     // available to code in bitcoin-common, so we query them here and push the
     // data into the returned UniValue.
     TxToUniv(tx, uint256(), entry, true, RPCSerializationFlags());
 
     if (!hashBlock.IsNull()) {
         LOCK(cs_main);
 
         entry.pushKV("blockhash", hashBlock.GetHex());
         CBlockIndex *pindex = LookupBlockIndex(hashBlock);
         if (pindex) {
             if (::ChainActive().Contains(pindex)) {
                 entry.pushKV("confirmations",
                              1 + ::ChainActive().Height() - pindex->nHeight);
                 entry.pushKV("time", pindex->GetBlockTime());
                 entry.pushKV("blocktime", pindex->GetBlockTime());
             } else {
                 entry.pushKV("confirmations", 0);
             }
         }
     }
 }
 
 static UniValue getrawtransaction(const Config &config,
                                   const JSONRPCRequest &request) {
     RPCHelpMan{
         "getrawtransaction",
         "By default this function only works for mempool transactions. When "
         "called with a blockhash\n"
         "argument, getrawtransaction will return the transaction if the "
         "specified block is available and\n"
         "the transaction is found in that block. When called without a "
         "blockhash argument, getrawtransaction\n"
         "will return the transaction if it is in the mempool, or if -txindex "
         "is enabled and the transaction\n"
         "is in a block in the blockchain.\n"
 
         "\nReturn the raw transaction data.\n"
         "\nIf verbose is 'true', returns an Object with information about "
         "'txid'.\n"
         "If verbose is 'false' or omitted, returns a string that is "
         "serialized, hex-encoded data for 'txid'.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id"},
             {"verbose", RPCArg::Type::BOOL, /* default */ "false",
              "If false, return a string, otherwise return a json object"},
             {"blockhash", RPCArg::Type::STR_HEX,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "The block in which to look for the transaction"},
         },
         {
             RPCResult{"if verbose is not set or set to false",
                       RPCResult::Type::STR, "data",
                       "The serialized, hex-encoded data for 'txid'"},
             RPCResult{
                 "if verbose is set to true",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::BOOL, "in_active_chain",
                      "Whether specified block is in the active chain or not "
                      "(only present with explicit \"blockhash\" argument)"},
                     {RPCResult::Type::STR_HEX, "hex",
                      "The serialized, hex-encoded data for 'txid'"},
                     {RPCResult::Type::STR_HEX, "txid",
                      "The transaction id (same as provided)"},
                     {RPCResult::Type::STR_HEX, "hash", "The transaction hash"},
                     {RPCResult::Type::NUM, "size",
                      "The serialized transaction size"},
                     {RPCResult::Type::NUM, "version", "The version"},
                     {RPCResult::Type::NUM_TIME, "locktime", "The lock time"},
                     {RPCResult::Type::ARR,
                      "vin",
                      "",
                      {
                          {RPCResult::Type::OBJ,
                           "",
                           "",
                           {
                               {RPCResult::Type::STR_HEX, "txid",
                                "The transaction id"},
                               {RPCResult::Type::STR, "vout", ""},
                               {RPCResult::Type::OBJ,
                                "scriptSig",
                                "The script",
                                {
                                    {RPCResult::Type::STR, "asm", "asm"},
                                    {RPCResult::Type::STR_HEX, "hex", "hex"},
                                }},
                               {RPCResult::Type::NUM, "sequence",
                                "The script sequence number"},
                           }},
                      }},
                     {RPCResult::Type::ARR,
                      "vout",
                      "",
                      {
                          {RPCResult::Type::OBJ,
                           "",
                           "",
                           {
                               {RPCResult::Type::NUM, "value",
                                "The value in " + CURRENCY_UNIT},
                               {RPCResult::Type::NUM, "n", "index"},
                               {RPCResult::Type::OBJ,
                                "scriptPubKey",
                                "",
                                {
                                    {RPCResult::Type::STR, "asm", "the asm"},
                                    {RPCResult::Type::STR, "hex", "the hex"},
                                    {RPCResult::Type::NUM, "reqSigs",
                                     "The required sigs"},
                                    {RPCResult::Type::STR, "type",
                                     "The type, eg 'pubkeyhash'"},
                                    {RPCResult::Type::ARR,
                                     "addresses",
                                     "",
                                     {
                                         {RPCResult::Type::STR, "address",
                                          "bitcoin address"},
                                     }},
                                }},
                           }},
                      }},
                     {RPCResult::Type::STR_HEX, "blockhash", "the block hash"},
                     {RPCResult::Type::NUM, "confirmations",
                      "The confirmations"},
                     {RPCResult::Type::NUM_TIME, "blocktime",
                      "The block time expressed in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::NUM, "time", "Same as \"blocktime\""},
                 }},
         },
         RPCExamples{HelpExampleCli("getrawtransaction", "\"mytxid\"") +
                     HelpExampleCli("getrawtransaction", "\"mytxid\" true") +
                     HelpExampleRpc("getrawtransaction", "\"mytxid\", true") +
                     HelpExampleCli("getrawtransaction",
                                    "\"mytxid\" false \"myblockhash\"") +
                     HelpExampleCli("getrawtransaction",
                                    "\"mytxid\" true \"myblockhash\"")},
     }
         .Check(request);
 
     bool in_active_chain = true;
     TxId txid = TxId(ParseHashV(request.params[0], "parameter 1"));
     CBlockIndex *blockindex = nullptr;
 
     const CChainParams &params = config.GetChainParams();
     if (txid == params.GenesisBlock().hashMerkleRoot) {
         // Special exception for the genesis block coinbase transaction
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "The genesis block coinbase is not considered an "
                            "ordinary transaction and cannot be retrieved");
     }
 
     // Accept either a bool (true) or a num (>=1) to indicate verbose output.
     bool fVerbose = false;
     if (!request.params[1].isNull()) {
         fVerbose = request.params[1].isNum()
                        ? (request.params[1].get_int() != 0)
                        : request.params[1].get_bool();
     }
 
     if (!request.params[2].isNull()) {
         LOCK(cs_main);
 
         BlockHash blockhash(ParseHashV(request.params[2], "parameter 3"));
         blockindex = LookupBlockIndex(blockhash);
         if (!blockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Block hash not found");
         }
         in_active_chain = ::ChainActive().Contains(blockindex);
     }
 
     bool f_txindex_ready = false;
     if (g_txindex && !blockindex) {
         f_txindex_ready = g_txindex->BlockUntilSyncedToCurrentChain();
     }
 
     CTransactionRef tx;
     BlockHash hash_block;
     if (!GetTransaction(txid, tx, params.GetConsensus(), hash_block,
                         blockindex)) {
         std::string errmsg;
         if (blockindex) {
             if (!blockindex->nStatus.hasData()) {
                 throw JSONRPCError(RPC_MISC_ERROR, "Block not available");
             }
             errmsg = "No such transaction found in the provided block";
         } else if (!g_txindex) {
             errmsg = "No such mempool transaction. Use -txindex or provide a "
                      "block hash to enable blockchain transaction queries";
         } else if (!f_txindex_ready) {
             errmsg = "No such mempool transaction. Blockchain transactions are "
                      "still in the process of being indexed";
         } else {
             errmsg = "No such mempool or blockchain transaction";
         }
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            errmsg +
                                ". Use gettransaction for wallet transactions.");
     }
 
     if (!fVerbose) {
         return EncodeHexTx(*tx, RPCSerializationFlags());
     }
 
     UniValue result(UniValue::VOBJ);
     if (blockindex) {
         result.pushKV("in_active_chain", in_active_chain);
     }
     TxToJSON(*tx, hash_block, result);
     return result;
 }
 
 static UniValue gettxoutproof(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "gettxoutproof",
         "Returns a hex-encoded proof that \"txid\" was included in a block.\n"
         "\nNOTE: By default this function only works sometimes. "
         "This is when there is an\n"
         "unspent output in the utxo for this transaction. To make it always "
         "work,\n"
         "you need to maintain a transaction index, using the -txindex command "
         "line option or\n"
         "specify the block in which the transaction is included manually (by "
         "blockhash).\n",
         {
             {
                 "txids",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The txids to filter",
                 {
                     {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED,
                      "A transaction hash"},
                 },
             },
             {"blockhash", RPCArg::Type::STR_HEX,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "If specified, looks for txid in the block with this hash"},
         },
         RPCResult{
             RPCResult::Type::STR, "data",
             "A string that is a serialized, hex-encoded data for the proof."},
         RPCExamples{""},
     }
         .Check(request);
 
     std::set<TxId> setTxIds;
     TxId oneTxId;
     UniValue txids = request.params[0].get_array();
     for (unsigned int idx = 0; idx < txids.size(); idx++) {
         const UniValue &utxid = txids[idx];
         TxId txid(ParseHashV(utxid, "txid"));
         if (setTxIds.count(txid)) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 std::string("Invalid parameter, duplicated txid: ") +
                     utxid.get_str());
         }
 
         setTxIds.insert(txid);
         oneTxId = txid;
     }
 
     CBlockIndex *pblockindex = nullptr;
 
     BlockHash hashBlock;
     if (!request.params[1].isNull()) {
         LOCK(cs_main);
         hashBlock = BlockHash(ParseHashV(request.params[1], "blockhash"));
         pblockindex = LookupBlockIndex(hashBlock);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
     } else {
         LOCK(cs_main);
         // Loop through txids and try to find which block they're in. Exit loop
         // once a block is found.
         for (const auto &txid : setTxIds) {
             const Coin &coin =
                 AccessByTxid(::ChainstateActive().CoinsTip(), txid);
             if (!coin.IsSpent()) {
                 pblockindex = ::ChainActive()[coin.GetHeight()];
                 break;
             }
         }
     }
 
     // Allow txindex to catch up if we need to query it and before we acquire
     // cs_main.
     if (g_txindex && !pblockindex) {
         g_txindex->BlockUntilSyncedToCurrentChain();
     }
 
     const Consensus::Params &params = config.GetChainParams().GetConsensus();
 
     LOCK(cs_main);
 
     if (pblockindex == nullptr) {
         CTransactionRef tx;
         if (!GetTransaction(oneTxId, tx, params, hashBlock) ||
             hashBlock.IsNull()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Transaction not yet in block");
         }
 
         pblockindex = LookupBlockIndex(hashBlock);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Transaction index corrupt");
         }
     }
 
     CBlock block;
     if (!ReadBlockFromDisk(block, pblockindex, params)) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Can't read block from disk");
     }
 
     unsigned int ntxFound = 0;
     for (const auto &tx : block.vtx) {
         if (setTxIds.count(tx->GetId())) {
             ntxFound++;
         }
     }
 
     if (ntxFound != setTxIds.size()) {
         throw JSONRPCError(
             RPC_INVALID_ADDRESS_OR_KEY,
             "Not all transactions found in specified or retrieved block");
     }
 
     CDataStream ssMB(SER_NETWORK, PROTOCOL_VERSION);
     CMerkleBlock mb(block, setTxIds);
     ssMB << mb;
     std::string strHex = HexStr(ssMB);
     return strHex;
 }
 
 static UniValue verifytxoutproof(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "verifytxoutproof",
         "Verifies that a proof points to a transaction in a block, returning "
         "the transaction it commits to\n"
         "and throwing an RPC error if the block is not in our best chain\n",
         {
             {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hex-encoded proof generated by gettxoutproof"},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "txid",
                        "The txid(s) which the proof commits to, or empty array "
                        "if the proof can not be validated."},
                   }},
         RPCExamples{""},
     }
         .Check(request);
 
     CDataStream ssMB(ParseHexV(request.params[0], "proof"), SER_NETWORK,
                      PROTOCOL_VERSION);
     CMerkleBlock merkleBlock;
     ssMB >> merkleBlock;
 
     UniValue res(UniValue::VARR);
 
     std::vector<uint256> vMatch;
     std::vector<size_t> vIndex;
     if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) !=
         merkleBlock.header.hashMerkleRoot) {
         return res;
     }
 
     LOCK(cs_main);
 
     const CBlockIndex *pindex = LookupBlockIndex(merkleBlock.header.GetHash());
     if (!pindex || !::ChainActive().Contains(pindex) || pindex->nTx == 0) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Block not found in chain");
     }
 
     // Check if proof is valid, only add results if so
     if (pindex->nTx == merkleBlock.txn.GetNumTransactions()) {
         for (const uint256 &hash : vMatch) {
             res.push_back(hash.GetHex());
         }
     }
 
     return res;
 }
 
 static UniValue createrawtransaction(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "createrawtransaction",
         "Create a transaction spending the given inputs and creating new "
         "outputs.\n"
         "Outputs can be addresses or data.\n"
         "Returns hex-encoded raw transaction.\n"
         "Note that the transaction's inputs are not signed, and\n"
         "it is not stored in the wallet or transmitted to the network.\n",
         {
             {
                 "inputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The inputs",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                             {"sequence", RPCArg::Type::NUM, /* default */
                              "depends on the value of the 'locktime' argument",
                              "The sequence number"},
                         },
                     },
                 },
             },
             {
                 "outputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The outputs (key-value pairs), where none of "
                 "the keys are duplicated.\n"
                 "That is, each address can only appear once and there can only "
                 "be one 'data' object.\n"
                 "For compatibility reasons, a dictionary, which holds the "
                 "key-value pairs directly, is also\n"
                 "                             accepted as second parameter.",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"address", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key (string) is the "
                              "bitcoin address, the value (float or string) is "
                              "the amount in " +
                                  CURRENCY_UNIT},
                         },
                     },
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"data", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key must be \"data\", the "
                              "value is hex-encoded data"},
                         },
                     },
                 },
             },
             {"locktime", RPCArg::Type::NUM, /* default */ "0",
              "Raw locktime. Non-0 value also locktime-activates inputs"},
         },
         RPCResult{RPCResult::Type::STR_HEX, "transaction",
                   "hex string of the transaction"},
         RPCExamples{
             HelpExampleCli("createrawtransaction",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                            "\" \"[{\\\"address\\\":0.01}]\"") +
             HelpExampleCli("createrawtransaction",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                            "\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"") +
             HelpExampleRpc("createrawtransaction",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                            "\", \"[{\\\"address\\\":0.01}]\"") +
             HelpExampleRpc("createrawtransaction",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                            "\", \"[{\\\"data\\\":\\\"00010203\\\"}]\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params,
                  {UniValue::VARR,
                   UniValueType(), // ARR or OBJ, checked later
                   UniValue::VNUM},
                  true);
 
     CMutableTransaction rawTx =
         ConstructTransaction(config.GetChainParams(), request.params[0],
                              request.params[1], request.params[2]);
 
     return EncodeHexTx(CTransaction(rawTx));
 }
 
 static UniValue decoderawtransaction(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "decoderawtransaction",
         "Return a JSON object representing the serialized, hex-encoded "
         "transaction.\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction hex string"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR_HEX, "txid", "The transaction id"},
                 {RPCResult::Type::STR_HEX, "hash", "The transaction hash"},
                 {RPCResult::Type::NUM, "size", "The transaction size"},
                 {RPCResult::Type::NUM, "version", "The version"},
                 {RPCResult::Type::NUM_TIME, "locktime", "The lock time"},
                 {RPCResult::Type::ARR,
                  "vin",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "txid",
                            "The transaction id"},
                           {RPCResult::Type::NUM, "vout", "The output number"},
                           {RPCResult::Type::OBJ,
                            "scriptSig",
                            "The script",
                            {
                                {RPCResult::Type::STR, "asm", "asm"},
                                {RPCResult::Type::STR_HEX, "hex", "hex"},
                            }},
                           {RPCResult::Type::NUM, "sequence",
                            "The script sequence number"},
                       }},
                  }},
                 {RPCResult::Type::ARR,
                  "vout",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::NUM, "value",
                            "The value in " + CURRENCY_UNIT},
                           {RPCResult::Type::NUM, "n", "index"},
                           {RPCResult::Type::OBJ,
                            "scriptPubKey",
                            "",
                            {
                                {RPCResult::Type::STR, "asm", "the asm"},
                                {RPCResult::Type::STR_HEX, "hex", "the hex"},
                                {RPCResult::Type::NUM, "reqSigs",
                                 "The required sigs"},
                                {RPCResult::Type::STR, "type",
                                 "The type, eg 'pubkeyhash'"},
                                {RPCResult::Type::ARR,
                                 "addresses",
                                 "",
                                 {
                                     {RPCResult::Type::STR, "address",
                                      "bitcoin address"},
                                 }},
                            }},
                       }},
                  }},
             }},
         RPCExamples{HelpExampleCli("decoderawtransaction", "\"hexstring\"") +
                     HelpExampleRpc("decoderawtransaction", "\"hexstring\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     CMutableTransaction mtx;
 
     if (!DecodeHexTx(mtx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     UniValue result(UniValue::VOBJ);
     TxToUniv(CTransaction(std::move(mtx)), uint256(), result, false);
 
     return result;
 }
 
 static std::string GetAllOutputTypes() {
     std::vector<std::string> ret;
     using U = std::underlying_type<TxoutType>::type;
     for (U i = (U)TxoutType::NONSTANDARD; i <= (U)TxoutType::NULL_DATA; ++i) {
         ret.emplace_back(GetTxnOutputType(static_cast<TxoutType>(i)));
     }
     return Join(ret, ", ");
 }
 
 static UniValue decodescript(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "decodescript",
         "Decode a hex-encoded script.\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hex-encoded script"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR, "asm", "Script public key"},
                 {RPCResult::Type::STR, "type",
                  "The output type (e.g. " + GetAllOutputTypes() + ")"},
                 {RPCResult::Type::NUM, "reqSigs", "The required signatures"},
                 {RPCResult::Type::ARR,
                  "addresses",
                  "",
                  {
                      {RPCResult::Type::STR, "address", "bitcoin address"},
                  }},
                 {RPCResult::Type::STR, "p2sh",
                  "address of P2SH script wrapping this redeem script (not "
                  "returned if the script is already a P2SH)"},
             }},
         RPCExamples{HelpExampleCli("decodescript", "\"hexstring\"") +
                     HelpExampleRpc("decodescript", "\"hexstring\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     UniValue r(UniValue::VOBJ);
     CScript script;
     if (request.params[0].get_str().size() > 0) {
         std::vector<uint8_t> scriptData(
             ParseHexV(request.params[0], "argument"));
         script = CScript(scriptData.begin(), scriptData.end());
     } else {
         // Empty scripts are valid.
     }
 
     ScriptPubKeyToUniv(script, r, /* fIncludeHex */ false);
 
     UniValue type;
     type = find_value(r, "type");
 
     if (type.isStr() && type.get_str() != "scripthash") {
         // P2SH cannot be wrapped in a P2SH. If this script is already a P2SH,
         // don't return the address for a P2SH of the P2SH.
         r.pushKV("p2sh", EncodeDestination(ScriptHash(script), config));
     }
 
     return r;
 }
 
 static UniValue combinerawtransaction(const Config &config,
                                       const JSONRPCRequest &request) {
     RPCHelpMan{
         "combinerawtransaction",
         "Combine multiple partially signed transactions into one "
         "transaction.\n"
         "The combined transaction may be another partially signed transaction "
         "or a \n"
         "fully signed transaction.",
         {
             {
                 "txs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The hex strings of partially signed "
                 "transactions",
                 {
                     {"hexstring", RPCArg::Type::STR_HEX,
                      RPCArg::Optional::OMITTED, "A transaction hash"},
                 },
             },
         },
         RPCResult{RPCResult::Type::STR, "",
                   "The hex-encoded raw transaction with signature(s)"},
         RPCExamples{HelpExampleCli("combinerawtransaction",
                                    "[\"myhex1\", \"myhex2\", \"myhex3\"]")},
     }
         .Check(request);
 
     UniValue txs = request.params[0].get_array();
     std::vector<CMutableTransaction> txVariants(txs.size());
 
     for (unsigned int idx = 0; idx < txs.size(); idx++) {
         if (!DecodeHexTx(txVariants[idx], txs[idx].get_str())) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                strprintf("TX decode failed for tx %d", idx));
         }
     }
 
     if (txVariants.empty()) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Missing transactions");
     }
 
     // mergedTx will end up with all the signatures; it
     // starts as a clone of the rawtx:
     CMutableTransaction mergedTx(txVariants[0]);
 
     // Fetch previous transactions (inputs):
     CCoinsView viewDummy;
     CCoinsViewCache view(&viewDummy);
     {
         const CTxMemPool &mempool = EnsureMemPool(request.context);
         LOCK(cs_main);
         LOCK(mempool.cs);
         CCoinsViewCache &viewChain = ::ChainstateActive().CoinsTip();
         CCoinsViewMemPool viewMempool(&viewChain, mempool);
         // temporarily switch cache backend to db+mempool view
         view.SetBackend(viewMempool);
 
         for (const CTxIn &txin : mergedTx.vin) {
             // Load entries from viewChain into view; can fail.
             view.AccessCoin(txin.prevout);
         }
 
         // switch back to avoid locking mempool for too long
         view.SetBackend(viewDummy);
     }
 
     // Use CTransaction for the constant parts of the
     // transaction to avoid rehashing.
     const CTransaction txConst(mergedTx);
     // Sign what we can:
     for (size_t i = 0; i < mergedTx.vin.size(); i++) {
         CTxIn &txin = mergedTx.vin[i];
         const Coin &coin = view.AccessCoin(txin.prevout);
         if (coin.IsSpent()) {
             throw JSONRPCError(RPC_VERIFY_ERROR,
                                "Input not found or already spent");
         }
         SignatureData sigdata;
 
         const CTxOut &txout = coin.GetTxOut();
 
         // ... and merge in other signatures:
         for (const CMutableTransaction &txv : txVariants) {
             if (txv.vin.size() > i) {
                 sigdata.MergeSignatureData(DataFromTransaction(txv, i, txout));
             }
         }
         ProduceSignature(
             DUMMY_SIGNING_PROVIDER,
             MutableTransactionSignatureCreator(&mergedTx, i, txout.nValue),
             txout.scriptPubKey, sigdata);
 
         UpdateInput(txin, sigdata);
     }
 
     return EncodeHexTx(CTransaction(mergedTx));
 }
 
 static UniValue signrawtransactionwithkey(const Config &config,
                                           const JSONRPCRequest &request) {
     RPCHelpMan{
         "signrawtransactionwithkey",
         "Sign inputs for raw transaction (serialized, hex-encoded).\n"
         "The second argument is an array of base58-encoded private\n"
         "keys that will be the only keys used to sign the transaction.\n"
         "The third optional argument (may be null) is an array of previous "
         "transaction outputs that\n"
         "this transaction depends on but may not yet be in the block chain.\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction hex string"},
             {
                 "privkeys",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The base58-encoded private keys for signing",
                 {
                     {"privatekey", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                      "private key in base58-encoding"},
                 },
             },
             {
                 "prevtxs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::OMITTED_NAMED_ARG,
                 "The previous dependent transaction outputs",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                             {"scriptPubKey", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "script key"},
                             {"redeemScript", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::OMITTED,
                              "(required for P2SH) redeem script"},
                             {"amount", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO, "The amount spent"},
                         },
                     },
                 },
             },
             {"sighashtype", RPCArg::Type::STR, /* default */ "ALL|FORKID",
              "The signature hash type. Must be one of:\n"
              "       \"ALL|FORKID\"\n"
              "       \"NONE|FORKID\"\n"
              "       \"SINGLE|FORKID\"\n"
              "       \"ALL|FORKID|ANYONECANPAY\"\n"
              "       \"NONE|FORKID|ANYONECANPAY\"\n"
              "       \"SINGLE|FORKID|ANYONECANPAY\""},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR_HEX, "hex",
                  "The hex-encoded raw transaction with signature(s)"},
                 {RPCResult::Type::BOOL, "complete",
                  "If the transaction has a complete set of signatures"},
                 {RPCResult::Type::ARR,
                  "errors",
                  "Script verification errors (if there are any)",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "txid",
                            "The hash of the referenced, previous transaction"},
                           {RPCResult::Type::NUM, "vout",
                            "The index of the output to spent and used as "
                            "input"},
                           {RPCResult::Type::STR_HEX, "scriptSig",
                            "The hex-encoded signature script"},
                           {RPCResult::Type::NUM, "sequence",
                            "Script sequence number"},
                           {RPCResult::Type::STR, "error",
                            "Verification or signing error related to the "
                            "input"},
                       }},
                  }},
             }},
         RPCExamples{
             HelpExampleCli("signrawtransactionwithkey",
                            "\"myhex\" \"[\\\"key1\\\",\\\"key2\\\"]\"") +
             HelpExampleRpc("signrawtransactionwithkey",
                            "\"myhex\", \"[\\\"key1\\\",\\\"key2\\\"]\"")},
     }
         .Check(request);
 
     RPCTypeCheck(
         request.params,
         {UniValue::VSTR, UniValue::VARR, UniValue::VARR, UniValue::VSTR}, true);
 
     CMutableTransaction mtx;
     if (!DecodeHexTx(mtx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     FillableSigningProvider keystore;
     const UniValue &keys = request.params[1].get_array();
     for (size_t idx = 0; idx < keys.size(); ++idx) {
         UniValue k = keys[idx];
         CKey key = DecodeSecret(k.get_str());
         if (!key.IsValid()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid private key");
         }
         keystore.AddKey(key);
     }
 
     // Fetch previous transactions (inputs):
     std::map<COutPoint, Coin> coins;
     for (const CTxIn &txin : mtx.vin) {
         // Create empty map entry keyed by prevout.
         coins[txin.prevout];
     }
     NodeContext &node = EnsureNodeContext(request.context);
     FindCoins(node, coins);
 
     // Parse the prevtxs array
     ParsePrevouts(request.params[2], &keystore, coins);
 
     UniValue result(UniValue::VOBJ);
     SignTransaction(mtx, &keystore, coins, request.params[3], result);
     return result;
 }
 
 static UniValue sendrawtransaction(const Config &config,
                                    const JSONRPCRequest &request) {
     RPCHelpMan{
         "sendrawtransaction",
         "Submits raw transaction (serialized, hex-encoded) to local node and "
         "network.\n"
         "\nAlso see createrawtransaction and "
         "signrawtransactionwithkey calls.\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hex string of the raw transaction"},
             {"maxfeerate", RPCArg::Type::AMOUNT,
              /* default */
              FormatMoney(DEFAULT_MAX_RAW_TX_FEE_RATE.GetFeePerK()),
              "Reject transactions whose fee rate is higher than the specified "
              "value, expressed in " +
                  CURRENCY_UNIT + "/kB\nSet to 0 to accept any fee rate.\n"},
         },
         RPCResult{RPCResult::Type::STR_HEX, "", "The transaction hash in hex"},
         RPCExamples{
             "\nCreate a transaction\n" +
             HelpExampleCli(
                 "createrawtransaction",
                 "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" "
                 "\"{\\\"myaddress\\\":0.01}\"") +
             "Sign the transaction, and get back the hex\n" +
             HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
             "\nSend the transaction (signed hex)\n" +
             HelpExampleCli("sendrawtransaction", "\"signedhex\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("sendrawtransaction", "\"signedhex\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params,
                  {
                      UniValue::VSTR,
                      // VNUM or VSTR, checked inside AmountFromValue()
                      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)));
 
     const CFeeRate max_raw_tx_fee_rate =
         request.params[1].isNull()
             ? DEFAULT_MAX_RAW_TX_FEE_RATE
             : CFeeRate(AmountFromValue(request.params[1]));
 
     int64_t virtual_size = GetVirtualTransactionSize(*tx);
     Amount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
 
     std::string err_string;
     AssertLockNotHeld(cs_main);
     NodeContext &node = EnsureNodeContext(request.context);
     const TransactionError err = BroadcastTransaction(
         node, config, tx, err_string, max_raw_tx_fee, /*relay*/ true,
         /*wait_callback*/ true);
     if (err != TransactionError::OK) {
         throw JSONRPCTransactionError(err, err_string);
     }
 
     return tx->GetHash().GetHex();
 }
 
 static UniValue testmempoolaccept(const Config &config,
                                   const JSONRPCRequest &request) {
     RPCHelpMan{
         "testmempoolaccept",
         "Returns result of mempool acceptance tests indicating if raw"
         " transaction (serialized, hex-encoded) would be accepted"
         " by mempool.\n"
         "\nThis checks if the transaction violates the consensus or policy "
         "rules.\n"
         "\nSee sendrawtransaction call.\n",
         {
             {
                 "rawtxs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "An array of hex strings of raw transactions.\n"
                 "                             Length must be one for now.",
                 {
                     {"rawtx", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED,
                      ""},
                 },
             },
             {"maxfeerate", RPCArg::Type::AMOUNT,
              /* default */
              FormatMoney(DEFAULT_MAX_RAW_TX_FEE_RATE.GetFeePerK()),
              "Reject transactions whose fee rate is higher than the specified "
              "value, expressed in " +
                  CURRENCY_UNIT + "/kB\n"},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "The result of the mempool acceptance test for each raw "
                   "transaction in the input array.\n"
                   "Length is exactly one for now.",
                   {
                       {RPCResult::Type::OBJ,
                        "",
                        "",
                        {
                            {RPCResult::Type::STR_HEX, "txid",
                             "The transaction hash in hex"},
                            {RPCResult::Type::BOOL, "allowed",
                             "If the mempool allows this tx to be inserted"},
                            {RPCResult::Type::STR, "reject-reason",
                             "Rejection string (only present when 'allowed' is "
                             "false)"},
                        }},
                   }},
         RPCExamples{
             "\nCreate a transaction\n" +
             HelpExampleCli(
                 "createrawtransaction",
                 "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" "
                 "\"{\\\"myaddress\\\":0.01}\"") +
             "Sign the transaction, and get back the hex\n" +
             HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
             "\nTest acceptance of the transaction (signed hex)\n" +
             HelpExampleCli("testmempoolaccept", "[\"signedhex\"]") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("testmempoolaccept", "[\"signedhex\"]")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params,
                  {
                      UniValue::VARR,
                      // VNUM or VSTR, checked inside AmountFromValue()
                      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();
 
     const CFeeRate max_raw_tx_fee_rate =
         request.params[1].isNull()
             ? DEFAULT_MAX_RAW_TX_FEE_RATE
             : CFeeRate(AmountFromValue(request.params[1]));
 
     CTxMemPool &mempool = EnsureMemPool(request.context);
     int64_t virtual_size = GetVirtualTransactionSize(*tx);
     Amount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
 
     UniValue result(UniValue::VARR);
     UniValue result_0(UniValue::VOBJ);
     result_0.pushKV("txid", txid.GetHex());
 
     TxValidationState state;
     bool test_accept_res;
     {
         LOCK(cs_main);
         test_accept_res = AcceptToMemoryPool(
             config, mempool, state, std::move(tx), false /* bypass_limits */,
             max_raw_tx_fee, true /* test_accept */);
     }
     result_0.pushKV("allowed", test_accept_res);
     if (!test_accept_res) {
         if (state.IsInvalid()) {
             if (state.GetResult() == TxValidationResult::TX_MISSING_INPUTS) {
                 result_0.pushKV("reject-reason", "missing-inputs");
             } else {
                 result_0.pushKV("reject-reason",
                                 strprintf("%s", state.GetRejectReason()));
             }
         } else {
             result_0.pushKV("reject-reason", state.GetRejectReason());
         }
     }
 
     result.push_back(std::move(result_0));
     return result;
 }
 
 static std::string WriteHDKeypath(std::vector<uint32_t> &keypath) {
     std::string keypath_str = "m";
     for (uint32_t num : keypath) {
         keypath_str += "/";
         bool hardened = false;
         if (num & 0x80000000) {
             hardened = true;
             num &= ~0x80000000;
         }
 
         keypath_str += ToString(num);
         if (hardened) {
             keypath_str += "'";
         }
     }
     return keypath_str;
 }
 
 static UniValue decodepsbt(const Config &config,
                            const JSONRPCRequest &request) {
     RPCHelpMan{
         "decodepsbt",
         "Return a JSON object representing the serialized, base64-encoded "
         "partially signed Bitcoin transaction.\n",
         {
             {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The PSBT base64 string"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "tx",
                  "The decoded network-serialized unsigned transaction.",
                  {
                      {RPCResult::Type::ELISION, "",
                       "The layout is the same as the output of "
                       "decoderawtransaction."},
                  }},
                 {RPCResult::Type::OBJ_DYN,
                  "unknown",
                  "The unknown global fields",
                  {
                      {RPCResult::Type::STR_HEX, "key",
                       "(key-value pair) An unknown key-value pair"},
                  }},
                 {RPCResult::Type::ARR,
                  "inputs",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::OBJ,
                            "utxo",
                            /* optional */ true,
                            "Transaction output for UTXOs",
                            {
                                {RPCResult::Type::NUM, "amount",
                                 "The value in " + CURRENCY_UNIT},
                                {RPCResult::Type::OBJ,
                                 "scriptPubKey",
                                 "",
                                 {
                                     {RPCResult::Type::STR, "asm", "The asm"},
                                     {RPCResult::Type::STR_HEX, "hex",
                                      "The hex"},
                                     {RPCResult::Type::STR, "type",
                                      "The type, eg 'pubkeyhash'"},
                                     {RPCResult::Type::STR, "address",
                                      " Bitcoin address if there is one"},
                                 }},
                            }},
                           {RPCResult::Type::OBJ_DYN,
                            "partial_signatures",
                            /* optional */ true,
                            "",
                            {
                                {RPCResult::Type::STR, "pubkey",
                                 "The public key and signature that corresponds "
                                 "to it."},
                            }},
                           {RPCResult::Type::STR, "sighash", /* optional */ true,
                            "The sighash type to be used"},
                           {RPCResult::Type::OBJ,
                            "redeem_script",
                            /* optional */ true,
                            "",
                            {
                                {RPCResult::Type::STR, "asm", "The asm"},
                                {RPCResult::Type::STR_HEX, "hex", "The hex"},
                                {RPCResult::Type::STR, "type",
                                 "The type, eg 'pubkeyhash'"},
                            }},
                           {RPCResult::Type::ARR,
                            "bip32_derivs",
                            /* optional */ true,
                            "",
                            {
                                {RPCResult::Type::OBJ,
                                 "pubkey",
                                 /* optional */ true,
                                 "The public key with the derivation path as "
                                 "the value.",
                                 {
                                     {RPCResult::Type::STR, "master_fingerprint",
                                      "The fingerprint of the master key"},
                                     {RPCResult::Type::STR, "path", "The path"},
                                 }},
                            }},
                           {RPCResult::Type::OBJ,
                            "final_scriptsig",
                            /* optional */ true,
                            "",
                            {
                                {RPCResult::Type::STR, "asm", "The asm"},
                                {RPCResult::Type::STR, "hex", "The hex"},
                            }},
                           {RPCResult::Type::OBJ_DYN,
                            "unknown",
                            "The unknown global fields",
                            {
                                {RPCResult::Type::STR_HEX, "key",
                                 "(key-value pair) An unknown key-value pair"},
                            }},
                       }},
                  }},
                 {RPCResult::Type::ARR,
                  "outputs",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::OBJ,
                            "redeem_script",
                            /* optional */ true,
                            "",
                            {
                                {RPCResult::Type::STR, "asm", "The asm"},
                                {RPCResult::Type::STR_HEX, "hex", "The hex"},
                                {RPCResult::Type::STR, "type",
                                 "The type, eg 'pubkeyhash'"},
                            }},
                           {RPCResult::Type::ARR,
                            "bip32_derivs",
                            /* optional */ true,
                            "",
                            {
                                {RPCResult::Type::OBJ,
                                 "",
                                 "",
                                 {
                                     {RPCResult::Type::STR, "pubkey",
                                      "The public key this path corresponds to"},
                                     {RPCResult::Type::STR, "master_fingerprint",
                                      "The fingerprint of the master key"},
                                     {RPCResult::Type::STR, "path", "The path"},
                                 }},
                            }},
                           {RPCResult::Type::OBJ_DYN,
                            "unknown",
                            "The unknown global fields",
                            {
                                {RPCResult::Type::STR_HEX, "key",
                                 "(key-value pair) An unknown key-value pair"},
                            }},
                       }},
                  }},
                 {RPCResult::Type::STR_AMOUNT, "fee", /* optional */ true,
                  "The transaction fee paid if all UTXOs slots in the PSBT have "
                  "been filled."},
             }},
         RPCExamples{HelpExampleCli("decodepsbt", "\"psbt\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     // Unserialize the transactions
     PartiallySignedTransaction psbtx;
     std::string error;
     if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            strprintf("TX decode failed %s", error));
     }
 
     UniValue result(UniValue::VOBJ);
 
     // Add the decoded tx
     UniValue tx_univ(UniValue::VOBJ);
     TxToUniv(CTransaction(*psbtx.tx), uint256(), tx_univ, false);
     result.pushKV("tx", tx_univ);
 
     // Unknown data
     if (psbtx.unknown.size() > 0) {
         UniValue unknowns(UniValue::VOBJ);
         for (auto entry : psbtx.unknown) {
             unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
         }
         result.pushKV("unknown", unknowns);
     }
 
     // inputs
     Amount total_in = Amount::zero();
     bool have_all_utxos = true;
     UniValue inputs(UniValue::VARR);
     for (size_t i = 0; i < psbtx.inputs.size(); ++i) {
         const PSBTInput &input = psbtx.inputs[i];
         UniValue in(UniValue::VOBJ);
         // UTXOs
         if (!input.utxo.IsNull()) {
             const CTxOut &txout = input.utxo;
 
             UniValue out(UniValue::VOBJ);
 
-            out.pushKV("amount", ValueFromAmount(txout.nValue));
+            out.pushKV("amount", txout.nValue);
             if (MoneyRange(txout.nValue) &&
                 MoneyRange(total_in + txout.nValue)) {
                 total_in += txout.nValue;
             } else {
                 // Hack to just not show fee later
                 have_all_utxos = false;
             }
 
             UniValue o(UniValue::VOBJ);
             ScriptToUniv(txout.scriptPubKey, o, true);
             out.pushKV("scriptPubKey", o);
             in.pushKV("utxo", out);
         } else {
             have_all_utxos = false;
         }
 
         // Partial sigs
         if (!input.partial_sigs.empty()) {
             UniValue partial_sigs(UniValue::VOBJ);
             for (const auto &sig : input.partial_sigs) {
                 partial_sigs.pushKV(HexStr(sig.second.first),
                                     HexStr(sig.second.second));
             }
             in.pushKV("partial_signatures", partial_sigs);
         }
 
         // Sighash
         uint8_t sighashbyte = input.sighash_type.getRawSigHashType() & 0xff;
         if (sighashbyte > 0) {
             in.pushKV("sighash", SighashToStr(sighashbyte));
         }
 
         // Redeem script
         if (!input.redeem_script.empty()) {
             UniValue r(UniValue::VOBJ);
             ScriptToUniv(input.redeem_script, r, false);
             in.pushKV("redeem_script", r);
         }
 
         // keypaths
         if (!input.hd_keypaths.empty()) {
             UniValue keypaths(UniValue::VARR);
             for (auto entry : input.hd_keypaths) {
                 UniValue keypath(UniValue::VOBJ);
                 keypath.pushKV("pubkey", HexStr(entry.first));
 
                 keypath.pushKV(
                     "master_fingerprint",
                     strprintf("%08x", ReadBE32(entry.second.fingerprint)));
                 keypath.pushKV("path", WriteHDKeypath(entry.second.path));
                 keypaths.push_back(keypath);
             }
             in.pushKV("bip32_derivs", keypaths);
         }
 
         // Final scriptSig
         if (!input.final_script_sig.empty()) {
             UniValue scriptsig(UniValue::VOBJ);
             scriptsig.pushKV("asm",
                              ScriptToAsmStr(input.final_script_sig, true));
             scriptsig.pushKV("hex", HexStr(input.final_script_sig));
             in.pushKV("final_scriptSig", scriptsig);
         }
 
         // Unknown data
         if (input.unknown.size() > 0) {
             UniValue unknowns(UniValue::VOBJ);
             for (auto entry : input.unknown) {
                 unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
             }
             in.pushKV("unknown", unknowns);
         }
 
         inputs.push_back(in);
     }
     result.pushKV("inputs", inputs);
 
     // outputs
     Amount output_value = Amount::zero();
     UniValue outputs(UniValue::VARR);
     for (size_t i = 0; i < psbtx.outputs.size(); ++i) {
         const PSBTOutput &output = psbtx.outputs[i];
         UniValue out(UniValue::VOBJ);
         // Redeem script
         if (!output.redeem_script.empty()) {
             UniValue r(UniValue::VOBJ);
             ScriptToUniv(output.redeem_script, r, false);
             out.pushKV("redeem_script", r);
         }
 
         // keypaths
         if (!output.hd_keypaths.empty()) {
             UniValue keypaths(UniValue::VARR);
             for (auto entry : output.hd_keypaths) {
                 UniValue keypath(UniValue::VOBJ);
                 keypath.pushKV("pubkey", HexStr(entry.first));
                 keypath.pushKV(
                     "master_fingerprint",
                     strprintf("%08x", ReadBE32(entry.second.fingerprint)));
                 keypath.pushKV("path", WriteHDKeypath(entry.second.path));
                 keypaths.push_back(keypath);
             }
             out.pushKV("bip32_derivs", keypaths);
         }
 
         // Unknown data
         if (output.unknown.size() > 0) {
             UniValue unknowns(UniValue::VOBJ);
             for (auto entry : output.unknown) {
                 unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
             }
             out.pushKV("unknown", unknowns);
         }
 
         outputs.push_back(out);
 
         // Fee calculation
         if (MoneyRange(psbtx.tx->vout[i].nValue) &&
             MoneyRange(output_value + psbtx.tx->vout[i].nValue)) {
             output_value += psbtx.tx->vout[i].nValue;
         } else {
             // Hack to just not show fee later
             have_all_utxos = false;
         }
     }
     result.pushKV("outputs", outputs);
     if (have_all_utxos) {
-        result.pushKV("fee", ValueFromAmount(total_in - output_value));
+        result.pushKV("fee", total_in - output_value);
     }
 
     return result;
 }
 
 static UniValue combinepsbt(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "combinepsbt",
         "Combine multiple partially signed Bitcoin transactions into one "
         "transaction.\n"
         "Implements the Combiner role.\n",
         {
             {
                 "txs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The base64 strings of partially signed transactions",
                 {
                     {"psbt", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                      "A base64 string of a PSBT"},
                 },
             },
         },
         RPCResult{RPCResult::Type::STR, "",
                   "The base64-encoded partially signed transaction"},
         RPCExamples{HelpExampleCli(
             "combinepsbt", "[\"mybase64_1\", \"mybase64_2\", \"mybase64_3\"]")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VARR}, true);
 
     // Unserialize the transactions
     std::vector<PartiallySignedTransaction> psbtxs;
     UniValue txs = request.params[0].get_array();
     if (txs.empty()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Parameter 'txs' cannot be empty");
     }
     for (size_t i = 0; i < txs.size(); ++i) {
         PartiallySignedTransaction psbtx;
         std::string error;
         if (!DecodeBase64PSBT(psbtx, txs[i].get_str(), error)) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                strprintf("TX decode failed %s", error));
         }
         psbtxs.push_back(psbtx);
     }
 
     PartiallySignedTransaction merged_psbt;
     const TransactionError error = CombinePSBTs(merged_psbt, psbtxs);
     if (error != TransactionError::OK) {
         throw JSONRPCTransactionError(error);
     }
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << merged_psbt;
     return EncodeBase64(MakeUCharSpan(ssTx));
 }
 
 static UniValue finalizepsbt(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "finalizepsbt",
         "Finalize the inputs of a PSBT. If the transaction is fully signed, it "
         "will produce a\n"
         "network serialized transaction which can be broadcast with "
         "sendrawtransaction. Otherwise a PSBT will be\n"
         "created which has the final_scriptSigfields filled for inputs that "
         "are complete.\n"
         "Implements the Finalizer and Extractor roles.\n",
         {
             {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
              "A base64 string of a PSBT"},
             {"extract", RPCArg::Type::BOOL, /* default */ "true",
              "If true and the transaction is complete,\n"
              "                             extract and return the complete "
              "transaction in normal network serialization instead of the "
              "PSBT."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "psbt",
                        "The base64-encoded partially signed transaction if not "
                        "extracted"},
                       {RPCResult::Type::STR_HEX, "hex",
                        "The hex-encoded network transaction if extracted"},
                       {RPCResult::Type::BOOL, "complete",
                        "If the transaction has a complete set of signatures"},
                   }},
         RPCExamples{HelpExampleCli("finalizepsbt", "\"psbt\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VBOOL}, true);
 
     // Unserialize the transactions
     PartiallySignedTransaction psbtx;
     std::string error;
     if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            strprintf("TX decode failed %s", error));
     }
 
     bool extract = request.params[1].isNull() || (!request.params[1].isNull() &&
                                                   request.params[1].get_bool());
 
     CMutableTransaction mtx;
     bool complete = FinalizeAndExtractPSBT(psbtx, mtx);
 
     UniValue result(UniValue::VOBJ);
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     std::string result_str;
 
     if (complete && extract) {
         ssTx << mtx;
         result_str = HexStr(ssTx);
         result.pushKV("hex", result_str);
     } else {
         ssTx << psbtx;
         result_str = EncodeBase64(ssTx.str());
         result.pushKV("psbt", result_str);
     }
     result.pushKV("complete", complete);
 
     return result;
 }
 
 static UniValue createpsbt(const Config &config,
                            const JSONRPCRequest &request) {
     RPCHelpMan{
         "createpsbt",
         "Creates a transaction in the Partially Signed Transaction format.\n"
         "Implements the Creator role.\n",
         {
             {
                 "inputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The json objects",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                             {"sequence", RPCArg::Type::NUM, /* default */
                              "depends on the value of the 'locktime' argument",
                              "The sequence number"},
                         },
                     },
                 },
             },
             {
                 "outputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The outputs (key-value pairs), where none of "
                 "the keys are duplicated.\n"
                 "That is, each address can only appear once and there can only "
                 "be one 'data' object.\n"
                 "For compatibility reasons, a dictionary, which holds the "
                 "key-value pairs directly, is also\n"
                 "                             accepted as second parameter.",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"address", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key (string) is the "
                              "bitcoin address, the value (float or string) is "
                              "the amount in " +
                                  CURRENCY_UNIT},
                         },
                     },
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"data", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key must be \"data\", the "
                              "value is hex-encoded data"},
                         },
                     },
                 },
             },
             {"locktime", RPCArg::Type::NUM, /* default */ "0",
              "Raw locktime. Non-0 value also locktime-activates inputs"},
         },
         RPCResult{RPCResult::Type::STR, "",
                   "The resulting raw transaction (base64-encoded string)"},
         RPCExamples{HelpExampleCli(
             "createpsbt", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                           "\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params,
                  {
                      UniValue::VARR,
                      UniValueType(), // ARR or OBJ, checked later
                      UniValue::VNUM,
                  },
                  true);
 
     CMutableTransaction rawTx =
         ConstructTransaction(config.GetChainParams(), request.params[0],
                              request.params[1], request.params[2]);
 
     // Make a blank psbt
     PartiallySignedTransaction psbtx;
     psbtx.tx = rawTx;
     for (size_t i = 0; i < rawTx.vin.size(); ++i) {
         psbtx.inputs.push_back(PSBTInput());
     }
     for (size_t i = 0; i < rawTx.vout.size(); ++i) {
         psbtx.outputs.push_back(PSBTOutput());
     }
 
     // Serialize the PSBT
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
 
     return EncodeBase64(MakeUCharSpan(ssTx));
 }
 
 static UniValue converttopsbt(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "converttopsbt",
         "Converts a network serialized transaction to a PSBT. "
         "This should be used only with createrawtransaction and "
         "fundrawtransaction\n"
         "createpsbt and walletcreatefundedpsbt should be used for new "
         "applications.\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hex string of a raw transaction"},
             {"permitsigdata", RPCArg::Type::BOOL, /* default */ "false",
              "If true, any signatures in the input will be discarded and "
              "conversion.\n"
              "                              will continue. If false, RPC will "
              "fail if any signatures are present."},
         },
         RPCResult{RPCResult::Type::STR, "",
                   "The resulting raw transaction (base64-encoded string)"},
         RPCExamples{
             "\nCreate a transaction\n" +
             HelpExampleCli("createrawtransaction",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
                            "\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"") +
             "\nConvert the transaction to a PSBT\n" +
             HelpExampleCli("converttopsbt", "\"rawtransaction\"")},
     }
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VBOOL}, true);
 
     // parse hex string from parameter
     CMutableTransaction tx;
     bool permitsigdata =
         request.params[1].isNull() ? false : request.params[1].get_bool();
     if (!DecodeHexTx(tx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     // Remove all scriptSigs from inputs
     for (CTxIn &input : tx.vin) {
         if (!input.scriptSig.empty() && !permitsigdata) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                "Inputs must not have scriptSigs");
         }
         input.scriptSig.clear();
     }
 
     // Make a blank psbt
     PartiallySignedTransaction psbtx;
     psbtx.tx = tx;
     for (size_t i = 0; i < tx.vin.size(); ++i) {
         psbtx.inputs.push_back(PSBTInput());
     }
     for (size_t i = 0; i < tx.vout.size(); ++i) {
         psbtx.outputs.push_back(PSBTOutput());
     }
 
     // Serialize the PSBT
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
 
     return EncodeBase64(MakeUCharSpan(ssTx));
 }
 
 UniValue utxoupdatepsbt(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "utxoupdatepsbt",
         "Updates all inputs and outputs in a PSBT with data from output "
         "descriptors, the UTXO set or the mempool.\n",
         {
             {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
              "A base64 string of a PSBT"},
             {"descriptors",
              RPCArg::Type::ARR,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "An array of either strings or objects",
              {
                  {"", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                   "An output descriptor"},
                  {"",
                   RPCArg::Type::OBJ,
                   RPCArg::Optional::OMITTED,
                   "An object with an output descriptor and extra information",
                   {
                       {"desc", RPCArg::Type::STR, RPCArg::Optional::NO,
                        "An output descriptor"},
                       {"range", RPCArg::Type::RANGE, "1000",
                        "Up to what index HD chains should be explored (either "
                        "end or [begin,end])"},
                   }},
              }},
         },
         RPCResult{RPCResult::Type::STR, "",
                   "The base64-encoded partially signed transaction with inputs "
                   "updated"},
         RPCExamples{HelpExampleCli("utxoupdatepsbt", "\"psbt\"")}}
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VARR}, true);
 
     // Unserialize the transactions
     PartiallySignedTransaction psbtx;
     std::string error;
     if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            strprintf("TX decode failed %s", error));
     }
 
     // Parse descriptors, if any.
     FlatSigningProvider provider;
     if (!request.params[1].isNull()) {
         auto descs = request.params[1].get_array();
         for (size_t i = 0; i < descs.size(); ++i) {
             EvalDescriptorStringOrObject(descs[i], provider);
         }
     }
     // We don't actually need private keys further on; hide them as a
     // precaution.
     HidingSigningProvider public_provider(&provider, /* nosign */ true,
                                           /* nobip32derivs */ false);
 
     // Fetch previous transactions (inputs):
     CCoinsView viewDummy;
     CCoinsViewCache view(&viewDummy);
     {
         const CTxMemPool &mempool = EnsureMemPool(request.context);
         LOCK2(cs_main, mempool.cs);
         CCoinsViewCache &viewChain = ::ChainstateActive().CoinsTip();
         CCoinsViewMemPool viewMempool(&viewChain, mempool);
         // temporarily switch cache backend to db+mempool view
         view.SetBackend(viewMempool);
 
         for (const CTxIn &txin : psbtx.tx->vin) {
             // Load entries from viewChain into view; can fail.
             view.AccessCoin(txin.prevout);
         }
 
         // switch back to avoid locking mempool for too long
         view.SetBackend(viewDummy);
     }
 
     // Fill the inputs
     for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
         PSBTInput &input = psbtx.inputs.at(i);
 
         if (!input.utxo.IsNull()) {
             continue;
         }
 
         // Update script/keypath information using descriptor data.
         // Note that SignPSBTInput does a lot more than just constructing ECDSA
         // signatures we don't actually care about those here, in fact.
         SignPSBTInput(public_provider, psbtx, i,
                       /* sighash_type */ SigHashType().withForkId());
     }
 
     // Update script/keypath information using descriptor data.
     for (unsigned int i = 0; i < psbtx.tx->vout.size(); ++i) {
         UpdatePSBTOutput(public_provider, psbtx, i);
     }
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
     return EncodeBase64(MakeUCharSpan(ssTx));
 }
 
 UniValue joinpsbts(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "joinpsbts",
         "Joins multiple distinct PSBTs with different inputs and outputs "
         "into one PSBT with inputs and outputs from all of the PSBTs\n"
         "No input in any of the PSBTs can be in more than one of the PSBTs.\n",
         {{"txs",
           RPCArg::Type::ARR,
           RPCArg::Optional::NO,
           "The base64 strings of partially signed transactions",
           {{"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
             "A base64 string of a PSBT"}}}},
         RPCResult{RPCResult::Type::STR, "",
                   "The base64-encoded partially signed transaction"},
         RPCExamples{HelpExampleCli("joinpsbts", "\"psbt\"")}}
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VARR}, true);
 
     // Unserialize the transactions
     std::vector<PartiallySignedTransaction> psbtxs;
     UniValue txs = request.params[0].get_array();
 
     if (txs.size() <= 1) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "At least two PSBTs are required to join PSBTs.");
     }
 
     int32_t best_version = 1;
     uint32_t best_locktime = 0xffffffff;
     for (size_t i = 0; i < txs.size(); ++i) {
         PartiallySignedTransaction psbtx;
         std::string error;
         if (!DecodeBase64PSBT(psbtx, txs[i].get_str(), error)) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                strprintf("TX decode failed %s", error));
         }
         psbtxs.push_back(psbtx);
         // Choose the highest version number
         if (psbtx.tx->nVersion > best_version) {
             best_version = psbtx.tx->nVersion;
         }
         // Choose the lowest lock time
         if (psbtx.tx->nLockTime < best_locktime) {
             best_locktime = psbtx.tx->nLockTime;
         }
     }
 
     // Create a blank psbt where everything will be added
     PartiallySignedTransaction merged_psbt;
     merged_psbt.tx = CMutableTransaction();
     merged_psbt.tx->nVersion = best_version;
     merged_psbt.tx->nLockTime = best_locktime;
 
     // Merge
     for (auto &psbt : psbtxs) {
         for (size_t i = 0; i < psbt.tx->vin.size(); ++i) {
             if (!merged_psbt.AddInput(psbt.tx->vin[i], psbt.inputs[i])) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf(
                         "Input %s:%d exists in multiple PSBTs",
                         psbt.tx->vin[i].prevout.GetTxId().ToString().c_str(),
                         psbt.tx->vin[i].prevout.GetN()));
             }
         }
         for (size_t i = 0; i < psbt.tx->vout.size(); ++i) {
             merged_psbt.AddOutput(psbt.tx->vout[i], psbt.outputs[i]);
         }
         merged_psbt.unknown.insert(psbt.unknown.begin(), psbt.unknown.end());
     }
 
     // Generate list of shuffled indices for shuffling inputs and outputs of the
     // merged PSBT
     std::vector<int> input_indices(merged_psbt.inputs.size());
     std::iota(input_indices.begin(), input_indices.end(), 0);
     std::vector<int> output_indices(merged_psbt.outputs.size());
     std::iota(output_indices.begin(), output_indices.end(), 0);
 
     // Shuffle input and output indices lists
     Shuffle(input_indices.begin(), input_indices.end(), FastRandomContext());
     Shuffle(output_indices.begin(), output_indices.end(), FastRandomContext());
 
     PartiallySignedTransaction shuffled_psbt;
     shuffled_psbt.tx = CMutableTransaction();
     shuffled_psbt.tx->nVersion = merged_psbt.tx->nVersion;
     shuffled_psbt.tx->nLockTime = merged_psbt.tx->nLockTime;
     for (int i : input_indices) {
         shuffled_psbt.AddInput(merged_psbt.tx->vin[i], merged_psbt.inputs[i]);
     }
     for (int i : output_indices) {
         shuffled_psbt.AddOutput(merged_psbt.tx->vout[i],
                                 merged_psbt.outputs[i]);
     }
     shuffled_psbt.unknown.insert(merged_psbt.unknown.begin(),
                                  merged_psbt.unknown.end());
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << shuffled_psbt;
     return EncodeBase64(MakeUCharSpan(ssTx));
 }
 
 UniValue analyzepsbt(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "analyzepsbt",
         "Analyzes and provides information about the current status of a "
         "PSBT and its inputs\n",
         {{"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
           "A base64 string of a PSBT"}},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::ARR,
                  "inputs",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::BOOL, "has_utxo",
                            "Whether a UTXO is provided"},
                           {RPCResult::Type::BOOL, "is_final",
                            "Whether the input is finalized"},
                           {RPCResult::Type::OBJ,
                            "missing",
                            /* optional */ true,
                            "Things that are missing that are required to "
                            "complete this input",
                            {
                                {RPCResult::Type::ARR,
                                 "pubkeys",
                                 /* optional */ true,
                                 "",
                                 {
                                     {RPCResult::Type::STR_HEX, "keyid",
                                      "Public key ID, hash160 of the public "
                                      "key, of a public key whose BIP 32 "
                                      "derivation path is missing"},
                                 }},
                                {RPCResult::Type::ARR,
                                 "signatures",
                                 /* optional */ true,
                                 "",
                                 {
                                     {RPCResult::Type::STR_HEX, "keyid",
                                      "Public key ID, hash160 of the public "
                                      "key, of a public key whose signature is "
                                      "missing"},
                                 }},
                                {RPCResult::Type::STR_HEX, "redeemscript",
                                 /* optional */ true,
                                 "Hash160 of the redeemScript that is missing"},
                            }},
                           {RPCResult::Type::STR, "next", /* optional */ true,
                            "Role of the next person that this input needs to "
                            "go to"},
                       }},
                  }},
                 {RPCResult::Type::NUM, "estimated_vsize", /* optional */ true,
                  "Estimated vsize of the final signed transaction"},
                 {RPCResult::Type::STR_AMOUNT, "estimated_feerate",
                  /* optional */ true,
                  "Estimated feerate of the final signed transaction in " +
                      CURRENCY_UNIT +
                      "/kB. Shown only if all UTXO slots in the PSBT have been "
                      "filled"},
                 {RPCResult::Type::STR_AMOUNT, "fee", /* optional */ true,
                  "The transaction fee paid. Shown only if all UTXO slots in "
                  "the PSBT have been filled"},
                 {RPCResult::Type::STR, "next",
                  "Role of the next person that this psbt needs to go to"},
                 {RPCResult::Type::STR, "error",
                  "Error message if there is one"},
             }},
         RPCExamples{HelpExampleCli("analyzepsbt", "\"psbt\"")}}
         .Check(request);
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     // Unserialize the transaction
     PartiallySignedTransaction psbtx;
     std::string error;
     if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            strprintf("TX decode failed %s", error));
     }
 
     PSBTAnalysis psbta = AnalyzePSBT(psbtx);
 
     UniValue result(UniValue::VOBJ);
     UniValue inputs_result(UniValue::VARR);
     for (const auto &input : psbta.inputs) {
         UniValue input_univ(UniValue::VOBJ);
         UniValue missing(UniValue::VOBJ);
 
         input_univ.pushKV("has_utxo", input.has_utxo);
         input_univ.pushKV("is_final", input.is_final);
         input_univ.pushKV("next", PSBTRoleName(input.next));
 
         if (!input.missing_pubkeys.empty()) {
             UniValue missing_pubkeys_univ(UniValue::VARR);
             for (const CKeyID &pubkey : input.missing_pubkeys) {
                 missing_pubkeys_univ.push_back(HexStr(pubkey));
             }
             missing.pushKV("pubkeys", missing_pubkeys_univ);
         }
         if (!input.missing_redeem_script.IsNull()) {
             missing.pushKV("redeemscript", HexStr(input.missing_redeem_script));
         }
         if (!input.missing_sigs.empty()) {
             UniValue missing_sigs_univ(UniValue::VARR);
             for (const CKeyID &pubkey : input.missing_sigs) {
                 missing_sigs_univ.push_back(HexStr(pubkey));
             }
             missing.pushKV("signatures", missing_sigs_univ);
         }
         if (!missing.getKeys().empty()) {
             input_univ.pushKV("missing", missing);
         }
         inputs_result.push_back(input_univ);
     }
     if (!inputs_result.empty()) {
         result.pushKV("inputs", inputs_result);
     }
     if (psbta.estimated_vsize != std::nullopt) {
         result.pushKV("estimated_vsize", (int)*psbta.estimated_vsize);
     }
     if (psbta.estimated_feerate != std::nullopt) {
         result.pushKV("estimated_feerate",
-                      ValueFromAmount(psbta.estimated_feerate->GetFeePerK()));
+                      psbta.estimated_feerate->GetFeePerK());
     }
     if (psbta.fee != std::nullopt) {
-        result.pushKV("fee", ValueFromAmount(*psbta.fee));
+        result.pushKV("fee", *psbta.fee);
     }
     result.pushKV("next", PSBTRoleName(psbta.next));
     if (!psbta.error.empty()) {
         result.pushKV("error", psbta.error);
     }
 
     return result;
 }
 
 void RegisterRawTransactionRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            name                         actor (function)           argNames
         //  ------------------- ------------------------     ----------------------     ----------
         { "rawtransactions",    "getrawtransaction",         getrawtransaction,         {"txid","verbose","blockhash"} },
         { "rawtransactions",    "createrawtransaction",      createrawtransaction,      {"inputs","outputs","locktime"} },
         { "rawtransactions",    "decoderawtransaction",      decoderawtransaction,      {"hexstring"} },
         { "rawtransactions",    "decodescript",              decodescript,              {"hexstring"} },
         { "rawtransactions",    "sendrawtransaction",        sendrawtransaction,        {"hexstring","maxfeerate"} },
         { "rawtransactions",    "combinerawtransaction",     combinerawtransaction,     {"txs"} },
         { "rawtransactions",    "signrawtransactionwithkey", signrawtransactionwithkey, {"hexstring","privkeys","prevtxs","sighashtype"} },
         { "rawtransactions",    "testmempoolaccept",         testmempoolaccept,         {"rawtxs","maxfeerate"} },
         { "rawtransactions",    "decodepsbt",                decodepsbt,                {"psbt"} },
         { "rawtransactions",    "combinepsbt",               combinepsbt,               {"txs"} },
         { "rawtransactions",    "finalizepsbt",               finalizepsbt,               {"psbt", "extract"} },
         { "rawtransactions",    "createpsbt",                createpsbt,                {"inputs","outputs","locktime"} },
         { "rawtransactions",    "converttopsbt",             converttopsbt,             {"hexstring","permitsigdata"} },
         { "rawtransactions",    "utxoupdatepsbt",            utxoupdatepsbt,            {"psbt", "descriptors"} },
         { "rawtransactions",    "joinpsbts",                 joinpsbts,                 {"txs"} },
         { "rawtransactions",    "analyzepsbt",               analyzepsbt,               {"psbt"} },
         { "blockchain",         "gettxoutproof",             gettxoutproof,             {"txids", "blockhash"} },
         { "blockchain",         "verifytxoutproof",          verifytxoutproof,          {"proof"} },
     };
     // clang-format on
 
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/src/test/fuzz/integer.cpp b/src/test/fuzz/integer.cpp
index f9d8d93ce..36f331098 100644
--- a/src/test/fuzz/integer.cpp
+++ b/src/test/fuzz/integer.cpp
@@ -1,312 +1,311 @@
 // Copyright (c) 2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <amount.h>
 #include <arith_uint256.h>
 #include <chainparams.h>
 #include <compressor.h>
 #include <config.h>
 #include <consensus/merkle.h>
 #include <core_io.h>
 #include <crypto/common.h>
 #include <crypto/siphash.h>
 #include <ctime>
 #include <key_io.h>
 #include <memusage.h>
 #include <netbase.h>
 #include <policy/settings.h>
 #include <pow/pow.h>
 #include <protocol.h>
 #include <pubkey.h>
 #include <rpc/util.h>
 #include <script/signingprovider.h>
 #include <script/standard.h>
 #include <serialize.h>
 #include <streams.h>
 #include <uint256.h>
 #include <util/check.h>
 #include <util/moneystr.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <version.h>
 
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 
 #include <cassert>
 #include <chrono>
 #include <ctime>
 #include <limits>
 #include <set>
 #include <vector>
 
 void initialize() {
     SelectParams(CBaseChainParams::REGTEST);
 }
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     if (buffer.size() < sizeof(uint256) + sizeof(uint160)) {
         return;
     }
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     const uint256 u256(
         fuzzed_data_provider.ConsumeBytes<uint8_t>(sizeof(uint256)));
     const uint160 u160(
         fuzzed_data_provider.ConsumeBytes<uint8_t>(sizeof(uint160)));
     const uint64_t u64 = fuzzed_data_provider.ConsumeIntegral<uint64_t>();
     const int64_t i64 = fuzzed_data_provider.ConsumeIntegral<int64_t>();
     const uint32_t u32 = fuzzed_data_provider.ConsumeIntegral<uint32_t>();
     const int32_t i32 = fuzzed_data_provider.ConsumeIntegral<int32_t>();
     const uint16_t u16 = fuzzed_data_provider.ConsumeIntegral<uint16_t>();
     const int16_t i16 = fuzzed_data_provider.ConsumeIntegral<int16_t>();
     const uint8_t u8 = fuzzed_data_provider.ConsumeIntegral<uint8_t>();
     const int8_t i8 = fuzzed_data_provider.ConsumeIntegral<int8_t>();
     // We cannot assume a specific value of std::is_signed<char>::value:
     // ConsumeIntegral<char>() instead of casting from {u,}int8_t.
     const char ch = fuzzed_data_provider.ConsumeIntegral<char>();
     const bool b = fuzzed_data_provider.ConsumeBool();
 
     const Consensus::Params &consensus_params = Params().GetConsensus();
     (void)CheckProofOfWork(BlockHash(u256), u32, consensus_params);
 
     if (i64 >= 0) {
         Amount satoshis = i64 * SATOSHI;
         if (satoshis <= MAX_MONEY) {
             const uint64_t compressed_money_amount = CompressAmount(satoshis);
             assert(satoshis == DecompressAmount(compressed_money_amount));
             static const uint64_t compressed_money_amount_max =
                 CompressAmount(MAX_MONEY - 1 * SATOSHI);
             assert(compressed_money_amount <= compressed_money_amount_max);
         } else {
             (void)CompressAmount(satoshis);
         }
     }
 
     static const uint256 u256_min(uint256S(
         "0000000000000000000000000000000000000000000000000000000000000000"));
     static const uint256 u256_max(uint256S(
         "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
     const std::vector<uint256> v256{u256, u256_min, u256_max};
     (void)ComputeMerkleRoot(v256);
     (void)CountBits(u64);
     (void)DecompressAmount(u64);
     (void)FormatISO8601Date(i64);
     (void)FormatISO8601DateTime(i64);
     // FormatMoney(i) not defined when i == std::numeric_limits<int64_t>::min()
     if (i64 != std::numeric_limits<int64_t>::min()) {
         Amount parsed_money;
         if (ParseMoney(FormatMoney(i64 * SATOSHI), parsed_money)) {
             assert(parsed_money == i64 * SATOSHI);
         }
     }
     (void)GetSizeOfCompactSize(u64);
     (void)GetSpecialScriptSize(u32);
     if (!MultiplicationOverflow(i64, static_cast<int64_t>(::nBytesPerSigOp)) &&
         !AdditionOverflow(i64 * ::nBytesPerSigOp, static_cast<int64_t>(4))) {
         (void)GetVirtualTransactionSize(i64, i64);
     }
     if (!MultiplicationOverflow(i64, static_cast<int64_t>(u32)) &&
         !AdditionOverflow(i64, static_cast<int64_t>(4)) &&
         !AdditionOverflow(i64 * u32, static_cast<int64_t>(4))) {
         (void)GetVirtualTransactionSize(i64, i64, u32);
     }
     (void)HexDigit(ch);
     (void)MoneyRange(i64 * SATOSHI);
     (void)ToString(i64);
     (void)IsDigit(ch);
     (void)IsSpace(ch);
     (void)IsSwitchChar(ch);
     (void)memusage::DynamicUsage(ch);
     (void)memusage::DynamicUsage(i16);
     (void)memusage::DynamicUsage(i32);
     (void)memusage::DynamicUsage(i64);
     (void)memusage::DynamicUsage(i8);
     (void)memusage::DynamicUsage(u16);
     (void)memusage::DynamicUsage(u32);
     (void)memusage::DynamicUsage(u64);
     (void)memusage::DynamicUsage(u8);
     const uint8_t uch = static_cast<uint8_t>(u8);
     (void)memusage::DynamicUsage(uch);
     {
         const std::set<int64_t> i64s{i64, static_cast<int64_t>(u64)};
         const size_t dynamic_usage = memusage::DynamicUsage(i64s);
         const size_t incremental_dynamic_usage =
             memusage::IncrementalDynamicUsage(i64s);
         assert(dynamic_usage == incremental_dynamic_usage * i64s.size());
     }
     (void)MillisToTimeval(i64);
     const double d = ser_uint64_to_double(u64);
     assert(ser_double_to_uint64(d) == u64);
     const float f = ser_uint32_to_float(u32);
     assert(ser_float_to_uint32(f) == u32);
     (void)SighashToStr(uch);
     (void)SipHashUint256(u64, u64, u256);
     (void)SipHashUint256Extra(u64, u64, u256, u32);
     (void)ToLower(ch);
     (void)ToUpper(ch);
-    // ValueFromAmount(i) not defined when i ==
+    // Amount::operator UniValue() not defined when Amount::amount ==
     // std::numeric_limits<int64_t>::min()
     if (i64 != std::numeric_limits<int64_t>::min()) {
         Amount parsed_money;
-        if (ParseMoney(ValueFromAmount(i64 * SATOSHI).getValStr(),
-                       parsed_money)) {
+        if (ParseMoney(UniValue(i64 * SATOSHI).getValStr(), parsed_money)) {
             assert(parsed_money == i64 * SATOSHI);
         }
     }
     if (i32 >= 0 && i32 <= 16) {
         assert(i32 == CScript::DecodeOP_N(CScript::EncodeOP_N(i32)));
     }
 
     const std::chrono::seconds seconds{i64};
     assert(count_seconds(seconds) == i64);
 
     const CScriptNum script_num{i64};
     (void)script_num.getint();
     (void)script_num.getvch();
 
     const arith_uint256 au256 = UintToArith256(u256);
     assert(ArithToUint256(au256) == u256);
     assert(uint256S(au256.GetHex()) == u256);
     (void)au256.bits();
     (void)au256.GetCompact(/* fNegative= */ false);
     (void)au256.GetCompact(/* fNegative= */ true);
     (void)au256.getdouble();
     (void)au256.GetHex();
     (void)au256.GetLow64();
     (void)au256.size();
     (void)au256.ToString();
 
     const CKeyID key_id{u160};
     const CScriptID script_id{u160};
     // CTxDestination = CNoDestination ∪ PKHash ∪ ScriptHash
     const PKHash pk_hash{u160};
     const ScriptHash script_hash{u160};
     const std::vector<CTxDestination> destinations{pk_hash, script_hash};
     const SigningProvider store;
     const Config &config = GetConfig();
     for (const CTxDestination &destination : destinations) {
         (void)DescribeAddress(destination);
         (void)EncodeDestination(destination, config);
         (void)GetKeyForDestination(store, destination);
         (void)GetScriptForDestination(destination);
         (void)IsValidDestination(destination);
     }
 
     {
         CDataStream stream(SER_NETWORK, INIT_PROTO_VERSION);
 
         uint256 deserialized_u256;
         stream << u256;
         stream >> deserialized_u256;
         assert(u256 == deserialized_u256 && stream.empty());
 
         uint160 deserialized_u160;
         stream << u160;
         stream >> deserialized_u160;
         assert(u160 == deserialized_u160 && stream.empty());
 
         uint64_t deserialized_u64;
         stream << u64;
         stream >> deserialized_u64;
         assert(u64 == deserialized_u64 && stream.empty());
 
         int64_t deserialized_i64;
         stream << i64;
         stream >> deserialized_i64;
         assert(i64 == deserialized_i64 && stream.empty());
 
         uint32_t deserialized_u32;
         stream << u32;
         stream >> deserialized_u32;
         assert(u32 == deserialized_u32 && stream.empty());
 
         int32_t deserialized_i32;
         stream << i32;
         stream >> deserialized_i32;
         assert(i32 == deserialized_i32 && stream.empty());
 
         uint16_t deserialized_u16;
         stream << u16;
         stream >> deserialized_u16;
         assert(u16 == deserialized_u16 && stream.empty());
 
         int16_t deserialized_i16;
         stream << i16;
         stream >> deserialized_i16;
         assert(i16 == deserialized_i16 && stream.empty());
 
         uint8_t deserialized_u8;
         stream << u8;
         stream >> deserialized_u8;
         assert(u8 == deserialized_u8 && stream.empty());
 
         int8_t deserialized_i8;
         stream << i8;
         stream >> deserialized_i8;
         assert(i8 == deserialized_i8 && stream.empty());
 
         char deserialized_ch;
         stream << ch;
         stream >> deserialized_ch;
         assert(ch == deserialized_ch && stream.empty());
 
         bool deserialized_b;
         stream << b;
         stream >> deserialized_b;
         assert(b == deserialized_b && stream.empty());
     }
 
     {
         const ServiceFlags service_flags = (ServiceFlags)u64;
         (void)HasAllDesirableServiceFlags(service_flags);
         (void)MayHaveUsefulAddressDB(service_flags);
     }
 
     {
         CDataStream stream(SER_NETWORK, INIT_PROTO_VERSION);
 
         ser_writedata64(stream, u64);
         const uint64_t deserialized_u64 = ser_readdata64(stream);
         assert(u64 == deserialized_u64 && stream.empty());
 
         ser_writedata32(stream, u32);
         const uint32_t deserialized_u32 = ser_readdata32(stream);
         assert(u32 == deserialized_u32 && stream.empty());
 
         ser_writedata32be(stream, u32);
         const uint32_t deserialized_u32be = ser_readdata32be(stream);
         assert(u32 == deserialized_u32be && stream.empty());
 
         ser_writedata16(stream, u16);
         const uint16_t deserialized_u16 = ser_readdata16(stream);
         assert(u16 == deserialized_u16 && stream.empty());
 
         ser_writedata16be(stream, u16);
         const uint16_t deserialized_u16be = ser_readdata16be(stream);
         assert(u16 == deserialized_u16be && stream.empty());
 
         ser_writedata8(stream, u8);
         const uint8_t deserialized_u8 = ser_readdata8(stream);
         assert(u8 == deserialized_u8 && stream.empty());
     }
 
     {
         CDataStream stream(SER_NETWORK, INIT_PROTO_VERSION);
 
         WriteCompactSize(stream, u64);
         try {
             const uint64_t deserialized_u64 = ReadCompactSize(stream);
             assert(u64 == deserialized_u64 && stream.empty());
         } catch (const std::ios_base::failure &) {
         }
     }
 
     try {
         CHECK_NONFATAL(b);
     } catch (const NonFatalCheckError &) {
     }
 }
diff --git a/src/test/fuzz/transaction.cpp b/src/test/fuzz/transaction.cpp
index e8148e724..46bd53993 100644
--- a/src/test/fuzz/transaction.cpp
+++ b/src/test/fuzz/transaction.cpp
@@ -1,113 +1,113 @@
 // Copyright (c) 2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
 #include <coins.h>
 #include <consensus/tx_check.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <core_memusage.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <primitives/transaction.h>
 #include <streams.h>
 #include <test/fuzz/fuzz.h>
 #include <validation.h>
 #include <version.h>
 
 #include <univalue.h>
 
 #include <cassert>
 
 void initialize() {
     SelectParams(CBaseChainParams::REGTEST);
 }
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
     try {
         int nVersion;
         ds >> nVersion;
         ds.SetVersion(nVersion);
     } catch (const std::ios_base::failure &) {
         return;
     }
     bool valid_tx = true;
     const CTransaction tx = [&] {
         try {
             return CTransaction(deserialize, ds);
         } catch (const std::ios_base::failure &) {
             valid_tx = false;
             return CTransaction();
         }
     }();
     bool valid_mutable_tx = true;
     CDataStream ds_mtx(buffer, SER_NETWORK, INIT_PROTO_VERSION);
     CMutableTransaction mutable_tx;
     try {
         int nVersion;
         ds_mtx >> nVersion;
         ds_mtx.SetVersion(nVersion);
         ds_mtx >> mutable_tx;
     } catch (const std::ios_base::failure &) {
         valid_mutable_tx = false;
     }
     assert(valid_tx == valid_mutable_tx);
     if (!valid_tx) {
         return;
     }
 
     TxValidationState state;
     (void)CheckRegularTransaction(tx, state);
 
     const CFeeRate dust_relay_fee{DUST_RELAY_TX_FEE};
     std::string reason;
     const bool is_standard_with_permit_bare_multisig = IsStandardTx(
         tx, /* permit_bare_multisig= */ true, dust_relay_fee, reason);
     const bool is_standard_without_permit_bare_multisig = IsStandardTx(
         tx, /* permit_bare_multisig= */ false, dust_relay_fee, reason);
     if (is_standard_without_permit_bare_multisig) {
         assert(is_standard_with_permit_bare_multisig);
     }
     std::unique_ptr<CChainParams> params =
         CreateChainParams(CBaseChainParams::REGTEST);
     (void)tx.GetHash();
     (void)tx.GetTotalSize();
     try {
         (void)tx.GetValueOut();
     } catch (const std::runtime_error &) {
     }
     (void)tx.IsCoinBase();
     (void)tx.IsNull();
     (void)tx.ToString();
 
     (void)EncodeHexTx(tx);
     (void)GetVirtualTransactionSize(tx);
     (void)ContextualCheckTransaction(params->GetConsensus(), tx, state, 1024,
                                      1024, 0);
     (void)IsStandardTx(tx, reason);
     (void)RecursiveDynamicUsage(tx);
 
     CCoinsView coins_view;
     const CCoinsViewCache coins_view_cache(&coins_view);
     (void)AreInputsStandard(tx, coins_view_cache, STANDARD_SCRIPT_VERIFY_FLAGS);
 
     UniValue u(UniValue::VOBJ);
-    // ValueFromAmount(i) not defined when i ==
+    // Amount::operator UniValue() not defined when Amount.amount ==
     // std::numeric_limits<int64_t>::min()
     bool skip_tx_to_univ = false;
     for (const CTxOut &txout : tx.vout) {
         if (txout.nValue == std::numeric_limits<int64_t>::min() * SATOSHI) {
             skip_tx_to_univ = true;
         }
     }
     if (!skip_tx_to_univ) {
         TxToUniv(tx, /* hashBlock */ {}, u);
         static const uint256 u256_max(
             uint256S("fffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
                      "fffffff"));
         TxToUniv(tx, u256_max, u);
     }
 }
diff --git a/src/test/rpc_tests.cpp b/src/test/rpc_tests.cpp
index 95295696a..143b5a9e7 100644
--- a/src/test/rpc_tests.cpp
+++ b/src/test/rpc_tests.cpp
@@ -1,515 +1,511 @@
 // 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 <rpc/blockchain.h>
 #include <rpc/client.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 
 #include <config.h>
 #include <core_io.h>
 #include <interfaces/chain.h>
 #include <node/context.h>
 #include <util/ref.h>
 #include <util/time.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/test/unit_test.hpp>
 
 #include <univalue.h>
 
 UniValue CallRPC(const std::string &args, const util::Ref &context) {
     std::vector<std::string> vArgs;
     boost::split(vArgs, args, boost::is_any_of(" \t"));
     std::string strMethod = vArgs[0];
     vArgs.erase(vArgs.begin());
     GlobalConfig config;
     JSONRPCRequest request(context);
     request.strMethod = strMethod;
     request.params = RPCConvertValues(strMethod, vArgs);
     request.fHelp = false;
     if (RPCIsInWarmup(nullptr)) {
         SetRPCWarmupFinished();
     }
     try {
         UniValue result = tableRPC.execute(config, request);
         return result;
     } catch (const UniValue &objError) {
         throw std::runtime_error(find_value(objError, "message").get_str());
     }
 }
 
 class RPCTestingSetup : public TestingSetup {
 public:
     UniValue CallRPC(const std::string &args) {
         const util::Ref context{m_node};
         return ::CallRPC(args, context);
     }
 };
 
 BOOST_FIXTURE_TEST_SUITE(rpc_tests, RPCTestingSetup)
 
 BOOST_AUTO_TEST_CASE(rpc_rawparams) {
     // Test raw transaction API argument handling
     UniValue r;
 
     BOOST_CHECK_THROW(CallRPC("getrawtransaction"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("getrawtransaction not_hex"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("getrawtransaction "
                               "a3b807410df0b60fcb9736768df5823938b2f838694939ba"
                               "45f3c0a1bff150ed not_int"),
                       std::runtime_error);
 
     BOOST_CHECK_THROW(CallRPC("createrawtransaction"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("createrawtransaction null null"),
                       std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("createrawtransaction not_array"),
                       std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("createrawtransaction {} {}"),
                       std::runtime_error);
     BOOST_CHECK_NO_THROW(CallRPC("createrawtransaction [] {}"));
     BOOST_CHECK_THROW(CallRPC("createrawtransaction [] {} extra"),
                       std::runtime_error);
 
     BOOST_CHECK_THROW(CallRPC("decoderawtransaction"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("decoderawtransaction null"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("decoderawtransaction DEADBEEF"),
                       std::runtime_error);
     std::string rawtx =
         "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a9"
         "9ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0ef"
         "e71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b17"
         "36ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc31071"
         "1c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b383"
         "9e2bbf32d826a1e222031fd888ac00000000";
     BOOST_CHECK_NO_THROW(
         r = CallRPC(std::string("decoderawtransaction ") + rawtx));
     BOOST_CHECK_EQUAL(find_value(r.get_obj(), "size").get_int(), 193);
     BOOST_CHECK_EQUAL(find_value(r.get_obj(), "version").get_int(), 1);
     BOOST_CHECK_EQUAL(find_value(r.get_obj(), "locktime").get_int(), 0);
     BOOST_CHECK_THROW(
         r = CallRPC(std::string("decoderawtransaction ") + rawtx + " extra"),
         std::runtime_error);
 
     // Only check failure cases for sendrawtransaction, there's no network to
     // send to...
     BOOST_CHECK_THROW(CallRPC("sendrawtransaction"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("sendrawtransaction null"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("sendrawtransaction DEADBEEF"),
                       std::runtime_error);
     BOOST_CHECK_THROW(
         CallRPC(std::string("sendrawtransaction ") + rawtx + " extra"),
         std::runtime_error);
 }
 
 BOOST_AUTO_TEST_CASE(rpc_togglenetwork) {
     UniValue r;
 
     r = CallRPC("getnetworkinfo");
     bool netState = find_value(r.get_obj(), "networkactive").get_bool();
     BOOST_CHECK_EQUAL(netState, true);
 
     BOOST_CHECK_NO_THROW(CallRPC("setnetworkactive false"));
     r = CallRPC("getnetworkinfo");
     int numConnection = find_value(r.get_obj(), "connections").get_int();
     BOOST_CHECK_EQUAL(numConnection, 0);
 
     netState = find_value(r.get_obj(), "networkactive").get_bool();
     BOOST_CHECK_EQUAL(netState, false);
 
     BOOST_CHECK_NO_THROW(CallRPC("setnetworkactive true"));
     r = CallRPC("getnetworkinfo");
     netState = find_value(r.get_obj(), "networkactive").get_bool();
     BOOST_CHECK_EQUAL(netState, true);
 }
 
 BOOST_AUTO_TEST_CASE(rpc_rawsign) {
     UniValue r;
     // input is a 1-of-2 multisig (so is output):
     std::string prevout = "[{\"txid\":"
                           "\"b4cc287e58f87cdae59417329f710f3ecd75a4ee1d2872b724"
                           "8f50977c8493f3\","
                           "\"vout\":1,\"scriptPubKey\":"
                           "\"a914b10c9df5f7edf436c697f02f1efdba4cf399615187\","
                           "\"amount\":3.14159,"
                           "\"redeemScript\":"
                           "\"512103debedc17b3df2badbcdd86d5feb4562b86fe182e5998"
                           "abd8bcd4f122c6155b1b21027e940bb73ab8732bfdf7f9216ece"
                           "fca5b94d6df834e77e108f68e66f126044c052ae\"}]";
     r = CallRPC(std::string("createrawtransaction ") + prevout + " " +
                 "{\"3HqAe9LtNBjnsfM4CyYaWTnvCaUYT7v4oZ\":11}");
     std::string notsigned = r.get_str();
     std::string privkey1 =
         "\"KzsXybp9jX64P5ekX1KUxRQ79Jht9uzW7LorgwE65i5rWACL6LQe\"";
     std::string privkey2 =
         "\"Kyhdf5LuKTRx4ge69ybABsiUAWjVRK4XGxAKk2FQLp2HjGMy87Z4\"";
     r = CallRPC(std::string("signrawtransactionwithkey ") + notsigned + " [] " +
                 prevout);
     BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == false);
     r = CallRPC(std::string("signrawtransactionwithkey ") + notsigned + " [" +
                 privkey1 + "," + privkey2 + "] " + prevout);
     BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == true);
 }
 
 BOOST_AUTO_TEST_CASE(rpc_rawsign_missing_amount) {
     // Old format, missing amount parameter for prevout should generate
     // an RPC error.  This is because of new replay-protected tx's require
     // nonzero amount present in signed tx.
     // See: https://github.com/Bitcoin-ABC/bitcoin-abc/issues/63
     // (We will re-use the tx + keys from the above rpc_rawsign test for
     // simplicity.)
     UniValue r;
     std::string prevout = "[{\"txid\":"
                           "\"b4cc287e58f87cdae59417329f710f3ecd75a4ee1d2872b724"
                           "8f50977c8493f3\","
                           "\"vout\":1,\"scriptPubKey\":"
                           "\"a914b10c9df5f7edf436c697f02f1efdba4cf399615187\","
                           "\"redeemScript\":"
                           "\"512103debedc17b3df2badbcdd86d5feb4562b86fe182e5998"
                           "abd8bcd4f122c6155b1b21027e940bb73ab8732bfdf7f9216ece"
                           "fca5b94d6df834e77e108f68e66f126044c052ae\"}]";
     r = CallRPC(std::string("createrawtransaction ") + prevout + " " +
                 "{\"3HqAe9LtNBjnsfM4CyYaWTnvCaUYT7v4oZ\":11}");
     std::string notsigned = r.get_str();
     std::string privkey1 =
         "\"KzsXybp9jX64P5ekX1KUxRQ79Jht9uzW7LorgwE65i5rWACL6LQe\"";
     std::string privkey2 =
         "\"Kyhdf5LuKTRx4ge69ybABsiUAWjVRK4XGxAKk2FQLp2HjGMy87Z4\"";
 
     bool exceptionThrownDueToMissingAmount = false,
          errorWasMissingAmount = false;
 
     try {
         r = CallRPC(std::string("signrawtransactionwithkey ") + notsigned +
                     " [" + privkey1 + "," + privkey2 + "] " + prevout);
     } catch (const std::runtime_error &e) {
         exceptionThrownDueToMissingAmount = true;
         if (std::string(e.what()).find("amount") != std::string::npos) {
             errorWasMissingAmount = true;
         }
     }
     BOOST_CHECK(exceptionThrownDueToMissingAmount == true);
     BOOST_CHECK(errorWasMissingAmount == true);
 }
 
 BOOST_AUTO_TEST_CASE(rpc_createraw_op_return) {
     BOOST_CHECK_NO_THROW(
         CallRPC("createrawtransaction "
                 "[{\"txid\":"
                 "\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff1"
                 "50ed\",\"vout\":0}] {\"data\":\"68656c6c6f776f726c64\"}"));
 
     // Key not "data" (bad address)
     BOOST_CHECK_THROW(
         CallRPC("createrawtransaction "
                 "[{\"txid\":"
                 "\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff1"
                 "50ed\",\"vout\":0}] {\"somedata\":\"68656c6c6f776f726c64\"}"),
         std::runtime_error);
 
     // Bad hex encoding of data output
     BOOST_CHECK_THROW(
         CallRPC("createrawtransaction "
                 "[{\"txid\":"
                 "\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff1"
                 "50ed\",\"vout\":0}] {\"data\":\"12345\"}"),
         std::runtime_error);
     BOOST_CHECK_THROW(
         CallRPC("createrawtransaction "
                 "[{\"txid\":"
                 "\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff1"
                 "50ed\",\"vout\":0}] {\"data\":\"12345g\"}"),
         std::runtime_error);
 
     // Data 81 bytes long
     BOOST_CHECK_NO_THROW(
         CallRPC("createrawtransaction "
                 "[{\"txid\":"
                 "\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff1"
                 "50ed\",\"vout\":0}] "
                 "{\"data\":"
                 "\"010203040506070809101112131415161718192021222324252627282930"
                 "31323334353637383940414243444546474849505152535455565758596061"
                 "6263646566676869707172737475767778798081\"}"));
 }
 
 BOOST_AUTO_TEST_CASE(rpc_format_monetary_values) {
-    BOOST_CHECK(ValueFromAmount(Amount::zero()).write() == "0.00000000");
-    BOOST_CHECK(ValueFromAmount(SATOSHI).write() == "0.00000001");
-    BOOST_CHECK(ValueFromAmount(17622195 * SATOSHI).write() == "0.17622195");
-    BOOST_CHECK(ValueFromAmount(50000000 * SATOSHI).write() == "0.50000000");
-    BOOST_CHECK(ValueFromAmount(89898989 * SATOSHI).write() == "0.89898989");
-    BOOST_CHECK(ValueFromAmount(100000000 * SATOSHI).write() == "1.00000000");
-    BOOST_CHECK(ValueFromAmount(int64_t(2099999999999990) * SATOSHI).write() ==
+    BOOST_CHECK(UniValue(Amount::zero()).write() == "0.00000000");
+    BOOST_CHECK(UniValue(SATOSHI).write() == "0.00000001");
+    BOOST_CHECK(UniValue(17622195 * SATOSHI).write() == "0.17622195");
+    BOOST_CHECK(UniValue(50000000 * SATOSHI).write() == "0.50000000");
+    BOOST_CHECK(UniValue(89898989 * SATOSHI).write() == "0.89898989");
+    BOOST_CHECK(UniValue(100000000 * SATOSHI).write() == "1.00000000");
+    BOOST_CHECK(UniValue(int64_t(2099999999999990) * SATOSHI).write() ==
                 "20999999.99999990");
-    BOOST_CHECK(ValueFromAmount(int64_t(2099999999999999) * SATOSHI).write() ==
+    BOOST_CHECK(UniValue(int64_t(2099999999999999) * SATOSHI).write() ==
                 "20999999.99999999");
 
-    BOOST_CHECK_EQUAL(ValueFromAmount(Amount::zero()).write(), "0.00000000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(123456789 * (COIN / 10000)).write(),
+    BOOST_CHECK_EQUAL(UniValue(Amount::zero()).write(), "0.00000000");
+    BOOST_CHECK_EQUAL(UniValue(123456789 * (COIN / 10000)).write(),
                       "12345.67890000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(-1 * COIN).write(), "-1.00000000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(-1 * COIN / 10).write(), "-0.10000000");
-
-    BOOST_CHECK_EQUAL(ValueFromAmount(100000000 * COIN).write(),
-                      "100000000.00000000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(10000000 * COIN).write(),
-                      "10000000.00000000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(1000000 * COIN).write(),
-                      "1000000.00000000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(100000 * COIN).write(),
-                      "100000.00000000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(10000 * COIN).write(), "10000.00000000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(1000 * COIN).write(), "1000.00000000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(100 * COIN).write(), "100.00000000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(10 * COIN).write(), "10.00000000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(COIN).write(), "1.00000000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(COIN / 10).write(), "0.10000000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(COIN / 100).write(), "0.01000000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(COIN / 1000).write(), "0.00100000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(COIN / 10000).write(), "0.00010000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(COIN / 100000).write(), "0.00001000");
-    BOOST_CHECK_EQUAL(ValueFromAmount(COIN / 1000000).write(), "0.00000100");
-    BOOST_CHECK_EQUAL(ValueFromAmount(COIN / 10000000).write(), "0.00000010");
-    BOOST_CHECK_EQUAL(ValueFromAmount(COIN / 100000000).write(), "0.00000001");
+    BOOST_CHECK_EQUAL(UniValue(-1 * COIN).write(), "-1.00000000");
+    BOOST_CHECK_EQUAL(UniValue(-1 * COIN / 10).write(), "-0.10000000");
+
+    BOOST_CHECK_EQUAL(UniValue(100000000 * COIN).write(), "100000000.00000000");
+    BOOST_CHECK_EQUAL(UniValue(10000000 * COIN).write(), "10000000.00000000");
+    BOOST_CHECK_EQUAL(UniValue(1000000 * COIN).write(), "1000000.00000000");
+    BOOST_CHECK_EQUAL(UniValue(100000 * COIN).write(), "100000.00000000");
+    BOOST_CHECK_EQUAL(UniValue(10000 * COIN).write(), "10000.00000000");
+    BOOST_CHECK_EQUAL(UniValue(1000 * COIN).write(), "1000.00000000");
+    BOOST_CHECK_EQUAL(UniValue(100 * COIN).write(), "100.00000000");
+    BOOST_CHECK_EQUAL(UniValue(10 * COIN).write(), "10.00000000");
+    BOOST_CHECK_EQUAL(UniValue(COIN).write(), "1.00000000");
+    BOOST_CHECK_EQUAL(UniValue(COIN / 10).write(), "0.10000000");
+    BOOST_CHECK_EQUAL(UniValue(COIN / 100).write(), "0.01000000");
+    BOOST_CHECK_EQUAL(UniValue(COIN / 1000).write(), "0.00100000");
+    BOOST_CHECK_EQUAL(UniValue(COIN / 10000).write(), "0.00010000");
+    BOOST_CHECK_EQUAL(UniValue(COIN / 100000).write(), "0.00001000");
+    BOOST_CHECK_EQUAL(UniValue(COIN / 1000000).write(), "0.00000100");
+    BOOST_CHECK_EQUAL(UniValue(COIN / 10000000).write(), "0.00000010");
+    BOOST_CHECK_EQUAL(UniValue(COIN / 100000000).write(), "0.00000001");
 }
 
 static UniValue ValueFromString(const std::string &str) {
     UniValue value;
     BOOST_CHECK(value.setNumStr(str));
     return value;
 }
 
 BOOST_AUTO_TEST_CASE(rpc_parse_monetary_values) {
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("-0.00000001")),
                       UniValue);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0")), Amount::zero());
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.00000000")),
                       Amount::zero());
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.00000001")), SATOSHI);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.17622195")),
                       17622195 * SATOSHI);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.5")),
                       50000000 * SATOSHI);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.50000000")),
                       50000000 * SATOSHI);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.89898989")),
                       89898989 * SATOSHI);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("1.00000000")),
                       100000000 * SATOSHI);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("20999999.9999999")),
                       int64_t(2099999999999990) * SATOSHI);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("20999999.99999999")),
                       int64_t(2099999999999999) * SATOSHI);
 
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("1e-8")),
                       COIN / 100000000);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.1e-7")),
                       COIN / 100000000);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.01e-6")),
                       COIN / 100000000);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString(
                           "0."
                           "0000000000000000000000000000000000000000000000000000"
                           "000000000000000000000001e+68")),
                       COIN / 100000000);
     BOOST_CHECK_EQUAL(
         AmountFromValue(ValueFromString("10000000000000000000000000000000000000"
                                         "000000000000000000000000000e-64")),
         COIN);
     BOOST_CHECK_EQUAL(
         AmountFromValue(ValueFromString(
             "0."
             "000000000000000000000000000000000000000000000000000000000000000100"
             "000000000000000000000000000000000000000000000000000e64")),
         COIN);
 
     // should fail
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e-9")), UniValue);
     // should fail
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("0.000000019")),
                       UniValue);
     // should pass, cut trailing 0
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.00000001000000")),
                       SATOSHI);
     // should fail
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("19e-9")), UniValue);
     // should pass, leading 0 is present
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.19e-6")),
                       19 * SATOSHI);
 
     // overflow error
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("92233720368.54775808")),
                       UniValue);
     // overflow error
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e+11")), UniValue);
     // overflow error signless
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e11")), UniValue);
     // overflow error
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("93e+9")), UniValue);
 }
 
 BOOST_AUTO_TEST_CASE(json_parse_errors) {
     // Valid
     BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0").get_real(), 1.0);
     // Valid, with leading or trailing whitespace
     BOOST_CHECK_EQUAL(ParseNonRFCJSONValue(" 1.0").get_real(), 1.0);
     BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0 ").get_real(), 1.0);
 
     // should fail, missing leading 0, therefore invalid JSON
     BOOST_CHECK_THROW(AmountFromValue(ParseNonRFCJSONValue(".19e-6")),
                       std::runtime_error);
     BOOST_CHECK_EQUAL(AmountFromValue(ParseNonRFCJSONValue(
                           "0.00000000000000000000000000000000000001e+30 ")),
                       SATOSHI);
     // Invalid, initial garbage
     BOOST_CHECK_THROW(ParseNonRFCJSONValue("[1.0"), std::runtime_error);
     BOOST_CHECK_THROW(ParseNonRFCJSONValue("a1.0"), std::runtime_error);
     // Invalid, trailing garbage
     BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0sds"), std::runtime_error);
     BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0]"), std::runtime_error);
     // BCH addresses should fail parsing
     BOOST_CHECK_THROW(
         ParseNonRFCJSONValue("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"),
         std::runtime_error);
     BOOST_CHECK_THROW(ParseNonRFCJSONValue("3J98t1WpEZ73CNmQviecrnyiWrnqRhWNL"),
                       std::runtime_error);
 }
 
 BOOST_AUTO_TEST_CASE(rpc_ban) {
     BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
 
     UniValue r;
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0 add")));
     // portnumber for setban not allowed
     BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.0.0:8334")),
                       std::runtime_error);
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     UniValue ar = r.get_array();
     UniValue o1 = ar[0].get_obj();
     UniValue adr = find_value(o1, "address");
     BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/32");
     BOOST_CHECK_NO_THROW(CallRPC(std::string("setban 127.0.0.0 remove")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     BOOST_CHECK_EQUAL(ar.size(), 0UL);
 
     // Set ban way in the future: 2283-12-18 19:33:20
     BOOST_CHECK_NO_THROW(
         r = CallRPC(std::string("setban 127.0.0.0/24 add 9907731200 true")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     o1 = ar[0].get_obj();
     adr = find_value(o1, "address");
     UniValue banned_until = find_value(o1, "banned_until");
     BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/24");
     // absolute time check
     BOOST_CHECK_EQUAL(banned_until.get_int64(), 9907731200);
 
     BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
 
     BOOST_CHECK_NO_THROW(
         r = CallRPC(std::string("setban 127.0.0.0/24 add 200")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     o1 = ar[0].get_obj();
     adr = find_value(o1, "address");
     banned_until = find_value(o1, "banned_until");
     BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/24");
     int64_t now = GetTime();
     BOOST_CHECK(banned_until.get_int64() > now);
     BOOST_CHECK(banned_until.get_int64() - now <= 200);
 
     // must throw an exception because 127.0.0.1 is in already banned subnet
     // range
     BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.0.1 add")),
                       std::runtime_error);
 
     BOOST_CHECK_NO_THROW(CallRPC(std::string("setban 127.0.0.0/24 remove")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     BOOST_CHECK_EQUAL(ar.size(), 0UL);
 
     BOOST_CHECK_NO_THROW(
         r = CallRPC(std::string("setban 127.0.0.0/255.255.0.0 add")));
     BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.1.1 add")),
                       std::runtime_error);
 
     BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     BOOST_CHECK_EQUAL(ar.size(), 0UL);
 
     // invalid IP
     BOOST_CHECK_THROW(r = CallRPC(std::string("setban test add")),
                       std::runtime_error);
 
     // IPv6 tests
     BOOST_CHECK_NO_THROW(
         r = CallRPC(
             std::string("setban FE80:0000:0000:0000:0202:B3FF:FE1E:8329 add")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     o1 = ar[0].get_obj();
     adr = find_value(o1, "address");
     BOOST_CHECK_EQUAL(adr.get_str(), "fe80::202:b3ff:fe1e:8329/128");
 
     BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string(
                              "setban 2001:db8::/ffff:fffc:0:0:0:0:0:0 add")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     o1 = ar[0].get_obj();
     adr = find_value(o1, "address");
     BOOST_CHECK_EQUAL(adr.get_str(), "2001:db8::/30");
 
     BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
     BOOST_CHECK_NO_THROW(
         r = CallRPC(std::string(
             "setban 2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/128 add")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     o1 = ar[0].get_obj();
     adr = find_value(o1, "address");
     BOOST_CHECK_EQUAL(adr.get_str(),
                       "2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/128");
 }
 
 BOOST_AUTO_TEST_CASE(rpc_convert_values_generatetoaddress) {
     UniValue result;
 
     BOOST_CHECK_NO_THROW(result = RPCConvertValues(
                              "generatetoaddress",
                              {"101", "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a"}));
     BOOST_CHECK_EQUAL(result[0].get_int(), 101);
     BOOST_CHECK_EQUAL(result[1].get_str(),
                       "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a");
 
     BOOST_CHECK_NO_THROW(result = RPCConvertValues(
                              "generatetoaddress",
                              {"101", "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU"}));
     BOOST_CHECK_EQUAL(result[0].get_int(), 101);
     BOOST_CHECK_EQUAL(result[1].get_str(),
                       "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU");
 
     BOOST_CHECK_NO_THROW(result = RPCConvertValues(
                              "generatetoaddress",
                              {"1", "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a", "9"}));
     BOOST_CHECK_EQUAL(result[0].get_int(), 1);
     BOOST_CHECK_EQUAL(result[1].get_str(),
                       "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a");
     BOOST_CHECK_EQUAL(result[2].get_int(), 9);
 
     BOOST_CHECK_NO_THROW(result = RPCConvertValues(
                              "generatetoaddress",
                              {"1", "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU", "9"}));
     BOOST_CHECK_EQUAL(result[0].get_int(), 1);
     BOOST_CHECK_EQUAL(result[1].get_str(),
                       "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU");
     BOOST_CHECK_EQUAL(result[2].get_int(), 9);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index ac50433b3..62c26cabd 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -1,3357 +1,3357 @@
 // 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 <script/signingprovider.h>
 
 #include <core_io.h>
 #include <key.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 std::string 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, FormatScriptError(err) + " where " +
                                                 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 &Opcode(const opcodetype &_op) {
         DoPush();
         spendTx.vin[0].scriptSig << _op;
         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));
+            amount.push_back(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)
                         .Opcode(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)
             .Opcode(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)
             .Opcode(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)
             .Opcode(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)
             .Opcode(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)
             .Opcode(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
     FillableSigningProvider 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());
         BOOST_CHECK(keystore.AddKey(key));
     }
 
     CMutableTransaction txFrom = BuildCreditingTransaction(
         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:
     BOOST_CHECK(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:
     BOOST_CHECK(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;
     BOOST_CHECK(keystore.AddCScript(pkSingle));
     scriptPubKey = GetScriptForDestination(ScriptHash(pkSingle));
     BOOST_CHECK(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;
     BOOST_CHECK(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);
     BOOST_CHECK(keystore.AddCScript(scriptPubKey));
     BOOST_CHECK(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());
 }
 
 #if defined(HAVE_CONSENSUS_LIB)
 
 /* Test simple (successful) usage of bitcoinconsensus_verify_script */
 BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_returns_true) {
     unsigned int libconsensus_flags = 0;
     int nIn = 0;
 
     CScript scriptPubKey;
     CScript scriptSig;
 
     scriptPubKey << OP_1;
     const CTransaction creditTx(
         BuildCreditingTransaction(scriptPubKey, SATOSHI));
     const CTransaction spendTx(BuildSpendingTransaction(scriptSig, creditTx));
 
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << spendTx;
 
     bitcoinconsensus_error err;
     int result = bitcoinconsensus_verify_script(
         scriptPubKey.data(), scriptPubKey.size(), (const uint8_t *)&stream[0],
         stream.size(), nIn, libconsensus_flags, &err);
     BOOST_CHECK_EQUAL(result, 1);
     BOOST_CHECK_EQUAL(err, bitcoinconsensus_ERR_OK);
 }
 
 /* Test bitcoinconsensus_verify_script returns invalid tx index err*/
 BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_tx_index_err) {
     unsigned int libconsensus_flags = 0;
     int nIn = 3;
 
     CScript scriptPubKey;
     CScript scriptSig;
 
     scriptPubKey << OP_EQUAL;
     const CTransaction creditTx(
         BuildCreditingTransaction(scriptPubKey, SATOSHI));
     const CTransaction spendTx(BuildSpendingTransaction(scriptSig, creditTx));
 
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << spendTx;
 
     bitcoinconsensus_error err;
     int result = bitcoinconsensus_verify_script(
         scriptPubKey.data(), scriptPubKey.size(), (const uint8_t *)&stream[0],
         stream.size(), nIn, libconsensus_flags, &err);
     BOOST_CHECK_EQUAL(result, 0);
     BOOST_CHECK_EQUAL(err, bitcoinconsensus_ERR_TX_INDEX);
 }
 
 /* Test bitcoinconsensus_verify_script returns tx size mismatch err*/
 BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_tx_size) {
     unsigned int libconsensus_flags = 0;
     int nIn = 0;
 
     CScript scriptPubKey;
     CScript scriptSig;
 
     scriptPubKey << OP_EQUAL;
     const CTransaction creditTx(
         BuildCreditingTransaction(scriptPubKey, SATOSHI));
     const CTransaction spendTx(BuildSpendingTransaction(scriptSig, creditTx));
 
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << spendTx;
 
     bitcoinconsensus_error err;
     int result = bitcoinconsensus_verify_script(
         scriptPubKey.data(), scriptPubKey.size(), (const uint8_t *)&stream[0],
         stream.size() * 2, nIn, libconsensus_flags, &err);
     BOOST_CHECK_EQUAL(result, 0);
     BOOST_CHECK_EQUAL(err, bitcoinconsensus_ERR_TX_SIZE_MISMATCH);
 }
 
 /* Test bitcoinconsensus_verify_script returns invalid tx serialization error */
 BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_tx_serialization) {
     unsigned int libconsensus_flags = 0;
     int nIn = 0;
 
     CScript scriptPubKey;
     CScript scriptSig;
 
     scriptPubKey << OP_EQUAL;
     const CTransaction creditTx(
         BuildCreditingTransaction(scriptPubKey, SATOSHI));
     const CTransaction spendTx(BuildSpendingTransaction(scriptSig, creditTx));
 
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << 0xffffffff;
 
     bitcoinconsensus_error err;
     int result = bitcoinconsensus_verify_script(
         scriptPubKey.data(), scriptPubKey.size(), (const uint8_t *)&stream[0],
         stream.size(), nIn, libconsensus_flags, &err);
     BOOST_CHECK_EQUAL(result, 0);
     BOOST_CHECK_EQUAL(err, bitcoinconsensus_ERR_TX_DESERIALIZE);
 }
 
 /* Test bitcoinconsensus_verify_script returns amount required error */
 BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_amount_required_err) {
     unsigned int libconsensus_flags =
         bitcoinconsensus_SCRIPT_ENABLE_SIGHASH_FORKID;
     int nIn = 0;
 
     CScript scriptPubKey;
     CScript scriptSig;
 
     scriptPubKey << OP_EQUAL;
     const CTransaction creditTx(
         BuildCreditingTransaction(scriptPubKey, SATOSHI));
     const CTransaction spendTx(BuildSpendingTransaction(scriptSig, creditTx));
 
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << spendTx;
 
     bitcoinconsensus_error err;
     int result = bitcoinconsensus_verify_script(
         scriptPubKey.data(), scriptPubKey.size(), (const uint8_t *)&stream[0],
         stream.size(), nIn, libconsensus_flags, &err);
     BOOST_CHECK_EQUAL(result, 0);
     BOOST_CHECK_EQUAL(err, bitcoinconsensus_ERR_AMOUNT_REQUIRED);
 }
 
 /* Test bitcoinconsensus_verify_script returns invalid flags err */
 BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_invalid_flags) {
     unsigned int libconsensus_flags = 1 << 3;
     int nIn = 0;
 
     CScript scriptPubKey;
     CScript scriptSig;
 
     scriptPubKey << OP_EQUAL;
     const CTransaction creditTx(
         BuildCreditingTransaction(scriptPubKey, SATOSHI));
     const CTransaction spendTx(BuildSpendingTransaction(scriptSig, creditTx));
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << spendTx;
 
     bitcoinconsensus_error err;
     int result = bitcoinconsensus_verify_script(
         scriptPubKey.data(), scriptPubKey.size(), (const uint8_t *)&stream[0],
         stream.size(), nIn, libconsensus_flags, &err);
     BOOST_CHECK_EQUAL(result, 0);
     BOOST_CHECK_EQUAL(err, bitcoinconsensus_ERR_INVALID_FLAGS);
 }
 
 #endif
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/util/moneystr.h b/src/util/moneystr.h
index e8e134a7b..c063aff74 100644
--- a/src/util/moneystr.h
+++ b/src/util/moneystr.h
@@ -1,28 +1,28 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 /**
  * Money parsing/formatting utilities.
  */
 #ifndef BITCOIN_UTIL_MONEYSTR_H
 #define BITCOIN_UTIL_MONEYSTR_H
 
 #include <amount.h>
 #include <attributes.h>
 
 #include <string>
 
 /**
  * Do not use these functions to represent or parse monetary amounts to or from
- * JSON but use AmountFromValue and ValueFromAmount for that.
+ * JSON but use AmountFromValue and the Amount::operator UniValue() for that.
  */
 std::string FormatMoney(const Amount n);
 /**
  * Parse an amount denoted in full coins. E.g. "0.0034" supplied on the command
  * line.
  **/
 NODISCARD bool ParseMoney(const std::string &str, Amount &nRet);
 
 #endif // BITCOIN_UTIL_MONEYSTR_H
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index d96ecebcc..6e1d2b8ce 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -1,2331 +1,2331 @@
 // 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 <cstdint>
 #include <tuple>
 
 using interfaces::FoundBlock;
 
 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(Span<const uint8_t>(&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, LegacyScriptPubKeyMan *spk_man,
                          const CWallet *const pwallet, const CKeyID &keyid,
                          std::string &strAddr, std::string &strLabel)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     bool fLabelFound = false;
     CKey key;
     spk_man->GetKey(keyid, key);
     for (const auto &dest : GetAllDestinationsForKey(key.GetPubKey())) {
         const auto *address_book_entry = pwallet->FindAddressBookEntry(dest);
         if (address_book_entry) {
             if (!strAddr.empty()) {
                 strAddr += ",";
             }
             strAddr += EncodeDestination(dest, config);
             strLabel = EncodeDumpString(address_book_entry->GetLabel());
             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) {
     RPCHelpMan{
         "importprivkey",
         "Adds 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"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\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"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         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")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Cannot import private keys to a wallet with "
                            "private keys disabled");
     }
 
     EnsureLegacyScriptPubKeyMan(*wallet, true);
 
     WalletRescanReserver reserver(*pwallet);
     bool fRescan = true;
     {
         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().havePruned()) {
             // Exit early and print an error.
             // If a block is pruned after this check, we will import the key(s),
             // but fail the rescan with a generic error.
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Rescan is disabled when blocks are pruned");
         }
 
         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();
         CHECK_NONFATAL(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->FindAddressBookEntry(dest)) {
                     pwallet->SetAddressBook(dest, strLabel, "receive");
                 }
             }
 
             // Use timestamp of 1 to scan the whole chain
             if (!pwallet->ImportPrivKeys({{vchAddress, key}}, 1)) {
                 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) {
     RPCHelpMan{
         "abortrescan",
         "Stops current wallet rescan triggered by an RPC call, e.g. by an "
         "importprivkey call.\n"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\n",
         {},
         RPCResult{RPCResult::Type::BOOL, "",
                   "Whether the abort was successful"},
         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", "")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     if (!pwallet->IsScanning() || pwallet->IsAbortingRescan()) {
         return false;
     }
     pwallet->AbortRescan();
     return true;
 }
 
 UniValue importaddress(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "importaddress",
         "Adds 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"
         "Hint: use importmulti to import more than one address.\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"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\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"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         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")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     EnsureLegacyScriptPubKeyMan(*pwallet, true);
 
     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().havePruned()) {
         // Exit early and print an error.
         // If a block is pruned after this check, we will import the key(s),
         // but fail the rescan with a generic error.
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Rescan is disabled when blocks are pruned");
     }
 
     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();
     }
 
     {
         LOCK(pwallet->cs_wallet);
 
         CTxDestination dest = DecodeDestination(request.params[0].get_str(),
                                                 wallet->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");
             }
 
             pwallet->MarkDirty();
 
             pwallet->ImportScriptPubKeys(
                 strLabel, {GetScriptForDestination(dest)},
                 false /* have_solving_data */, true /* apply_label */,
                 1 /* timestamp */);
         } else if (IsHex(request.params[0].get_str())) {
             std::vector<uint8_t> data(ParseHex(request.params[0].get_str()));
             CScript redeem_script(data.begin(), data.end());
 
             std::set<CScript> scripts = {redeem_script};
             pwallet->ImportScripts(scripts, 0 /* timestamp */);
 
             if (fP2SH) {
                 scripts.insert(
                     GetScriptForDestination(ScriptHash(redeem_script)));
             }
 
             pwallet->ImportScriptPubKeys(
                 strLabel, scripts, false /* have_solving_data */,
                 true /* apply_label */, 1 /* timestamp */);
         } else {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid Bitcoin address or script");
         }
     }
     if (fRescan) {
         RescanWallet(*pwallet, reserver);
         {
             LOCK(pwallet->cs_wallet);
             pwallet->ReacceptWalletTransactions();
         }
     }
 
     return NullUniValue;
 }
 
 UniValue importprunedfunds(const Config &config,
                            const JSONRPCRequest &request) {
     RPCHelpMan{
         "importprunedfunds",
         "Imports funds without rescan. Corresponding address or script must "
         "previously be included in wallet. Aimed towards pruned wallets. The "
         "end-user is responsible to import additional transactions that "
         "subsequently spend the imported outputs or rescan after the point in "
         "the blockchain the transaction is included.\n",
         {
             {"rawtransaction", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "A raw transaction in hex funding an already-existing address in "
              "wallet"},
             {"txoutproof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hex output from gettxoutproof that contains the transaction"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{""},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     CMutableTransaction tx;
     if (!DecodeHexTx(tx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
     uint256 txid = tx.GetId();
 
     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;
     if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) !=
         merkleBlock.header.hashMerkleRoot) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Something wrong with merkleblock");
     }
 
     LOCK(pwallet->cs_wallet);
     int height;
     if (!pwallet->chain().findAncestorByHash(pwallet->GetLastBlockHash(),
                                              merkleBlock.header.GetHash(),
                                              FoundBlock().height(height))) {
         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");
     }
 
     size_t txnIndex = vIndex[it - vMatch.begin()];
 
     CWalletTx::Confirmation confirm(CWalletTx::Status::CONFIRMED, height,
                                     merkleBlock.header.GetHash(), txnIndex);
 
     CTransactionRef tx_ref = MakeTransactionRef(tx);
     if (pwallet->IsMine(*tx_ref)) {
         pwallet->AddToWallet(std::move(tx_ref), confirm);
         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) {
     RPCHelpMan{
         "removeprunedfunds",
         "Deletes the specified transaction from the wallet. Meant for use "
         "with pruned wallets and as a companion to importprunedfunds. This "
         "will affect wallet balances.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hex-encoded id of the transaction you are deleting"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("removeprunedfunds",
                                    "\"a8d0c0184dde994a09ec054286f1ce581bebf4644"
                                    "6a512166eae7628734ea0a5\"") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc("removeprunedfunds",
                                    "\"a8d0c0184dde994a09ec054286f1ce581bebf4644"
                                    "6a512166eae7628734ea0a5\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     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) {
     RPCHelpMan{
         "importpubkey",
         "Adds 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"
         "Hint: use importmulti to import more than one public 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 pubkey exists but related transactions "
         "are still missing, leading to temporarily incorrect/bogus balances "
         "and unspent outputs until rescan completes.\n"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\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"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         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")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     EnsureLegacyScriptPubKeyMan(*wallet, true);
 
     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().havePruned()) {
         // Exit early and print an error.
         // If a block is pruned after this check, we will import the key(s),
         // but fail the rescan with a generic error.
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Rescan is disabled when blocks are pruned");
     }
 
     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");
     }
 
     {
         LOCK(pwallet->cs_wallet);
 
         std::set<CScript> script_pub_keys;
         for (const auto &dest : GetAllDestinationsForKey(pubKey)) {
             script_pub_keys.insert(GetScriptForDestination(dest));
         }
 
         pwallet->MarkDirty();
 
         pwallet->ImportScriptPubKeys(strLabel, script_pub_keys,
                                      true /* have_solving_data */,
                                      true /* apply_label */, 1 /* timestamp */);
 
         pwallet->ImportPubKeys({pubKey.GetID()}, {{pubKey.GetID(), pubKey}},
                                {} /* key_origins */, false /* add_keypool */,
                                false /* internal */, 1 /* timestamp */);
     }
     if (fRescan) {
         RescanWallet(*pwallet, reserver);
         {
             LOCK(pwallet->cs_wallet);
             pwallet->ReacceptWalletTransactions();
         }
     }
 
     return NullUniValue;
 }
 
 UniValue importwallet(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "importwallet",
         "Imports keys from a wallet dump file (see dumpwallet). Requires a "
         "new wallet backup to include imported keys.\n"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\n",
         {
             {"filename", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The wallet file"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         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\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     EnsureLegacyScriptPubKeyMan(*wallet, true);
 
     if (pwallet->chain().havePruned()) {
         // Exit early and print an error.
         // If a block is pruned after this check, we will import the key(s),
         // but fail the rescan with a generic error.
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Importing wallets is disabled when blocks are pruned");
     }
 
     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;
     {
         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");
         }
         CHECK_NONFATAL(pwallet->chain().findBlock(
             pwallet->GetLastBlockHash(), FoundBlock().time(nTimeBegin)));
 
         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();
             CHECK_NONFATAL(key.VerifyPubKey(pubkey));
             CKeyID keyid = pubkey.GetID();
 
             pwallet->WalletLogPrintf("Importing %s...\n",
                                      EncodeDestination(PKHash(keyid), config));
 
             if (!pwallet->ImportPrivKeys({{keyid, key}}, time)) {
                 pwallet->WalletLogPrintf(
                     "Error importing key for %s\n",
                     EncodeDestination(PKHash(keyid), config));
                 fGood = false;
                 continue;
             }
 
             if (has_label) {
                 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;
 
             if (!pwallet->ImportScripts({script}, time)) {
                 pwallet->WalletLogPrintf("Error importing script %s\n",
                                          HexStr(script));
                 fGood = false;
                 continue;
             }
             if (time > 0) {
                 nTimeBegin = std::min(nTimeBegin, time);
             }
 
             progress++;
         }
 
         // hide progress dialog in GUI
         pwallet->chain().showProgress("", 100, false);
     }
     // 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) {
     RPCHelpMan{
         "dumpprivkey",
         "Reveals 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{RPCResult::Type::STR, "key", "The private key"},
         RPCExamples{HelpExampleCli("dumpprivkey", "\"myaddress\"") +
                     HelpExampleCli("importprivkey", "\"mykey\"") +
                     HelpExampleRpc("dumpprivkey", "\"myaddress\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     LegacyScriptPubKeyMan &spk_man = EnsureLegacyScriptPubKeyMan(*wallet);
 
     LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);
 
     EnsureWalletIsUnlocked(pwallet);
 
     std::string strAddress = request.params[0].get_str();
     CTxDestination dest =
         DecodeDestination(strAddress, wallet->GetChainParams());
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid Bitcoin address");
     }
     auto keyid = GetKeyForDestination(spk_man, dest);
     if (keyid.IsNull()) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to a key");
     }
     CKey vchSecret;
     if (!spk_man.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) {
     RPCHelpMan{
         "dumpwallet",
         "Dumps 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 (absolute path recommended)"},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "filename",
                        "The filename with full absolute path"},
                   }},
         RPCExamples{HelpExampleCli("dumpwallet", "\"test\"") +
                     HelpExampleRpc("dumpwallet", "\"test\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const pwallet =
         GetWalletForJSONRPCRequest(request);
     if (!pwallet) {
         return NullUniValue;
     }
 
     CWallet &wallet = *pwallet;
     LegacyScriptPubKeyMan &spk_man = EnsureLegacyScriptPubKeyMan(wallet);
 
     // 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
     wallet.BlockUntilSyncedToCurrentChain();
 
     LOCK2(wallet.cs_wallet, spk_man.cs_KeyStore);
 
     EnsureWalletIsUnlocked(&wallet);
 
     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<CKeyID, int64_t> mapKeyBirth;
     const std::map<CKeyID, int64_t> &mapKeyPool = spk_man.GetAllReserveKeys();
     wallet.GetKeyBirthTimes(mapKeyBirth);
 
     std::set<CScriptID> scripts = spk_man.GetCScripts();
 
     // sort time/key pairs
     std::vector<std::pair<int64_t, CKeyID>> vKeyBirth;
     for (const auto &entry : mapKeyBirth) {
         vKeyBirth.push_back(std::make_pair(entry.second, entry.first));
     }
     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()));
     file << strprintf("# * Best block at time of backup was %i (%s),\n",
                       wallet.GetLastBlockHeight(),
                       wallet.GetLastBlockHash().ToString());
     int64_t block_time = 0;
     CHECK_NONFATAL(wallet.chain().findBlock(wallet.GetLastBlockHash(),
                                             FoundBlock().time(block_time)));
     file << strprintf("#   mined on %s\n", FormatISO8601DateTime(block_time));
     file << "\n";
 
     // add the base58check encoded extended master if the wallet uses HD
     CKeyID seed_id = spk_man.GetHDChain().seed_id;
     if (!seed_id.IsNull()) {
         CKey seed;
         if (spk_man.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 (spk_man.GetKey(keyid, key)) {
             file << strprintf("%s %s ", EncodeSecret(key), strTime);
             if (GetWalletAddressesForKey(config, &spk_man, &wallet, 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 (spk_man.mapKeyMetadata[keyid].hdKeypath == "s") {
                 file << "inactivehdseed=1";
             } else {
                 file << "change=1";
             }
             file << strprintf(
                 " # addr=%s%s\n", strAddr,
                 (spk_man.mapKeyMetadata[keyid].has_key_origin
                      ? " hdkeypath=" +
                            WriteHDKeypath(
                                spk_man.mapKeyMetadata[keyid].key_origin.path)
                      : ""));
         }
     }
     file << "\n";
     for (const CScriptID &scriptid : scripts) {
         CScript script;
         std::string create_time = "0";
         std::string address = EncodeDestination(ScriptHash(scriptid), config);
         // get birth times for scripts with metadata
         auto it = spk_man.m_script_metadata.find(scriptid);
         if (it != spk_man.m_script_metadata.end()) {
             create_time = FormatISO8601DateTime(it->second.nCreateTime);
         }
         if (spk_man.GetCScript(scriptid, script)) {
             file << strprintf("%s %s script=1", HexStr(script), 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;
 }
 
 static UniValue dumpcoins(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "dumpcoins",
         "dump all the UTXO tracked by the wallet.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ_DYN,
             "",
             "",
             {{
                 RPCResult::Type::ARR,
                 "address",
                 "The list of UTXO corresponding to this address.",
                 {{
                     RPCResult::Type::OBJ,
                     "",
                     "",
                     {
                         {RPCResult::Type::STR_HEX, "txid",
                          "The transaction id"},
                         {RPCResult::Type::NUM, "vout", "The output number"},
                         {RPCResult::Type::NUM, "depth", "The output's depth"},
                         {RPCResult::Type::STR_AMOUNT, "value",
                          "The output's amount"},
                     },
                 }},
             }},
         },
         RPCExamples{HelpExampleCli("dumpcoins", "") +
                     HelpExampleRpc("dumpcoins", "")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const pwallet =
         GetWalletForJSONRPCRequest(request);
     if (!pwallet) {
         return NullUniValue;
     }
 
     CWallet &wallet = *pwallet;
 
     // 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
     wallet.BlockUntilSyncedToCurrentChain();
 
     LOCK(wallet.cs_wallet);
 
     EnsureWalletIsUnlocked(&wallet);
 
     UniValue result(UniValue::VOBJ);
     for (const auto &p : wallet.ListCoins()) {
         UniValue coins(UniValue::VARR);
         for (const auto &o : p.second) {
             UniValue utxo(UniValue::VOBJ);
             utxo.pushKV("txid", o.tx->GetId().ToString());
             utxo.pushKV("vout", o.i);
             utxo.pushKV("depth", o.nDepth);
-            utxo.pushKV("value", ValueFromAmount(o.tx->tx->vout[o.i].nValue));
+            utxo.pushKV("value", o.tx->tx->vout[o.i].nValue);
 
             coins.push_back(std::move(utxo));
         }
 
         result.pushKV(EncodeDestination(p.first, config), coins);
     }
 
     return result;
 }
 
 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;
     TxoutType script_type = Solver(script, solverdata);
 
     switch (script_type) {
         case TxoutType::PUBKEY: {
             CPubKey pubkey(solverdata[0].begin(), solverdata[0].end());
             import_data.used_keys.emplace(pubkey.GetID(), false);
             return "";
         }
         case TxoutType::PUBKEYHASH: {
             CKeyID id = CKeyID(uint160(solverdata[0]));
             import_data.used_keys[id] = true;
             return "";
         }
         case TxoutType::SCRIPTHASH: {
             if (script_ctx == ScriptContext::P2SH) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Trying to nest P2SH inside another P2SH");
             }
             CHECK_NONFATAL(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 TxoutType::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 TxoutType::NULL_DATA:
             return "unspendable script";
         case TxoutType::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->GetChainParams());
         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;
     std::string error;
     auto parsed_desc =
         Parse(descriptor, keys, error, /* require_checksum = */ true);
     if (!parsed_desc) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
     }
 
     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");
         }
         std::tie(range_start, range_end) = ParseDescriptorRange(data["range"]);
     }
 
     const UniValue &priv_keys =
         data.exists("keys") ? data["keys"].get_array() : UniValue();
 
     // Expand all descriptors to get public keys and scripts, and private keys
     // if available.
     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);
         }
 
         parsed_desc->ExpandPrivate(i, keys, out_keys);
 
         std::copy(out_keys.pubkeys.begin(), out_keys.pubkeys.end(),
                   std::inserter(pubkey_map, pubkey_map.end()));
         std::copy(out_keys.keys.begin(), out_keys.keys.end(),
                   std::inserter(privkey_map, privkey_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 (pwallet->IsMine(script) & ISMINE_SPENDABLE) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "The wallet already contains the private "
                                    "key for this address or script (\"" +
                                        HexStr(script) + "\")");
             }
         }
 
         // All good, time to import
         pwallet->MarkDirty();
         if (!pwallet->ImportScripts(import_data.import_scripts, timestamp)) {
             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) {
     RPCHelpMan{
         "importmulti",
         "\nImport addresses/scripts (with private or public keys, redeem "
         "script (P2SH)), optionally rescanning the blockchain from the "
         "earliest creation time of the imported scripts. Requires a new wallet "
         "backup.\n"
         "If an address/script is imported without all of the private keys "
         "required to spend from that address, it will be watchonly. The "
         "'watchonly' option must be set to true in this case or a warning will "
         "be returned.\n"
         "Conversely, if all the private keys are provided and the "
         "address/script is spendable, the watchonly option must be set to "
         "false, or a warning will be returned.\n"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\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 expressed in " +
                               UNIX_EPOCH_TIME +
                               ",\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::RANGE,
                           RPCArg::Optional::OMITTED,
                           "If a ranged descriptor is used, this specifies the "
                           "end or the range (in the form [begin,end]) to "
                           "import"},
                          {"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 watchonly."},
                          {"label", RPCArg::Type::STR, /* default */ "''",
                           "Label to assign to the address, only allowed with "
                           "internal=false"},
                          {"keypool", RPCArg::Type::BOOL, /* default */ "false",
                           "Stating whether imported public keys should be "
                           "added to the keypool for when users request new "
                           "addresses. Only allowed when wallet private keys "
                           "are disabled"},
                      },
                  },
              },
              "\"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{RPCResult::Type::ARR,
                   "",
                   "Response is an array with the same size as the input that "
                   "has the execution result",
                   {
                       {RPCResult::Type::OBJ,
                        "",
                        "",
                        {
                            {RPCResult::Type::BOOL, "success", ""},
                            {RPCResult::Type::ARR,
                             "warnings",
                             /* optional */ true,
                             "",
                             {
                                 {RPCResult::Type::STR, "", ""},
                             }},
                            {RPCResult::Type::OBJ,
                             "error",
                             /* optional */ true,
                             "",
                             {
                                 {RPCResult::Type::ELISION, "", "JSONRPC error"},
                             }},
                        }},
                   }},
         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}'")
 
         },
     }
         .Check(mainRequest);
 
     std::shared_ptr<CWallet> const wallet =
         GetWalletForJSONRPCRequest(mainRequest);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     RPCTypeCheck(mainRequest.params, {UniValue::VARR, UniValue::VOBJ});
 
     EnsureLegacyScriptPubKeyMan(*wallet, true);
 
     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);
     {
         LOCK(pwallet->cs_wallet);
         EnsureWalletIsUnlocked(pwallet);
 
         // Verify all timestamps are present before importing any keys.
         CHECK_NONFATAL(pwallet->chain().findBlock(
             pwallet->GetLastBlockHash(),
             FoundBlock().time(nLowestTimestamp).mtpTime(now)));
         for (const UniValue &data : requests.getValues()) {
             GetImportTimestamp(data, now);
         }
 
         const int64_t minimumTimestamp = 1;
 
         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 */);
         {
             LOCK(pwallet->cs_wallet);
             pwallet->ReacceptWalletTransactions();
         }
 
         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;
 }
 
 static UniValue ProcessDescriptorImport(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 {
         if (!data.exists("desc")) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Descriptor not found.");
         }
 
         const std::string &descriptor = data["desc"].get_str();
         const bool active =
             data.exists("active") ? data["active"].get_bool() : false;
         const bool internal =
             data.exists("internal") ? data["internal"].get_bool() : false;
         const std::string &label =
             data.exists("label") ? data["label"].get_str() : "";
 
         // Parse descriptor string
         FlatSigningProvider keys;
         std::string error;
         auto parsed_desc =
             Parse(descriptor, keys, error, /* require_checksum = */ true);
         if (!parsed_desc) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
         }
 
         // Range check
         int64_t range_start = 0, range_end = 1, next_index = 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")) {
                 auto range = ParseDescriptorRange(data["range"]);
                 range_start = range.first;
                 // Specified range end is inclusive, but we need range end as
                 // exclusive
                 range_end = range.second + 1;
             } else {
                 warnings.push_back(
                     "Range not given, using default keypool range");
                 range_start = 0;
                 range_end = gArgs.GetArg("-keypool", DEFAULT_KEYPOOL_SIZE);
             }
             next_index = range_start;
 
             if (data.exists("next_index")) {
                 next_index = data["next_index"].get_int64();
                 // bound checks
                 if (next_index < range_start || next_index >= range_end) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "next_index is out of range");
                 }
             }
         }
 
         // Active descriptors must be ranged
         if (active && !parsed_desc->IsRange()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Active descriptors must be ranged");
         }
 
         // Ranged descriptors should not have a label
         if (data.exists("range") && data.exists("label")) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Ranged descriptors should not have a label");
         }
 
         // Internal addresses should not have a label either
         if (internal && data.exists("label")) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Internal addresses should not have a label");
         }
 
         // Combo descriptor check
         if (active && !parsed_desc->IsSingleType()) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Combo descriptors cannot be set to active");
         }
 
         // If the wallet disabled private keys, abort if private keys exist
         if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
             !keys.keys.empty()) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Cannot import private keys to a wallet with "
                                "private keys disabled");
         }
 
         // Need to ExpandPrivate to check if private keys are available for all
         // pubkeys
         FlatSigningProvider expand_keys;
         std::vector<CScript> scripts;
         parsed_desc->Expand(0, keys, scripts, expand_keys);
         parsed_desc->ExpandPrivate(0, keys, expand_keys);
 
         // Check if all private keys are provided
         bool have_all_privkeys = !expand_keys.keys.empty();
         for (const auto &entry : expand_keys.origins) {
             const CKeyID &key_id = entry.first;
             CKey key;
             if (!expand_keys.GetKey(key_id, key)) {
                 have_all_privkeys = false;
                 break;
             }
         }
 
         // If private keys are enabled, check some things.
         if (!pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
             if (keys.keys.empty()) {
                 throw JSONRPCError(
                     RPC_WALLET_ERROR,
                     "Cannot import descriptor without private keys to a wallet "
                     "with private keys enabled");
             }
             if (!have_all_privkeys) {
                 warnings.push_back(
                     "Not all private keys provided. Some wallet functionality "
                     "may return unexpected errors");
             }
         }
 
         WalletDescriptor w_desc(std::move(parsed_desc), timestamp, range_start,
                                 range_end, next_index);
 
         // Check if the wallet already contains the descriptor
         auto existing_spk_manager =
             pwallet->GetDescriptorScriptPubKeyMan(w_desc);
         if (existing_spk_manager) {
             LOCK(existing_spk_manager->cs_desc_man);
             if (range_start >
                 existing_spk_manager->GetWalletDescriptor().range_start) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMS,
                     strprintf(
                         "range_start can only decrease; current range = "
                         "[%d,%d]",
                         existing_spk_manager->GetWalletDescriptor().range_start,
                         existing_spk_manager->GetWalletDescriptor().range_end));
             }
         }
 
         // Add descriptor to the wallet
         auto spk_manager = pwallet->AddWalletDescriptor(w_desc, keys, label);
         if (spk_manager == nullptr) {
             throw JSONRPCError(
                 RPC_WALLET_ERROR,
                 strprintf("Could not add descriptor '%s'", descriptor));
         }
 
         // Set descriptor as active if necessary
         if (active) {
             if (!w_desc.descriptor->GetOutputType()) {
                 warnings.push_back(
                     "Unknown output type, cannot set descriptor to active.");
             } else {
                 pwallet->SetActiveScriptPubKeyMan(
                     spk_manager->GetID(), *w_desc.descriptor->GetOutputType(),
                     internal);
             }
         }
 
         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;
 }
 
 UniValue importdescriptors(const Config &config,
                            const JSONRPCRequest &main_request) {
     RPCHelpMan{
         "importdescriptors",
         "\nImport descriptors. This will trigger a rescan of the blockchain "
         "based on the earliest timestamp of all descriptors being imported. "
         "Requires a new wallet backup.\n"
         "\nNote: This call can take over an hour to complete if using an early "
         "timestamp; during that time, other rpc calls\n"
         "may report that the imported keys, addresses or scripts exist but "
         "related transactions are still missing.\n",
         {
             {"requests",
              RPCArg::Type::ARR,
              RPCArg::Optional::NO,
              "Data to be imported",
              {
                  {
                      "",
                      RPCArg::Type::OBJ,
                      RPCArg::Optional::OMITTED,
                      "",
                      {
                          {"desc", RPCArg::Type::STR, RPCArg::Optional::NO,
                           "Descriptor to import."},
                          {"active", RPCArg::Type::BOOL, /* default */ "false",
                           "Set this descriptor to be the active descriptor for "
                           "the corresponding output type/externality"},
                          {"range", RPCArg::Type::RANGE,
                           RPCArg::Optional::OMITTED,
                           "If a ranged descriptor is used, this specifies the "
                           "end or the range (in the form [begin,end]) to "
                           "import"},
                          {"next_index", RPCArg::Type::NUM,
                           RPCArg::Optional::OMITTED,
                           "If a ranged descriptor is set to active, this "
                           "specifies the next index to generate addresses "
                           "from"},
                          {"timestamp",
                           RPCArg::Type::NUM,
                           RPCArg::Optional::NO,
                           "Time from which to start rescanning the blockchain "
                           "for this descriptor, in " +
                               UNIX_EPOCH_TIME +
                               "\n"
                               "                                                "
                               "              Use the string \"now\" to "
                               "substitute the current synced blockchain time.\n"
                               "                                                "
                               "              \"now\" can be specified to "
                               "bypass scanning, for outputs 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 timestamp\n"
                               "                                                "
                               "              of all descriptors being imported "
                               "will be scanned.",
                           /* oneline_description */ "",
                           {"timestamp | \"now\"", "integer / string"}},
                          {"internal", RPCArg::Type::BOOL, /* default */ "false",
                           "Whether matching outputs should be treated as not "
                           "incoming payments (e.g. change)"},
                          {"label", RPCArg::Type::STR, /* default */ "''",
                           "Label to assign to the address, only allowed with "
                           "internal=false"},
                      },
                  },
              },
              "\"requests\""},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "Response is an array with the same size as the input that "
                   "has the execution result",
                   {
                       {RPCResult::Type::OBJ,
                        "",
                        "",
                        {
                            {RPCResult::Type::BOOL, "success", ""},
                            {RPCResult::Type::ARR,
                             "warnings",
                             /* optional */ true,
                             "",
                             {
                                 {RPCResult::Type::STR, "", ""},
                             }},
                            {RPCResult::Type::OBJ,
                             "error",
                             /* optional */ true,
                             "",
                             {
                                 {RPCResult::Type::ELISION, "", "JSONRPC error"},
                             }},
                        }},
                   }},
         RPCExamples{
             HelpExampleCli("importdescriptors",
                            "'[{ \"desc\": \"<my descriptor>\", "
                            "\"timestamp\":1455191478, \"internal\": true }, "
                            "{ \"desc\": \"<my desccriptor 2>\", \"label\": "
                            "\"example 2\", \"timestamp\": 1455191480 }]'") +
             HelpExampleCli(
                 "importdescriptors",
                 "'[{ \"desc\": \"<my descriptor>\", \"timestamp\":1455191478, "
                 "\"active\": true, \"range\": [0,100], \"label\": \"<my "
                 "cashaddr wallet>\" }]'")},
     }
         .Check(main_request);
 
     std::shared_ptr<CWallet> const wallet =
         GetWalletForJSONRPCRequest(main_request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     //  Make sure wallet is a descriptor wallet
     if (!pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "importdescriptors is not available for non-descriptor wallets");
     }
 
     RPCTypeCheck(main_request.params, {UniValue::VARR, UniValue::VOBJ});
 
     WalletRescanReserver reserver(*pwallet);
     if (!reserver.reserve()) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Wallet is currently rescanning. Abort existing rescan or wait.");
     }
 
     const UniValue &requests = main_request.params[0];
     const int64_t minimum_timestamp = 1;
     int64_t now = 0;
     int64_t lowest_timestamp = 0;
     bool rescan = false;
     UniValue response(UniValue::VARR);
     {
         LOCK(pwallet->cs_wallet);
         EnsureWalletIsUnlocked(pwallet);
 
         CHECK_NONFATAL(pwallet->chain().findBlock(
             pwallet->GetLastBlockHash(),
             FoundBlock().time(lowest_timestamp).mtpTime(now)));
 
         // Get all timestamps and extract the lowest timestamp
         for (const UniValue &request : requests.getValues()) {
             // This throws an error if "timestamp" doesn't exist
             const int64_t timestamp =
                 std::max(GetImportTimestamp(request, now), minimum_timestamp);
             const UniValue result =
                 ProcessDescriptorImport(pwallet, request, timestamp);
             response.push_back(result);
 
             if (lowest_timestamp > timestamp) {
                 lowest_timestamp = timestamp;
             }
 
             // If we know the chain tip, and at least one request was successful
             // then allow rescan
             if (!rescan && result["success"].get_bool()) {
                 rescan = true;
             }
         }
         pwallet->ConnectScriptPubKeyManNotifiers();
     }
 
     // Rescan the blockchain using the lowest timestamp
     if (rescan) {
         int64_t scanned_time = pwallet->RescanFromTime(
             lowest_timestamp, reserver, true /* update */);
         {
             LOCK(pwallet->cs_wallet);
             pwallet->ReacceptWalletTransactions();
         }
 
         if (pwallet->IsAbortingRescan()) {
             throw JSONRPCError(RPC_MISC_ERROR, "Rescan aborted by user.");
         }
 
         if (scanned_time > lowest_timestamp) {
             std::vector<UniValue> results = response.getValues();
             response.clear();
             response.setArray();
 
             // Compose the response
             for (unsigned int i = 0; i < requests.size(); ++i) {
                 const UniValue &request = requests.getValues().at(i);
 
                 // If the descriptor timestamp 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 (scanned_time <= 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 descriptor with 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 desc. As a "
                                 "result, transactions and coins using this "
                                 "desc 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),
                                 scanned_time - TIMESTAMP_WINDOW - 1,
                                 TIMESTAMP_WINDOW)));
                     response.push_back(std::move(result));
                 }
             }
         }
     }
 
     return response;
 }
 
 Span<const CRPCCommand> GetWalletDumpRPCCommands() {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            name                        actor (function)          argNames
         //  ------------------- ------------------------    ----------------------    ----------
         { "wallet",             "abortrescan",              abortrescan,              {} },
         { "wallet",             "dumpprivkey",              dumpprivkey,              {"address"}  },
         { "wallet",             "dumpwallet",               dumpwallet,               {"filename"} },
         { "wallet",             "dumpcoins",                dumpcoins,                {} },
         { "wallet",             "importdescriptors",        importdescriptors,        {"requests"} },
         { "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
 
     return MakeSpan(commands);
 }
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 560905e34..b1919d329 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -1,5036 +1,5029 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <amount.h>
 #include <chainparams.h> // for GetConsensus.
 #include <coins.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
 #include <network.h>
 #include <node/context.h>
 #include <outputtype.h>
 #include <policy/fees.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/message.h> // For MessageSign()
 #include <util/moneystr.h>
 #include <util/ref.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <util/url.h>
 #include <util/vector.h>
 #include <wallet/coincontrol.h>
 #include <wallet/context.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 <optional>
 
 using interfaces::FoundBlock;
 
 static const std::string WALLET_ENDPOINT_BASE = "/wallet/";
 static const std::string HELP_REQUIRING_PASSPHRASE{
     "\nRequires wallet passphrase to be set with walletpassphrase call if "
     "wallet is encrypted.\n"};
 
 static inline bool GetAvoidReuseFlag(const 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;
 }
 
 /**
  * Used by RPC commands that have an include_watchonly parameter. We default to
  * true for watchonly wallets if include_watchonly isn't explicitly set.
  */
 static bool ParseIncludeWatchonly(const UniValue &include_watchonly,
                                   const CWallet &pwallet) {
     if (include_watchonly.isNull()) {
         // if include_watchonly isn't explicitly set, then check if we have a
         // watchonly wallet
         return pwallet.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
     }
 
     // otherwise return whatever include_watchonly was set to
     return include_watchonly.get_bool();
 }
 
 /**
  * Checks if a CKey is in the given CWallet compressed or otherwise
  */
 bool HaveKey(const SigningProvider &wallet, const CKey &key) {
     CKey key2;
     key2.Set(key.begin(), key.end(), !key.IsCompressed());
     return wallet.HaveKey(key.GetPubKey().GetID()) ||
            wallet.HaveKey(key2.GetPubKey().GetID());
 }
 
 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) {
     CHECK_NONFATAL(!request.fHelp);
     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();
     if (wallets.size() == 1) {
         return wallets[0];
     }
 
     if (wallets.empty()) {
         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(const CWallet *pwallet) {
     if (pwallet->IsLocked()) {
         throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED,
                            "Error: Please enter the wallet passphrase with "
                            "walletpassphrase first.");
     }
 }
 
 WalletContext &EnsureWalletContext(const util::Ref &context) {
     if (!context.Has<WalletContext>()) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Wallet context not found");
     }
     return context.Get<WalletContext>();
 }
 
 // also_create should only be set to true only when the RPC is expected to add
 // things to a blank wallet and make it no longer blank
 LegacyScriptPubKeyMan &EnsureLegacyScriptPubKeyMan(CWallet &wallet,
                                                    bool also_create) {
     LegacyScriptPubKeyMan *spk_man = wallet.GetLegacyScriptPubKeyMan();
     if (!spk_man && also_create) {
         spk_man = wallet.GetOrCreateLegacyScriptPubKeyMan();
     }
     if (!spk_man) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "This type of wallet does not support this command");
     }
     return *spk_man;
 }
 
 static void WalletTxToJSON(interfaces::Chain &chain, const CWalletTx &wtx,
                            UniValue &entry) {
     int confirms = wtx.GetDepthInMainChain();
     entry.pushKV("confirmations", confirms);
     if (wtx.IsCoinBase()) {
         entry.pushKV("generated", true);
     }
     if (confirms > 0) {
         entry.pushKV("blockhash", wtx.m_confirm.hashBlock.GetHex());
         entry.pushKV("blockheight", wtx.m_confirm.block_height);
         entry.pushKV("blockindex", wtx.m_confirm.nIndex);
         int64_t block_time;
         CHECK_NONFATAL(chain.findBlock(wtx.m_confirm.hashBlock,
                                        FoundBlock().time(block_time)));
         entry.pushKV("blocktime", block_time);
     } else {
         entry.pushKV("trusted", wtx.IsTrusted());
     }
     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) {
     RPCHelpMan{
         "getnewaddress",
         "Returns a new Bitcoin address for receiving payments.\n"
         "If 'label' is specified, it is added to the address book \n"
         "so payments received with the address will be associated with "
         "'label'.\n",
         {
             {"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."},
             {"address_type", RPCArg::Type::STR,
              /* default */ "set by -addresstype",
              "The address type to use. Options are \"legacy\"."},
         },
         RPCResult{RPCResult::Type::STR, "address", "The new bitcoin address"},
         RPCExamples{HelpExampleCli("getnewaddress", "") +
                     HelpExampleRpc("getnewaddress", "")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     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()));
         }
     }
 
     CTxDestination dest;
     std::string error;
     if (!pwallet->GetNewDestination(output_type, label, dest, error)) {
         throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, error);
     }
 
     return EncodeDestination(dest, config);
 }
 
 static UniValue getrawchangeaddress(const Config &config,
                                     const JSONRPCRequest &request) {
     RPCHelpMan{
         "getrawchangeaddress",
         "Returns a new Bitcoin address, for receiving change.\n"
         "This is for use with raw transactions, NOT normal use.\n",
         {},
         RPCResult{RPCResult::Type::STR, "address", "The address"},
         RPCExamples{HelpExampleCli("getrawchangeaddress", "") +
                     HelpExampleRpc("getrawchangeaddress", "")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     LOCK(pwallet->cs_wallet);
 
     if (!pwallet->CanGetAddresses(true)) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Error: This wallet has no available keys");
     }
 
     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()));
         }
     }
 
     CTxDestination dest;
     std::string error;
     if (!pwallet->GetNewChangeDestination(output_type, dest, error)) {
         throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, error);
     }
     return EncodeDestination(dest, config);
 }
 
 static UniValue setlabel(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "setlabel",
         "Sets the label associated with the given address.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address to be associated with a label."},
             {"label", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The label to assign to the address."},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{
             HelpExampleCli("setlabel",
                            "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"tabby\"") +
             HelpExampleRpc(
                 "setlabel",
                 "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\", \"tabby\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     LOCK(pwallet->cs_wallet);
 
     CTxDestination dest = DecodeDestination(request.params[0].get_str(),
                                             wallet->GetChainParams());
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid Bitcoin address");
     }
 
     std::string label = LabelFromValue(request.params[1]);
 
     if (pwallet->IsMine(dest)) {
         pwallet->SetAddressBook(dest, label, "receive");
     } else {
         pwallet->SetAddressBook(dest, label, "send");
     }
 
     return NullUniValue;
 }
 
 static CTransactionRef SendMoney(CWallet *const pwallet,
                                  const CTxDestination &address, Amount nValue,
                                  bool fSubtractFeeFromAmount,
                                  const CCoinControl &coin_control,
                                  mapValue_t mapValue) {
     Amount curBalance =
         pwallet->GetBalance(0, coin_control.m_avoid_address_reuse)
             .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");
     }
 
     // Parse Bitcoin address
     CScript scriptPubKey = GetScriptForDestination(address);
 
     // Create and send the transaction
     Amount nFeeRequired = Amount::zero();
     bilingual_str error;
     std::vector<CRecipient> vecSend;
     int nChangePosRet = -1;
     CRecipient recipient = {scriptPubKey, nValue, fSubtractFeeFromAmount};
     vecSend.push_back(recipient);
 
     CTransactionRef tx;
     if (!pwallet->CreateTransaction(vecSend, tx, nFeeRequired, nChangePosRet,
                                     error, coin_control)) {
         if (!fSubtractFeeFromAmount && nValue + nFeeRequired > curBalance) {
             error = strprintf(Untranslated("Error: This transaction requires a "
                                            "transaction fee of at least %s"),
                               FormatMoney(nFeeRequired));
         }
         throw JSONRPCError(RPC_WALLET_ERROR, error.original);
     }
     pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */);
     return tx;
 }
 
 static UniValue sendtoaddress(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "sendtoaddress",
         "Send an amount to a given address.\n" + HELP_REQUIRING_PASSPHRASE,
         {
             {"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."},
             {"avoid_reuse", RPCArg::Type::BOOL,
              /* default */ "true",
              "(only available if avoid_reuse wallet flag is set) Avoid "
              "spending from dirty addresses; addresses are considered\n"
              "                             dirty if they have previously "
              "been used in a transaction."},
         },
         RPCResult{RPCResult::Type::STR_HEX, "txid", "The transaction id."},
         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\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     // 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();
 
     LOCK(pwallet->cs_wallet);
 
     CTxDestination dest = DecodeDestination(request.params[0].get_str(),
                                             wallet->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;
     coin_control.m_avoid_address_reuse =
         GetAvoidReuseFlag(pwallet, request.params[5]);
     // We also enable partial spend avoidance if reuse avoidance is set.
     coin_control.m_avoid_partial_spends |= coin_control.m_avoid_address_reuse;
 
     EnsureWalletIsUnlocked(pwallet);
 
     CTransactionRef tx =
         SendMoney(pwallet, dest, nAmount, fSubtractFeeFromAmount, coin_control,
                   std::move(mapValue));
     return tx->GetId().GetHex();
 }
 
 static UniValue listaddressgroupings(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "listaddressgroupings",
         "Lists groups of addresses which have had their common ownership\n"
         "made public by common use as inputs or as the resulting change\n"
         "in past transactions\n",
         {},
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::ARR,
                        "",
                        "",
                        {
                            {RPCResult::Type::ARR,
                             "",
                             "",
                             {
                                 {RPCResult::Type::STR, "address",
                                  "The bitcoin address"},
                                 {RPCResult::Type::STR_AMOUNT, "amount",
                                  "The amount in " + CURRENCY_UNIT},
                                 {RPCResult::Type::STR, "label",
                                  /* optional */ true, "The label"},
                             }},
                        }},
                   }},
         RPCExamples{HelpExampleCli("listaddressgroupings", "") +
                     HelpExampleRpc("listaddressgroupings", "")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     // 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();
 
     LOCK(pwallet->cs_wallet);
 
     UniValue jsonGroupings(UniValue::VARR);
     std::map<CTxDestination, Amount> balances = pwallet->GetAddressBalances();
     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]));
+            addressInfo.push_back(balances[address]);
 
             const auto *address_book_entry =
                 pwallet->FindAddressBookEntry(address);
             if (address_book_entry) {
                 addressInfo.push_back(address_book_entry->GetLabel());
             }
             jsonGrouping.push_back(addressInfo);
         }
         jsonGroupings.push_back(jsonGrouping);
     }
 
     return jsonGroupings;
 }
 
 static UniValue signmessage(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "signmessage",
         "Sign a message with the private key of an address" +
             HELP_REQUIRING_PASSPHRASE,
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address to use for the private key."},
             {"message", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The message to create a signature of."},
         },
         RPCResult{RPCResult::Type::STR, "signature",
                   "The signature of the message encoded in base 64"},
         RPCExamples{
             "\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",
                            "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" "
                            "\"signature\" \"my message\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc(
                 "signmessage",
                 "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\", \"my message\"")},
     }
         .Check(request);
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     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, wallet->GetChainParams());
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");
     }
 
     const PKHash *pkhash = boost::get<PKHash>(&dest);
     if (!pkhash) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");
     }
 
     std::string signature;
     SigningResult err = pwallet->SignMessage(strMessage, *pkhash, signature);
     if (err == SigningResult::SIGNING_FAILED) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            SigningResultString(err));
     } else if (err != SigningResult::OK) {
         throw JSONRPCError(RPC_WALLET_ERROR, SigningResultString(err));
     }
 
     return signature;
 }
 
 static Amount GetReceived(const CWallet &wallet, const UniValue &params,
                           bool by_label)
     EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) {
     std::set<CTxDestination> address_set;
 
     if (by_label) {
         // Get the set of addresses assigned to label
         std::string label = LabelFromValue(params[0]);
         address_set = wallet.GetLabelAddresses(label);
     } else {
         // Get the address
         CTxDestination dest =
             DecodeDestination(params[0].get_str(), wallet.GetChainParams());
         if (!IsValidDestination(dest)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid Bitcoin address");
         }
         CScript script_pub_key = GetScriptForDestination(dest);
         if (!wallet.IsMine(script_pub_key)) {
             throw JSONRPCError(RPC_WALLET_ERROR, "Address not found in wallet");
         }
         address_set.insert(dest);
     }
 
     // Minimum confirmations
     int min_depth = 1;
     if (!params[1].isNull()) {
         min_depth = params[1].get_int();
     }
 
     // Tally
     Amount amount = Amount::zero();
     for (const std::pair<const TxId, CWalletTx> &wtx_pair : wallet.mapWallet) {
         const CWalletTx &wtx = wtx_pair.second;
         TxValidationState txState;
         if (wtx.IsCoinBase() ||
             !wallet.chain().contextualCheckTransactionForCurrentBlock(
                 *wtx.tx, txState) ||
             wtx.GetDepthInMainChain() < min_depth) {
             continue;
         }
 
         for (const CTxOut &txout : wtx.tx->vout) {
             CTxDestination address;
             if (ExtractDestination(txout.scriptPubKey, address) &&
                 wallet.IsMine(address) && address_set.count(address)) {
                 amount += txout.nValue;
             }
         }
     }
 
     return amount;
 }
 
 static UniValue getreceivedbyaddress(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "getreceivedbyaddress",
         "Returns the total amount received by the given address in "
         "transactions with at least minconf confirmations.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address for transactions."},
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "Only include transactions confirmed at least this many times."},
         },
         RPCResult{RPCResult::Type::STR_AMOUNT, "amount",
                   "The total amount in " + CURRENCY_UNIT +
                       " received at this address."},
         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")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     // 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();
 
     LOCK(pwallet->cs_wallet);
 
-    return ValueFromAmount(GetReceived(*pwallet, request.params,
-                                       /* by_label */ false));
+    return GetReceived(*pwallet, request.params,
+                       /* by_label */ false);
 }
 
 static UniValue getreceivedbylabel(const Config &config,
                                    const JSONRPCRequest &request) {
     RPCHelpMan{
         "getreceivedbylabel",
         "Returns the total amount received by addresses with <label> in "
         "transactions with at least [minconf] confirmations.\n",
         {
             {"label", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The selected label, may be the default label using \"\"."},
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "Only include transactions confirmed at least this many times."},
         },
         RPCResult{RPCResult::Type::STR_AMOUNT, "amount",
                   "The total amount in " + CURRENCY_UNIT +
                       " received for this label."},
         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")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     // 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();
 
     LOCK(pwallet->cs_wallet);
 
-    return ValueFromAmount(GetReceived(*pwallet, request.params,
-                                       /* by_label */ true));
+    return GetReceived(*pwallet, request.params,
+                       /* by_label */ true);
 }
 
 static UniValue getbalance(const Config &config,
                            const JSONRPCRequest &request) {
     RPCHelpMan{
         "getbalance",
         "Returns the total available balance.\n"
         "The available balance is what the wallet considers currently "
         "spendable, and is\n"
         "thus affected by options which limit spendability such as "
         "-spendzeroconfchange.\n",
         {
             {"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 */ "true for watch-only wallets, otherwise false",
              "Also include balance in watch-only addresses (see "
              "'importaddress')"},
             {"avoid_reuse", RPCArg::Type::BOOL,
              /* default */ "true",
              "(only available if avoid_reuse wallet flag is set) Do not "
              "include balance in dirty outputs; addresses are considered dirty "
              "if they have previously been used in a transaction."},
         },
         RPCResult{RPCResult::Type::STR_AMOUNT, "amount",
                   "The total amount in " + CURRENCY_UNIT +
                       " received for this wallet."},
         RPCExamples{
             "\nThe total amount in the wallet with 0 or more confirmations\n" +
             HelpExampleCli("getbalance", "") +
             "\nThe total amount in the wallet with at least 6 confirmations\n" +
             HelpExampleCli("getbalance", "\"*\" 6") + "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("getbalance", "\"*\", 6")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     // 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();
 
     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 = ParseIncludeWatchonly(request.params[2], *pwallet);
 
     bool avoid_reuse = GetAvoidReuseFlag(pwallet, request.params[3]);
 
     const auto bal = pwallet->GetBalance(min_depth, avoid_reuse);
 
-    return ValueFromAmount(bal.m_mine_trusted + (include_watchonly
-                                                     ? bal.m_watchonly_trusted
-                                                     : Amount::zero()));
+    return bal.m_mine_trusted +
+           (include_watchonly ? bal.m_watchonly_trusted : Amount::zero());
 }
 
 static UniValue getunconfirmedbalance(const Config &config,
                                       const JSONRPCRequest &request) {
     RPCHelpMan{
         "getunconfirmedbalance",
         "DEPRECATED\nIdentical to getbalances().mine.untrusted_pending\n",
         {},
         RPCResult{RPCResult::Type::NUM, "", "The balance"},
         RPCExamples{""},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     // 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();
 
     LOCK(pwallet->cs_wallet);
 
-    return ValueFromAmount(pwallet->GetBalance().m_mine_untrusted_pending);
+    return pwallet->GetBalance().m_mine_untrusted_pending;
 }
 
 static UniValue sendmany(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "sendmany",
         "Send multiple times. Amounts are double-precision "
         "floating point numbers." +
             HELP_REQUIRING_PASSPHRASE,
         {
             {"dummy", RPCArg::Type::STR, RPCArg::Optional::NO,
              "Must be set to \"\" for backwards compatibility.", "\"\""},
             {
                 "amounts",
                 RPCArg::Type::OBJ,
                 RPCArg::Optional::NO,
                 "The 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,
                 "The 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{RPCResult::Type::STR_HEX, "txid",
                   "The transaction id for the send. Only 1 transaction is "
                   "created regardless of the number of addresses."},
         RPCExamples{
             "\nSend two amounts to two different addresses:\n" +
             HelpExampleCli(
                 "sendmany",
                 "\"\" "
                 "\"{\\\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\\\":"
                 "0.01,"
                 "\\\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\\\":0."
                 "02}\"") +
             "\nSend two amounts to two different addresses setting the "
             "confirmation and comment:\n" +
             HelpExampleCli(
                 "sendmany",
                 "\"\" "
                 "\"{\\\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\\\":"
                 "0.01,"
                 "\\\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\\\":0."
                 "02}\" "
                 "6 \"testing\"") +
             "\nSend two amounts to two different addresses, subtract fee "
             "from amount:\n" +
             HelpExampleCli(
                 "sendmany",
                 "\"\" "
                 "\"{\\\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\\\":"
                 "0.01,"
                 "\\\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\\\":0."
                 "02}\" 1 \"\" "
                 "\"[\\\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\\\","
                 "\\\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\\\"]"
                 "\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc(
                 "sendmany",
                 "\"\", "
                 "{\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\":0.01,"
                 "\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\":0.02}, "
                 "6, "
                 "\"testing\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     // 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();
 
     LOCK(pwallet->cs_wallet);
 
     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_, wallet->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
     Amount nFeeRequired = Amount::zero();
     int nChangePosRet = -1;
     bilingual_str error;
     CTransactionRef tx;
     CCoinControl coinControl;
     bool fCreated = pwallet->CreateTransaction(
         vecSend, tx, nFeeRequired, nChangePosRet, error, coinControl);
     if (!fCreated) {
         throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, error.original);
     }
     pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */);
     return tx->GetId().GetHex();
 }
 
 static UniValue addmultisigaddress(const Config &config,
                                    const JSONRPCRequest &request) {
     RPCHelpMan{
         "addmultisigaddress",
         "Add an 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"
         "This functionality is only intended for use with non-watchonly "
         "addresses.\n"
         "See `importaddress` for watchonly p2sh address support.\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,
                 "The 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{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "address",
                        "The value of the new multisig address"},
                       {RPCResult::Type::STR_HEX, "redeemScript",
                        "The string value of the hex-encoded redemption script"},
                       {RPCResult::Type::STR, "descriptor",
                        "The descriptor for this multisig"},
                   }},
         RPCExamples{
             "\nAdd a multisig address from 2 addresses\n" +
             HelpExampleCli("addmultisigaddress",
                            "2 "
                            "\"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\","
                            "\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("addmultisigaddress",
                            "2, "
                            "\"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\","
                            "\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     LegacyScriptPubKeyMan &spk_man = EnsureLegacyScriptPubKeyMan(*pwallet);
 
     LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);
 
     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(wallet->GetChainParams(), spk_man,
                                            keys_or_addrs[i].get_str()));
         }
     }
 
     OutputType output_type = pwallet->m_default_address_type;
 
     // Construct using pay-to-script-hash:
     CScript inner;
     CTxDestination dest = AddAndGetMultisigDestination(
         required, pubkeys, output_type, spk_man, inner);
     pwallet->SetAddressBook(dest, label, "send");
 
     // Make the descriptor
     std::unique_ptr<Descriptor> descriptor =
         InferDescriptor(GetScriptForDestination(dest), spk_man);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("address", EncodeDestination(dest, config));
     result.pushKV("redeemScript", HexStr(inner));
     result.pushKV("descriptor", descriptor->ToString());
     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, const 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 (ParseIncludeWatchonly(params[2], *pwallet)) {
         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(),
                                       pwallet->GetChainParams())) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "address_filter parameter was invalid");
         }
         filtered_address =
             DecodeDestination(params[3].get_str(), pwallet->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;
 
         TxValidationState state;
         if (wtx.IsCoinBase() ||
             !pwallet->chain().contextualCheckTransactionForCurrentBlock(
                 *wtx.tx, state)) {
             continue;
         }
 
         int nDepth = wtx.GetDepthInMainChain();
         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 = pwallet->IsMine(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 m_address_book iterator
     // If we aren't filtering, go from begin() to end()
     auto start = pwallet->m_address_book.begin();
     auto end = pwallet->m_address_book.end();
     // If we are filtering, find() the applicable entry
     if (has_filtered_address) {
         start = pwallet->m_address_book.find(filtered_address);
         if (start != end) {
             end = std::next(start);
         }
     }
 
     for (auto item_it = start; item_it != end; ++item_it) {
         if (item_it->second.IsChange()) {
             continue;
         }
         const CTxDestination &address = item_it->first;
         const std::string &label = item_it->second.GetLabel();
         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("amount", 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("amount", 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) {
     RPCHelpMan{
         "listreceivedbyaddress",
         "List 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 */ "true for watch-only wallets, otherwise 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{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "",
                  "",
                  {
                      {RPCResult::Type::BOOL, "involvesWatchonly",
                       "Only returns true if imported addresses were involved "
                       "in transaction"},
                      {RPCResult::Type::STR, "address", "The receiving address"},
                      {RPCResult::Type::STR_AMOUNT, "amount",
                       "The total amount in " + CURRENCY_UNIT +
                           " received by the address"},
                      {RPCResult::Type::NUM, "confirmations",
                       "The number of confirmations of the most recent "
                       "transaction included"},
                      {RPCResult::Type::STR, "label",
                       "The label of the receiving address. The default label "
                       "is \"\""},
                      {RPCResult::Type::ARR,
                       "txids",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "txid",
                            "The ids of transactions received with the address"},
                       }},
                  }},
             }},
         RPCExamples{
             HelpExampleCli("listreceivedbyaddress", "") +
             HelpExampleCli("listreceivedbyaddress", "6 true") +
             HelpExampleRpc("listreceivedbyaddress", "6, true, true") +
             HelpExampleRpc(
                 "listreceivedbyaddress",
                 "6, true, true, \"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     // 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();
 
     LOCK(pwallet->cs_wallet);
 
     return ListReceived(config, pwallet, request.params, false);
 }
 
 static UniValue listreceivedbylabel(const Config &config,
                                     const JSONRPCRequest &request) {
     RPCHelpMan{
         "listreceivedbylabel",
         "List 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 */ "true for watch-only wallets, otherwise false",
              "Whether to include watch-only addresses (see 'importaddress')."},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "",
                  "",
                  {
                      {RPCResult::Type::BOOL, "involvesWatchonly",
                       "Only returns true if imported addresses were involved "
                       "in transaction"},
                      {RPCResult::Type::STR_AMOUNT, "amount",
                       "The total amount received by addresses with this label"},
                      {RPCResult::Type::NUM, "confirmations",
                       "The number of confirmations of the most recent "
                       "transaction included"},
                      {RPCResult::Type::STR, "label",
                       "The label of the receiving address. The default label "
                       "is \"\""},
                  }},
             }},
         RPCExamples{HelpExampleCli("listreceivedbylabel", "") +
                     HelpExampleCli("listreceivedbylabel", "6 true") +
                     HelpExampleRpc("listreceivedbylabel", "6, true, true")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     // 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();
 
     LOCK(pwallet->cs_wallet);
 
     return ListReceived(config, 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(const 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 ||
                 (pwallet->IsMine(s.destination) & ISMINE_WATCH_ONLY)) {
                 entry.pushKV("involvesWatchonly", true);
             }
             MaybePushAddress(entry, s.destination);
             entry.pushKV("category", "send");
-            entry.pushKV("amount", ValueFromAmount(-s.amount));
+            entry.pushKV("amount", -s.amount);
             const auto *address_book_entry =
                 pwallet->FindAddressBookEntry(s.destination);
             if (address_book_entry) {
                 entry.pushKV("label", address_book_entry->GetLabel());
             }
             entry.pushKV("vout", s.vout);
-            entry.pushKV("fee", ValueFromAmount(-1 * nFee));
+            entry.pushKV("fee", -1 * nFee);
             if (fLong) {
                 WalletTxToJSON(pwallet->chain(), wtx, entry);
             }
             entry.pushKV("abandoned", wtx.isAbandoned());
             ret.push_back(entry);
         }
     }
 
     // Received
     if (listReceived.size() > 0 && wtx.GetDepthInMainChain() >= nMinDepth) {
         for (const COutputEntry &r : listReceived) {
             std::string label;
             const auto *address_book_entry =
                 pwallet->FindAddressBookEntry(r.destination);
             if (address_book_entry) {
                 label = address_book_entry->GetLabel();
             }
             if (filter_label && label != *filter_label) {
                 continue;
             }
             UniValue entry(UniValue::VOBJ);
             if (involvesWatchonly ||
                 (pwallet->IsMine(r.destination) & ISMINE_WATCH_ONLY)) {
                 entry.pushKV("involvesWatchonly", true);
             }
             MaybePushAddress(entry, r.destination);
             if (wtx.IsCoinBase()) {
                 if (wtx.GetDepthInMainChain() < 1) {
                     entry.pushKV("category", "orphan");
                 } else if (wtx.IsImmatureCoinBase()) {
                     entry.pushKV("category", "immature");
                 } else {
                     entry.pushKV("category", "generate");
                 }
             } else {
                 entry.pushKV("category", "receive");
             }
-            entry.pushKV("amount", ValueFromAmount(r.amount));
+            entry.pushKV("amount", r.amount);
             if (address_book_entry) {
                 entry.pushKV("label", label);
             }
             entry.pushKV("vout", r.vout);
             if (fLong) {
                 WalletTxToJSON(pwallet->chain(), wtx, entry);
             }
             ret.push_back(entry);
         }
     }
 }
 
 static const std::vector<RPCResult> TransactionDescriptionString() {
     return {
         {RPCResult::Type::NUM, "confirmations",
          "The number of confirmations for the transaction. Negative "
          "confirmations means the\n"
          "transaction conflicted that many blocks ago."},
         {RPCResult::Type::BOOL, "generated",
          "Only present if transaction only input is a coinbase one."},
         {RPCResult::Type::BOOL, "trusted",
          "Only present if we consider transaction to be trusted and so safe to "
          "spend from."},
         {RPCResult::Type::STR_HEX, "blockhash",
          "The block hash containing the transaction."},
         {RPCResult::Type::NUM, "blockheight",
          "The block height containing the transaction."},
         {RPCResult::Type::NUM, "blockindex",
          "The index of the transaction in the block that includes it."},
         {RPCResult::Type::NUM_TIME, "blocktime",
          "The block time expressed in " + UNIX_EPOCH_TIME + "."},
         {RPCResult::Type::STR_HEX, "txid", "The transaction id."},
         {RPCResult::Type::ARR,
          "walletconflicts",
          "Conflicting transaction ids.",
          {
              {RPCResult::Type::STR_HEX, "txid", "The transaction id."},
          }},
         {RPCResult::Type::NUM_TIME, "time",
          "The transaction time expressed in " + UNIX_EPOCH_TIME + "."},
         {RPCResult::Type::NUM_TIME, "timereceived",
          "The time received expressed in " + UNIX_EPOCH_TIME + "."},
         {RPCResult::Type::STR, "comment",
          "If a comment is associated with the transaction, only present if not "
          "empty."},
     };
 }
 
 UniValue listtransactions(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "listtransactions",
         "If a label name is provided, this will return only incoming "
         "transactions paying to addresses with the specified label.\n"
         "\nReturns up to 'count' most recent transactions skipping the first "
         "'from' transactions.\n",
         {
             {"label|dummy", 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 */ "true for watch-only wallets, otherwise false",
              "Include transactions to watch-only addresses (see "
              "'importaddress')"},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ, "", "",
                  Cat(Cat<std::vector<RPCResult>>(
                          {
                              {RPCResult::Type::BOOL, "involvesWatchonly",
                               "Only returns true if imported addresses were "
                               "involved in transaction."},
                              {RPCResult::Type::STR, "address",
                               "The bitcoin address of the transaction."},
                              {RPCResult::Type::STR, "category",
                               "The transaction category.\n"
                               "\"send\"                  Transactions sent.\n"
                               "\"receive\"               Non-coinbase "
                               "transactions received.\n"
                               "\"generate\"              Coinbase transactions "
                               "received with more than 100 confirmations.\n"
                               "\"immature\"              Coinbase transactions "
                               "received with 100 or fewer confirmations.\n"
                               "\"orphan\"                Orphaned coinbase "
                               "transactions received."},
                              {RPCResult::Type::STR_AMOUNT, "amount",
                               "The amount in " + CURRENCY_UNIT +
                                   ". This is negative for the 'send' category, "
                                   "and is positive\n"
                                   "for all other categories"},
                              {RPCResult::Type::STR, "label",
                               "A comment for the address/transaction, if any"},
                              {RPCResult::Type::NUM, "vout", "the vout value"},
                              {RPCResult::Type::STR_AMOUNT, "fee",
                               "The amount of the fee in " + CURRENCY_UNIT +
                                   ". This is negative and only available for "
                                   "the\n"
                                   "'send' category of transactions."},
                          },
                          TransactionDescriptionString()),
                      {
                          {RPCResult::Type::BOOL, "abandoned",
                           "'true' if the transaction has been abandoned "
                           "(inputs are respendable). Only available for the \n"
                           "'send' category of transactions."},
                      })},
             }},
         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")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     // 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 (ParseIncludeWatchonly(request.params[3], *pwallet)) {
         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);
 
     {
         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(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;
     }
 
     const std::vector<UniValue> &txs = ret.getValues();
     UniValue result{UniValue::VARR};
     // Return oldest to newest
     result.push_backV({txs.rend() - nFrom - nCount, txs.rend() - nFrom});
     return result;
 }
 
 static UniValue listsinceblock(const Config &config,
                                const JSONRPCRequest &request) {
     RPCHelpMan{
         "listsinceblock",
         "Get all transactions in blocks since block [blockhash], or all "
         "transactions if omitted.\n"
         "If \"blockhash\" is no longer a part of the main chain, transactions "
         "from the fork point onward are included.\n"
         "Additionally, if include_removed is set, transactions affecting the "
         "wallet which were removed are returned in the \"removed\" array.\n",
         {
             {"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 */ "true for watch-only wallets, otherwise 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{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::ARR,
                  "transactions",
                  "",
                  {
                      {RPCResult::Type::OBJ, "", "",
                       Cat(Cat<std::vector<RPCResult>>(
                               {
                                   {RPCResult::Type::BOOL, "involvesWatchonly",
                                    "Only returns true if imported addresses "
                                    "were involved in transaction."},
                                   {RPCResult::Type::STR, "address",
                                    "The bitcoin address of the transaction."},
                                   {RPCResult::Type::STR, "category",
                                    "The transaction category.\n"
                                    "\"send\"                  Transactions "
                                    "sent.\n"
                                    "\"receive\"               Non-coinbase "
                                    "transactions received.\n"
                                    "\"generate\"              Coinbase "
                                    "transactions received with more than 100 "
                                    "confirmations.\n"
                                    "\"immature\"              Coinbase "
                                    "transactions received with 100 or fewer "
                                    "confirmations.\n"
                                    "\"orphan\"                Orphaned "
                                    "coinbase transactions received."},
                                   {RPCResult::Type::STR_AMOUNT, "amount",
                                    "The amount in " + CURRENCY_UNIT +
                                        ". This is negative for the 'send' "
                                        "category, and is positive\n"
                                        "for all other categories"},
                                   {RPCResult::Type::NUM, "vout",
                                    "the vout value"},
                                   {RPCResult::Type::STR_AMOUNT, "fee",
                                    "The amount of the fee in " + CURRENCY_UNIT +
                                        ". This is negative and only available "
                                        "for the\n"
                                        "'send' category of transactions."},
                               },
                               TransactionDescriptionString()),
                           {
                               {RPCResult::Type::BOOL, "abandoned",
                                "'true' if the transaction has been abandoned "
                                "(inputs are respendable). Only available for "
                                "the \n"
                                "'send' category of transactions."},
                               {RPCResult::Type::STR, "comment",
                                "If a comment is associated with the "
                                "transaction."},
                               {RPCResult::Type::STR, "label",
                                "A comment for the address/transaction, if any"},
                               {RPCResult::Type::STR, "to",
                                "If a comment to is associated with the "
                                "transaction."},
                           })},
                  }},
                 {RPCResult::Type::ARR,
                  "removed",
                  "<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.",
                  {
                      {RPCResult::Type::ELISION, "", ""},
                  }},
                 {RPCResult::Type::STR_HEX, "lastblock",
                  "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"},
             }},
         RPCExamples{HelpExampleCli("listsinceblock", "") +
                     HelpExampleCli("listsinceblock",
                                    "\"000000000000000bacf66f7497b7dc45ef753ee9a"
                                    "7d38571037cdb1a57f663ad\" 6") +
                     HelpExampleRpc("listsinceblock",
                                    "\"000000000000000bacf66f7497b7dc45ef753ee9a"
                                    "7d38571037cdb1a57f663ad\", 6")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const pwallet =
         GetWalletForJSONRPCRequest(request);
 
     if (!pwallet) {
         return NullUniValue;
     }
 
     const CWallet &wallet = *pwallet;
     // 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
     wallet.BlockUntilSyncedToCurrentChain();
 
     LOCK(wallet.cs_wallet);
 
     // Height of the specified block or the common ancestor, if the block
     // provided was in a deactivated chain.
     std::optional<int> height;
 
     // Height of the specified block, even if it's in a deactivated chain.
     std::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 = int{};
         altheight = int{};
         if (!wallet.chain().findCommonAncestor(
                 blockId, wallet.GetLastBlockHash(),
                 /* ancestor out */ FoundBlock().height(*height),
                 /* blockId out */ FoundBlock().height(*altheight))) {
             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 (ParseIncludeWatchonly(request.params[2], wallet)) {
         filter |= ISMINE_WATCH_ONLY;
     }
 
     bool include_removed =
         (request.params[3].isNull() || request.params[3].get_bool());
 
     int depth = height ? wallet.GetLastBlockHeight() + 1 - *height : -1;
 
     UniValue transactions(UniValue::VARR);
 
     for (const std::pair<const TxId, CWalletTx> &pairWtx : wallet.mapWallet) {
         const CWalletTx &tx = pairWtx.second;
 
         if (depth == -1 || tx.GetDepthInMainChain() < depth) {
             ListTransactions(&wallet, 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 (!wallet.chain().findBlock(blockId, FoundBlock().data(block)) ||
             block.IsNull()) {
             throw JSONRPCError(RPC_INTERNAL_ERROR,
                                "Can't read block from disk");
         }
         for (const CTransactionRef &tx : block.vtx) {
             auto it = wallet.mapWallet.find(tx->GetId());
             if (it != wallet.mapWallet.end()) {
                 // We want all transactions regardless of confirmation count to
                 // appear here, even negative confirmation ones, hence the big
                 // negative.
                 ListTransactions(&wallet, it->second, -100000000, true, removed,
                                  filter, nullptr /* filter_label */);
             }
         }
         blockId = block.hashPrevBlock;
         --*altheight;
     }
 
     BlockHash lastblock;
     CHECK_NONFATAL(wallet.chain().findAncestorByHeight(
         wallet.GetLastBlockHash(),
         wallet.GetLastBlockHeight() + 1 - target_confirms,
         FoundBlock().hash(lastblock)));
 
     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) {
     RPCHelpMan{
         "gettransaction",
         "Get detailed information about in-wallet transaction <txid>\n",
         {
             {"txid", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The transaction id"},
             {"include_watchonly", RPCArg::Type::BOOL,
              /* default */ "true for watch-only wallets, otherwise false",
              "Whether to include watch-only addresses in balance calculation "
              "and details[]"},
             {"verbose", RPCArg::Type::BOOL, /* default */ "false",
              "Whether to include a `decoded` field containing the decoded "
              "transaction (equivalent to RPC decoderawtransaction)"},
         },
         RPCResult{
             RPCResult::Type::OBJ, "", "",
             Cat(Cat<std::vector<RPCResult>>(
                     {
                         {RPCResult::Type::STR_AMOUNT, "amount",
                          "The amount in " + CURRENCY_UNIT},
                         {RPCResult::Type::STR_AMOUNT, "fee",
                          "The amount of the fee in " + CURRENCY_UNIT +
                              ". This is negative and only available for the\n"
                              "'send' category of transactions."},
                     },
                     TransactionDescriptionString()),
                 {
                     {RPCResult::Type::ARR,
                      "details",
                      "",
                      {
                          {RPCResult::Type::OBJ,
                           "",
                           "",
                           {
                               {RPCResult::Type::BOOL, "involvesWatchonly",
                                "Only returns true if imported addresses were "
                                "involved in transaction."},
                               {RPCResult::Type::STR, "address",
                                "The bitcoin address involved in the "
                                "transaction."},
                               {RPCResult::Type::STR, "category",
                                "The transaction category.\n"
                                "\"send\"                  Transactions sent.\n"
                                "\"receive\"               Non-coinbase "
                                "transactions received.\n"
                                "\"generate\"              Coinbase "
                                "transactions received with more than 100 "
                                "confirmations.\n"
                                "\"immature\"              Coinbase "
                                "transactions received with 100 or fewer "
                                "confirmations.\n"
                                "\"orphan\"                Orphaned coinbase "
                                "transactions received."},
                               {RPCResult::Type::STR_AMOUNT, "amount",
                                "The amount in " + CURRENCY_UNIT},
                               {RPCResult::Type::STR, "label",
                                "A comment for the address/transaction, if any"},
                               {RPCResult::Type::NUM, "vout", "the vout value"},
                               {RPCResult::Type::STR_AMOUNT, "fee",
                                "The amount of the fee in " + CURRENCY_UNIT +
                                    ". This is negative and only available for "
                                    "the \n"
                                    "'send' category of transactions."},
                               {RPCResult::Type::BOOL, "abandoned",
                                "'true' if the transaction has been abandoned "
                                "(inputs are respendable). Only available for "
                                "the \n"
                                "'send' category of transactions."},
                           }},
                      }},
                     {RPCResult::Type::STR_HEX, "hex",
                      "Raw data for transaction"},
                     {RPCResult::Type::OBJ,
                      "decoded",
                      "Optional, the decoded transaction (only present when "
                      "`verbose` is passed)",
                      {
                          {RPCResult::Type::ELISION, "",
                           "Equivalent to the RPC decoderawtransaction method, "
                           "or the RPC getrawtransaction method when `verbose` "
                           "is passed."},
                      }},
                 })},
         RPCExamples{HelpExampleCli("gettransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\"") +
                     HelpExampleCli("gettransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\" true") +
                     HelpExampleCli("gettransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\" false true") +
                     HelpExampleRpc("gettransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     // 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();
 
     LOCK(pwallet->cs_wallet);
 
     TxId txid(ParseHashV(request.params[0], "txid"));
 
     isminefilter filter = ISMINE_SPENDABLE;
     if (ParseIncludeWatchonly(request.params[1], *pwallet)) {
         filter |= ISMINE_WATCH_ONLY;
     }
 
     bool verbose =
         request.params[2].isNull() ? false : request.params[2].get_bool();
 
     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(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));
+    entry.pushKV("amount", nNet - nFee);
     if (wtx.IsFromMe(filter)) {
-        entry.pushKV("fee", ValueFromAmount(nFee));
+        entry.pushKV("fee", nFee);
     }
 
     WalletTxToJSON(pwallet->chain(), wtx, entry);
 
     UniValue details(UniValue::VARR);
     ListTransactions(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);
 
     if (verbose) {
         UniValue decoded(UniValue::VOBJ);
         TxToUniv(*wtx.tx, uint256(), decoded, false);
         entry.pushKV("decoded", decoded);
     }
 
     return entry;
 }
 
 static UniValue abandontransaction(const Config &config,
                                    const JSONRPCRequest &request) {
     RPCHelpMan{
         "abandontransaction",
         "Mark in-wallet transaction <txid> as abandoned\n"
         "This will mark this transaction and all its in-wallet descendants as "
         "abandoned which will allow\n"
         "for their inputs to be respent.  It can be used to replace \"stuck\" "
         "or evicted transactions.\n"
         "It only works on transactions which are not included in a block and "
         "are not currently in the mempool.\n"
         "It has no effect on transactions which are already abandoned.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("abandontransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\"") +
                     HelpExampleRpc("abandontransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     // 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();
 
     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(txid)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Transaction not eligible for abandonment");
     }
 
     return NullUniValue;
 }
 
 static UniValue backupwallet(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "backupwallet",
         "Safely 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"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("backupwallet", "\"backup.dat\"") +
                     HelpExampleRpc("backupwallet", "\"backup.dat\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     // 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();
 
     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) {
     RPCHelpMan{
         "keypoolrefill",
         "Fills the keypool." + HELP_REQUIRING_PASSPHRASE,
         {
             {"newsize", RPCArg::Type::NUM, /* default */ "100",
              "The new keypool size"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("keypoolrefill", "") +
                     HelpExampleRpc("keypoolrefill", "")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     if (pwallet->IsLegacy() &&
         pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Error: Private keys are disabled for this wallet");
     }
 
     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) {
     RPCHelpMan{
         "walletpassphrase",
         "Stores the wallet decryption key in memory for 'timeout' seconds.\n"
         "This is needed prior to performing transactions related to private "
         "keys such as sending bitcoins\n"
         "\nNote:\n"
         "Issuing the walletpassphrase command while the wallet is already "
         "unlocked will set a new unlock\n"
         "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)."},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         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")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     int64_t nSleepTime;
     int64_t relock_time;
     // Prevent concurrent calls to walletpassphrase with the same wallet.
     LOCK(pwallet->m_unlock_mutex);
     {
         LOCK(pwallet->cs_wallet);
 
         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
         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;
         relock_time = pwallet->nRelockTime;
     }
 
     // rpcRunLater must be called without cs_wallet held otherwise a deadlock
     // can occur. The deadlock would happen when RPCRunLater removes the
     // previous timer (and waits for the callback to finish if already running)
     // and the callback locks cs_wallet.
     AssertLockNotHeld(wallet->cs_wallet);
     // 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, relock_time] {
             if (auto shared_wallet = weak_wallet.lock()) {
                 LOCK(shared_wallet->cs_wallet);
                 // Skip if this is not the most recent rpcRunLater callback.
                 if (shared_wallet->nRelockTime != relock_time) {
                     return;
                 }
                 shared_wallet->Lock();
                 shared_wallet->nRelockTime = 0;
             }
         },
         nSleepTime);
 
     return NullUniValue;
 }
 
 static UniValue walletpassphrasechange(const Config &config,
                                        const JSONRPCRequest &request) {
     RPCHelpMan{
         "walletpassphrasechange",
         "Changes the wallet passphrase from 'oldpassphrase' to "
         "'newpassphrase'.\n",
         {
             {"oldpassphrase", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The current passphrase"},
             {"newpassphrase", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The new passphrase"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("walletpassphrasechange",
                                    "\"old one\" \"new one\"") +
                     HelpExampleRpc("walletpassphrasechange",
                                    "\"old one\", \"new one\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     LOCK(pwallet->cs_wallet);
 
     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) {
     RPCHelpMan{
         "walletlock",
         "Removes the wallet encryption key from memory, locking the wallet.\n"
         "After calling this method, you will need to call walletpassphrase "
         "again\n"
         "before being able to call any methods which require the wallet to be "
         "unlocked.\n",
         {},
         RPCResult{RPCResult::Type::NONE, "", ""},
         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", "")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     LOCK(pwallet->cs_wallet);
 
     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) {
     RPCHelpMan{
         "encryptwallet",
         "Encrypts 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."},
         },
         RPCResult{RPCResult::Type::STR, "",
                   "A string with further instructions"},
         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\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     LOCK(pwallet->cs_wallet);
 
     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         throw JSONRPCError(
             RPC_WALLET_ENCRYPTION_FAILED,
             "Error: wallet does not contain private keys, nothing to encrypt.");
     }
 
     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) {
     RPCHelpMan{
         "lockunspent",
         "Updates list of temporarily unspendable outputs.\n"
         "Temporarily lock (unlock=false) or unlock (unlock=true) specified "
         "transaction outputs.\n"
         "If no transaction outputs are specified when unlocking then all "
         "current locked transaction outputs are unlocked.\n"
         "A locked transaction output will not be chosen by automatic coin "
         "selection, when spending bitcoins.\n"
         "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",
                 "The transaction outputs and within each, 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{RPCResult::Type::BOOL, "",
                   "Whether the command was successful or not"},
         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}]\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     // 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();
 
     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(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) {
     RPCHelpMan{
         "listlockunspent",
         "Returns list of temporarily unspendable outputs.\n"
         "See the lockunspent call to lock and unlock transactions for "
         "spending.\n",
         {},
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::OBJ,
                        "",
                        "",
                        {
                            {RPCResult::Type::STR_HEX, "txid",
                             "The transaction id locked"},
                            {RPCResult::Type::NUM, "vout", "The vout value"},
                        }},
                   }},
         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", "")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     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) {
     RPCHelpMan{
         "settxfee",
         "Set the transaction fee per kB for this wallet. Overrides the "
         "global -paytxfee command line parameter.\n"
         "Can be deactivated by passing 0 as the fee. In that case automatic "
         "fee selection will be used by default.\n",
         {
             {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO,
              "The transaction fee in " + CURRENCY_UNIT + "/kB"},
         },
         RPCResult{RPCResult::Type::BOOL, "", "Returns true if successful"},
         RPCExamples{HelpExampleCli("settxfee", "0.00001") +
                     HelpExampleRpc("settxfee", "0.00001")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     LOCK(pwallet->cs_wallet);
 
     Amount nAmount = AmountFromValue(request.params[0]);
     CFeeRate tx_fee_rate(nAmount, 1000);
     CFeeRate max_tx_fee_rate(pwallet->m_default_max_tx_fee, 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()));
     } else if (tx_fee_rate > max_tx_fee_rate) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             strprintf("txfee cannot be more than wallet max tx fee (%s)",
                       max_tx_fee_rate.ToString()));
     }
 
     pwallet->m_pay_tx_fee = tx_fee_rate;
     return true;
 }
 
 static UniValue getbalances(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "getbalances",
         "Returns an object with all balances in " + CURRENCY_UNIT + ".\n",
         {},
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::OBJ,
                        "mine",
                        "balances from outputs that the wallet can sign",
                        {
                            {RPCResult::Type::STR_AMOUNT, "trusted",
                             "trusted balance (outputs created by the wallet or "
                             "confirmed outputs)"},
                            {RPCResult::Type::STR_AMOUNT, "untrusted_pending",
                             "untrusted pending balance (outputs created by "
                             "others that are in the mempool)"},
                            {RPCResult::Type::STR_AMOUNT, "immature",
                             "balance from immature coinbase outputs"},
                            {RPCResult::Type::STR_AMOUNT, "used",
                             "(only present if avoid_reuse is set) balance from "
                             "coins sent to addresses that were previously "
                             "spent from (potentially privacy violating)"},
                        }},
                       {RPCResult::Type::OBJ,
                        "watchonly",
                        "watchonly balances (not present if wallet does not "
                        "watch anything)",
                        {
                            {RPCResult::Type::STR_AMOUNT, "trusted",
                             "trusted balance (outputs created by the wallet or "
                             "confirmed outputs)"},
                            {RPCResult::Type::STR_AMOUNT, "untrusted_pending",
                             "untrusted pending balance (outputs created by "
                             "others that are in the mempool)"},
                            {RPCResult::Type::STR_AMOUNT, "immature",
                             "balance from immature coinbase outputs"},
                        }},
                   }},
         RPCExamples{HelpExampleCli("getbalances", "") +
                     HelpExampleRpc("getbalances", "")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const rpc_wallet =
         GetWalletForJSONRPCRequest(request);
     if (!rpc_wallet) {
         return NullUniValue;
     }
     CWallet &wallet = *rpc_wallet;
 
     // 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
     wallet.BlockUntilSyncedToCurrentChain();
 
     LOCK(wallet.cs_wallet);
 
     const auto bal = wallet.GetBalance();
     UniValue balances{UniValue::VOBJ};
     {
         UniValue balances_mine{UniValue::VOBJ};
-        balances_mine.pushKV("trusted", ValueFromAmount(bal.m_mine_trusted));
-        balances_mine.pushKV("untrusted_pending",
-                             ValueFromAmount(bal.m_mine_untrusted_pending));
-        balances_mine.pushKV("immature", ValueFromAmount(bal.m_mine_immature));
+        balances_mine.pushKV("trusted", bal.m_mine_trusted);
+        balances_mine.pushKV("untrusted_pending", bal.m_mine_untrusted_pending);
+        balances_mine.pushKV("immature", bal.m_mine_immature);
         if (wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
             // If the AVOID_REUSE flag is set, bal has been set to just the
             // un-reused address balance. Get the total balance, and then
             // subtract bal to get the reused address balance.
             const auto full_bal = wallet.GetBalance(0, false);
-            balances_mine.pushKV(
-                "used", ValueFromAmount(full_bal.m_mine_trusted +
-                                        full_bal.m_mine_untrusted_pending -
-                                        bal.m_mine_trusted -
-                                        bal.m_mine_untrusted_pending));
+            balances_mine.pushKV("used", full_bal.m_mine_trusted +
+                                             full_bal.m_mine_untrusted_pending -
+                                             bal.m_mine_trusted -
+                                             bal.m_mine_untrusted_pending);
         }
         balances.pushKV("mine", balances_mine);
     }
     auto spk_man = wallet.GetLegacyScriptPubKeyMan();
     if (spk_man && spk_man->HaveWatchOnly()) {
         UniValue balances_watchonly{UniValue::VOBJ};
-        balances_watchonly.pushKV("trusted",
-                                  ValueFromAmount(bal.m_watchonly_trusted));
-        balances_watchonly.pushKV(
-            "untrusted_pending",
-            ValueFromAmount(bal.m_watchonly_untrusted_pending));
-        balances_watchonly.pushKV("immature",
-                                  ValueFromAmount(bal.m_watchonly_immature));
+        balances_watchonly.pushKV("trusted", bal.m_watchonly_trusted);
+        balances_watchonly.pushKV("untrusted_pending",
+                                  bal.m_watchonly_untrusted_pending);
+        balances_watchonly.pushKV("immature", bal.m_watchonly_immature);
         balances.pushKV("watchonly", balances_watchonly);
     }
     return balances;
 }
 
 static UniValue getwalletinfo(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "getwalletinfo",
         "Returns an object containing various wallet state info.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {{
                 {RPCResult::Type::STR, "walletname", "the wallet name"},
                 {RPCResult::Type::NUM, "walletversion", "the wallet version"},
                 {RPCResult::Type::STR_AMOUNT, "balance",
                  "DEPRECATED. Identical to getbalances().mine.trusted"},
                 {RPCResult::Type::STR_AMOUNT, "unconfirmed_balance",
                  "DEPRECATED. Identical to "
                  "getbalances().mine.untrusted_pending"},
                 {RPCResult::Type::STR_AMOUNT, "immature_balance",
                  "DEPRECATED. Identical to getbalances().mine.immature"},
                 {RPCResult::Type::NUM, "txcount",
                  "the total number of transactions in the wallet"},
                 {RPCResult::Type::NUM_TIME, "keypoololdest",
                  "the " + UNIX_EPOCH_TIME +
                      " of the oldest pre-generated key in the key pool. Legacy "
                      "wallets only."},
                 {RPCResult::Type::NUM, "keypoolsize",
                  "how many new keys are pre-generated (only counts external "
                  "keys)"},
                 {RPCResult::Type::NUM, "keypoolsize_hd_internal",
                  "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)"},
                 {RPCResult::Type::NUM_TIME, "unlocked_until",
                  "the " + UNIX_EPOCH_TIME +
                      " until which the wallet is unlocked for transfers, or 0 "
                      "if the wallet is locked"},
                 {RPCResult::Type::STR_AMOUNT, "paytxfee",
                  "the transaction fee configuration, set in " + CURRENCY_UNIT +
                      "/kB"},
                 {RPCResult::Type::STR_HEX, "hdseedid", /* optional */ true,
                  "the Hash160 of the HD seed (only present when HD is "
                  "enabled)"},
                 {RPCResult::Type::BOOL, "private_keys_enabled",
                  "false if privatekeys are disabled for this wallet (enforced "
                  "watch-only wallet)"},
                 {RPCResult::Type::OBJ,
                  "scanning",
                  "current scanning details, or false if no scan is in progress",
                  {
                      {RPCResult::Type::NUM, "duration",
                       "elapsed seconds since scan start"},
                      {RPCResult::Type::NUM, "progress",
                       "scanning progress percentage [0.0, 1.0]"},
                  }},
                 {RPCResult::Type::BOOL, "avoid_reuse",
                  "whether this wallet tracks clean/dirty coins in terms of "
                  "reuse"},
                 {RPCResult::Type::BOOL, "descriptors",
                  "whether this wallet uses descriptors for scriptPubKey "
                  "management"},
             }},
         },
         RPCExamples{HelpExampleCli("getwalletinfo", "") +
                     HelpExampleRpc("getwalletinfo", "")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     // 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();
 
     LOCK(pwallet->cs_wallet);
 
     UniValue obj(UniValue::VOBJ);
 
     size_t kpExternalSize = pwallet->KeypoolCountExternalKeys();
     const auto bal = pwallet->GetBalance();
     int64_t kp_oldest = pwallet->GetOldestKeyPoolTime();
     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("balance", bal.m_mine_trusted);
+    obj.pushKV("unconfirmed_balance", bal.m_mine_untrusted_pending);
+    obj.pushKV("immature_balance", bal.m_mine_immature);
     obj.pushKV("txcount", (int)pwallet->mapWallet.size());
     if (kp_oldest > 0) {
         obj.pushKV("keypoololdest", kp_oldest);
     }
     obj.pushKV("keypoolsize", (int64_t)kpExternalSize);
 
     LegacyScriptPubKeyMan *spk_man = pwallet->GetLegacyScriptPubKeyMan();
     if (spk_man) {
         CKeyID seed_id = spk_man->GetHDChain().seed_id;
         if (!seed_id.IsNull()) {
             obj.pushKV("hdseedid", seed_id.GetHex());
         }
     }
 
     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()));
+    obj.pushKV("paytxfee", pwallet->m_pay_tx_fee.GetFeePerK());
     obj.pushKV("private_keys_enabled",
                !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
     if (pwallet->IsScanning()) {
         UniValue scanning(UniValue::VOBJ);
         scanning.pushKV("duration", pwallet->ScanningDuration() / 1000);
         scanning.pushKV("progress", pwallet->ScanningProgress());
         obj.pushKV("scanning", scanning);
     } else {
         obj.pushKV("scanning", false);
     }
     obj.pushKV("avoid_reuse",
                pwallet->IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE));
     obj.pushKV("descriptors",
                pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
     return obj;
 }
 
 static UniValue listwalletdir(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "listwalletdir",
         "Returns a list of wallets in the wallet directory.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::ARR,
                  "wallets",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR, "name", "The wallet name"},
                       }},
                  }},
             }},
         RPCExamples{HelpExampleCli("listwalletdir", "") +
                     HelpExampleRpc("listwalletdir", "")},
     }
         .Check(request);
 
     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) {
     RPCHelpMan{
         "listwallets",
         "Returns a list of currently loaded wallets.\n"
         "For full information on the wallet, use \"getwalletinfo\"\n",
         {},
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "walletname", "the wallet name"},
                   }},
         RPCExamples{HelpExampleCli("listwallets", "") +
                     HelpExampleRpc("listwallets", "")},
     }
         .Check(request);
 
     UniValue obj(UniValue::VARR);
 
     for (const std::shared_ptr<CWallet> &wallet : GetWallets()) {
         LOCK(wallet->cs_wallet);
         obj.push_back(wallet->GetName());
     }
 
     return obj;
 }
 
 static UniValue loadwallet(const Config &config,
                            const JSONRPCRequest &request) {
     RPCHelpMan{
         "loadwallet",
         "Loads a wallet from a wallet file or directory."
         "\nNote that all wallet command-line options used when starting "
         "bitcoind will be"
         "\napplied to the new wallet (eg -zapwallettxes, rescan, etc).\n",
         {
             {"filename", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The wallet directory or .dat file."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "name",
                        "The wallet name if loaded successfully."},
                       {RPCResult::Type::STR, "warning",
                        "Warning message if wallet was not loaded cleanly."},
                   }},
         RPCExamples{HelpExampleCli("loadwallet", "\"test.dat\"") +
                     HelpExampleRpc("loadwallet", "\"test.dat\"")},
     }
         .Check(request);
 
     const CChainParams &chainParams = config.GetChainParams();
 
     WalletContext &context = EnsureWalletContext(request.context);
     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.");
         }
     }
 
     bilingual_str error;
     std::vector<bilingual_str> warnings;
     std::shared_ptr<CWallet> const wallet =
         LoadWallet(chainParams, *context.chain, location, error, warnings);
     if (!wallet) {
         throw JSONRPCError(RPC_WALLET_ERROR, error.original);
     }
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("name", wallet->GetName());
     obj.pushKV("warning", Join(warnings, Untranslated("\n")).original);
 
     return obj;
 }
 
 static UniValue setwalletflag(const Config &config,
                               const JSONRPCRequest &request) {
     std::string flags = "";
     for (auto &it : WALLET_FLAG_MAP) {
         if (it.second & MUTABLE_WALLET_FLAGS) {
             flags += (flags == "" ? "" : ", ") + it.first;
         }
     }
     RPCHelpMan{
         "setwalletflag",
         "Change the state of the given wallet flag for a wallet.\n",
         {
             {"flag", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The name of the flag to change. Current available flags: " +
                  flags},
             {"value", RPCArg::Type::BOOL, /* default */ "true",
              "The new state."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "flag_name",
                        "The name of the flag that was modified"},
                       {RPCResult::Type::BOOL, "flag_state",
                        "The new state of the flag"},
                       {RPCResult::Type::STR, "warnings",
                        "Any warnings associated with the change"},
                   }},
         RPCExamples{HelpExampleCli("setwalletflag", "avoid_reuse") +
                     HelpExampleRpc("setwalletflag", "\"avoid_reuse\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     std::string flag_str = request.params[0].get_str();
     bool value = request.params[1].isNull() || request.params[1].get_bool();
 
     if (!WALLET_FLAG_MAP.count(flag_str)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            strprintf("Unknown wallet flag: %s", flag_str));
     }
 
     auto flag = WALLET_FLAG_MAP.at(flag_str);
 
     if (!(flag & MUTABLE_WALLET_FLAGS)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            strprintf("Wallet flag is immutable: %s", flag_str));
     }
 
     UniValue res(UniValue::VOBJ);
 
     if (pwallet->IsWalletFlagSet(flag) == value) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            strprintf("Wallet flag is already set to %s: %s",
                                      value ? "true" : "false", flag_str));
     }
 
     res.pushKV("flag_name", flag_str);
     res.pushKV("flag_state", value);
 
     if (value) {
         pwallet->SetWalletFlag(flag);
     } else {
         pwallet->UnsetWalletFlag(flag);
     }
 
     if (flag && value && WALLET_FLAG_CAVEATS.count(flag)) {
         res.pushKV("warnings", WALLET_FLAG_CAVEATS.at(flag));
     }
 
     return res;
 }
 
 static UniValue createwallet(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "createwallet",
         "Creates and loads a new wallet.\n",
         {
             {"wallet_name", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The name for the new wallet. If this is a path, the wallet will "
              "be created at the path location."},
             {"disable_private_keys", RPCArg::Type::BOOL, /* 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."},
             {"passphrase", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
              "Encrypt the wallet with this passphrase."},
             {"avoid_reuse", RPCArg::Type::BOOL, /* default */ "false",
              "Keep track of coin reuse, and treat dirty and clean coins "
              "differently with privacy considerations in mind."},
             {"descriptors", RPCArg::Type::BOOL, /* default */ "false",
              "Create a native descriptor wallet. The wallet will use "
              "descriptors internally to handle address creation"},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "name",
                        "The wallet name if created successfully. If the wallet "
                        "was created using a full path, the wallet_name will be "
                        "the full path."},
                       {RPCResult::Type::STR, "warning",
                        "Warning message if wallet was not loaded cleanly."},
                   }},
         RPCExamples{HelpExampleCli("createwallet", "\"testwallet\"") +
                     HelpExampleRpc("createwallet", "\"testwallet\"")},
     }
         .Check(request);
 
     WalletContext &context = EnsureWalletContext(request.context);
     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;
     }
 
     SecureString passphrase;
     passphrase.reserve(100);
     std::vector<bilingual_str> warnings;
     if (!request.params[3].isNull()) {
         passphrase = request.params[3].get_str().c_str();
         if (passphrase.empty()) {
             // Empty string means unencrypted
             warnings.emplace_back(
                 Untranslated("Empty string given as passphrase, wallet will "
                              "not be encrypted."));
         }
     }
 
     if (!request.params[4].isNull() && request.params[4].get_bool()) {
         flags |= WALLET_FLAG_AVOID_REUSE;
     }
     if (!request.params[5].isNull() && request.params[5].get_bool()) {
         flags |= WALLET_FLAG_DESCRIPTORS;
         warnings.emplace_back(
             Untranslated("Wallet is an experimental descriptor wallet"));
     }
 
     bilingual_str error;
     std::shared_ptr<CWallet> wallet;
     WalletCreationStatus status =
         CreateWallet(config.GetChainParams(), *context.chain, passphrase, flags,
                      request.params[0].get_str(), error, warnings, wallet);
     switch (status) {
         case WalletCreationStatus::CREATION_FAILED:
             throw JSONRPCError(RPC_WALLET_ERROR, error.original);
         case WalletCreationStatus::ENCRYPTION_FAILED:
             throw JSONRPCError(RPC_WALLET_ENCRYPTION_FAILED, error.original);
         case WalletCreationStatus::SUCCESS:
             break;
             // no default case, so the compiler can warn about missing cases
     }
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("name", wallet->GetName());
     obj.pushKV("warning", Join(warnings, Untranslated("\n")).original);
 
     return obj;
 }
 
 static UniValue unloadwallet(const Config &config,
                              const JSONRPCRequest &request) {
     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."},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("unloadwallet", "wallet_name") +
                     HelpExampleRpc("unloadwallet", "wallet_name")},
     }
         .Check(request);
 
     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) {
     RPCHelpMan{
         "listunspent",
         "Returns array of unspent transaction outputs\n"
         "with between minconf and maxconf (inclusive) confirmations.\n"
         "Optionally filter to only include txouts paid to specified "
         "addresses.\n",
         {
             {"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",
                 "The 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{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "",
                  "",
                  {
                      {RPCResult::Type::STR_HEX, "txid", "the transaction id"},
                      {RPCResult::Type::NUM, "vout", "the vout value"},
                      {RPCResult::Type::STR, "address", "the bitcoin address"},
                      {RPCResult::Type::STR, "label",
                       "The associated label, or \"\" for the default label"},
                      {RPCResult::Type::STR, "scriptPubKey", "the script key"},
                      {RPCResult::Type::STR_AMOUNT, "amount",
                       "the transaction output amount in " + CURRENCY_UNIT},
                      {RPCResult::Type::NUM, "confirmations",
                       "The number of confirmations"},
                      {RPCResult::Type::STR_HEX, "redeemScript",
                       "The redeemScript if scriptPubKey is P2SH"},
                      {RPCResult::Type::BOOL, "spendable",
                       "Whether we have the private keys to spend this output"},
                      {RPCResult::Type::BOOL, "solvable",
                       "Whether we know how to spend this output, ignoring the "
                       "lack of keys"},
                      {RPCResult::Type::BOOL, "reused",
                       "(only present if avoid_reuse is set) Whether this "
                       "output is reused/dirty (sent to an address that was "
                       "previously spent from)"},
                      {RPCResult::Type::STR, "desc",
                       "(only when solvable) A descriptor for spending this "
                       "output"},
                      {RPCResult::Type::BOOL, "safe",
                       "Whether this output is considered safe to spend. "
                       "Unconfirmed transactions\n"
                       "from outside keys and unconfirmed replacement "
                       "transactions are considered unsafe\n"
                       "and are not eligible for spending by fundrawtransaction "
                       "and sendtoaddress."},
                  }},
             }},
         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 } ")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     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(), wallet->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;
     {
         CCoinControl cctl;
         cctl.m_avoid_address_reuse = false;
         cctl.m_min_depth = nMinDepth;
         cctl.m_max_depth = nMaxDepth;
         LOCK(pwallet->cs_wallet);
         pwallet->AvailableCoins(vecOutputs, !include_unsafe, &cctl,
                                 nMinimumAmount, nMaximumAmount,
                                 nMinimumSumAmount, nMaximumCount);
     }
 
     LOCK(pwallet->cs_wallet);
 
     const bool avoid_reuse = pwallet->IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE);
 
     for (const COutput &out : vecOutputs) {
         CTxDestination address;
         const CScript &scriptPubKey = out.tx->tx->vout[out.i].scriptPubKey;
         bool fValidAddress = ExtractDestination(scriptPubKey, address);
         bool reused =
             avoid_reuse && pwallet->IsSpentKey(out.tx->GetId(), out.i);
 
         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));
 
             const auto *address_book_entry =
                 pwallet->FindAddressBookEntry(address);
             if (address_book_entry) {
                 entry.pushKV("label", address_book_entry->GetLabel());
             }
 
             std::unique_ptr<SigningProvider> provider =
                 pwallet->GetSolvingProvider(scriptPubKey);
             if (provider) {
                 if (scriptPubKey.IsPayToScriptHash()) {
                     const CScriptID &hash =
                         CScriptID(boost::get<ScriptHash>(address));
                     CScript redeemScript;
                     if (provider->GetCScript(hash, redeemScript)) {
                         entry.pushKV("redeemScript", HexStr(redeemScript));
                     }
                 }
             }
         }
 
         entry.pushKV("scriptPubKey", HexStr(scriptPubKey));
-        entry.pushKV("amount", ValueFromAmount(out.tx->tx->vout[out.i].nValue));
+        entry.pushKV("amount", 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) {
             std::unique_ptr<SigningProvider> provider =
                 pwallet->GetSolvingProvider(scriptPubKey);
             if (provider) {
                 auto descriptor = InferDescriptor(scriptPubKey, *provider);
                 entry.pushKV("desc", descriptor->ToString());
             }
         }
         if (avoid_reuse) {
             entry.pushKV("reused", reused);
         }
         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,
                      CCoinControl &coinControl) {
     // 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();
 
     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,
                 {
                     {"add_inputs", UniValueType(UniValue::VBOOL)},
                     {"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("add_inputs")) {
                 coinControl.m_add_inputs = options["add_inputs"].get_bool();
             }
 
             if (options.exists("changeAddress")) {
                 CTxDestination dest =
                     DecodeDestination(options["changeAddress"].get_str(),
                                       pwallet->GetChainParams());
 
                 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();
             }
 
             coinControl.fAllowWatchOnly =
                 ParseIncludeWatchonly(options["includeWatching"], *pwallet);
 
             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();
             }
         }
     } else {
         // if options is null and not a bool
         coinControl.fAllowWatchOnly =
             ParseIncludeWatchonly(NullUniValue, *pwallet);
     }
 
     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);
     }
 
     bilingual_str error;
 
     if (!pwallet->FundTransaction(tx, fee_out, change_position, error,
                                   lockUnspents, setSubtractFeeFromOutputs,
                                   coinControl)) {
         throw JSONRPCError(RPC_WALLET_ERROR, error.original);
     }
 }
 
 static UniValue fundrawtransaction(const Config &config,
                                    const JSONRPCRequest &request) {
     RPCHelpMan{
         "fundrawtransaction",
         "If the transaction has no inputs, they will be automatically selected "
         "to meet its out value.\n"
         "It will add at most one change output to the outputs.\n"
         "No existing outputs will be modified unless "
         "\"subtractFeeFromOutputs\" is specified.\n"
         "Note that inputs which were signed may need to be resigned after "
         "completion since in/outputs have been added.\n"
         "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}",
              {
                  {"add_inputs", RPCArg::Type::BOOL, /* default */ "true",
                   "For a transaction with existing inputs, automatically "
                   "include more if they are not enough."},
                  {"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 */ "true for watch-only wallets, otherwise false",
                   "Also select inputs which are watch only.\n"
                   "Only solvable inputs can be used. Watch-only destinations "
                   "are solvable if the public key and/or output script was "
                   "imported,\n"
                   "e.g. with 'importpubkey' or 'importmulti' with the "
                   "'pubkeys' or 'desc' field."},
                  {"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",
                      "The 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{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR_HEX, "hex",
                  "The resulting raw transaction (hex-encoded string)"},
                 {RPCResult::Type::STR_AMOUNT, "fee",
                  "Fee in " + CURRENCY_UNIT + " the resulting transaction pays"},
                 {RPCResult::Type::NUM, "changepos",
                  "The position of the added change output, or -1"},
             }},
         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\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     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;
     CCoinControl coin_control;
     // Automatically select (additional) coins. Can be overridden by
     // options.add_inputs.
     coin_control.m_add_inputs = true;
     FundTransaction(pwallet, tx, fee, change_position, request.params[1],
                     coin_control);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("hex", EncodeHexTx(CTransaction(tx)));
-    result.pushKV("fee", ValueFromAmount(fee));
+    result.pushKV("fee", fee);
     result.pushKV("changepos", change_position);
 
     return result;
 }
 
 UniValue signrawtransactionwithwallet(const Config &config,
                                       const JSONRPCRequest &request) {
     RPCHelpMan{
         "signrawtransactionwithwallet",
         "Sign inputs for raw transaction (serialized, hex-encoded).\n"
         "The second optional argument (may be null) is an array of previous "
         "transaction outputs that\n"
         "this transaction depends on but may not yet be in the block chain.\n" +
             HELP_REQUIRING_PASSPHRASE,
         {
             {"hexstring", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The transaction hex string"},
             {
                 "prevtxs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::OMITTED_NAMED_ARG,
                 "The previous dependent transaction outputs",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                             {"scriptPubKey", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "script key"},
                             {"redeemScript", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::OMITTED, "(required for P2SH)"},
                             {"amount", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO, "The amount spent"},
                         },
                     },
                 },
             },
             {"sighashtype", RPCArg::Type::STR, /* default */ "ALL|FORKID",
              "The signature hash type. Must be one of\n"
              "       \"ALL|FORKID\"\n"
              "       \"NONE|FORKID\"\n"
              "       \"SINGLE|FORKID\"\n"
              "       \"ALL|FORKID|ANYONECANPAY\"\n"
              "       \"NONE|FORKID|ANYONECANPAY\"\n"
              "       \"SINGLE|FORKID|ANYONECANPAY\""},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR_HEX, "hex",
                  "The hex-encoded raw transaction with signature(s)"},
                 {RPCResult::Type::BOOL, "complete",
                  "If the transaction has a complete set of signatures"},
                 {RPCResult::Type::ARR,
                  "errors",
                  "Script verification errors (if there are any)",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "txid",
                            "The hash of the referenced, previous transaction"},
                           {RPCResult::Type::NUM, "vout",
                            "The index of the output to spent and used as "
                            "input"},
                           {RPCResult::Type::STR_HEX, "scriptSig",
                            "The hex-encoded signature script"},
                           {RPCResult::Type::NUM, "sequence",
                            "Script sequence number"},
                           {RPCResult::Type::STR, "error",
                            "Verification or signing error related to the "
                            "input"},
                       }},
                  }},
             }},
         RPCExamples{
             HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
             HelpExampleRpc("signrawtransactionwithwallet", "\"myhex\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     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
     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);
 
     // Parse the prevtxs array
     ParsePrevouts(request.params[1], nullptr, coins);
 
     SigHashType nHashType = ParseSighashString(request.params[2]);
     if (!nHashType.hasForkId()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Signature must use SIGHASH_FORKID");
     }
 
     // Script verification errors
     std::map<int, std::string> input_errors;
 
     bool complete =
         pwallet->SignTransaction(mtx, coins, nHashType, input_errors);
     UniValue result(UniValue::VOBJ);
     SignTransactionResultToJSON(mtx, complete, coins, input_errors, result);
     return result;
 }
 
 UniValue rescanblockchain(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "rescanblockchain",
         "Rescan the local blockchain for wallet related transactions.\n"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\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{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "start_height",
                  "The block height where the rescan started (the requested "
                  "height or 0)"},
                 {RPCResult::Type::NUM, "stop_height",
                  "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."},
             }},
         RPCExamples{HelpExampleCli("rescanblockchain", "100000 120000") +
                     HelpExampleRpc("rescanblockchain", "100000, 120000")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     WalletRescanReserver reserver(*pwallet);
     if (!reserver.reserve()) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Wallet is currently rescanning. Abort existing rescan or wait.");
     }
 
     int start_height = 0;
     std::optional<int> stop_height;
     BlockHash start_block;
     {
         LOCK(pwallet->cs_wallet);
         int tip_height = pwallet->GetLastBlockHeight();
 
         if (!request.params[0].isNull()) {
             start_height = request.params[0].get_int();
             if (start_height < 0 || start_height > tip_height) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Invalid start_height");
             }
         }
 
         if (!request.params[1].isNull()) {
             stop_height = request.params[1].get_int();
             if (*stop_height < 0 || *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 (!pwallet->chain().hasBlocks(pwallet->GetLastBlockHash(),
                                         start_height, stop_height)) {
             throw JSONRPCError(
                 RPC_MISC_ERROR,
                 "Can't rescan beyond pruned data. Use RPC call "
                 "getblockchaininfo to determine your pruned height.");
         }
 
         CHECK_NONFATAL(pwallet->chain().findAncestorByHeight(
             pwallet->GetLastBlockHash(), start_height,
             FoundBlock().hash(start_block)));
     }
 
     CWallet::ScanResult result = pwallet->ScanForWalletTransactions(
         start_block, start_height, stop_height, 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:
     const SigningProvider *const provider;
 
     void ProcessSubScript(const CScript &subscript, UniValue &obj) const {
         // Always present: script type and redeemscript
         std::vector<std::vector<uint8_t>> solutions_data;
         TxoutType which_type = Solver(subscript, solutions_data);
         obj.pushKV("script", GetTxnOutputType(which_type));
         obj.pushKV("hex", HexStr(subscript));
 
         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));
             // 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 == TxoutType::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));
             }
             obj.pushKV("pubkeys", std::move(pubkeys));
         }
     }
 
     explicit DescribeWalletAddressVisitor(const SigningProvider *_provider)
         : provider(_provider) {}
 
     UniValue operator()(const CNoDestination &dest) const {
         return UniValue(UniValue::VOBJ);
     }
 
     UniValue operator()(const PKHash &pkhash) const {
         CKeyID keyID(ToKeyID(pkhash));
         UniValue obj(UniValue::VOBJ);
         CPubKey vchPubKey;
         if (provider && provider->GetPubKey(keyID, vchPubKey)) {
             obj.pushKV("pubkey", HexStr(vchPubKey));
             obj.pushKV("iscompressed", vchPubKey.IsCompressed());
         }
         return obj;
     }
 
     UniValue operator()(const ScriptHash &scripthash) const {
         CScriptID scriptID(scripthash);
         UniValue obj(UniValue::VOBJ);
         CScript subscript;
         if (provider && provider->GetCScript(scriptID, subscript)) {
             ProcessSubScript(subscript, obj);
         }
         return obj;
     }
 };
 
 static UniValue DescribeWalletAddress(const CWallet *const pwallet,
                                       const CTxDestination &dest) {
     UniValue ret(UniValue::VOBJ);
     UniValue detail = DescribeAddress(dest);
     CScript script = GetScriptForDestination(dest);
     std::unique_ptr<SigningProvider> provider = nullptr;
     if (pwallet) {
         provider = pwallet->GetSolvingProvider(script);
     }
     ret.pushKVs(detail);
     ret.pushKVs(boost::apply_visitor(
         DescribeWalletAddressVisitor(provider.get()), 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.GetLabel());
     }
     ret.pushKV("purpose", data.purpose);
     return ret;
 }
 
 UniValue getaddressinfo(const Config &config, const JSONRPCRequest &request) {
     RPCHelpMan{
         "getaddressinfo",
         "\nReturn information about the given bitcoin address.\n"
         "Some of the information will only be present if the address is in the "
         "active wallet.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address for which to get information."},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR, "address",
                  "The bitcoin address validated."},
                 {RPCResult::Type::STR_HEX, "scriptPubKey",
                  "The hex-encoded scriptPubKey generated by the address."},
                 {RPCResult::Type::BOOL, "ismine", "If the address is yours."},
                 {RPCResult::Type::BOOL, "iswatchonly",
                  "If the address is watchonly."},
                 {RPCResult::Type::BOOL, "solvable",
                  "If we know how to spend coins sent to this address, ignoring "
                  "the possible lack of private keys."},
                 {RPCResult::Type::STR, "desc", /* optional */ true,
                  "A descriptor for spending coins sent to this address (only "
                  "when solvable)."},
                 {RPCResult::Type::BOOL, "isscript", "If the key is a script."},
                 {RPCResult::Type::BOOL, "ischange",
                  "If the address was used for change output."},
                 {RPCResult::Type::STR, "script", /* optional */ true,
                  "The output script type. Only if isscript is true and the "
                  "redeemscript is known. Possible\n"
                  "                                                         "
                  "types: nonstandard, pubkey, pubkeyhash, scripthash, "
                  "multisig, nulldata."},
                 {RPCResult::Type::STR_HEX, "hex", /* optional */ true,
                  "The redeemscript for the p2sh address."},
                 {RPCResult::Type::ARR,
                  "pubkeys",
                  /* optional */ true,
                  "Array of pubkeys associated with the known redeemscript "
                  "(only if script is multisig).",
                  {
                      {RPCResult::Type::STR, "pubkey", ""},
                  }},
                 {RPCResult::Type::NUM, "sigsrequired", /* optional */ true,
                  "The number of signatures required to spend multisig output "
                  "(only if script is multisig)."},
                 {RPCResult::Type::STR_HEX, "pubkey", /* optional */ true,
                  "The hex value of the raw public key for single-key addresses "
                  "(possibly embedded in P2SH)."},
                 {RPCResult::Type::OBJ,
                  "embedded",
                  /* optional */ true,
                  "Information about the address embedded in P2SH, if "
                  "relevant and known.",
                  {
                      {RPCResult::Type::ELISION, "",
                       "Includes all\n"
                       "                                                        "
                       " getaddressinfo output fields for the embedded address, "
                       "excluding metadata (timestamp, hdkeypath,\n"
                       "hdseedid) and relation to the wallet (ismine, "
                       "iswatchonly)."},
                  }},
                 {RPCResult::Type::BOOL, "iscompressed", /* optional */ true,
                  "If the pubkey is compressed."},
                 {RPCResult::Type::STR, "label",
                  "DEPRECATED. The label associated with the address. Defaults "
                  "to \"\". Replaced by the labels array below."},
                 {RPCResult::Type::NUM_TIME, "timestamp", /* optional */ true,
                  "The creation time of the key, if available, expressed in " +
                      UNIX_EPOCH_TIME + "."},
                 {RPCResult::Type::STR, "hdkeypath", /* optional */ true,
                  "The HD keypath, if the key is HD and available."},
                 {RPCResult::Type::STR_HEX, "hdseedid", /* optional */ true,
                  "The Hash160 of the HD seed."},
                 {RPCResult::Type::STR_HEX, "hdmasterfingerprint",
                  /* optional */ true, "The fingerprint of the master key."},
                 {RPCResult::Type::ARR,
                  "labels",
                  "Array of labels associated with the address. Currently "
                  "limited to one label but returned\n"
                  "as an array to keep the API stable if multiple labels are "
                  "enabled in the future.",
                  {
                      {RPCResult::Type::STR, "label name",
                       "The label name. Defaults to \"\"."},
                      {RPCResult::Type::OBJ,
                       "",
                       "DEPRECATED, will be removed in a future version. To "
                       "re-enable, launch bitcoind with "
                       "`-deprecatedrpc=labelspurpose`",
                       {
                           {RPCResult::Type::STR, "name",
                            "The label name. Defaults to \"\"."},
                           {RPCResult::Type::STR, "purpose",
                            "The purpose of the associated address (send or "
                            "receive)."},
                       }},
                  }},
             }},
         RPCExamples{HelpExampleCli("getaddressinfo", EXAMPLE_ADDRESS) +
                     HelpExampleRpc("getaddressinfo", EXAMPLE_ADDRESS)},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     LOCK(pwallet->cs_wallet);
 
     UniValue ret(UniValue::VOBJ);
     CTxDestination dest = DecodeDestination(request.params[0].get_str(),
                                             wallet->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));
 
     std::unique_ptr<SigningProvider> provider =
         pwallet->GetSolvingProvider(scriptPubKey);
 
     isminetype mine = pwallet->IsMine(dest);
     ret.pushKV("ismine", bool(mine & ISMINE_SPENDABLE));
 
     bool solvable = provider && IsSolvable(*provider, scriptPubKey);
     ret.pushKV("solvable", solvable);
 
     if (solvable) {
         ret.pushKV("desc",
                    InferDescriptor(scriptPubKey, *provider)->ToString());
     }
 
     ret.pushKV("iswatchonly", bool(mine & ISMINE_WATCH_ONLY));
 
     UniValue detail = DescribeWalletAddress(pwallet, dest);
     ret.pushKVs(detail);
 
     // DEPRECATED: Return label field if existing. Currently only one label can
     // be associated with an address, so the label should be equivalent to the
     // value of the name key/value pair in the labels array below.
     const auto *address_book_entry = pwallet->FindAddressBookEntry(dest);
     if (pwallet->chain().rpcEnableDeprecated("label") && address_book_entry) {
         ret.pushKV("label", address_book_entry->GetLabel());
     }
 
     ret.pushKV("ischange", pwallet->IsChange(scriptPubKey));
 
     ScriptPubKeyMan *spk_man = pwallet->GetScriptPubKeyMan(scriptPubKey);
     if (spk_man) {
         if (const std::unique_ptr<CKeyMetadata> meta =
                 spk_man->GetMetadata(dest)) {
             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));
             }
         }
     }
 
     // Return a `labels` array containing the label associated with the address,
     // equivalent to the `label` field above. Currently only one label can be
     // associated with an address, but we return an array so the API remains
     // stable if we allow multiple labels to be associated with an address in
     // the future.
     UniValue labels(UniValue::VARR);
     if (address_book_entry) {
         // DEPRECATED: The previous behavior of returning an array containing a
         // JSON object of `name` and `purpose` key/value pairs is deprecated.
         if (pwallet->chain().rpcEnableDeprecated("labelspurpose")) {
             labels.push_back(AddressBookDataToJSON(*address_book_entry, true));
         } else {
             labels.push_back(address_book_entry->GetLabel());
         }
     }
     ret.pushKV("labels", std::move(labels));
 
     return ret;
 }
 
 UniValue getaddressesbylabel(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "getaddressesbylabel",
         "Returns the list of addresses assigned the specified label.\n",
         {
             {"label", RPCArg::Type::STR, RPCArg::Optional::NO, "The label."},
         },
         RPCResult{RPCResult::Type::OBJ_DYN,
                   "",
                   "json object with addresses as keys",
                   {
                       {RPCResult::Type::OBJ,
                        "address",
                        "Information about address",
                        {
                            {RPCResult::Type::STR, "purpose",
                             "Purpose of address (\"send\" for sending address, "
                             "\"receive\" for receiving address)"},
                        }},
                   }},
         RPCExamples{HelpExampleCli("getaddressesbylabel", "\"tabby\"") +
                     HelpExampleRpc("getaddressesbylabel", "\"tabby\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     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->m_address_book) {
         if (item.second.IsChange()) {
             continue;
         }
         if (item.second.GetLabel() == label) {
             std::string address = EncodeDestination(item.first, config);
             // CWallet::m_address_book 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;
             CHECK_NONFATAL(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) {
     RPCHelpMan{
         "listlabels",
         "Returns the list of all labels, or labels that are assigned to "
         "addresses with a specific purpose.\n",
         {
             {"purpose", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              "Address purpose to list labels for ('send','receive'). An empty "
              "string is the same as not providing this argument."},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "label", "Label name"},
                   }},
         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")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     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->m_address_book) {
         if (entry.second.IsChange()) {
             continue;
         }
         if (purpose.empty() || entry.second.purpose == purpose) {
             label_set.insert(entry.second.GetLabel());
         }
     }
 
     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) {
     RPCHelpMan{
         "sethdseed",
         "Set 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" +
             HELP_REQUIRING_PASSPHRASE,
         {
             {"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"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("sethdseed", "") +
                     HelpExampleCli("sethdseed", "false") +
                     HelpExampleCli("sethdseed", "true \"wifkey\"") +
                     HelpExampleRpc("sethdseed", "true, \"wifkey\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     LegacyScriptPubKeyMan &spk_man =
         EnsureLegacyScriptPubKeyMan(*pwallet, true);
 
     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");
     }
 
     LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);
 
     // 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. Use the upgradewallet "
             "RPC 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 = spk_man.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(spk_man, 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 = spk_man.DeriveNewSeed(key);
     }
 
     spk_man.SetHDSeed(master_pub_key);
     if (flush_key_pool) {
         spk_man.NewKeyPool();
     }
 
     return NullUniValue;
 }
 
 static UniValue walletprocesspsbt(const Config &config,
                                   const JSONRPCRequest &request) {
     RPCHelpMan{
         "walletprocesspsbt",
         "Update a PSBT with input information from our wallet and then sign "
         "inputs that we can sign for." +
             HELP_REQUIRING_PASSPHRASE,
         {
             {"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 */ "true",
              "Includes the BIP 32 derivation paths for public keys if we know "
              "them"},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "psbt",
                        "The base64-encoded partially signed transaction"},
                       {RPCResult::Type::BOOL, "complete",
                        "If the transaction has a complete set of signatures"},
                   }},
         RPCExamples{HelpExampleCli("walletprocesspsbt", "\"psbt\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     const CWallet *const pwallet = wallet.get();
 
     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() ? true : request.params[3].get_bool();
     bool complete = true;
     const TransactionError err =
         pwallet->FillPSBT(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) {
     RPCHelpMan{
         "walletcreatefundedpsbt",
         "Creates and funds a transaction in the Partially Signed Transaction "
         "format.\n"
         "Implements the Creator and Updater roles.\n",
         {
             {
                 "inputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The inputs. Leave empty to add inputs automatically. See "
                 "add_inputs option.",
                 {
                     {
                         "",
                         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,
                 "The outputs (key-value pairs), where none of "
                 "the keys are duplicated.\n"
                 "That is, each address can only appear once and there can only "
                 "be one 'data' object.\n"
                 "For compatibility reasons, a dictionary, which holds the "
                 "key-value pairs directly, is also\n"
                 "                             accepted as second parameter.",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"address", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key (string) is the "
                              "bitcoin address, the value (float or string) is "
                              "the amount in " +
                                  CURRENCY_UNIT + ""},
                         },
                     },
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"data", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key must be \"data\", the "
                              "value is hex-encoded data"},
                         },
                     },
                 },
             },
             {"locktime", RPCArg::Type::NUM, /* default */ "0",
              "Raw locktime. Non-0 value also locktime-activates inputs\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,
              "",
              {
                  {"add_inputs", RPCArg::Type::BOOL, /* default */ "false",
                   "If inputs are specified, automatically include more if they "
                   "are not enough."},
                  {"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 */ "true for watch-only wallets, otherwise 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",
                      "The outputs to subtract the fee from.\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 */ "true",
              "Includes the BIP 32 derivation paths for public keys if we know "
              "them"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR, "psbt",
                  "The resulting raw transaction (base64-encoded string)"},
                 {RPCResult::Type::STR_AMOUNT, "fee",
                  "Fee in " + CURRENCY_UNIT + " the resulting transaction pays"},
                 {RPCResult::Type::NUM, "changepos",
                  "The position of the added change output, or -1"},
             }},
         RPCExamples{
             "\nCreate a transaction with no inputs\n" +
             HelpExampleCli("walletcreatefundedpsbt",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" "
                            "\"[{\\\"data\\\":\\\"00010203\\\"}]\"")},
     }
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     RPCTypeCheck(request.params,
                  {UniValue::VARR,
                   UniValueType(), // ARR or OBJ, checked later
                   UniValue::VNUM, UniValue::VOBJ},
                  true);
 
     Amount fee;
     int change_position;
     CMutableTransaction rawTx =
         ConstructTransaction(wallet->GetChainParams(), request.params[0],
                              request.params[1], request.params[2]);
     CCoinControl coin_control;
     // Automatically select coins, unless at least one is manually selected. Can
     // be overridden by options.add_inputs.
     coin_control.m_add_inputs = rawTx.vin.size() == 0;
     FundTransaction(pwallet, rawTx, fee, change_position, request.params[3],
                     coin_control);
 
     // Make a blank psbt
     PartiallySignedTransaction psbtx(rawTx);
 
     // Fill transaction with out data but don't sign
     bool bip32derivs =
         request.params[4].isNull() ? true : request.params[4].get_bool();
     bool complete = true;
     const TransactionError err = pwallet->FillPSBT(
         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("fee", fee);
     result.pushKV("changepos", change_position);
     return result;
 }
 
 static UniValue upgradewallet(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{"upgradewallet",
                "\nUpgrade the wallet. Upgrades to the latest version if no "
                "version number is specified\n"
                "New keys may be generated and a new wallet backup will need to "
                "be made.",
                {{"version", RPCArg::Type::NUM,
                  /* default */ strprintf("%d", FEATURE_LATEST),
                  "The version number to upgrade to. Default is the latest "
                  "wallet version"}},
                RPCResult{RPCResult::Type::NONE, "", ""},
                RPCExamples{HelpExampleCli("upgradewallet", "200300") +
                            HelpExampleRpc("upgradewallet", "200300")}}
         .Check(request);
 
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     if (!wallet) {
         return NullUniValue;
     }
     CWallet *const pwallet = wallet.get();
 
     RPCTypeCheck(request.params, {UniValue::VNUM}, true);
 
     EnsureWalletIsUnlocked(pwallet);
 
     int version = 0;
     if (!request.params[0].isNull()) {
         version = request.params[0].get_int();
     }
 
     bilingual_str error;
     std::vector<bilingual_str> warnings;
     if (!pwallet->UpgradeWallet(version, error, warnings)) {
         throw JSONRPCError(RPC_WALLET_ERROR, error.original);
     }
     return error.original;
 }
 
 Span<const CRPCCommand> GetWalletRPCCommands() {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            name                            actor (function)              argNames
         //  ------------------- ------------------------        ----------------------        ----------
         { "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", "passphrase", "avoid_reuse", "descriptors"} },
         { "wallet",             "encryptwallet",                encryptwallet,                {"passphrase"} },
         { "wallet",             "getaddressesbylabel",          getaddressesbylabel,          {"label"} },
         { "wallet",             "getaddressinfo",               getaddressinfo,               {"address"} },
         { "wallet",             "getbalance",                   getbalance,                   {"dummy","minconf","include_watchonly","avoid_reuse"} },
         { "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","verbose"} },
         { "wallet",             "getunconfirmedbalance",         getunconfirmedbalance,         {} },
         { "wallet",             "getbalances",                  getbalances,                  {} },
         { "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","avoid_reuse"} },
         { "wallet",             "sethdseed",                    sethdseed,                    {"newkeypool","seed"} },
         { "wallet",             "setlabel",                     setlabel,                     {"address","label"} },
         { "wallet",             "settxfee",                     settxfee,                     {"amount"} },
         { "wallet",             "setwalletflag",                 setwalletflag,                 {"flag","value"} },
         { "wallet",             "signmessage",                  signmessage,                  {"address","message"} },
         { "wallet",             "signrawtransactionwithwallet", signrawtransactionwithwallet, {"hextring","prevtxs","sighashtype"} },
         { "wallet",             "unloadwallet",                 unloadwallet,                 {"wallet_name"} },
         { "wallet",             "upgradewallet",                upgradewallet,                {"version"} },
         { "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
 
     return MakeSpan(commands);
 }