diff --git a/src/node/transaction.cpp b/src/node/transaction.cpp
index 9e956f680..eb281ef10 100644
--- a/src/node/transaction.cpp
+++ b/src/node/transaction.cpp
@@ -1,89 +1,117 @@
 // 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 <node/transaction.h>
 
 #include <config.h>
 #include <consensus/validation.h>
 #include <net.h>
 #include <primitives/txid.h>
-#include <rpc/server.h>
 #include <txmempool.h>
 #include <validation.h>
 #include <validationinterface.h>
 
 #include <future>
 
-TxId BroadcastTransaction(const Config &config, const CTransactionRef tx,
-                          const bool allowhighfees) {
+const char *TransactionErrorString(const TransactionError err) {
+    switch (err) {
+        case TransactionError::OK:
+            return "No error";
+        case TransactionError::MISSING_INPUTS:
+            return "Missing inputs";
+        case TransactionError::ALREADY_IN_CHAIN:
+            return "Transaction already in block chain";
+        case TransactionError::P2P_DISABLED:
+            return "Peer-to-peer functionality missing or disabled";
+        case TransactionError::MEMPOOL_REJECTED:
+            return "Transaction rejected by AcceptToMemoryPool";
+        case TransactionError::MEMPOOL_ERROR:
+            return "AcceptToMemoryPool failed";
+        case TransactionError::INVALID_PSBT:
+            return "PSBT is not sane";
+        case TransactionError::SIGHASH_MISMATCH:
+            return "Specified sighash value does not match existing value";
+
+        case TransactionError::UNKNOWN_ERROR:
+        default:
+            break;
+    }
+    return "Unknown error";
+}
+
+bool BroadcastTransaction(const Config &config, const CTransactionRef tx,
+                          TxId &txid, TransactionError &error,
+                          std::string &err_string, const bool allowhighfees) {
     std::promise<void> promise;
-    const TxId &txid = tx->GetId();
+    txid = tx->GetId();
 
     Amount nMaxRawTxFee = maxTxFee;
     if (allowhighfees) {
         nMaxRawTxFee = Amount::zero();
     }
 
     { // cs_main scope
         LOCK(cs_main);
         CCoinsViewCache &view = *pcoinsTip;
         bool fHaveChain = false;
         for (size_t o = 0; !fHaveChain && o < tx->vout.size(); o++) {
             const Coin &existingCoin = view.AccessCoin(COutPoint(txid, o));
             fHaveChain = !existingCoin.IsSpent();
         }
 
         bool fHaveMempool = g_mempool.exists(txid);
         if (!fHaveMempool && !fHaveChain) {
             // Push to local node and sync with wallets.
             CValidationState state;
             bool fMissingInputs;
             if (!AcceptToMemoryPool(config, g_mempool, state, std::move(tx),
                                     &fMissingInputs, false /* bypass_limits */,
                                     nMaxRawTxFee)) {
                 if (state.IsInvalid()) {
-                    throw JSONRPCError(RPC_TRANSACTION_REJECTED,
-                                       FormatStateMessage(state));
+                    err_string = FormatStateMessage(state);
+                    error = TransactionError::MEMPOOL_REJECTED;
+                    return false;
                 }
 
                 if (fMissingInputs) {
-                    throw JSONRPCError(RPC_TRANSACTION_ERROR, "Missing inputs");
+                    error = TransactionError::MISSING_INPUTS;
+                    return false;
                 }
 
-                throw JSONRPCError(RPC_TRANSACTION_ERROR,
-                                   FormatStateMessage(state));
+                err_string = FormatStateMessage(state);
+                error = TransactionError::MEMPOOL_ERROR;
+                return false;
             } else {
                 // If wallet is enabled, ensure that the wallet has been made
                 // aware of the new transaction prior to returning. This
                 // prevents a race where a user might call sendrawtransaction
                 // with a transaction to/from their wallet, immediately call
                 // some wallet RPC, and get a stale result because callbacks
                 // have not yet been processed.
                 CallFunctionInValidationInterfaceQueue(
                     [&promise] { promise.set_value(); });
             }
         } else if (fHaveChain) {
-            throw JSONRPCError(RPC_TRANSACTION_ALREADY_IN_CHAIN,
-                               "transaction already in block chain");
+            error = TransactionError::ALREADY_IN_CHAIN;
+            return false;
         } else {
             // Make sure we don't block forever if re-sending a transaction
             // already in mempool.
             promise.set_value();
         }
     } // cs_main
 
     promise.get_future().wait();
 
     if (!g_connman) {
-        throw JSONRPCError(
-            RPC_CLIENT_P2P_DISABLED,
-            "Error: Peer-to-peer functionality missing or disabled");
+        error = TransactionError::P2P_DISABLED;
+        return false;
     }
 
     CInv inv(MSG_TX, txid);
     g_connman->ForEachNode([&inv](CNode *pnode) { pnode->PushInventory(inv); });
 
-    return txid;
+    return true;
 }
diff --git a/src/node/transaction.h b/src/node/transaction.h
index c8eea037d..dad94689e 100644
--- a/src/node/transaction.h
+++ b/src/node/transaction.h
@@ -1,17 +1,47 @@
 // Copyright (c) 2017-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_NODE_TRANSACTION_H
 #define BITCOIN_NODE_TRANSACTION_H
 
 #include <primitives/transaction.h>
 
 class Config;
 struct TxId;
 
-/** Broadcast a transaction */
-TxId BroadcastTransaction(const Config &config, CTransactionRef tx,
+enum class TransactionError {
+    OK = 0,
+    UNKNOWN_ERROR,
+
+    MISSING_INPUTS,
+    ALREADY_IN_CHAIN,
+    P2P_DISABLED,
+    MEMPOOL_REJECTED,
+    MEMPOOL_ERROR,
+    INVALID_PSBT,
+    SIGHASH_MISMATCH,
+
+    ERROR_COUNT
+};
+
+#define TRANSACTION_ERR_LAST TransactionError::ERROR_COUNT
+
+const char *TransactionErrorString(const TransactionError error);
+
+/**
+ * Broadcast a transaction
+ *
+ * @param[in]  tx the transaction to broadcast
+ * @param[out] &txid the txid of the transaction, if successfully broadcast
+ * @param[out] &error reference to UniValue to fill with error info on failure
+ * @param[out] &err_string reference to std::string to fill with error string if
+ * available
+ * @param[in]  allowhighfees whether to allow fees exceeding maxTxFee
+ * return true on success, false on error (and fills in `error`)
+ */
+bool BroadcastTransaction(const Config &config, CTransactionRef tx, TxId &txid,
+                          TransactionError &error, std::string &err_string,
                           bool allowhighfees = false);
 
 #endif // BITCOIN_NODE_TRANSACTION_H
diff --git a/src/psbt.h b/src/psbt.h
index 7650539a7..4beb4221a 100644
--- a/src/psbt.h
+++ b/src/psbt.h
@@ -1,481 +1,482 @@
 // 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.
 
 #ifndef BITCOIN_PSBT_H
 #define BITCOIN_PSBT_H
 
 #include <attributes.h>
+#include <node/transaction.h>
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <script/sign.h>
 
 // Magic bytes
 static constexpr uint8_t PSBT_MAGIC_BYTES[5] = {'p', 's', 'b', 't', 0xff};
 
 // Global types
 static constexpr uint8_t PSBT_GLOBAL_UNSIGNED_TX = 0x00;
 
 // Input types
 static constexpr uint8_t PSBT_IN_UTXO = 0x00;
 static constexpr uint8_t PSBT_IN_PARTIAL_SIG = 0x02;
 static constexpr uint8_t PSBT_IN_SIGHASH = 0x03;
 static constexpr uint8_t PSBT_IN_REDEEMSCRIPT = 0x04;
 static constexpr uint8_t PSBT_IN_BIP32_DERIVATION = 0x06;
 static constexpr uint8_t PSBT_IN_SCRIPTSIG = 0x07;
 
 // Output types
 static constexpr uint8_t PSBT_OUT_REDEEMSCRIPT = 0x00;
 static constexpr uint8_t PSBT_OUT_BIP32_DERIVATION = 0x02;
 
 // The separator is 0x00. Reading this in means that the unserializer can
 // interpret it as a 0 length key which indicates that this is the separator.
 // The separator has no value.
 static constexpr uint8_t PSBT_SEPARATOR = 0x00;
 
 /** A structure for PSBTs which contain per-input information */
 struct PSBTInput {
     CTxOut utxo;
     CScript redeem_script;
     CScript final_script_sig;
     std::map<CPubKey, KeyOriginInfo> hd_keypaths;
     std::map<CKeyID, SigPair> partial_sigs;
     std::map<std::vector<uint8_t>, std::vector<uint8_t>> unknown;
     SigHashType sighash_type = SigHashType(0);
 
     bool IsNull() const;
     void FillSignatureData(SignatureData &sigdata) const;
     void FromSignatureData(const SignatureData &sigdata);
     void Merge(const PSBTInput &input);
     bool IsSane() const;
     PSBTInput() {}
 
     template <typename Stream> inline void Serialize(Stream &s) const {
         // Write the utxo
         if (!utxo.IsNull()) {
             SerializeToVector(s, PSBT_IN_UTXO);
             SerializeToVector(s, utxo);
         }
 
         if (final_script_sig.empty()) {
             // Write any partial signatures
             for (auto sig_pair : partial_sigs) {
                 SerializeToVector(s, PSBT_IN_PARTIAL_SIG,
                                   MakeSpan(sig_pair.second.first));
                 s << sig_pair.second.second;
             }
 
             // Write the sighash type
             if (sighash_type.getRawSigHashType() != 0) {
                 SerializeToVector(s, PSBT_IN_SIGHASH);
                 SerializeToVector(s, sighash_type);
             }
 
             // Write the redeem script
             if (!redeem_script.empty()) {
                 SerializeToVector(s, PSBT_IN_REDEEMSCRIPT);
                 s << redeem_script;
             }
 
             // Write any hd keypaths
             SerializeHDKeypaths(s, hd_keypaths, PSBT_IN_BIP32_DERIVATION);
         }
 
         // Write script sig
         if (!final_script_sig.empty()) {
             SerializeToVector(s, PSBT_IN_SCRIPTSIG);
             s << final_script_sig;
         }
 
         // Write unknown things
         for (auto &entry : unknown) {
             s << entry.first;
             s << entry.second;
         }
 
         s << PSBT_SEPARATOR;
     }
 
     template <typename Stream> inline void Unserialize(Stream &s) {
         // Read loop
         while (!s.empty()) {
             // Read
             std::vector<uint8_t> key;
             s >> key;
 
             // the key is empty if that was actually a separator byte
             // This is a special case for key lengths 0 as those are not allowed
             // (except for separator)
             if (key.empty()) {
                 return;
             }
 
             // First byte of key is the type
             uint8_t type = key[0];
 
             // Do stuff based on type
             switch (type) {
                 case PSBT_IN_UTXO:
                     if (!utxo.IsNull()) {
                         throw std::ios_base::failure(
                             "Duplicate Key, input utxo already provided");
                     } else if (key.size() != 1) {
                         throw std::ios_base::failure(
                             "utxo key is more than one byte type");
                     }
                     UnserializeFromVector(s, utxo);
                     break;
                 case PSBT_IN_PARTIAL_SIG: {
                     // Make sure that the key is the size of pubkey + 1
                     if (key.size() != CPubKey::PUBLIC_KEY_SIZE + 1 &&
                         key.size() != CPubKey::COMPRESSED_PUBLIC_KEY_SIZE + 1) {
                         throw std::ios_base::failure(
                             "Size of key was not the expected size for the "
                             "type partial signature pubkey");
                     }
                     // Read in the pubkey from key
                     CPubKey pubkey(key.begin() + 1, key.end());
                     if (!pubkey.IsFullyValid()) {
                         throw std::ios_base::failure("Invalid pubkey");
                     }
                     if (partial_sigs.count(pubkey.GetID()) > 0) {
                         throw std::ios_base::failure(
                             "Duplicate Key, input partial signature for pubkey "
                             "already provided");
                     }
 
                     // Read in the signature from value
                     std::vector<uint8_t> sig;
                     s >> sig;
 
                     // Add to list
                     partial_sigs.emplace(pubkey.GetID(),
                                          SigPair(pubkey, std::move(sig)));
                     break;
                 }
                 case PSBT_IN_SIGHASH:
                     if (sighash_type.getRawSigHashType() != 0) {
                         throw std::ios_base::failure(
                             "Duplicate Key, input sighash type already "
                             "provided");
                     } else if (key.size() != 1) {
                         throw std::ios_base::failure(
                             "Sighash type key is more than one byte type");
                     }
                     UnserializeFromVector(s, sighash_type);
                     break;
                 case PSBT_IN_REDEEMSCRIPT: {
                     if (!redeem_script.empty()) {
                         throw std::ios_base::failure(
                             "Duplicate Key, input redeemScript already "
                             "provided");
                     } else if (key.size() != 1) {
                         throw std::ios_base::failure(
                             "Input redeemScript key is more than one byte "
                             "type");
                     }
                     s >> redeem_script;
                     break;
                 }
                 case PSBT_IN_BIP32_DERIVATION: {
                     DeserializeHDKeypaths(s, key, hd_keypaths);
                     break;
                 }
                 case PSBT_IN_SCRIPTSIG: {
                     if (!final_script_sig.empty()) {
                         throw std::ios_base::failure(
                             "Duplicate Key, input final scriptSig already "
                             "provided");
                     } else if (key.size() != 1) {
                         throw std::ios_base::failure(
                             "Final scriptSig key is more than one byte type");
                     }
                     s >> final_script_sig;
                     break;
                 }
                 // Unknown stuff
                 default:
                     if (unknown.count(key) > 0) {
                         throw std::ios_base::failure(
                             "Duplicate Key, key for unknown value already "
                             "provided");
                     }
                     // Read in the value
                     std::vector<uint8_t> val_bytes;
                     s >> val_bytes;
                     unknown.emplace(std::move(key), std::move(val_bytes));
                     break;
             }
         }
     }
 
     template <typename Stream> PSBTInput(deserialize_type, Stream &s) {
         Unserialize(s);
     }
 };
 
 /** A structure for PSBTs which contains per output information */
 struct PSBTOutput {
     CScript redeem_script;
     std::map<CPubKey, KeyOriginInfo> hd_keypaths;
     std::map<std::vector<uint8_t>, std::vector<uint8_t>> unknown;
 
     bool IsNull() const;
     void FillSignatureData(SignatureData &sigdata) const;
     void FromSignatureData(const SignatureData &sigdata);
     void Merge(const PSBTOutput &output);
     bool IsSane() const;
     PSBTOutput() {}
 
     template <typename Stream> inline void Serialize(Stream &s) const {
         // Write the redeem script
         if (!redeem_script.empty()) {
             SerializeToVector(s, PSBT_OUT_REDEEMSCRIPT);
             s << redeem_script;
         }
 
         // Write any hd keypaths
         SerializeHDKeypaths(s, hd_keypaths, PSBT_OUT_BIP32_DERIVATION);
 
         // Write unknown things
         for (auto &entry : unknown) {
             s << entry.first;
             s << entry.second;
         }
 
         s << PSBT_SEPARATOR;
     }
 
     template <typename Stream> inline void Unserialize(Stream &s) {
         // Read loop
         while (!s.empty()) {
             // Read
             std::vector<uint8_t> key;
             s >> key;
 
             // the key is empty if that was actually a separator byte
             // This is a special case for key lengths 0 as those are not allowed
             // (except for separator)
             if (key.empty()) {
                 return;
             }
 
             // First byte of key is the type
             uint8_t type = key[0];
 
             // Do stuff based on type
             switch (type) {
                 case PSBT_OUT_REDEEMSCRIPT: {
                     if (!redeem_script.empty()) {
                         throw std::ios_base::failure(
                             "Duplicate Key, output redeemScript already "
                             "provided");
                     } else if (key.size() != 1) {
                         throw std::ios_base::failure(
                             "Output redeemScript key is more than one byte "
                             "type");
                     }
                     s >> redeem_script;
                     break;
                 }
                 case PSBT_OUT_BIP32_DERIVATION: {
                     DeserializeHDKeypaths(s, key, hd_keypaths);
                     break;
                 }
                 // Unknown stuff
                 default: {
                     if (unknown.count(key) > 0) {
                         throw std::ios_base::failure(
                             "Duplicate Key, key for unknown value already "
                             "provided");
                     }
                     // Read in the value
                     std::vector<uint8_t> val_bytes;
                     s >> val_bytes;
                     unknown.emplace(std::move(key), std::move(val_bytes));
                     break;
                 }
             }
         }
     }
 
     template <typename Stream> PSBTOutput(deserialize_type, Stream &s) {
         Unserialize(s);
     }
 };
 
 /**
  * A version of CTransaction with the PSBT format.
  */
 struct PartiallySignedTransaction {
     boost::optional<CMutableTransaction> tx;
     std::vector<PSBTInput> inputs;
     std::vector<PSBTOutput> outputs;
     std::map<std::vector<uint8_t>, std::vector<uint8_t>> unknown;
 
     bool IsNull() const;
 
     /**
      * Merge psbt into this. The two psbts must have the same underlying
      * CTransaction (i.e. the same actual Bitcoin transaction.) Returns true if
      * the merge succeeded, false otherwise.
      */
     NODISCARD bool Merge(const PartiallySignedTransaction &psbt);
     bool IsSane() const;
     PartiallySignedTransaction() {}
     PartiallySignedTransaction(const PartiallySignedTransaction &psbt_in)
         : tx(psbt_in.tx), inputs(psbt_in.inputs), outputs(psbt_in.outputs),
           unknown(psbt_in.unknown) {}
     explicit PartiallySignedTransaction(const CTransaction &txIn);
 
     template <typename Stream> inline void Serialize(Stream &s) const {
         // magic bytes
         s << PSBT_MAGIC_BYTES;
 
         // unsigned tx flag
         SerializeToVector(s, PSBT_GLOBAL_UNSIGNED_TX);
 
         // Write serialized tx to a stream
         SerializeToVector(s, *tx);
 
         // Write the unknown things
         for (auto &entry : unknown) {
             s << entry.first;
             s << entry.second;
         }
 
         // Separator
         s << PSBT_SEPARATOR;
 
         // Write inputs
         for (const PSBTInput &input : inputs) {
             s << input;
         }
 
         // Write outputs
         for (const PSBTOutput &output : outputs) {
             s << output;
         }
     }
 
     template <typename Stream> inline void Unserialize(Stream &s) {
         // Read the magic bytes
         uint8_t magic[5];
         s >> magic;
         if (!std::equal(magic, magic + 5, PSBT_MAGIC_BYTES)) {
             throw std::ios_base::failure("Invalid PSBT magic bytes");
         }
 
         // Read global data
         while (!s.empty()) {
             // Read
             std::vector<uint8_t> key;
             s >> key;
 
             // the key is empty if that was actually a separator byte
             // This is a special case for key lengths 0 as those are not allowed
             // (except for separator)
             if (key.empty()) {
                 break;
             }
 
             // First byte of key is the type
             uint8_t type = key[0];
 
             // Do stuff based on type
             switch (type) {
                 case PSBT_GLOBAL_UNSIGNED_TX: {
                     if (tx) {
                         throw std::ios_base::failure(
                             "Duplicate Key, unsigned tx already provided");
                     } else if (key.size() != 1) {
                         throw std::ios_base::failure(
                             "Global unsigned tx key is more than one byte "
                             "type");
                     }
                     CMutableTransaction mtx;
                     UnserializeFromVector(s, mtx);
                     tx = std::move(mtx);
                     // Make sure that all scriptSigs are empty.
                     for (const CTxIn &txin : tx->vin) {
                         if (!txin.scriptSig.empty()) {
                             throw std::ios_base::failure(
                                 "Unsigned tx does not have empty scriptSigs.");
                         }
                     }
                     break;
                 }
                 // Unknown stuff
                 default: {
                     if (unknown.count(key) > 0) {
                         throw std::ios_base::failure(
                             "Duplicate Key, key for unknown value already "
                             "provided");
                     }
                     // Read in the value
                     std::vector<uint8_t> val_bytes;
                     s >> val_bytes;
                     unknown.emplace(std::move(key), std::move(val_bytes));
                 }
             }
         }
 
         // Make sure that we got an unsigned tx
         if (!tx) {
             throw std::ios_base::failure(
                 "No unsigned transcation was provided");
         }
 
         // Read input data
         size_t i = 0;
         while (!s.empty() && i < tx->vin.size()) {
             PSBTInput input;
             s >> input;
             inputs.push_back(input);
             ++i;
         }
         // Make sure that the number of inputs matches the number of inputs in
         // the transaction
         if (inputs.size() != tx->vin.size()) {
             throw std::ios_base::failure("Inputs provided does not match the "
                                          "number of inputs in transaction.");
         }
 
         // Read output data
         i = 0;
         while (!s.empty() && i < tx->vout.size()) {
             PSBTOutput output;
             s >> output;
             outputs.push_back(output);
             ++i;
         }
         // Make sure that the number of outputs matches the number of outputs in
         // the transaction
         if (outputs.size() != tx->vout.size()) {
             throw std::ios_base::failure("Outputs provided does not match the "
                                          "number of outputs in transaction.");
         }
         // Sanity check
         if (!IsSane()) {
             throw std::ios_base::failure("PSBT is not sane.");
         }
     }
 
     template <typename Stream>
     PartiallySignedTransaction(deserialize_type, Stream &s) {
         Unserialize(s);
     }
 };
 
 /** Checks whether a PSBTInput is already signed. */
 bool PSBTInputSigned(PSBTInput &input);
 
 /**
  * Signs a PSBTInput, verifying that all provided data matches what is being
  * signed.
  */
 bool SignPSBTInput(const SigningProvider &provider,
                    PartiallySignedTransaction &psbt, int index,
                    SigHashType sighash = SigHashType());
 
 #endif // BITCOIN_PSBT_H
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 5c1d044e3..7b17e4f91 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -1,2042 +1,2050 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chain.h>
 #include <chainparams.h>
 #include <coins.h>
 #include <compat/byteswap.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <index/txindex.h>
 #include <init.h>
 #include <key_io.h>
 #include <keystore.h>
 #include <merkleblock.h>
 #include <node/transaction.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <psbt.h>
 #include <rpc/rawtransaction.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/script.h>
 #include <script/script_error.h>
 #include <script/sign.h>
 #include <script/standard.h>
 #include <txmempool.h>
 #include <uint256.h>
 #include <util/strencodings.h>
 #include <validation.h>
 #include <validationinterface.h>
 
 #include <cstdint>
 
 #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) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 3) {
         throw std::runtime_error(
             RPCHelpMan{
                 "getrawtransaction",
                 "\nNOTE: By default this function only works for "
                 "mempool transactions. If the -txindex option is\n"
                 "enabled, it also works for blockchain transactions. If "
                 "the block which contains the transaction\n"
                 "is known, its hash can be provided even for nodes "
                 "without -txindex. Note that if a blockhash is\n"
                 "provided, only that block will be searched and if the "
                 "transaction is in the mempool or other\n"
                 "blocks, or if this node does not have the given block "
                 "available, the transaction will not be found.\n"
                 "DEPRECATED: for now, it also works for transactions with "
                 "unspent outputs.\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, /* opt */ false,
                      /* default_val */ "", "The transaction id"},
                     {"verbose", RPCArg::Type::BOOL, /* opt */ true,
                      /* default_val */ "false",
                      "If false, return a string, otherwise return a json "
                      "object"},
                     {"blockhash", RPCArg::Type::STR_HEX, /* opt */ true,
                      /* default_val */ "",
                      "The block in which to look for the transaction"},
                 }}
                 .ToString() +
             "\nResult (if verbose is not set or set to false):\n"
             "\"data\"      (string) The serialized, hex-encoded data for "
             "'txid'\n"
 
             "\nResult (if verbose is set to true):\n"
             "{\n"
             "  \"in_active_chain\": b, (bool) Whether specified block is in "
             "the active chain or not (only present with explicit \"blockhash\" "
             "argument)\n"
             "  \"hex\" : \"data\",       (string) The serialized, hex-encoded "
             "data for 'txid'\n"
             "  \"txid\" : \"id\",        (string) The transaction id (same as "
             "provided)\n"
             "  \"hash\" : \"id\",        (string) The transaction hash "
             "(differs from txid for witness transactions)\n"
             "  \"size\" : n,             (numeric) The serialized transaction "
             "size\n"
             "  \"version\" : n,          (numeric) The version\n"
             "  \"locktime\" : ttt,       (numeric) The lock time\n"
             "  \"vin\" : [               (array of json objects)\n"
             "     {\n"
             "       \"txid\": \"id\",    (string) The transaction id\n"
             "       \"vout\": n,         (numeric) \n"
             "       \"scriptSig\": {     (json object) The script\n"
             "         \"asm\": \"asm\",  (string) asm\n"
             "         \"hex\": \"hex\"   (string) hex\n"
             "       },\n"
             "       \"sequence\": n      (numeric) The script sequence number\n"
             "     }\n"
             "     ,...\n"
             "  ],\n"
             "  \"vout\" : [              (array of json objects)\n"
             "     {\n"
             "       \"value\" : x.xxx,            (numeric) The value in " +
             CURRENCY_UNIT +
             "\n"
             "       \"n\" : n,                    (numeric) index\n"
             "       \"scriptPubKey\" : {          (json object)\n"
             "         \"asm\" : \"asm\",          (string) the asm\n"
             "         \"hex\" : \"hex\",          (string) the hex\n"
             "         \"reqSigs\" : n,            (numeric) The required sigs\n"
             "         \"type\" : \"pubkeyhash\",  (string) The type, eg "
             "'pubkeyhash'\n"
             "         \"addresses\" : [           (json array of string)\n"
             "           \"address\"        (string) bitcoin address\n"
             "           ,...\n"
             "         ]\n"
             "       }\n"
             "     }\n"
             "     ,...\n"
             "  ],\n"
             "  \"blockhash\" : \"hash\",   (string) the block hash\n"
             "  \"confirmations\" : n,      (numeric) The confirmations\n"
             "  \"time\" : ttt,             (numeric) The transaction time in "
             "seconds since epoch (Jan 1 1970 GMT)\n"
             "  \"blocktime\" : ttt         (numeric) The block time in seconds "
             "since epoch (Jan 1 1970 GMT)\n"
             "}\n"
 
             "\nExamples:\n" +
             HelpExampleCli("getrawtransaction", "\"mytxid\"") +
             HelpExampleCli("getrawtransaction", "\"mytxid\" true") +
             HelpExampleRpc("getrawtransaction", "\"mytxid\", true") +
             HelpExampleCli("getrawtransaction",
                            "\"mytxid\" false \"myblockhash\"") +
             HelpExampleCli("getrawtransaction",
                            "\"mytxid\" true \"myblockhash\""));
     }
 
     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, true,
                         blockindex)) {
         std::string errmsg;
         if (blockindex) {
             if (!blockindex->nStatus.hasData()) {
                 throw JSONRPCError(RPC_MISC_ERROR, "Block not available");
             }
             errmsg = "No such transaction found in the provided block";
         } else if (!g_txindex) {
             errmsg = "No such mempool transaction. Use -txindex to enable "
                      "blockchain transaction queries";
         } else if (!f_txindex_ready) {
             errmsg = "No such mempool transaction. Blockchain transactions are "
                      "still in the process of being indexed";
         } else {
             errmsg = "No such mempool or blockchain transaction";
         }
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            errmsg +
                                ". Use gettransaction for wallet transactions.");
     }
 
     if (!fVerbose) {
         return EncodeHexTx(*tx, RPCSerializationFlags());
     }
 
     UniValue result(UniValue::VOBJ);
     if (blockindex) {
         result.pushKV("in_active_chain", in_active_chain);
     }
     TxToJSON(*tx, hash_block, result);
     return result;
 }
 
 static UniValue gettxoutproof(const Config &config,
                               const JSONRPCRequest &request) {
     if (request.fHelp ||
         (request.params.size() != 1 && request.params.size() != 2)) {
         throw std::runtime_error(
             RPCHelpMan{
                 "gettxoutproof",
                 "\nReturns a hex-encoded proof that \"txid\" was "
                 "included in a block.\n"
                 "\nNOTE: By default this function only works sometimes. "
                 "This is when there is an\n"
                 "unspent output in the utxo for this transaction. To "
                 "make it always work,\n"
                 "you need to maintain a transaction index, using the "
                 "-txindex command line option or\n"
                 "specify the block in which the transaction is included "
                 "manually (by blockhash).\n",
                 {
                     {
                         "txids",
                         RPCArg::Type::ARR,
                         /* opt */ false,
                         /* default_val */ "",
                         "A json array of txids to filter",
                         {
                             {"txid", RPCArg::Type::STR_HEX, /* opt */ false,
                              /* default_val */ "", "A transaction hash"},
                         },
                     },
                     {"blockhash", RPCArg::Type::STR_HEX, /* opt */ true,
                      /* default_val */ "",
                      "If specified, looks for txid in the block with this "
                      "hash"},
                 }}
                 .ToString() +
             "\nResult:\n"
             "\"data\"           (string) A string that is a serialized, "
             "hex-encoded data for the proof.\n");
     }
 
     std::set<TxId> setTxIds;
     TxId oneTxId;
     UniValue txids = request.params[0].get_array();
     for (unsigned int idx = 0; idx < txids.size(); idx++) {
         const UniValue &utxid = txids[idx];
         TxId txid(ParseHashV(utxid, "txid"));
         if (setTxIds.count(txid)) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 std::string("Invalid parameter, duplicated txid: ") +
                     utxid.get_str());
         }
 
         setTxIds.insert(txid);
         oneTxId = txid;
     }
 
     CBlockIndex *pblockindex = nullptr;
 
     BlockHash hashBlock;
     if (!request.params[1].isNull()) {
         LOCK(cs_main);
         hashBlock = BlockHash(ParseHashV(request.params[1], "blockhash"));
         pblockindex = LookupBlockIndex(hashBlock);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
     } else {
         LOCK(cs_main);
         // Loop through txids and try to find which block they're in. Exit loop
         // once a block is found.
         for (const auto &txid : setTxIds) {
             const Coin &coin = AccessByTxid(*pcoinsTip, txid);
             if (!coin.IsSpent()) {
                 pblockindex = ::ChainActive()[coin.GetHeight()];
                 break;
             }
         }
     }
 
     // Allow txindex to catch up if we need to query it and before we acquire
     // cs_main.
     if (g_txindex && !pblockindex) {
         g_txindex->BlockUntilSyncedToCurrentChain();
     }
 
     const Consensus::Params &params = config.GetChainParams().GetConsensus();
 
     LOCK(cs_main);
 
     if (pblockindex == nullptr) {
         CTransactionRef tx;
         if (!GetTransaction(oneTxId, tx, params, hashBlock, false) ||
             hashBlock.IsNull()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Transaction not yet in block");
         }
 
         pblockindex = LookupBlockIndex(hashBlock);
         if (!pblockindex) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Transaction index corrupt");
         }
     }
 
     CBlock block;
     if (!ReadBlockFromDisk(block, pblockindex, params)) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Can't read block from disk");
     }
 
     unsigned int ntxFound = 0;
     for (const auto &tx : block.vtx) {
         if (setTxIds.count(tx->GetId())) {
             ntxFound++;
         }
     }
 
     if (ntxFound != setTxIds.size()) {
         throw JSONRPCError(
             RPC_INVALID_ADDRESS_OR_KEY,
             "Not all transactions found in specified or retrieved block");
     }
 
     CDataStream ssMB(SER_NETWORK, PROTOCOL_VERSION);
     CMerkleBlock mb(block, setTxIds);
     ssMB << mb;
     std::string strHex = HexStr(ssMB.begin(), ssMB.end());
     return strHex;
 }
 
 static UniValue verifytxoutproof(const Config &config,
                                  const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"verifytxoutproof",
                        "\nVerifies that a proof points to a transaction in a "
                        "block, returning the transaction it commits to\n"
                        "and throwing an RPC error if the block is not in our "
                        "best chain\n",
                        {
                            {"proof", RPCArg::Type::STR_HEX, /* opt */ false,
                             /* default_val */ "",
                             "The hex-encoded proof generated by gettxoutproof"},
                        }}
                 .ToString() +
             "\nResult:\n"
             "[\"txid\"]      (array, strings) The txid(s) which the proof "
             "commits to, or empty array if the proof can not be validated.\n");
     }
 
     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;
 }
 
 CMutableTransaction ConstructTransaction(const CChainParams &params,
                                          const UniValue &inputs_in,
                                          const UniValue &outputs_in,
                                          const UniValue &locktime) {
     if (inputs_in.isNull() || outputs_in.isNull()) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "Invalid parameter, arguments 1 and 2 must be non-null");
     }
 
     UniValue inputs = inputs_in.get_array();
     const bool outputs_is_obj = outputs_in.isObject();
     UniValue outputs =
         outputs_is_obj ? outputs_in.get_obj() : outputs_in.get_array();
 
     CMutableTransaction rawTx;
 
     if (!locktime.isNull()) {
         int64_t nLockTime = locktime.get_int64();
         if (nLockTime < 0 || nLockTime > std::numeric_limits<uint32_t>::max()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, locktime out of range");
         }
 
         rawTx.nLockTime = nLockTime;
     }
 
     for (size_t idx = 0; idx < inputs.size(); idx++) {
         const UniValue &input = inputs[idx];
         const UniValue &o = input.get_obj();
 
         TxId txid(ParseHashO(o, "txid"));
 
         const UniValue &vout_v = find_value(o, "vout");
         if (vout_v.isNull()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, missing vout key");
         }
 
         if (!vout_v.isNum()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, vout must be a number");
         }
 
         int nOutput = vout_v.get_int();
         if (nOutput < 0) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, vout must be positive");
         }
 
         uint32_t nSequence =
             (rawTx.nLockTime ? std::numeric_limits<uint32_t>::max() - 1
                              : std::numeric_limits<uint32_t>::max());
 
         // Set the sequence number if passed in the parameters object.
         const UniValue &sequenceObj = find_value(o, "sequence");
         if (sequenceObj.isNum()) {
             int64_t seqNr64 = sequenceObj.get_int64();
             if (seqNr64 < 0 || seqNr64 > std::numeric_limits<uint32_t>::max()) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     "Invalid parameter, sequence number is out of range");
             }
 
             nSequence = uint32_t(seqNr64);
         }
 
         CTxIn in(COutPoint(txid, nOutput), CScript(), nSequence);
         rawTx.vin.push_back(in);
     }
 
     std::set<CTxDestination> destinations;
     if (!outputs_is_obj) {
         // Translate array of key-value pairs into dict
         UniValue outputs_dict = UniValue(UniValue::VOBJ);
         for (size_t i = 0; i < outputs.size(); ++i) {
             const UniValue &output = outputs[i];
             if (!output.isObject()) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Invalid parameter, key-value pair not an "
                                    "object as expected");
             }
             if (output.size() != 1) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Invalid parameter, key-value pair must "
                                    "contain exactly one key");
             }
             outputs_dict.pushKVs(output);
         }
         outputs = std::move(outputs_dict);
     }
     for (const std::string &name_ : outputs.getKeys()) {
         if (name_ == "data") {
             std::vector<uint8_t> data =
                 ParseHexV(outputs[name_].getValStr(), "Data");
 
             CTxOut out(Amount::zero(), CScript() << OP_RETURN << data);
             rawTx.vout.push_back(out);
         } else {
             CTxDestination destination = DecodeDestination(name_, params);
             if (!IsValidDestination(destination)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    std::string("Invalid Bitcoin address: ") +
                                        name_);
             }
 
             if (!destinations.insert(destination).second) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     std::string("Invalid parameter, duplicated address: ") +
                         name_);
             }
 
             CScript scriptPubKey = GetScriptForDestination(destination);
             Amount nAmount = AmountFromValue(outputs[name_]);
 
             CTxOut out(nAmount, scriptPubKey);
             rawTx.vout.push_back(out);
         }
     }
 
     return rawTx;
 }
 
 static UniValue createrawtransaction(const Config &config,
                                      const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 3) {
         throw std::runtime_error(
             RPCHelpMan{
                 "createrawtransaction",
                 "\nCreate a transaction spending the given inputs and creating "
                 "new outputs.\n"
                 "Outputs can be addresses or data.\n"
                 "Returns hex-encoded raw transaction.\n"
                 "Note that the transaction's inputs are not signed, and\n"
                 "it is not stored in the wallet or transmitted to the "
                 "network.\n",
                 {
                     {
                         "inputs",
                         RPCArg::Type::ARR,
                         /* opt */ false,
                         /* default_val */ "",
                         "A json array of json objects",
                         {
                             {
                                 "",
                                 RPCArg::Type::OBJ,
                                 /* opt */ false,
                                 /* default_val */ "",
                                 "",
                                 {
                                     {"txid", RPCArg::Type::STR_HEX,
                                      /* opt */ false, /* default_val */ "",
                                      "The transaction id"},
                                     {"vout", RPCArg::Type::NUM, /* opt */ false,
                                      /* default_val */ "", "The output number"},
                                     {"sequence", RPCArg::Type::NUM,
                                      /* opt */ true, /* default_val */ "",
                                      "The sequence number"},
                                 },
                             },
                         },
                     },
                     {
                         "outputs",
                         RPCArg::Type::ARR,
                         /* opt */ false,
                         /* default_val */ "",
                         "a json array with outputs (key-value pairs).\n"
                         "For compatibility reasons, a dictionary, which holds "
                         "the key-value pairs directly, is also\n"
                         "                             accepted as second "
                         "parameter.",
                         {
                             {
                                 "",
                                 RPCArg::Type::OBJ,
                                 /* opt */ true,
                                 /* default_val */ "",
                                 "",
                                 {
                                     {"address", RPCArg::Type::AMOUNT,
                                      /* opt */ false, /* default_val */ "",
                                      "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,
                                 /* opt */ true,
                                 /* default_val */ "",
                                 "",
                                 {
                                     {"data", RPCArg::Type::STR_HEX,
                                      /* opt */ false, /* default_val */ "",
                                      "A key-value pair. The key must be "
                                      "\"data\", the value is hex-encoded data"},
                                 },
                             },
                         },
                     },
                     {"locktime", RPCArg::Type::NUM, /* opt */ true,
                      /* default_val */ "0",
                      "Raw locktime. Non-0 value also locktime-activates "
                      "inputs"},
                 }}
                 .ToString() +
             "\nResult:\n"
             "\"transaction\"              (string) hex string of the "
             "transaction\n"
 
             "\nExamples:\n" +
             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\\\"}]\""));
     }
 
     RPCTypeCheck(request.params,
                  {UniValue::VARR,
                   UniValueType(), // ARR or OBJ, checked later
                   UniValue::VNUM},
                  true);
 
     CMutableTransaction rawTx =
         ConstructTransaction(config.GetChainParams(), request.params[0],
                              request.params[1], request.params[2]);
 
     return EncodeHexTx(CTransaction(rawTx));
 }
 
 static UniValue decoderawtransaction(const Config &config,
                                      const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"decoderawtransaction",
                        "\nReturn a JSON object representing the serialized, "
                        "hex-encoded transaction.\n",
                        {
                            {"hexstring", RPCArg::Type::STR_HEX, /* opt */ false,
                             /* default_val */ "", "The transaction hex string"},
                        }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"txid\" : \"id\",        (string) The transaction id\n"
             "  \"hash\" : \"id\",        (string) The transaction hash "
             "(differs from txid for witness transactions)\n"
             "  \"size\" : n,             (numeric) The transaction size\n"
             "  \"version\" : n,          (numeric) The version\n"
             "  \"locktime\" : ttt,       (numeric) The lock time\n"
             "  \"vin\" : [               (array of json objects)\n"
             "     {\n"
             "       \"txid\": \"id\",    (string) The transaction id\n"
             "       \"vout\": n,         (numeric) The output number\n"
             "       \"scriptSig\": {     (json object) The script\n"
             "         \"asm\": \"asm\",  (string) asm\n"
             "         \"hex\": \"hex\"   (string) hex\n"
             "       },\n"
             "       \"sequence\": n     (numeric) The script sequence number\n"
             "     }\n"
             "     ,...\n"
             "  ],\n"
             "  \"vout\" : [             (array of json objects)\n"
             "     {\n"
             "       \"value\" : x.xxx,            (numeric) The value in " +
             CURRENCY_UNIT +
             "\n"
             "       \"n\" : n,                    (numeric) index\n"
             "       \"scriptPubKey\" : {          (json object)\n"
             "         \"asm\" : \"asm\",          (string) the asm\n"
             "         \"hex\" : \"hex\",          (string) the hex\n"
             "         \"reqSigs\" : n,            (numeric) The required sigs\n"
             "         \"type\" : \"pubkeyhash\",  (string) The type, eg "
             "'pubkeyhash'\n"
             "         \"addresses\" : [           (json array of string)\n"
             "           \"12tvKAXCxZjSmdNbao16dKXC8tRWfcF5oc\"   (string) "
             "bitcoin address\n"
             "           ,...\n"
             "         ]\n"
             "       }\n"
             "     }\n"
             "     ,...\n"
             "  ],\n"
             "}\n"
 
             "\nExamples:\n" +
             HelpExampleCli("decoderawtransaction", "\"hexstring\"") +
             HelpExampleRpc("decoderawtransaction", "\"hexstring\""));
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     CMutableTransaction mtx;
 
     if (!DecodeHexTx(mtx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     UniValue result(UniValue::VOBJ);
     TxToUniv(CTransaction(std::move(mtx)), uint256(), result, false);
 
     return result;
 }
 
 static UniValue decodescript(const Config &config,
                              const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"decodescript",
                        "\nDecode a hex-encoded script.\n",
                        {
                            {"hexstring", RPCArg::Type::STR_HEX, /* opt */ false,
                             /* default_val */ "", "the hex-encoded script"},
                        }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"asm\":\"asm\",   (string) Script public key\n"
             "  \"hex\":\"hex\",   (string) hex-encoded public key\n"
             "  \"type\":\"type\", (string) The output type\n"
             "  \"reqSigs\": n,    (numeric) The required signatures\n"
             "  \"addresses\": [   (json array of string)\n"
             "     \"address\"     (string) bitcoin address\n"
             "     ,...\n"
             "  ],\n"
             "  \"p2sh\",\"address\" (string) address of P2SH script wrapping "
             "this redeem script (not returned if the script is already a "
             "P2SH).\n"
             "}\n"
             "\nExamples:\n" +
             HelpExampleCli("decodescript", "\"hexstring\"") +
             HelpExampleRpc("decodescript", "\"hexstring\""));
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     UniValue r(UniValue::VOBJ);
     CScript script;
     if (request.params[0].get_str().size() > 0) {
         std::vector<uint8_t> scriptData(
             ParseHexV(request.params[0], "argument"));
         script = CScript(scriptData.begin(), scriptData.end());
     } else {
         // Empty scripts are valid.
     }
 
     ScriptPubKeyToUniv(script, r, false);
 
     UniValue type;
     type = find_value(r, "type");
 
     if (type.isStr() && type.get_str() != "scripthash") {
         // P2SH cannot be wrapped in a P2SH. If this script is already a P2SH,
         // don't return the address for a P2SH of the P2SH.
         r.pushKV("p2sh", EncodeDestination(CScriptID(script), config));
     }
 
     return r;
 }
 
 /**
  * Pushes a JSON object for script verification or signing errors to vErrorsRet.
  */
 static void TxInErrorToJSON(const CTxIn &txin, UniValue &vErrorsRet,
                             const std::string &strMessage) {
     UniValue entry(UniValue::VOBJ);
     entry.pushKV("txid", txin.prevout.GetTxId().ToString());
     entry.pushKV("vout", uint64_t(txin.prevout.GetN()));
     entry.pushKV("scriptSig",
                  HexStr(txin.scriptSig.begin(), txin.scriptSig.end()));
     entry.pushKV("sequence", uint64_t(txin.nSequence));
     entry.pushKV("error", strMessage);
     vErrorsRet.push_back(entry);
 }
 
 static UniValue combinerawtransaction(const Config &config,
                                       const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"combinerawtransaction",
                        "\nCombine multiple partially signed transactions into "
                        "one transaction.\n"
                        "The combined transaction may be another partially "
                        "signed transaction or a \n"
                        "fully signed transaction.",
                        {
                            {
                                "txs",
                                RPCArg::Type::ARR,
                                /* opt */ false,
                                /* default_val */ "",
                                "A json array of hex strings of partially "
                                "signed transactions",
                                {
                                    {"hexstring", RPCArg::Type::STR_HEX,
                                     /* opt */ false, /* default_val */ "",
                                     "A transaction hash"},
                                },
                            },
                        }}
                 .ToString() +
             "\nResult:\n"
             "\"hex\"            (string) The hex-encoded raw transaction with "
             "signature(s)\n"
 
             "\nExamples:\n" +
             HelpExampleCli("combinerawtransaction",
                            "[\"myhex1\", \"myhex2\", \"myhex3\"]"));
     }
 
     UniValue txs = request.params[0].get_array();
     std::vector<CMutableTransaction> txVariants(txs.size());
 
     for (unsigned int idx = 0; idx < txs.size(); idx++) {
         if (!DecodeHexTx(txVariants[idx], txs[idx].get_str())) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                strprintf("TX decode failed for tx %d", idx));
         }
     }
 
     if (txVariants.empty()) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Missing transactions");
     }
 
     // mergedTx will end up with all the signatures; it
     // starts as a clone of the rawtx:
     CMutableTransaction mergedTx(txVariants[0]);
 
     // Fetch previous transactions (inputs):
     CCoinsView viewDummy;
     CCoinsViewCache view(&viewDummy);
     {
         LOCK(cs_main);
         LOCK(g_mempool.cs);
         CCoinsViewCache &viewChain = *pcoinsTip;
         CCoinsViewMemPool viewMempool(&viewChain, g_mempool);
         // temporarily switch cache backend to db+mempool view
         view.SetBackend(viewMempool);
 
         for (const CTxIn &txin : mergedTx.vin) {
             // Load entries from viewChain into view; can fail.
             view.AccessCoin(txin.prevout);
         }
 
         // switch back to avoid locking mempool for too long
         view.SetBackend(viewDummy);
     }
 
     // Use CTransaction for the constant parts of the
     // transaction to avoid rehashing.
     const CTransaction txConst(mergedTx);
     // Sign what we can:
     for (size_t i = 0; i < mergedTx.vin.size(); i++) {
         CTxIn &txin = mergedTx.vin[i];
         const Coin &coin = view.AccessCoin(txin.prevout);
         if (coin.IsSpent()) {
             throw JSONRPCError(RPC_VERIFY_ERROR,
                                "Input not found or already spent");
         }
         SignatureData sigdata;
 
         const CTxOut &txout = coin.GetTxOut();
 
         // ... and merge in other signatures:
         for (const CMutableTransaction &txv : txVariants) {
             if (txv.vin.size() > i) {
                 sigdata.MergeSignatureData(DataFromTransaction(txv, i, txout));
             }
         }
         ProduceSignature(
             DUMMY_SIGNING_PROVIDER,
             MutableTransactionSignatureCreator(&mergedTx, i, txout.nValue),
             txout.scriptPubKey, sigdata);
 
         UpdateInput(txin, sigdata);
     }
 
     return EncodeHexTx(CTransaction(mergedTx));
 }
 
 UniValue SignTransaction(interfaces::Chain &chain, CMutableTransaction &mtx,
                          const UniValue &prevTxsUnival,
                          CBasicKeyStore *keystore, bool is_temp_keystore,
                          const UniValue &hashType) {
     // Fetch previous transactions (inputs):
     CCoinsView viewDummy;
     CCoinsViewCache view(&viewDummy);
     {
         LOCK2(cs_main, g_mempool.cs);
         CCoinsViewCache &viewChain = *pcoinsTip;
         CCoinsViewMemPool viewMempool(&viewChain, g_mempool);
         // Temporarily switch cache backend to db+mempool view.
         view.SetBackend(viewMempool);
 
         for (const CTxIn &txin : mtx.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);
     }
 
     // Add previous txouts given in the RPC call:
     if (!prevTxsUnival.isNull()) {
         UniValue prevTxs = prevTxsUnival.get_array();
         for (size_t idx = 0; idx < prevTxs.size(); ++idx) {
             const UniValue &p = prevTxs[idx];
             if (!p.isObject()) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    "expected object with "
                                    "{\"txid'\",\"vout\",\"scriptPubKey\"}");
             }
 
             UniValue prevOut = p.get_obj();
 
             RPCTypeCheckObj(prevOut,
                             {
                                 {"txid", UniValueType(UniValue::VSTR)},
                                 {"vout", UniValueType(UniValue::VNUM)},
                                 {"scriptPubKey", UniValueType(UniValue::VSTR)},
                                 // "amount" is also required but check is done
                                 // below due to UniValue::VNUM erroneously
                                 // not accepting quoted numerics
                                 // (which are valid JSON)
                             });
 
             TxId txid(ParseHashO(prevOut, "txid"));
 
             int nOut = find_value(prevOut, "vout").get_int();
             if (nOut < 0) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    "vout must be positive");
             }
 
             COutPoint out(txid, nOut);
             std::vector<uint8_t> pkData(ParseHexO(prevOut, "scriptPubKey"));
             CScript scriptPubKey(pkData.begin(), pkData.end());
 
             {
                 const Coin &coin = view.AccessCoin(out);
                 if (!coin.IsSpent() &&
                     coin.GetTxOut().scriptPubKey != scriptPubKey) {
                     std::string err("Previous output scriptPubKey mismatch:\n");
                     err = err + ScriptToAsmStr(coin.GetTxOut().scriptPubKey) +
                           "\nvs:\n" + ScriptToAsmStr(scriptPubKey);
                     throw JSONRPCError(RPC_DESERIALIZATION_ERROR, err);
                 }
 
                 CTxOut txout;
                 txout.scriptPubKey = scriptPubKey;
                 txout.nValue = Amount::zero();
                 if (prevOut.exists("amount")) {
                     txout.nValue =
                         AmountFromValue(find_value(prevOut, "amount"));
                 } else {
                     // amount param is required in replay-protected txs.
                     // Note that we must check for its presence here rather
                     // than use RPCTypeCheckObj() above, since UniValue::VNUM
                     // parser incorrectly parses numerics with quotes, eg
                     // "3.12" as a string when JSON allows it to also parse
                     // as numeric. And we have to accept numerics with quotes
                     // because our own dogfood (our rpc results) always
                     // produces decimal numbers that are quoted
                     // eg getbalance returns "3.14152" rather than 3.14152
                     throw JSONRPCError(RPC_INVALID_PARAMETER, "Missing amount");
                 }
 
                 view.AddCoin(out, Coin(txout, 1, false), true);
             }
 
             // If redeemScript and private keys were given, add redeemScript to
             // the keystore so it can be signed
             if (is_temp_keystore && scriptPubKey.IsPayToScriptHash()) {
                 RPCTypeCheckObj(
                     prevOut, {
                                  {"redeemScript", UniValueType(UniValue::VSTR)},
                              });
                 UniValue v = find_value(prevOut, "redeemScript");
                 if (!v.isNull()) {
                     std::vector<uint8_t> rsData(ParseHexV(v, "redeemScript"));
                     CScript redeemScript(rsData.begin(), rsData.end());
                     keystore->AddCScript(redeemScript);
                 }
             }
         }
     }
 
     SigHashType sigHashType = ParseSighashString(hashType);
     if (!sigHashType.hasForkId()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Signature must use SIGHASH_FORKID");
     }
 
     // Script verification errors.
     UniValue vErrors(UniValue::VARR);
 
     // Use CTransaction for the constant parts of the transaction to avoid
     // rehashing.
     const CTransaction txConst(mtx);
     // Sign what we can:
     for (size_t i = 0; i < mtx.vin.size(); i++) {
         CTxIn &txin = mtx.vin[i];
         const Coin &coin = view.AccessCoin(txin.prevout);
         if (coin.IsSpent()) {
             TxInErrorToJSON(txin, vErrors, "Input not found or already spent");
             continue;
         }
 
         const CScript &prevPubKey = coin.GetTxOut().scriptPubKey;
         const Amount amount = coin.GetTxOut().nValue;
 
         SignatureData sigdata = DataFromTransaction(mtx, i, coin.GetTxOut());
         // Only sign SIGHASH_SINGLE if there's a corresponding output:
         if ((sigHashType.getBaseType() != BaseSigHashType::SINGLE) ||
             (i < mtx.vout.size())) {
             ProduceSignature(*keystore,
                              MutableTransactionSignatureCreator(&mtx, i, amount,
                                                                 sigHashType),
                              prevPubKey, sigdata);
         }
 
         UpdateInput(txin, sigdata);
 
         ScriptError serror = ScriptError::OK;
         if (!VerifyScript(
                 txin.scriptSig, prevPubKey, STANDARD_SCRIPT_VERIFY_FLAGS,
                 TransactionSignatureChecker(&txConst, i, amount), &serror)) {
             if (serror == ScriptError::INVALID_STACK_OPERATION) {
                 // Unable to sign input and verification failed (possible
                 // attempt to partially sign).
                 TxInErrorToJSON(txin, vErrors,
                                 "Unable to sign input, invalid stack size "
                                 "(possibly missing key)");
             } else {
                 TxInErrorToJSON(txin, vErrors, ScriptErrorString(serror));
             }
         }
     }
 
     bool fComplete = vErrors.empty();
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("hex", EncodeHexTx(CTransaction(mtx)));
     result.pushKV("complete", fComplete);
     if (!vErrors.empty()) {
         result.pushKV("errors", vErrors);
     }
 
     return result;
 }
 
 static UniValue signrawtransactionwithkey(const Config &config,
                                           const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 4) {
         throw std::runtime_error(
             RPCHelpMan{
                 "signrawtransactionwithkey",
                 "\nSign inputs for raw transaction (serialized, hex-encoded).\n"
                 "The second argument is an array of base58-encoded private\n"
                 "keys that will be the only keys used to sign the "
                 "transaction.\n"
                 "The third optional argument (may be null) is an array of "
                 "previous transaction outputs that\n"
                 "this transaction depends on but may not yet be in the block "
                 "chain.\n",
                 {
                     {"hexstring", RPCArg::Type::STR_HEX, /* opt */ false,
                      /* default_val */ "", "The transaction hex string"},
                     {
                         "privkeys",
                         RPCArg::Type::ARR,
                         /* opt */ false,
                         /* default_val */ "",
                         "A json array of base58-encoded private keys for "
                         "signing",
                         {
                             {"privatekey", RPCArg::Type::STR,
                              /* opt */ false, /* default_val */ "",
                              "private key in base58-encoding"},
                         },
                     },
                     {
                         "prevtxs",
                         RPCArg::Type::ARR,
                         /* opt */ true,
                         /* default_val */ "",
                         "A json array of previous dependent transaction "
                         "outputs",
                         {
                             {
                                 "",
                                 RPCArg::Type::OBJ,
                                 /* opt */ true,
                                 /* default_val */ "",
                                 "",
                                 {
                                     {"txid", RPCArg::Type::STR_HEX,
                                      /* opt */ false, /* default_val */ "",
                                      "The transaction id"},
                                     {"vout", RPCArg::Type::NUM, /* opt */ false,
                                      /* default_val */ "", "The output number"},
                                     {"scriptPubKey", RPCArg::Type::STR_HEX,
                                      /* opt */ false, /* default_val */ "",
                                      "script key"},
                                     {"redeemScript", RPCArg::Type::STR_HEX,
                                      /* opt */ true, /* default_val */ "",
                                      "(required for P2SH) redeem script"},
                                     {"amount", RPCArg::Type::AMOUNT,
                                      /* opt */ false, /* default_val */ "",
                                      "The amount spent"},
                                 },
                             },
                         },
                     },
                     {"sighashtype", RPCArg::Type::STR, /* opt */ true,
                      /* default_val */ "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\""},
                 }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"hex\" : \"value\",                  (string) The hex-encoded "
             "raw transaction with signature(s)\n"
             "  \"complete\" : true|false,          (boolean) If the "
             "transaction has a complete set of signatures\n"
             "  \"errors\" : [                      (json array of objects) "
             "Script verification errors (if there are any)\n"
             "    {\n"
             "      \"txid\" : \"hash\",              (string) The hash of the "
             "referenced, previous transaction\n"
             "      \"vout\" : n,                   (numeric) The index of the "
             "output to spent and used as input\n"
             "      \"scriptSig\" : \"hex\",          (string) The hex-encoded "
             "signature script\n"
             "      \"sequence\" : n,               (numeric) Script sequence "
             "number\n"
             "      \"error\" : \"text\"              (string) Verification or "
             "signing error related to the input\n"
             "    }\n"
             "    ,...\n"
             "  ]\n"
             "}\n"
 
             "\nExamples:\n" +
             HelpExampleCli("signrawtransactionwithkey", "\"myhex\"") +
             HelpExampleRpc("signrawtransactionwithkey", "\"myhex\""));
     }
 
     RPCTypeCheck(
         request.params,
         {UniValue::VSTR, UniValue::VARR, UniValue::VARR, UniValue::VSTR}, true);
 
     CMutableTransaction mtx;
     if (!DecodeHexTx(mtx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     CBasicKeyStore keystore;
     const UniValue &keys = request.params[1].get_array();
     for (size_t idx = 0; idx < keys.size(); ++idx) {
         UniValue k = keys[idx];
         CKey key = DecodeSecret(k.get_str());
         if (!key.IsValid()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid private key");
         }
         keystore.AddKey(key);
     }
 
     return SignTransaction(*g_rpc_interfaces->chain, mtx, request.params[2],
                            &keystore, true, request.params[3]);
 }
 
 static UniValue sendrawtransaction(const Config &config,
                                    const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{"sendrawtransaction",
                        "\nSubmits raw transaction (serialized, hex-encoded) to "
                        "local node and network.\n"
                        "\nAlso see createrawtransaction and "
                        "signrawtransactionwithkey calls.\n",
                        {
                            {"hexstring", RPCArg::Type::STR_HEX, /* opt */ false,
                             /* default_val */ "",
                             "The hex string of the raw transaction"},
                            {"allowhighfees", RPCArg::Type::BOOL, /* opt */ true,
                             /* default_val */ "false", "Allow high fees"},
                        }}
                 .ToString() +
             "\nResult:\n"
             "\"hex\"             (string) The transaction hash in hex\n"
             "\nExamples:\n"
             "\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\""));
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VBOOL});
 
     // 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)));
 
     bool allowhighfees = false;
     if (!request.params[1].isNull()) {
         allowhighfees = request.params[1].get_bool();
     }
 
-    return BroadcastTransaction(config, tx, allowhighfees).GetHex();
+    TxId txid;
+    TransactionError err;
+    std::string err_string;
+    if (!BroadcastTransaction(config, tx, txid, err, err_string,
+                              allowhighfees)) {
+        throw JSONRPCTransactionError(err, err_string);
+    }
+
+    return txid.GetHex();
 }
 
 static UniValue testmempoolaccept(const Config &config,
                                   const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{"testmempoolaccept",
                        "\nReturns if raw transaction (serialized, hex-encoded) "
                        "would be accepted by mempool.\n"
                        "\nThis checks if the transaction violates the "
                        "consensus or policy rules.\n"
                        "\nSee sendrawtransaction call.\n",
                        {
                            {
                                "rawtxs",
                                RPCArg::Type::ARR,
                                /* opt */ false,
                                /* default_val */ "",
                                "An array of hex strings of raw transactions.\n"
                                "                                        Length "
                                "must be one for now.",
                                {
                                    {"rawtx", RPCArg::Type::STR_HEX,
                                     /* opt */ false, /* default_val */ "", ""},
                                },
                            },
                            {"allowhighfees", RPCArg::Type::BOOL, /* opt */ true,
                             /* default_val */ "false", "Allow high fees"},
                        }}
                 .ToString() +
             "\nResult:\n"
             "[                   (array) The result of the mempool acceptance "
             "test for each raw transaction in the input array.\n"
             "                            Length is exactly one for now.\n"
             " {\n"
             "  \"txid\"           (string) The transaction hash in hex\n"
             "  \"allowed\"        (boolean) If the mempool allows this tx to "
             "be inserted\n"
             "  \"reject-reason\"  (string) Rejection string (only present when "
             "'allowed' is false)\n"
             " }\n"
             "]\n"
             "\nExamples:\n"
             "\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\"]"));
     }
 
     RPCTypeCheck(request.params, {UniValue::VARR, UniValue::VBOOL});
     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 uint256 &txid = tx->GetId();
 
     Amount max_raw_tx_fee = maxTxFee;
     if (!request.params[1].isNull() && request.params[1].get_bool()) {
         max_raw_tx_fee = Amount::zero();
     }
 
     UniValue result(UniValue::VARR);
     UniValue result_0(UniValue::VOBJ);
     result_0.pushKV("txid", txid.GetHex());
 
     CValidationState state;
     bool missing_inputs;
     bool test_accept_res;
     {
         LOCK(cs_main);
         test_accept_res = AcceptToMemoryPool(
             config, g_mempool, state, std::move(tx), &missing_inputs,
             false /* bypass_limits */, max_raw_tx_fee, true /* test_accept */);
     }
     result_0.pushKV("allowed", test_accept_res);
     if (!test_accept_res) {
         if (state.IsInvalid()) {
             result_0.pushKV("reject-reason",
                             strprintf("%i: %s", state.GetRejectCode(),
                                       state.GetRejectReason()));
         } else if (missing_inputs) {
             result_0.pushKV("reject-reason", "missing-inputs");
         } else {
             result_0.pushKV("reject-reason", state.GetRejectReason());
         }
     }
 
     result.push_back(std::move(result_0));
     return result;
 }
 
 static std::string WriteHDKeypath(std::vector<uint32_t> &keypath) {
     std::string keypath_str = "m";
     for (uint32_t num : keypath) {
         keypath_str += "/";
         bool hardened = false;
         if (num & 0x80000000) {
             hardened = true;
             num &= ~0x80000000;
         }
 
         keypath_str += std::to_string(num);
         if (hardened) {
             keypath_str += "'";
         }
     }
     return keypath_str;
 }
 
 static UniValue decodepsbt(const Config &config,
                            const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"decodepsbt",
                        "\nReturn a JSON object representing the serialized, "
                        "base64-encoded partially signed Bitcoin transaction.\n",
                        {
                            {"psbt", RPCArg::Type::STR, /* opt */ false,
                             /* default_val */ "", "The PSBT base64 string"},
                        }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"tx\" : {                   (json object) The decoded "
             "network-serialized unsigned transaction.\n"
             "    ...                                      The layout is the "
             "same as the output of decoderawtransaction.\n"
             "  },\n"
             "  \"unknown\" : {                (json object) The unknown global "
             "fields\n"
             "    \"key\" : \"value\"            (key-value pair) An unknown "
             "key-value pair\n"
             "     ...\n"
             "  },\n"
             "  \"inputs\" : [                 (array of json objects)\n"
             "    {\n"
             "      \"utxo\" : {            (json object, optional) Transaction "
             "output for UTXOs\n"
             "        \"amount\" : x.xxx,           (numeric) The value in " +
             CURRENCY_UNIT +
             "\n"
             "        \"scriptPubKey\" : {          (json object)\n"
             "          \"asm\" : \"asm\",            (string) The asm\n"
             "          \"hex\" : \"hex\",            (string) The hex\n"
             "          \"type\" : \"pubkeyhash\",    (string) The type, eg "
             "'pubkeyhash'\n"
             "          \"address\" : \"address\"     (string) Bitcoin address "
             "if there is one\n"
             "        }\n"
             "      },\n"
             "      \"partial_signatures\" : {             (json object, "
             "optional)\n"
             "        \"pubkey\" : \"signature\",           (string) The public "
             "key and signature that corresponds to it.\n"
             "        ,...\n"
             "      }\n"
             "      \"sighash\" : \"type\",                  (string, optional) "
             "The sighash type to be used\n"
             "      \"redeem_script\" : {       (json object, optional)\n"
             "          \"asm\" : \"asm\",            (string) The asm\n"
             "          \"hex\" : \"hex\",            (string) The hex\n"
             "          \"type\" : \"pubkeyhash\",    (string) The type, eg "
             "'pubkeyhash'\n"
             "        }\n"
             "      \"bip32_derivs\" : {          (json object, optional)\n"
             "        \"pubkey\" : {                     (json object, "
             "optional) The public key with the derivation path as the value.\n"
             "          \"master_fingerprint\" : \"fingerprint\"     (string) "
             "The fingerprint of the master key\n"
             "          \"path\" : \"path\",                         (string) "
             "The path\n"
             "        }\n"
             "        ,...\n"
             "      }\n"
             "      \"final_scriptsig\" : {       (json object, optional)\n"
             "          \"asm\" : \"asm\",            (string) The asm\n"
             "          \"hex\" : \"hex\",            (string) The hex\n"
             "        }\n"
             "      \"unknown\" : {                (json object) The unknown "
             "global fields\n"
             "        \"key\" : \"value\"            (key-value pair) An "
             "unknown key-value pair\n"
             "         ...\n"
             "      },\n"
             "    }\n"
             "    ,...\n"
             "  ]\n"
             "  \"outputs\" : [                 (array of json objects)\n"
             "    {\n"
             "      \"redeem_script\" : {       (json object, optional)\n"
             "          \"asm\" : \"asm\",            (string) The asm\n"
             "          \"hex\" : \"hex\",            (string) The hex\n"
             "          \"type\" : \"pubkeyhash\",    (string) The type, eg "
             "'pubkeyhash'\n"
             "        }\n"
             "      \"bip32_derivs\" : [          (array of json objects, "
             "optional)\n"
             "        {\n"
             "          \"pubkey\" : \"pubkey\",                     (string) "
             "The public key this path corresponds to\n"
             "          \"master_fingerprint\" : \"fingerprint\"     (string) "
             "The fingerprint of the master key\n"
             "          \"path\" : \"path\",                         (string) "
             "The path\n"
             "          }\n"
             "        }\n"
             "        ,...\n"
             "      ],\n"
             "      \"unknown\" : {                (json object) The unknown "
             "global fields\n"
             "        \"key\" : \"value\"            (key-value pair) An "
             "unknown key-value pair\n"
             "         ...\n"
             "      },\n"
             "    }\n"
             "    ,...\n"
             "  ]\n"
             "  \"fee\" : fee                      (numeric, optional) The "
             "transaction fee paid if all UTXOs slots in the PSBT have been "
             "filled.\n"
             "}\n"
 
             "\nExamples:\n" +
             HelpExampleCli("decodepsbt", "\"psbt\""));
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR});
 
     // Unserialize the transactions
     PartiallySignedTransaction psbtx;
     std::string error;
     if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            strprintf("TX decode failed %s", error));
     }
 
     UniValue result(UniValue::VOBJ);
 
     // Add the decoded tx
     UniValue tx_univ(UniValue::VOBJ);
     TxToUniv(CTransaction(*psbtx.tx), uint256(), tx_univ, false);
     result.pushKV("tx", tx_univ);
 
     // Unknown data
     if (psbtx.unknown.size() > 0) {
         UniValue unknowns(UniValue::VOBJ);
         for (auto entry : psbtx.unknown) {
             unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
         }
         result.pushKV("unknown", unknowns);
     }
 
     // inputs
     Amount total_in = Amount::zero();
     bool have_all_utxos = true;
     UniValue inputs(UniValue::VARR);
     for (size_t i = 0; i < psbtx.inputs.size(); ++i) {
         const PSBTInput &input = psbtx.inputs[i];
         UniValue in(UniValue::VOBJ);
         // UTXOs
         if (!input.utxo.IsNull()) {
             const CTxOut &txout = input.utxo;
 
             UniValue out(UniValue::VOBJ);
 
             out.pushKV("amount", ValueFromAmount(txout.nValue));
             total_in += txout.nValue;
 
             UniValue o(UniValue::VOBJ);
             ScriptToUniv(txout.scriptPubKey, o, true);
             out.pushKV("scriptPubKey", o);
             in.pushKV("utxo", out);
         } else {
             have_all_utxos = false;
         }
 
         // Partial sigs
         if (!input.partial_sigs.empty()) {
             UniValue partial_sigs(UniValue::VOBJ);
             for (const auto &sig : input.partial_sigs) {
                 partial_sigs.pushKV(HexStr(sig.second.first),
                                     HexStr(sig.second.second));
             }
             in.pushKV("partial_signatures", partial_sigs);
         }
 
         // Sighash
         uint8_t sighashbyte = input.sighash_type.getRawSigHashType() & 0xff;
         if (sighashbyte > 0) {
             in.pushKV("sighash", SighashToStr(sighashbyte));
         }
 
         // Redeem script
         if (!input.redeem_script.empty()) {
             UniValue r(UniValue::VOBJ);
             ScriptToUniv(input.redeem_script, r, false);
             in.pushKV("redeem_script", r);
         }
 
         // keypaths
         if (!input.hd_keypaths.empty()) {
             UniValue keypaths(UniValue::VARR);
             for (auto entry : input.hd_keypaths) {
                 UniValue keypath(UniValue::VOBJ);
                 keypath.pushKV("pubkey", HexStr(entry.first));
 
                 keypath.pushKV(
                     "master_fingerprint",
                     strprintf("%08x", ReadBE32(entry.second.fingerprint)));
                 keypath.pushKV("path", WriteHDKeypath(entry.second.path));
                 keypaths.push_back(keypath);
             }
             in.pushKV("bip32_derivs", keypaths);
         }
 
         // Final scriptSig
         if (!input.final_script_sig.empty()) {
             UniValue scriptsig(UniValue::VOBJ);
             scriptsig.pushKV("asm",
                              ScriptToAsmStr(input.final_script_sig, true));
             scriptsig.pushKV("hex", HexStr(input.final_script_sig));
             in.pushKV("final_scriptSig", scriptsig);
         }
 
         // Unknown data
         if (input.unknown.size() > 0) {
             UniValue unknowns(UniValue::VOBJ);
             for (auto entry : input.unknown) {
                 unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
             }
             in.pushKV("unknown", unknowns);
         }
 
         inputs.push_back(in);
     }
     result.pushKV("inputs", inputs);
 
     // outputs
     Amount output_value = Amount::zero();
     UniValue outputs(UniValue::VARR);
     for (size_t i = 0; i < psbtx.outputs.size(); ++i) {
         const PSBTOutput &output = psbtx.outputs[i];
         UniValue out(UniValue::VOBJ);
         // Redeem script
         if (!output.redeem_script.empty()) {
             UniValue r(UniValue::VOBJ);
             ScriptToUniv(output.redeem_script, r, false);
             out.pushKV("redeem_script", r);
         }
 
         // keypaths
         if (!output.hd_keypaths.empty()) {
             UniValue keypaths(UniValue::VARR);
             for (auto entry : output.hd_keypaths) {
                 UniValue keypath(UniValue::VOBJ);
                 keypath.pushKV("pubkey", HexStr(entry.first));
                 keypath.pushKV(
                     "master_fingerprint",
                     strprintf("%08x", ReadBE32(entry.second.fingerprint)));
                 keypath.pushKV("path", WriteHDKeypath(entry.second.path));
                 keypaths.push_back(keypath);
             }
             out.pushKV("bip32_derivs", keypaths);
         }
 
         // Unknown data
         if (output.unknown.size() > 0) {
             UniValue unknowns(UniValue::VOBJ);
             for (auto entry : output.unknown) {
                 unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
             }
             out.pushKV("unknown", unknowns);
         }
 
         outputs.push_back(out);
 
         // Fee calculation
         output_value += psbtx.tx->vout[i].nValue;
     }
     result.pushKV("outputs", outputs);
     if (have_all_utxos) {
         result.pushKV("fee", ValueFromAmount(total_in - output_value));
     }
 
     return result;
 }
 
 static UniValue combinepsbt(const Config &config,
                             const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{
                 "combinepsbt",
                 "\nCombine multiple partially signed Bitcoin transactions into "
                 "one transaction.\n"
                 "Implements the Combiner role.\n",
                 {
                     {
                         "txs",
                         RPCArg::Type::ARR,
                         /* opt */ false,
                         /* default_val */ "",
                         "A json array of base64 strings of partially signed "
                         "transactions",
                         {
                             {"psbt", RPCArg::Type::STR, /* opt */ false,
                              /* default_val */ "", "A base64 string of a PSBT"},
                         },
                     },
                 }}
                 .ToString() +
             "\nResult:\n"
             "  \"psbt\"          (string) The base64-encoded partially signed "
             "transaction\n"
             "\nExamples:\n" +
             HelpExampleCli("combinepsbt",
                            "[\"mybase64_1\", \"mybase64_2\", \"mybase64_3\"]"));
     }
 
     RPCTypeCheck(request.params, {UniValue::VARR}, true);
 
     // Unserialize the transactions
     std::vector<PartiallySignedTransaction> psbtxs;
     UniValue txs = request.params[0].get_array();
     for (size_t i = 0; i < txs.size(); ++i) {
         PartiallySignedTransaction psbtx;
         std::string error;
         if (!DecodeBase64PSBT(psbtx, txs[i].get_str(), error)) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                strprintf("TX decode failed %s", error));
         }
         psbtxs.push_back(psbtx);
     }
 
     // Copy the first one
     PartiallySignedTransaction merged_psbt(psbtxs[0]);
 
     // Merge
     for (auto it = std::next(psbtxs.begin()); it != psbtxs.end(); ++it) {
         if (!merged_psbt.Merge(*it)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "PSBTs do not refer to the same transactions.");
         }
     }
     if (!merged_psbt.IsSane()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Merged PSBT is inconsistent");
     }
 
     UniValue result(UniValue::VOBJ);
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << merged_psbt;
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 static UniValue finalizepsbt(const Config &config,
                              const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{"finalizepsbt",
                        "Finalize the inputs of a PSBT. If the transaction is "
                        "fully signed, it will produce a\n"
                        "network serialized transaction which can be broadcast "
                        "with sendrawtransaction. Otherwise a PSBT will be\n"
                        "created which has the final_scriptSigfields filled for "
                        "inputs that are complete.\n"
                        "Implements the Finalizer and Extractor roles.\n",
                        {
                            {"psbt", RPCArg::Type::STR, /* opt */ false,
                             /* default_val */ "", "A base64 string of a PSBT"},
                            {"extract", RPCArg::Type::BOOL, /* opt */ true,
                             /* default_val */ "true",
                             "If true and the transaction is complete,\n"
                             "                             extract and return "
                             "the complete transaction in normal network "
                             "serialization instead of the PSBT."},
                        }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"psbt\" : \"value\",          (string) The base64-encoded "
             "partially signed transaction if not extracted\n"
             "  \"hex\" : \"value\",           (string) The hex-encoded network "
             "transaction if extracted\n"
             "  \"complete\" : true|false,   (boolean) If the transaction has a "
             "complete set of signatures\n"
             "  ]\n"
             "}\n"
 
             "\nExamples:\n" +
             HelpExampleCli("finalizepsbt", "\"psbt\""));
     }
 
     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));
     }
 
     // Finalize input signatures -- in case we have partial signatures that add
     // up to a complete
     //   signature, but have not combined them yet (e.g. because the combiner
     //   that created this PartiallySignedTransaction did not understand them),
     //   this will combine them into a final script.
     bool complete = true;
     for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
         complete &=
             SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i, SigHashType());
     }
 
     UniValue result(UniValue::VOBJ);
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     bool extract = request.params[1].isNull() || (!request.params[1].isNull() &&
                                                   request.params[1].get_bool());
     if (complete && extract) {
         CMutableTransaction mtx(*psbtx.tx);
         for (size_t i = 0; i < mtx.vin.size(); ++i) {
             mtx.vin[i].scriptSig = psbtx.inputs[i].final_script_sig;
         }
         ssTx << mtx;
         result.pushKV("hex", HexStr(ssTx.str()));
     } else {
         ssTx << psbtx;
         result.pushKV("psbt", EncodeBase64(ssTx.str()));
     }
     result.pushKV("complete", complete);
 
     return result;
 }
 
 static UniValue createpsbt(const Config &config,
                            const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 3) {
         throw std::runtime_error(
             RPCHelpMan{
                 "createpsbt",
                 "\nCreates a transaction in the Partially Signed "
                 "Transaction format.\n"
                 "Implements the Creator role.\n",
                 {
                     {
                         "inputs",
                         RPCArg::Type::ARR,
                         /* opt */ false,
                         /* default_val */ "",
                         "A json array of json objects",
                         {
                             {
                                 "",
                                 RPCArg::Type::OBJ,
                                 /* opt */ false,
                                 /* default_val */ "",
                                 "",
                                 {
                                     {"txid", RPCArg::Type::STR_HEX,
                                      /* opt */ false, /* default_val */ "",
                                      "The transaction id"},
                                     {"vout", RPCArg::Type::NUM, /* opt */ false,
                                      /* default_val */ "", "The output number"},
                                     {"sequence", RPCArg::Type::NUM,
                                      /* opt */ true, /* default_val */ "",
                                      "The sequence number"},
                                 },
                             },
                         },
                     },
                     {
                         "outputs",
                         RPCArg::Type::ARR,
                         /* opt */ false,
                         /* default_val */ "",
                         "a json array with outputs (key-value pairs).\n"
                         "For compatibility reasons, a dictionary, which holds "
                         "the key-value pairs directly, is also\n"
                         "                             accepted as second "
                         "parameter.",
                         {
                             {
                                 "",
                                 RPCArg::Type::OBJ,
                                 /* opt */ true,
                                 /* default_val */ "",
                                 "",
                                 {
                                     {"address", RPCArg::Type::AMOUNT,
                                      /* opt */ false, /* default_val */ "",
                                      "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,
                                 /* opt */ true,
                                 /* default_val */ "",
                                 "",
                                 {
                                     {"data", RPCArg::Type::STR_HEX,
                                      /* opt */ false, /* default_val */ "",
                                      "A key-value pair. The key must be "
                                      "\"data\", the value is hex-encoded data"},
                                 },
                             },
                         },
                     },
                     {"locktime", RPCArg::Type::NUM, /* opt */ true,
                      /* default_val */ "0",
                      "Raw locktime. Non-0 value also locktime-activates "
                      "inputs"},
                 }}
                 .ToString() +
             "\nResult:\n"
             "  \"psbt\"        (string)  The resulting raw transaction "
             "(base64-encoded string)\n"
             "\nExamples:\n" +
             HelpExampleCli("createpsbt",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" "
                            "\"[{\\\"data\\\":\\\"00010203\\\"}]\""));
     }
 
     RPCTypeCheck(request.params,
                  {
                      UniValue::VARR,
                      UniValueType(), // ARR or OBJ, checked later
                      UniValue::VNUM,
                  },
                  true);
 
     CMutableTransaction rawTx =
         ConstructTransaction(config.GetChainParams(), request.params[0],
                              request.params[1], request.params[2]);
 
     // Make a blank psbt
     PartiallySignedTransaction psbtx;
     psbtx.tx = rawTx;
     for (size_t i = 0; i < rawTx.vin.size(); ++i) {
         psbtx.inputs.push_back(PSBTInput());
     }
     for (size_t i = 0; i < rawTx.vout.size(); ++i) {
         psbtx.outputs.push_back(PSBTOutput());
     }
 
     // Serialize the PSBT
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
 
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 static UniValue converttopsbt(const Config &config,
                               const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{
                 "converttopsbt",
                 "\nConverts a network serialized transaction to a PSBT. "
                 "This should be used only with createrawtransaction and "
                 "fundrawtransaction\n"
                 "createpsbt and walletcreatefundedpsbt should be used "
                 "for new applications.\n",
                 {
                     {"hexstring", RPCArg::Type::STR_HEX, /* opt */ false,
                      /* default_val */ "",
                      "The hex string of a raw transaction"},
                     {"permitsigdata", RPCArg::Type::BOOL, /* opt */ true,
                      /* default_val */ "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."},
                 }}
                 .ToString() +
             "\nResult:\n"
             "  \"psbt\"        (string)  The resulting raw transaction "
             "(base64-encoded string)\n"
             "\nExamples:\n"
             "\nCreate a transaction\n" +
             HelpExampleCli("createrawtransaction",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" "
                            "\"[{\\\"data\\\":\\\"00010203\\\"}]\"") +
             "\nConvert the transaction to a PSBT\n" +
             HelpExampleCli("converttopsbt", "\"rawtransaction\""));
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VBOOL}, true);
 
     // parse hex string from parameter
     CMutableTransaction tx;
     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() &&
             (request.params[1].isNull() ||
              (!request.params[1].isNull() && request.params[1].get_bool()))) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                "Inputs must not have scriptSigs");
         }
         input.scriptSig.clear();
     }
 
     // Make a blank psbt
     PartiallySignedTransaction psbtx;
     psbtx.tx = tx;
     for (size_t i = 0; i < tx.vin.size(); ++i) {
         psbtx.inputs.push_back(PSBTInput());
     }
     for (size_t i = 0; i < tx.vout.size(); ++i) {
         psbtx.outputs.push_back(PSBTOutput());
     }
 
     // Serialize the PSBT
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
 
     return EncodeBase64((uint8_t *)ssTx.data(), ssTx.size());
 }
 
 // clang-format off
 static const ContextFreeRPCCommand commands[] = {
     //  category            name                         actor (function)           argNames
     //  ------------------- ------------------------     ----------------------     ----------
     { "rawtransactions",    "getrawtransaction",         getrawtransaction,         {"txid","verbose","blockhash"} },
     { "rawtransactions",    "createrawtransaction",      createrawtransaction,      {"inputs","outputs","locktime"} },
     { "rawtransactions",    "decoderawtransaction",      decoderawtransaction,      {"hexstring"} },
     { "rawtransactions",    "decodescript",              decodescript,              {"hexstring"} },
     { "rawtransactions",    "sendrawtransaction",        sendrawtransaction,        {"hexstring","allowhighfees"} },
     { "rawtransactions",    "combinerawtransaction",     combinerawtransaction,     {"txs"} },
     { "rawtransactions",    "signrawtransactionwithkey", signrawtransactionwithkey, {"hexstring","privkeys","prevtxs","sighashtype"} },
     { "rawtransactions",    "testmempoolaccept",         testmempoolaccept,         {"rawtxs","allowhighfees"} },
     { "rawtransactions",    "decodepsbt",                decodepsbt,                {"psbt"} },
     { "rawtransactions",    "combinepsbt",               combinepsbt,               {"txs"} },
     { "rawtransactions",    "finalizepsbt",              finalizepsbt,              {"psbt", "extract"} },
     { "rawtransactions",    "createpsbt",                createpsbt,                {"inputs","outputs","locktime"} },
     { "rawtransactions",    "converttopsbt",             converttopsbt,             {"hexstring","permitsigdata"} },
 
     { "blockchain",         "gettxoutproof",             gettxoutproof,             {"txids", "blockhash"} },
     { "blockchain",         "verifytxoutproof",          verifytxoutproof,          {"proof"} },
 };
 // clang-format on
 
 void RegisterRawTransactionRPCCommands(CRPCTable &t) {
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 03d71527a..f1df78362 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -1,446 +1,473 @@
 // Copyright (c) 2017 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <key_io.h>
 #include <keystore.h>
 #include <pubkey.h>
 #include <rpc/protocol.h>
 #include <rpc/util.h>
 #include <tinyformat.h>
 #include <util/strencodings.h>
 
 #include <univalue.h>
 
 #include <boost/variant/static_visitor.hpp>
 
 InitInterfaces *g_rpc_interfaces = nullptr;
 
 // Converts a hex string to a public key if possible
 CPubKey HexToPubKey(const std::string &hex_in) {
     if (!IsHex(hex_in)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid public key: " + hex_in);
     }
     CPubKey vchPubKey(ParseHex(hex_in));
     if (!vchPubKey.IsFullyValid()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid public key: " + hex_in);
     }
     return vchPubKey;
 }
 
 // Retrieves a public key for an address from the given CKeyStore
 CPubKey AddrToPubKey(const CChainParams &chainparams, CKeyStore *const keystore,
                      const std::string &addr_in) {
     CTxDestination dest = DecodeDestination(addr_in, chainparams);
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid address: " + addr_in);
     }
     CKeyID key = GetKeyForDestination(*keystore, dest);
     if (key.IsNull()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            strprintf("%s does not refer to a key", addr_in));
     }
     CPubKey vchPubKey;
     if (!keystore->GetPubKey(key, vchPubKey)) {
         throw JSONRPCError(
             RPC_INVALID_ADDRESS_OR_KEY,
             strprintf("no full public key for address %s", addr_in));
     }
     if (!vchPubKey.IsFullyValid()) {
         throw JSONRPCError(RPC_INTERNAL_ERROR,
                            "Wallet contains an invalid public key");
     }
     return vchPubKey;
 }
 
 // Creates a multisig redeemscript from a given list of public keys and number
 // required.
 CScript CreateMultisigRedeemscript(const int required,
                                    const std::vector<CPubKey> &pubkeys) {
     // Gather public keys
     if (required < 1) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "a multisignature address must require at least one key to redeem");
     }
     if ((int)pubkeys.size() < required) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            strprintf("not enough keys supplied (got %u keys, "
                                      "but need at least %d to redeem)",
                                      pubkeys.size(), required));
     }
     if (pubkeys.size() > 16) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Number of keys involved in the multisignature "
                            "address creation > 16\nReduce the number");
     }
 
     CScript result = GetScriptForMultisig(required, pubkeys);
 
     if (result.size() > MAX_SCRIPT_ELEMENT_SIZE) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             (strprintf("redeemScript exceeds size limit: %d > %d",
                        result.size(), MAX_SCRIPT_ELEMENT_SIZE)));
     }
 
     return result;
 }
 
 class DescribeAddressVisitor : public boost::static_visitor<UniValue> {
 public:
     explicit DescribeAddressVisitor() {}
 
     UniValue operator()(const CNoDestination &dest) const {
         return UniValue(UniValue::VOBJ);
     }
 
     UniValue operator()(const CKeyID &keyID) const {
         UniValue obj(UniValue::VOBJ);
         obj.pushKV("isscript", false);
         return obj;
     }
 
     UniValue operator()(const CScriptID &scriptID) const {
         UniValue obj(UniValue::VOBJ);
         obj.pushKV("isscript", true);
         return obj;
     }
 };
 
 UniValue DescribeAddress(const CTxDestination &dest) {
     return boost::apply_visitor(DescribeAddressVisitor(), dest);
 }
 
+RPCErrorCode RPCErrorFromTransactionError(TransactionError terr) {
+    switch (terr) {
+        case TransactionError::MEMPOOL_REJECTED:
+            return RPC_TRANSACTION_REJECTED;
+        case TransactionError::ALREADY_IN_CHAIN:
+            return RPC_TRANSACTION_ALREADY_IN_CHAIN;
+        case TransactionError::P2P_DISABLED:
+            return RPC_CLIENT_P2P_DISABLED;
+        case TransactionError::INVALID_PSBT:
+        case TransactionError::SIGHASH_MISMATCH:
+            return RPC_DESERIALIZATION_ERROR;
+        default:
+            break;
+    }
+    return RPC_TRANSACTION_ERROR;
+}
+
+UniValue JSONRPCTransactionError(TransactionError terr,
+                                 const std::string &err_string) {
+    if (err_string.length() > 0) {
+        return JSONRPCError(RPCErrorFromTransactionError(terr), err_string);
+    } else {
+        return JSONRPCError(RPCErrorFromTransactionError(terr),
+                            TransactionErrorString(terr));
+    }
+}
+
 struct Section {
     Section(const std::string &left, const std::string &right)
         : m_left{left}, m_right{right} {}
     const std::string m_left;
     const std::string m_right;
 };
 
 struct Sections {
     std::vector<Section> m_sections;
     size_t m_max_pad{0};
 
     void PushSection(const Section &s) {
         m_max_pad = std::max(m_max_pad, s.m_left.size());
         m_sections.push_back(s);
     }
 
     enum class OuterType {
         ARR,
         OBJ,
         // Only set on first recursion
         NAMED_ARG,
     };
 
     void Push(const RPCArg &arg, const size_t current_indent = 5,
               const OuterType outer_type = OuterType::NAMED_ARG) {
         const auto indent = std::string(current_indent, ' ');
         const auto indent_next = std::string(current_indent + 2, ' ');
         switch (arg.m_type) {
             case RPCArg::Type::STR_HEX:
             case RPCArg::Type::STR:
             case RPCArg::Type::NUM:
             case RPCArg::Type::AMOUNT:
             case RPCArg::Type::BOOL: {
                 // Nothing more to do for non-recursive types on first recursion
                 if (outer_type == OuterType::NAMED_ARG) {
                     return;
                 }
                 auto left = indent;
                 if (arg.m_type_str.size() != 0 &&
                     outer_type == OuterType::OBJ) {
                     left += "\"" + arg.m_name + "\": " + arg.m_type_str.at(0);
                 } else {
                     left += outer_type == OuterType::OBJ
                                 ? arg.ToStringObj(/* oneline */ false)
                                 : arg.ToString(/* oneline */ false);
                 }
                 left += ",";
                 PushSection({left, arg.ToDescriptionString(
                                        /* implicitly_required */ outer_type ==
                                        OuterType::ARR)});
                 break;
             }
             case RPCArg::Type::OBJ:
             case RPCArg::Type::OBJ_USER_KEYS: {
                 const auto right =
                     outer_type == OuterType::NAMED_ARG
                         ? ""
                         : arg.ToDescriptionString(
                               /* implicitly_required */ outer_type ==
                               OuterType::ARR);
                 PushSection({indent + "{", right});
                 for (const auto &arg_inner : arg.m_inner) {
                     Push(arg_inner, current_indent + 2, OuterType::OBJ);
                 }
                 if (arg.m_type != RPCArg::Type::OBJ) {
                     PushSection({indent_next + "...", ""});
                 }
                 PushSection(
                     {indent + "}" +
                          (outer_type != OuterType::NAMED_ARG ? "," : ""),
                      ""});
                 break;
             }
             case RPCArg::Type::ARR: {
                 auto left = indent;
                 left += outer_type == OuterType::OBJ
                             ? "\"" + arg.m_name + "\": "
                             : "";
                 left += "[";
                 const auto right =
                     outer_type == OuterType::NAMED_ARG
                         ? ""
                         : arg.ToDescriptionString(
                               /* implicitly_required */ outer_type ==
                               OuterType::ARR);
                 PushSection({left, right});
                 for (const auto &arg_inner : arg.m_inner) {
                     Push(arg_inner, current_indent + 2, OuterType::ARR);
                 }
                 PushSection({indent_next + "...", ""});
                 PushSection(
                     {indent + "]" +
                          (outer_type != OuterType::NAMED_ARG ? "," : ""),
                      ""});
                 break;
             }
 
                 // no default case, so the compiler can warn about missing cases
         }
     }
 
     std::string ToString() const {
         std::string ret;
         const size_t pad = m_max_pad + 4;
         for (const auto &s : m_sections) {
             if (s.m_right.empty()) {
                 ret += s.m_left;
                 ret += "\n";
                 continue;
             }
 
             std::string left = s.m_left;
             left.resize(pad, ' ');
             ret += left;
 
             // Properly pad after newlines
             std::string right;
             size_t begin = 0;
             size_t new_line_pos = s.m_right.find_first_of('\n');
             while (true) {
                 right += s.m_right.substr(begin, new_line_pos - begin);
                 if (new_line_pos == std::string::npos) {
                     // No new line
                     break;
                 }
                 right += "\n" + std::string(pad, ' ');
                 begin = s.m_right.find_first_not_of(' ', new_line_pos + 1);
                 if (begin == std::string::npos) {
                     break; // Empty line
                 }
                 new_line_pos = s.m_right.find_first_of('\n', begin + 1);
             }
             ret += right;
             ret += "\n";
         }
         return ret;
     }
 };
 
 std::string RPCHelpMan::ToString() const {
     std::string ret;
 
     // Oneline summary
     ret += m_name;
     bool was_optional{false};
     for (const auto &arg : m_args) {
         ret += " ";
         if (arg.m_optional) {
             if (!was_optional) {
                 ret += "( ";
             }
             was_optional = true;
         } else {
             if (was_optional) {
                 ret += ") ";
             }
             was_optional = false;
         }
         ret += arg.ToString(/* oneline */ true);
     }
     if (was_optional) {
         ret += " )";
     }
     ret += "\n";
 
     // Description
     ret += m_description;
 
     // Arguments
     Sections sections;
     for (size_t i{0}; i < m_args.size(); ++i) {
         const auto &arg = m_args.at(i);
 
         if (i == 0) {
             ret += "\nArguments:\n";
         }
 
         // Push named argument name and description
         sections.m_sections.emplace_back(std::to_string(i + 1) + ". " +
                                              arg.m_name,
                                          arg.ToDescriptionString());
         sections.m_max_pad = std::max(sections.m_max_pad,
                                       sections.m_sections.back().m_left.size());
 
         // Recursively push nested args
         sections.Push(arg);
     }
     ret += sections.ToString();
 
     return ret;
 }
 
 std::string RPCArg::ToDescriptionString(const bool implicitly_required) const {
     std::string ret;
     ret += "(";
     if (m_type_str.size() != 0) {
         ret += m_type_str.at(1);
     } else {
         switch (m_type) {
             case Type::STR_HEX:
             case Type::STR: {
                 ret += "string";
                 break;
             }
             case Type::NUM: {
                 ret += "numeric";
                 break;
             }
             case Type::AMOUNT: {
                 ret += "numeric or string";
                 break;
             }
             case Type::BOOL: {
                 ret += "boolean";
                 break;
             }
             case Type::OBJ:
             case Type::OBJ_USER_KEYS: {
                 ret += "json object";
                 break;
             }
             case Type::ARR: {
                 ret += "json array";
                 break;
             }
 
                 // no default case, so the compiler can warn about missing cases
         }
     }
     if (!implicitly_required) {
         ret += ", ";
         if (m_optional) {
             ret += "optional";
             if (!m_default_value.empty()) {
                 ret += ", default=" + m_default_value;
             } else {
                 // TODO enable this assert, when all optional parameters have
                 // their default value documented
                 // assert(false);
             }
         } else {
             ret += "required";
             // Default value is ignored, and must not be present
             assert(m_default_value.empty());
         }
     }
     ret += ")";
     ret += m_description.empty() ? "" : " " + m_description;
     return ret;
 }
 
 std::string RPCArg::ToStringObj(const bool oneline) const {
     std::string res;
     res += "\"";
     res += m_name;
     if (oneline) {
         res += "\":";
     } else {
         res += "\": ";
     }
     switch (m_type) {
         case Type::STR:
             return res + "\"str\"";
         case Type::STR_HEX:
             return res + "\"hex\"";
         case Type::NUM:
             return res + "n";
         case Type::AMOUNT:
             return res + "amount";
         case Type::BOOL:
             return res + "bool";
         case Type::ARR:
             res += "[";
             for (const auto &i : m_inner) {
                 res += i.ToString(oneline) + ",";
             }
             return res + "...]";
         case Type::OBJ:
         case Type::OBJ_USER_KEYS:
             // Currently unused, so avoid writing dead code
             assert(false);
 
             // no default case, so the compiler can warn about missing cases
     }
     assert(false);
 }
 
 std::string RPCArg::ToString(const bool oneline) const {
     if (oneline && !m_oneline_description.empty()) {
         return m_oneline_description;
     }
 
     switch (m_type) {
         case Type::STR_HEX:
         case Type::STR: {
             return "\"" + m_name + "\"";
         }
         case Type::NUM:
         case Type::AMOUNT:
         case Type::BOOL: {
             return m_name;
         }
         case Type::OBJ:
         case Type::OBJ_USER_KEYS: {
             std::string res;
             for (size_t i = 0; i < m_inner.size();) {
                 res += m_inner[i].ToStringObj(oneline);
                 if (++i < m_inner.size()) {
                     res += ",";
                 }
             }
             if (m_type == Type::OBJ) {
                 return "{" + res + "}";
             } else {
                 return "{" + res + ",...}";
             }
         }
         case Type::ARR: {
             std::string res;
             for (const auto &i : m_inner) {
                 res += i.ToString(oneline) + ",";
             }
             return "[" + res + "...]";
         }
 
             // no default case, so the compiler can warn about missing cases
     }
     assert(false);
 }
diff --git a/src/rpc/util.h b/src/rpc/util.h
index 6e855fb70..0fd2c6a8a 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -1,124 +1,129 @@
 // Copyright (c) 2017 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_RPC_UTIL_H
 #define BITCOIN_RPC_UTIL_H
 
+#include <node/transaction.h>
 #include <script/standard.h> // For CTxDestination
 
 #include <string>
 #include <vector>
 
 class CChainParams;
 class CKeyStore;
 class CPubKey;
 class CScript;
 struct InitInterfaces;
 class UniValue;
 
 //! Pointers to interfaces that need to be accessible from RPC methods. Due to
 //! limitations of the RPC framework, there's currently no direct way to pass in
 //! state to RPC method implementations.
 extern InitInterfaces *g_rpc_interfaces;
 
 CPubKey HexToPubKey(const std::string &hex_in);
 CPubKey AddrToPubKey(const CChainParams &chainparams, CKeyStore *const keystore,
                      const std::string &addr_in);
 CScript CreateMultisigRedeemscript(const int required,
                                    const std::vector<CPubKey> &pubkeys);
 
 UniValue DescribeAddress(const CTxDestination &dest);
 
+RPCErrorCode RPCErrorFromTransactionError(TransactionError terr);
+UniValue JSONRPCTransactionError(TransactionError terr,
+                                 const std::string &err_string = "");
+
 struct RPCArg {
     enum class Type {
         OBJ,
         ARR,
         STR,
         NUM,
         BOOL,
         //! Special type where the user must set the keys e.g. to define
         //! multiple addresses; as opposed to e.g. an options object where the
         //! keys are predefined
         OBJ_USER_KEYS,
         //! Special type representing a floating point amount (can be either NUM
         //! or STR)
         AMOUNT,
         //! Special type that is a STR with only hex chars
         STR_HEX,
     };
     //! The name of the arg (can be empty for inner args)
     const std::string m_name;
     const Type m_type;
     //! Only used for arrays or dicts
     const std::vector<RPCArg> m_inner;
     const bool m_optional;
     const std::string m_default_value; //!< Only used for optional args
     const std::string m_description;
     //! Should be empty unless it is supposed to override the auto-generated
     //! summary line
     const std::string m_oneline_description;
 
     //! Should be empty unless it is supposed to override the
     //! auto-generated type strings. Vector length is either 0
     //! or 2, m_type_str.at(0) will override the type of the
     //! value in a key-value pair, m_type_str.at(1) will
     //! override the type in the argument description.
     const std::vector<std::string> m_type_str;
 
     RPCArg(const std::string &name, const Type &type, const bool opt,
            const std::string &default_val, const std::string &description,
            const std::string &oneline_description = "",
            const std::vector<std::string> &type_str = {})
         : m_name{name}, m_type{type}, m_optional{opt},
           m_default_value{default_val}, m_description{description},
           m_oneline_description{oneline_description}, m_type_str{type_str} {
         assert(type != Type::ARR && type != Type::OBJ);
     }
 
     RPCArg(const std::string &name, const Type &type, const bool opt,
            const std::string &default_val, const std::string &description,
            const std::vector<RPCArg> &inner,
            const std::string &oneline_description = "",
            const std::vector<std::string> &type_str = {})
         : m_name{name}, m_type{type}, m_inner{inner}, m_optional{opt},
           m_default_value{default_val}, m_description{description},
           m_oneline_description{oneline_description}, m_type_str{type_str} {
         assert(type == Type::ARR || type == Type::OBJ);
     }
 
     /**
      * Return the type string of the argument.
      * Set oneline to allow it to be overrided by a custom oneline type string
      * (m_oneline_description).
      */
     std::string ToString(bool oneline) const;
     /**
      * Return the type string of the argument when it is in an object (dict).
      * Set oneline to get the oneline representation (less whitespace)
      */
     std::string ToStringObj(bool oneline) const;
     /**
      * Return the description string, including the argument type and whether
      * the argument is required.
      * implicitly_required is set for arguments in an array, which are neither
      * optional nor required.
      */
     std::string ToDescriptionString(bool implicitly_required = false) const;
 };
 
 class RPCHelpMan {
 public:
     RPCHelpMan(const std::string &name, const std::string &description,
                const std::vector<RPCArg> &args)
         : m_name{name}, m_description{description}, m_args{args} {}
 
     std::string ToString() const;
 
 private:
     const std::string m_name;
     const std::string m_description;
     const std::vector<RPCArg> m_args;
 };
 
 #endif // BITCOIN_RPC_UTIL_H
diff --git a/src/wallet/psbtwallet.cpp b/src/wallet/psbtwallet.cpp
index 326a4d449..3c787b0e7 100644
--- a/src/wallet/psbtwallet.cpp
+++ b/src/wallet/psbtwallet.cpp
@@ -1,70 +1,68 @@
 // 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 <wallet/psbtwallet.h>
 
-#include <rpc/protocol.h>
-
 bool FillPSBT(const CWallet *pwallet, PartiallySignedTransaction &psbtx,
-              SigHashType sighash_type, bool sign, bool bip32derivs) {
+              TransactionError &error, bool &complete, SigHashType sighash_type,
+              bool sign, bool bip32derivs) {
     LOCK(pwallet->cs_wallet);
     // Get all of the previous transactions
-    bool complete = true;
+    complete = true;
     for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
         const CTxIn &txin = psbtx.tx->vin[i];
         PSBTInput &input = psbtx.inputs.at(i);
 
         if (PSBTInputSigned(input)) {
             continue;
         }
 
         // Verify input looks sane.
         if (!input.IsSane()) {
-            throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
-                               "PSBT input is not sane.");
+            error = TransactionError::INVALID_PSBT;
+            return false;
         }
 
         // If we have no utxo, grab it from the wallet.
         if (input.utxo.IsNull()) {
             const TxId &txid = txin.prevout.GetTxId();
             const auto it = pwallet->mapWallet.find(txid);
             if (it != pwallet->mapWallet.end()) {
                 const CWalletTx &wtx = it->second;
                 CTxOut utxo = wtx.tx->vout[txin.prevout.GetN()];
                 // Update UTXOs from the wallet.
                 input.utxo = utxo;
             }
         }
 
         // Get the Sighash type
         if (sign && input.sighash_type.getRawSigHashType() > 0 &&
             input.sighash_type != sighash_type) {
-            throw JSONRPCError(
-                RPC_DESERIALIZATION_ERROR,
-                "Specified sighash and sighash in PSBT do not match.");
+            error = TransactionError::SIGHASH_MISMATCH;
+            return false;
         }
 
         complete &=
             SignPSBTInput(HidingSigningProvider(pwallet, !sign, !bip32derivs),
                           psbtx, i, sighash_type);
     }
 
     // Fill in the bip32 keypaths and redeemscripts for the outputs so that
     // hardware wallets can identify change
     for (size_t i = 0; i < psbtx.tx->vout.size(); ++i) {
         const CTxOut &out = psbtx.tx->vout.at(i);
         PSBTOutput &psbt_out = psbtx.outputs.at(i);
 
         // Fill a SignatureData with output info
         SignatureData sigdata;
         psbt_out.FillSignatureData(sigdata);
 
         MutableTransactionSignatureCreator creator(
             psbtx.tx.get_ptr(), 0, out.nValue, SigHashType().withForkId());
         ProduceSignature(HidingSigningProvider(pwallet, true, !bip32derivs),
                          creator, out.scriptPubKey, sigdata);
         psbt_out.FromSignatureData(sigdata);
     }
-    return complete;
+    return true;
 }
diff --git a/src/wallet/psbtwallet.h b/src/wallet/psbtwallet.h
index 42a10cad3..9026c22ed 100644
--- a/src/wallet/psbtwallet.h
+++ b/src/wallet/psbtwallet.h
@@ -1,16 +1,34 @@
 // 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.
 
 #ifndef BITCOIN_WALLET_PSBTWALLET_H
 #define BITCOIN_WALLET_PSBTWALLET_H
 
+#include <node/transaction.h>
 #include <primitives/transaction.h>
 #include <psbt.h>
 #include <wallet/wallet.h>
 
+/**
+ * Fills out a PSBT with information from the wallet. Fills in UTXOs if we have
+ * them. Tries to sign if sign=true. Sets `complete` if the PSBT is now complete
+ * (i.e. has all required signatures or signature-parts, and is ready to
+ * finalize.) Sets `error` and returns false if something goes wrong.
+ *
+ * @param[in]  pwallet pointer to a wallet
+ * @param[in]  &psbtx reference to PartiallySignedTransaction to fill in
+ * @param[out] &error reference to UniValue to fill with error info on failure
+ * @param[out] &complete indicates whether the PSBT is now complete
+ * @param[in]  sighash_type the sighash type to use when signing (if PSBT does
+ * not specify)
+ * @param[in]  sign whether to sign or not
+ * @param[in]  bip32derivs whether to fill in bip32 derivation information if
+ * available return true on success, false on error (and fills in `error`)
+ */
 bool FillPSBT(const CWallet *pwallet, PartiallySignedTransaction &psbtx,
+              TransactionError &error, bool &complete,
               SigHashType sighash_type = SigHashType(), bool sign = true,
               bool bip32derivs = false);
 
 #endif // BITCOIN_WALLET_PSBTWALLET_H
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index af5ec35f5..dcb8014f1 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -1,4909 +1,4920 @@
 // 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 <chain.h>
 #include <chainparams.h> // for GetConsensus.
 #include <config.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <init.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
 #include <net.h>
+#include <node/transaction.h>
 #include <outputtype.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <rpc/mining.h>
 #include <rpc/rawtransaction.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <shutdown.h>
 #include <timedata.h>
 #include <util/moneystr.h>
 #include <util/system.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/psbtwallet.h>
 #include <wallet/rpcwallet.h>
 #include <wallet/wallet.h>
 #include <wallet/walletdb.h>
 #include <wallet/walletutil.h>
 
 #include <univalue.h>
 
 #include <event2/http.h>
 
 #include <functional>
 
 static const std::string WALLET_ENDPOINT_BASE = "/wallet/";
 
 static std::string urlDecode(const std::string &urlEncoded) {
     std::string res;
     if (!urlEncoded.empty()) {
         char *decoded = evhttp_uridecode(urlEncoded.c_str(), false, nullptr);
         if (decoded) {
             res = std::string(decoded);
             free(decoded);
         }
     }
     return res;
 }
 
 bool GetWalletNameFromJSONRPCRequest(const JSONRPCRequest &request,
                                      std::string &wallet_name) {
     if (request.URI.substr(0, WALLET_ENDPOINT_BASE.size()) ==
         WALLET_ENDPOINT_BASE) {
         // wallet endpoint was used
         wallet_name =
             urlDecode(request.URI.substr(WALLET_ENDPOINT_BASE.size()));
         return true;
     }
     return false;
 }
 
 std::shared_ptr<CWallet>
 GetWalletForJSONRPCRequest(const JSONRPCRequest &request) {
     std::string wallet_name;
     if (GetWalletNameFromJSONRPCRequest(request, wallet_name)) {
         std::shared_ptr<CWallet> pwallet = GetWallet(wallet_name);
         if (!pwallet) {
             throw JSONRPCError(
                 RPC_WALLET_NOT_FOUND,
                 "Requested wallet does not exist or is not loaded");
         }
         return pwallet;
     }
 
     std::vector<std::shared_ptr<CWallet>> wallets = GetWallets();
     return wallets.size() == 1 || (request.fHelp && wallets.size() > 0)
                ? wallets[0]
                : nullptr;
 }
 
 std::string HelpRequiringPassphrase(CWallet *const pwallet) {
     return pwallet && pwallet->IsCrypted()
                ? "\nRequires wallet passphrase to be set with walletpassphrase "
                  "call."
                : "";
 }
 
 bool EnsureWalletIsAvailable(CWallet *const pwallet, bool avoidException) {
     if (pwallet) {
         return true;
     }
     if (avoidException) {
         return false;
     }
     if (!HasWallets()) {
         throw JSONRPCError(RPC_METHOD_NOT_FOUND,
                            "Method not found (wallet method is disabled "
                            "because no wallet is loaded)");
     }
 
     throw JSONRPCError(RPC_WALLET_NOT_SPECIFIED,
                        "Wallet file not specified (must request wallet RPC "
                        "through /wallet/<filename> uri-path).");
 }
 
 void EnsureWalletIsUnlocked(CWallet *const pwallet) {
     if (pwallet->IsLocked()) {
         throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED,
                            "Error: Please enter the wallet passphrase with "
                            "walletpassphrase first.");
     }
 }
 
 static void WalletTxToJSON(interfaces::Chain &chain,
                            interfaces::Chain::Lock &locked_chain,
                            const CWalletTx &wtx, UniValue &entry) {
     int confirms = wtx.GetDepthInMainChain(locked_chain);
     entry.pushKV("confirmations", confirms);
     if (wtx.IsCoinBase()) {
         entry.pushKV("generated", true);
     }
     if (confirms > 0) {
         entry.pushKV("blockhash", wtx.hashBlock.GetHex());
         entry.pushKV("blockindex", wtx.nIndex);
         int64_t block_time;
         bool found_block =
             chain.findBlock(wtx.hashBlock, nullptr /* block */, &block_time);
         assert(found_block);
         entry.pushKV("blocktime", block_time);
     } else {
         entry.pushKV("trusted", wtx.IsTrusted(locked_chain));
     }
     uint256 hash = wtx.GetId();
     entry.pushKV("txid", hash.GetHex());
     UniValue conflicts(UniValue::VARR);
     for (const uint256 &conflict : wtx.GetConflicts()) {
         conflicts.push_back(conflict.GetHex());
     }
     entry.pushKV("walletconflicts", conflicts);
     entry.pushKV("time", wtx.GetTxTime());
     entry.pushKV("timereceived", (int64_t)wtx.nTimeReceived);
 
     for (const std::pair<const std::string, std::string> &item : wtx.mapValue) {
         entry.pushKV(item.first, item.second);
     }
 }
 
 static std::string LabelFromValue(const UniValue &value) {
     std::string label = value.get_str();
     if (label == "*") {
         throw JSONRPCError(RPC_WALLET_INVALID_LABEL_NAME, "Invalid label name");
     }
     return label;
 }
 
 static UniValue getnewaddress(const Config &config,
                               const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{
                 "getnewaddress",
                 "\nReturns a new Bitcoin address for receiving payments.\n"
                 "If 'label' is specified, it is added to the address book \n"
                 "so payments received with the address will be associated with "
                 "'label'.\n",
                 {
                     {"label", RPCArg::Type::STR, /* opt */ true,
                      /* default_val */ "",
                      "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."},
                 }}
                 .ToString() +
             "\nResult:\n"
             "\"address\"    (string) The new bitcoin address\n"
             "\nExamples:\n" +
             HelpExampleRpc("getnewaddress", ""));
     }
 
     // Belt and suspenders check for disabled private keys
     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Error: Private keys are disabled for this wallet");
     }
 
     LOCK(pwallet->cs_wallet);
 
     if (!pwallet->CanGetAddresses()) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Error: This wallet has no available keys");
     }
 
     // Parse the label first so we don't generate a key if there's an error
     std::string label;
     if (!request.params[0].isNull()) {
         label = LabelFromValue(request.params[0]);
     }
 
     OutputType output_type = pwallet->m_default_address_type;
     if (!request.params[1].isNull()) {
         if (!ParseOutputType(request.params[1].get_str(), output_type)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                strprintf("Unknown address type '%s'",
                                          request.params[1].get_str()));
         }
     }
 
     if (!pwallet->IsLocked()) {
         pwallet->TopUpKeyPool();
     }
 
     // Generate a new key that is added to wallet
     CPubKey newKey;
     if (!pwallet->GetKeyFromPool(newKey)) {
         throw JSONRPCError(
             RPC_WALLET_KEYPOOL_RAN_OUT,
             "Error: Keypool ran out, please call keypoolrefill first");
     }
     pwallet->LearnRelatedScripts(newKey, output_type);
     CTxDestination dest = GetDestinationForKey(newKey, output_type);
 
     pwallet->SetAddressBook(dest, label, "receive");
 
     return EncodeDestination(dest, config);
 }
 
 static UniValue getrawchangeaddress(const Config &config,
                                     const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 1) {
         throw std::runtime_error(
             RPCHelpMan{
                 "getrawchangeaddress",
                 "\nReturns a new Bitcoin address, for receiving change.\n"
                 "This is for use with raw transactions, NOT normal use.\n",
                 {}}
                 .ToString() +
             "\nResult:\n"
             "\"address\"    (string) The address\n"
             "\nExamples:\n" +
             HelpExampleCli("getrawchangeaddress", "") +
             HelpExampleRpc("getrawchangeaddress", ""));
     }
 
     // Belt and suspenders check for disabled private keys
     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Error: Private keys are disabled for this wallet");
     }
 
     LOCK(pwallet->cs_wallet);
 
     if (!pwallet->CanGetAddresses(true)) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Error: This wallet has no available keys");
     }
 
     if (!pwallet->IsLocked()) {
         pwallet->TopUpKeyPool();
     }
 
     OutputType output_type =
         pwallet->m_default_change_type != OutputType::CHANGE_AUTO
             ? pwallet->m_default_change_type
             : pwallet->m_default_address_type;
     if (!request.params[0].isNull()) {
         if (!ParseOutputType(request.params[0].get_str(), output_type)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                strprintf("Unknown address type '%s'",
                                          request.params[0].get_str()));
         }
     }
 
     CReserveKey reservekey(pwallet);
     CPubKey vchPubKey;
     if (!reservekey.GetReservedKey(vchPubKey, true)) {
         throw JSONRPCError(
             RPC_WALLET_KEYPOOL_RAN_OUT,
             "Error: Keypool ran out, please call keypoolrefill first");
     }
 
     reservekey.KeepKey();
 
     pwallet->LearnRelatedScripts(vchPubKey, output_type);
     CTxDestination dest = GetDestinationForKey(vchPubKey, output_type);
 
     return EncodeDestination(dest, config);
 }
 
 static UniValue setlabel(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 2) {
         throw std::runtime_error(
             RPCHelpMan{
                 "setlabel",
                 "\nSets the label associated with the given address.\n",
                 {
                     {"address", RPCArg::Type::STR, /* opt */ false,
                      /* default_val */ "",
                      "The bitcoin address to be associated with a label."},
                     {"label", RPCArg::Type::STR, /* opt */ false,
                      /* default_val */ "",
                      "The label to assign to the address."},
                 }}
                 .ToString() +
             "\nExamples:\n" +
             HelpExampleCli("setlabel",
                            "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"tabby\"") +
             HelpExampleRpc(
                 "setlabel",
                 "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\", \"tabby\""));
     }
     LOCK(pwallet->cs_wallet);
 
     CTxDestination dest =
         DecodeDestination(request.params[0].get_str(), config.GetChainParams());
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid Bitcoin address");
     }
 
     std::string old_label = pwallet->mapAddressBook[dest].name;
     std::string label = LabelFromValue(request.params[1]);
 
     if (IsMine(*pwallet, dest)) {
         pwallet->SetAddressBook(dest, label, "receive");
     } else {
         pwallet->SetAddressBook(dest, label, "send");
     }
 
     return NullUniValue;
 }
 
 static CTransactionRef SendMoney(interfaces::Chain::Lock &locked_chain,
                                  CWallet *const pwallet,
                                  const CTxDestination &address, Amount nValue,
                                  bool fSubtractFeeFromAmount,
                                  mapValue_t mapValue) {
     Amount curBalance = pwallet->GetBalance();
 
     // Check amount
     if (nValue <= Amount::zero()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid amount");
     }
 
     if (nValue > curBalance) {
         throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Insufficient funds");
     }
 
     if (pwallet->GetBroadcastTransactions() && !g_connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     // Parse Bitcoin address
     CScript scriptPubKey = GetScriptForDestination(address);
 
     // Create and send the transaction
     CReserveKey reservekey(pwallet);
     Amount nFeeRequired;
     std::string strError;
     std::vector<CRecipient> vecSend;
     int nChangePosRet = -1;
     CRecipient recipient = {scriptPubKey, nValue, fSubtractFeeFromAmount};
     vecSend.push_back(recipient);
 
     CCoinControl coinControl;
     CTransactionRef tx;
     if (!pwallet->CreateTransaction(locked_chain, vecSend, tx, reservekey,
                                     nFeeRequired, nChangePosRet, strError,
                                     coinControl)) {
         if (!fSubtractFeeFromAmount && nValue + nFeeRequired > curBalance) {
             strError = strprintf("Error: This transaction requires a "
                                  "transaction fee of at least %s",
                                  FormatMoney(nFeeRequired));
         }
         throw JSONRPCError(RPC_WALLET_ERROR, strError);
     }
     CValidationState state;
     if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */,
                                     reservekey, g_connman.get(), state)) {
         strError =
             strprintf("Error: The transaction was rejected! Reason given: %s",
                       FormatStateMessage(state));
         throw JSONRPCError(RPC_WALLET_ERROR, strError);
     }
     return tx;
 }
 
 static UniValue sendtoaddress(const Config &config,
                               const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 5) {
         throw std::runtime_error(
             RPCHelpMan{
                 "sendtoaddress",
                 "\nSend an amount to a given address.\n" +
                     HelpRequiringPassphrase(pwallet) + "\n",
                 {
                     {"address", RPCArg::Type::STR, /* opt */ false,
                      /* default_val */ "", "The bitcoin address to send to."},
                     {"amount", RPCArg::Type::AMOUNT, /* opt */ false,
                      /* default_val */ "",
                      "The amount in " + CURRENCY_UNIT + " to send. eg 0.1"},
                     {"comment", RPCArg::Type::STR, /* opt */ true,
                      /* default_val */ "",
                      "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, /* opt */ true,
                      /* default_val */ "",
                      "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,
                      /* opt */ true, /* default_val */ "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."},
                 }}
                 .ToString() +
             "\nResult:\n"
             "\"txid\"                  (string) The transaction id.\n"
             "\nExamples:\n" +
             HelpExampleCli("sendtoaddress",
                            "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 0.1") +
             HelpExampleCli("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvay"
                                             "dd\" 0.1 \"donation\" \"seans "
                                             "outpost\"") +
             HelpExampleCli(
                 "sendtoaddress",
                 "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 0.1 \"\" \"\" true") +
             HelpExampleRpc("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvay"
                                             "dd\", 0.1, \"donation\", \"seans "
                                             "outpost\""));
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     CTxDestination dest =
         DecodeDestination(request.params[0].get_str(), config.GetChainParams());
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
     }
 
     // Amount
     Amount nAmount = AmountFromValue(request.params[1]);
     if (nAmount <= Amount::zero()) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount for send");
     }
 
     // Wallet comments
     mapValue_t mapValue;
     if (!request.params[2].isNull() && !request.params[2].get_str().empty()) {
         mapValue["comment"] = request.params[2].get_str();
     }
     if (!request.params[3].isNull() && !request.params[3].get_str().empty()) {
         mapValue["to"] = request.params[3].get_str();
     }
 
     bool fSubtractFeeFromAmount = false;
     if (!request.params[4].isNull()) {
         fSubtractFeeFromAmount = request.params[4].get_bool();
     }
 
     EnsureWalletIsUnlocked(pwallet);
 
     CTransactionRef tx = SendMoney(*locked_chain, pwallet, dest, nAmount,
                                    fSubtractFeeFromAmount, std::move(mapValue));
     return tx->GetId().GetHex();
 }
 
 static UniValue listaddressgroupings(const Config &config,
                                      const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(
             RPCHelpMan{"listaddressgroupings",
                        "\nLists groups of addresses which have had their "
                        "common ownership\n"
                        "made public by common use as inputs or as the "
                        "resulting change\n"
                        "in past transactions\n",
                        {}}
                 .ToString() +
             "\nResult:\n"
             "[\n"
             "  [\n"
             "    [\n"
             "      \"address\",            (string) The bitcoin address\n"
             "      amount,                 (numeric) The amount in " +
             CURRENCY_UNIT +
             "\n"
             "      \"label\"               (string, optional) The label\n"
             "    ]\n"
             "    ,...\n"
             "  ]\n"
             "  ,...\n"
             "]\n"
             "\nExamples:\n" +
             HelpExampleCli("listaddressgroupings", "") +
             HelpExampleRpc("listaddressgroupings", ""));
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     UniValue jsonGroupings(UniValue::VARR);
     std::map<CTxDestination, Amount> balances =
         pwallet->GetAddressBalances(*locked_chain);
     for (const std::set<CTxDestination> &grouping :
          pwallet->GetAddressGroupings()) {
         UniValue jsonGrouping(UniValue::VARR);
         for (const CTxDestination &address : grouping) {
             UniValue addressInfo(UniValue::VARR);
             addressInfo.push_back(EncodeDestination(address, config));
             addressInfo.push_back(ValueFromAmount(balances[address]));
 
             if (pwallet->mapAddressBook.find(address) !=
                 pwallet->mapAddressBook.end()) {
                 addressInfo.push_back(
                     pwallet->mapAddressBook.find(address)->second.name);
             }
             jsonGrouping.push_back(addressInfo);
         }
         jsonGroupings.push_back(jsonGrouping);
     }
 
     return jsonGroupings;
 }
 
 static UniValue signmessage(const Config &config,
                             const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 2) {
         throw std::runtime_error(
             RPCHelpMan{"signmessage",
                        "\nSign a message with the private key of an address" +
                            HelpRequiringPassphrase(pwallet) + "\n",
                        {
                            {"address", RPCArg::Type::STR, /* opt */ false,
                             /* default_val */ "",
                             "The bitcoin address to use for the private key."},
                            {"message", RPCArg::Type::STR, /* opt */ false,
                             /* default_val */ "",
                             "The message to create a signature of."},
                        }}
                 .ToString() +
             "\nResult:\n"
             "\"signature\"          (string) The signature of the message "
             "encoded in base 64\n"
             "\nExamples:\n"
             "\nUnlock the wallet for 30 seconds\n" +
             HelpExampleCli("walletpassphrase", "\"mypassphrase\" 30") +
             "\nCreate the signature\n" +
             HelpExampleCli(
                 "signmessage",
                 "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"my message\"") +
             "\nVerify the signature\n" +
             HelpExampleCli("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4"
                                             "XX\" \"signature\" \"my "
                                             "message\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc(
                 "signmessage",
                 "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\", \"my message\""));
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     EnsureWalletIsUnlocked(pwallet);
 
     std::string strAddress = request.params[0].get_str();
     std::string strMessage = request.params[1].get_str();
 
     CTxDestination dest =
         DecodeDestination(strAddress, config.GetChainParams());
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");
     }
 
     const CKeyID *keyID = boost::get<CKeyID>(&dest);
     if (!keyID) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");
     }
 
     CKey key;
     if (!pwallet->GetKey(*keyID, key)) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Private key not available");
     }
 
     CHashWriter ss(SER_GETHASH, 0);
     ss << strMessageMagic;
     ss << strMessage;
 
     std::vector<uint8_t> vchSig;
     if (!key.SignCompact(ss.GetHash(), vchSig)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Sign failed");
     }
 
     return EncodeBase64(vchSig.data(), vchSig.size());
 }
 
 static UniValue getreceivedbyaddress(const Config &config,
                                      const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{
                 "getreceivedbyaddress",
                 "\nReturns the total amount received by the given address in "
                 "transactions with at least minconf confirmations.\n",
                 {
                     {"address", RPCArg::Type::STR, /* opt */ false,
                      /* default_val */ "",
                      "The bitcoin address for transactions."},
                     {"minconf", RPCArg::Type::NUM, /* opt */ true,
                      /* default_val */ "1",
                      "Only include transactions confirmed at least this many "
                      "times."},
                 }}
                 .ToString() +
             "\nResult:\n"
             "amount   (numeric) The total amount in " +
             CURRENCY_UNIT +
             " received at this address.\n"
             "\nExamples:\n"
             "\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"));
     }
 
     // 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();
 
     // Temporary, for ContextualCheckTransactionForCurrentBlock below. Removed
     // in upcoming commit.
     LockAnnotation lock(::cs_main);
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     // Bitcoin address
     CTxDestination dest =
         DecodeDestination(request.params[0].get_str(), config.GetChainParams());
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid Bitcoin address");
     }
     CScript scriptPubKey = GetScriptForDestination(dest);
     if (!IsMine(*pwallet, scriptPubKey)) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Address not found in wallet");
     }
 
     // Minimum confirmations
     int nMinDepth = 1;
     if (!request.params[1].isNull()) {
         nMinDepth = request.params[1].get_int();
     }
 
     // Tally
     Amount nAmount = Amount::zero();
     for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
         const CWalletTx &wtx = pairWtx.second;
 
         CValidationState state;
         if (wtx.IsCoinBase() ||
             !ContextualCheckTransactionForCurrentBlock(
                 config.GetChainParams().GetConsensus(), *wtx.tx, state)) {
             continue;
         }
 
         for (const CTxOut &txout : wtx.tx->vout) {
             if (txout.scriptPubKey == scriptPubKey) {
                 if (wtx.GetDepthInMainChain(*locked_chain) >= nMinDepth) {
                     nAmount += txout.nValue;
                 }
             }
         }
     }
 
     return ValueFromAmount(nAmount);
 }
 
 static UniValue getreceivedbylabel(const Config &config,
                                    const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{
                 "getreceivedbylabel",
                 "\nReturns the total amount received by addresses with <label> "
                 "in transactions with at least [minconf] confirmations.\n",
                 {
                     {"label", RPCArg::Type::STR, /* opt */ false,
                      /* default_val */ "",
                      "The selected label, may be the default label "
                      "using \"\"."},
                     {"minconf", RPCArg::Type::NUM, /* opt */ true,
                      /* default_val */ "1",
                      "Only include transactions confirmed at least this "
                      "many times."},
                 }}
                 .ToString() +
             "\nResult:\n"
             "amount              (numeric) The total amount in " +
             CURRENCY_UNIT +
             " received for this label.\n"
             "\nExamples:\n"
             "\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"));
     }
 
     // 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();
 
     // Temporary, for ContextualCheckTransactionForCurrentBlock below. Removed
     // in upcoming commit.
     LockAnnotation lock(::cs_main);
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     // Minimum confirmations
     int nMinDepth = 1;
     if (!request.params[1].isNull()) {
         nMinDepth = request.params[1].get_int();
     }
 
     // Get the set of pub keys assigned to label
     std::string label = LabelFromValue(request.params[0]);
     std::set<CTxDestination> setAddress = pwallet->GetLabelAddresses(label);
 
     // Tally
     Amount nAmount = Amount::zero();
     for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
         const CWalletTx &wtx = pairWtx.second;
         CValidationState state;
         if (wtx.IsCoinBase() ||
             !ContextualCheckTransactionForCurrentBlock(
                 config.GetChainParams().GetConsensus(), *wtx.tx, state)) {
             continue;
         }
 
         for (const CTxOut &txout : wtx.tx->vout) {
             CTxDestination address;
             if (ExtractDestination(txout.scriptPubKey, address) &&
                 IsMine(*pwallet, address) && setAddress.count(address)) {
                 if (wtx.GetDepthInMainChain(*locked_chain) >= nMinDepth) {
                     nAmount += txout.nValue;
                 }
             }
         }
     }
 
     return ValueFromAmount(nAmount);
 }
 
 static UniValue getbalance(const Config &config,
                            const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || (request.params.size() > 3)) {
         throw std::runtime_error(
             RPCHelpMan{"getbalance",
                        "\nReturns the total available balance.\n"
                        "The available balance is what the wallet considers "
                        "currently spendable, and is\n"
                        "thus affected by options which limit spendability such "
                        "as -spendzeroconfchange.\n",
                        {
                            {"dummy", RPCArg::Type::STR, /* opt */ true,
                             /* default_val */ "",
                             "Remains for backward compatibility. Must be "
                             "excluded or set to \"*\"."},
                            {"minconf", RPCArg::Type::NUM, /* opt */ true,
                             /* default_val */ "0",
                             "Only include transactions confirmed at least this "
                             "many times."},
                            {"include_watchonly", RPCArg::Type::BOOL,
                             /* opt */ true, /* default_val */ "false",
                             "Also include balance in watch-only addresses (see "
                             "'importaddress')"},
                        }}
                 .ToString() +
             "\nResult:\n"
             "amount              (numeric) The total amount in " +
             CURRENCY_UNIT +
             " received for this wallet.\n"
             "\nExamples:\n"
             "\nThe total amount in the wallet with 1 or more confirmations\n" +
             HelpExampleCli("getbalance", "") +
             "\nThe total amount in the wallet at least 6 blocks confirmed\n" +
             HelpExampleCli("getbalance", "\"*\" 6") + "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("getbalance", "\"*\", 6"));
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     const UniValue &dummy_value = request.params[0];
     if (!dummy_value.isNull() && dummy_value.get_str() != "*") {
         throw JSONRPCError(
             RPC_METHOD_DEPRECATED,
             "dummy first argument must be excluded or set to \"*\".");
     }
 
     int min_depth = 0;
     if (!request.params[1].isNull()) {
         min_depth = request.params[1].get_int();
     }
 
     isminefilter filter = ISMINE_SPENDABLE;
     if (!request.params[2].isNull() && request.params[2].get_bool()) {
         filter = filter | ISMINE_WATCH_ONLY;
     }
 
     return ValueFromAmount(pwallet->GetBalance(filter, min_depth));
 }
 
 static UniValue getunconfirmedbalance(const Config &config,
                                       const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 0) {
         throw std::runtime_error(RPCHelpMan{
             "getunconfirmedbalance",
             "Returns the server's total unconfirmed balance\n",
             {}}.ToString());
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     return ValueFromAmount(pwallet->GetUnconfirmedBalance());
 }
 
 static UniValue sendmany(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 5) {
         throw std::runtime_error(
             RPCHelpMan{
                 "sendmany",
                 "\nSend multiple times. Amounts are double-precision "
                 "floating point numbers." +
                     HelpRequiringPassphrase(pwallet) + "\n",
                 {
                     {"dummy", RPCArg::Type::STR, /* opt */ false,
                      /* default_val */ "",
                      "Must be set to \"\" for backwards compatibility.",
                      "\"\""},
                     {
                         "amounts",
                         RPCArg::Type::OBJ,
                         /* opt */ false,
                         /* default_val */ "",
                         "A json object with addresses and amounts",
                         {
                             {"address", RPCArg::Type::AMOUNT, /* opt */ false,
                              /* default_val */ "",
                              "The bitcoin address is the key, the numeric "
                              "amount (can be string) in " +
                                  CURRENCY_UNIT + " is the value"},
                         },
                     },
                     {"minconf", RPCArg::Type::NUM, /* opt */ true,
                      /* default_val */ "1",
                      "Only use the balance confirmed at least this many "
                      "times."},
                     {"comment", RPCArg::Type::STR, /* opt */ true,
                      /* default_val */ "", "A comment"},
                     {
                         "subtractfeefrom",
                         RPCArg::Type::ARR,
                         /* opt */ true,
                         /* default_val */ "",
                         "A json array with addresses.\n"
                         "                           The fee will be equally "
                         "deducted from the amount of each selected address.\n"
                         "                           Those recipients will "
                         "receive less bitcoins than you enter in their "
                         "corresponding amount field.\n"
                         "                           If no addresses are "
                         "specified here, the sender pays the fee.",
                         {
                             {"address", RPCArg::Type::STR, /* opt */ true,
                              /* default_val */ "",
                              "Subtract fee from this address"},
                         },
                     },
                 }}
                 .ToString() +
             "\nResult:\n"
             "\"txid\"                   (string) The transaction id for the "
             "send. Only 1 transaction is created regardless of \n"
             "                                    the number of addresses.\n"
             "\nExamples:\n"
             "\nSend two amounts to two different addresses:\n" +
             HelpExampleCli("sendmany",
                            "\"\" "
                            "\"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,"
                            "\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}"
                            "\"") +
             "\nSend two amounts to two different addresses setting the "
             "confirmation and comment:\n" +
             HelpExampleCli("sendmany",
                            "\"\" "
                            "\"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,"
                            "\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\" "
                            "6 \"testing\"") +
             "\nSend two amounts to two different addresses, subtract fee from "
             "amount:\n" +
             HelpExampleCli("sendmany",
                            "\"\" "
                            "\"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,"
                            "\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\" "
                            "1 \"\" "
                            "\"[\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\","
                            "\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\"]\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("sendmany",
                            "\"\", "
                            "\"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,"
                            "\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\","
                            " 6, \"testing\""));
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     if (pwallet->GetBroadcastTransactions() && !g_connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     if (!request.params[0].isNull() && !request.params[0].get_str().empty()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Dummy value must be set to \"\"");
     }
     UniValue sendTo = request.params[1].get_obj();
     int nMinDepth = 1;
     if (!request.params[2].isNull()) {
         nMinDepth = request.params[2].get_int();
     }
 
     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;
 
     Amount totalAmount = Amount::zero();
     std::vector<std::string> keys = sendTo.getKeys();
     for (const std::string &name_ : keys) {
         CTxDestination dest = DecodeDestination(name_, config.GetChainParams());
         if (!IsValidDestination(dest)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                std::string("Invalid Bitcoin address: ") +
                                    name_);
         }
 
         if (destinations.count(dest)) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 std::string("Invalid parameter, duplicated address: ") + name_);
         }
         destinations.insert(dest);
 
         CScript scriptPubKey = GetScriptForDestination(dest);
         Amount nAmount = AmountFromValue(sendTo[name_]);
         if (nAmount <= Amount::zero()) {
             throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount for send");
         }
         totalAmount += nAmount;
 
         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);
 
     // Check funds
     if (totalAmount > pwallet->GetLegacyBalance(ISMINE_SPENDABLE, nMinDepth)) {
         throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS,
                            "Wallet has insufficient funds");
     }
 
     // Shuffle recipient list
     std::shuffle(vecSend.begin(), vecSend.end(), FastRandomContext());
 
     // Send
     CReserveKey keyChange(pwallet);
     Amount nFeeRequired = Amount::zero();
     int nChangePosRet = -1;
     std::string strFailReason;
     CTransactionRef tx;
     CCoinControl coinControl;
     bool fCreated = pwallet->CreateTransaction(
         *locked_chain, vecSend, tx, keyChange, nFeeRequired, nChangePosRet,
         strFailReason, coinControl);
     if (!fCreated) {
         throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, strFailReason);
     }
     CValidationState state;
     if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */,
                                     keyChange, g_connman.get(), state)) {
         strFailReason = strprintf("Transaction commit failed:: %s",
                                   FormatStateMessage(state));
         throw JSONRPCError(RPC_WALLET_ERROR, strFailReason);
     }
 
     return tx->GetId().GetHex();
 }
 
 static UniValue addmultisigaddress(const Config &config,
                                    const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 3) {
         std::string msg =
             RPCHelpMan{
                 "addmultisigaddress",
                 "\nAdd a nrequired-to-sign multisignature address to the "
                 "wallet. "
                 "Requires a new wallet backup.\n"
                 "Each key is a Bitcoin address or hex-encoded public key.\n"
                 "If 'label' is specified (DEPRECATED), assign address to that "
                 "label.\n",
                 {
                     {"nrequired", RPCArg::Type::NUM, /* opt */ false,
                      /* default_val */ "",
                      "The number of required signatures out of the n keys or "
                      "addresses."},
                     {
                         "keys",
                         RPCArg::Type::ARR,
                         /* opt */ false,
                         /* default_val */ "",
                         "A json array of bitcoin addresses or hex-encoded "
                         "public keys",
                         {
                             {"key", RPCArg::Type::STR, /* opt */ false,
                              /* default_val */ "",
                              "bitcoin address or hex-encoded public key"},
                         },
                     },
                     {"label", RPCArg::Type::STR, /* opt */ true,
                      /* default_val */ "",
                      "A label to assign the addresses to."},
                 }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"address\":\"multisigaddress\",    (string) The value of the "
             "new multisig address.\n"
             "  \"redeemScript\":\"script\"         (string) The string value "
             "of the hex-encoded redemption script.\n"
             "}\n"
 
             "\nExamples:\n"
             "\nAdd a multisig address from 2 addresses\n" +
             HelpExampleCli("addmultisigaddress",
                            "2 "
                            "\"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\","
                            "\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("addmultisigaddress",
                            "2, "
                            "\"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\","
                            "\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"");
         throw std::runtime_error(msg);
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     std::string label;
     if (!request.params[2].isNull()) {
         label = LabelFromValue(request.params[2]);
     }
 
     int required = request.params[0].get_int();
 
     // Get the public keys
     const UniValue &keys_or_addrs = request.params[1].get_array();
     std::vector<CPubKey> pubkeys;
     for (size_t i = 0; i < keys_or_addrs.size(); ++i) {
         if (IsHex(keys_or_addrs[i].get_str()) &&
             (keys_or_addrs[i].get_str().length() == 66 ||
              keys_or_addrs[i].get_str().length() == 130)) {
             pubkeys.push_back(HexToPubKey(keys_or_addrs[i].get_str()));
         } else {
             pubkeys.push_back(AddrToPubKey(config.GetChainParams(), pwallet,
                                            keys_or_addrs[i].get_str()));
         }
     }
 
     OutputType output_type = pwallet->m_default_address_type;
 
     // Construct using pay-to-script-hash:
     CScript inner = CreateMultisigRedeemscript(required, pubkeys);
     CTxDestination dest =
         AddAndGetDestinationForScript(*pwallet, inner, output_type);
     pwallet->SetAddressBook(dest, label, "send");
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("address", EncodeDestination(dest, config));
     result.pushKV("redeemScript", HexStr(inner.begin(), inner.end()));
     return result;
 }
 
 struct tallyitem {
     Amount nAmount{Amount::zero()};
     int nConf{std::numeric_limits<int>::max()};
     std::vector<uint256> txids;
     bool fIsWatchonly{false};
     tallyitem() {}
 };
 
 static UniValue
 ListReceived(const Config &config, interfaces::Chain::Lock &locked_chain,
              CWallet *const pwallet, const UniValue &params, bool by_label)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     // Temporary, for ContextualCheckTransactionForCurrentBlock below. Removed
     // in upcoming commit.
     LockAnnotation lock(::cs_main);
 
     // Minimum confirmations
     int nMinDepth = 1;
     if (!params[0].isNull()) {
         nMinDepth = params[0].get_int();
     }
 
     // Whether to include empty labels
     bool fIncludeEmpty = false;
     if (!params[1].isNull()) {
         fIncludeEmpty = params[1].get_bool();
     }
 
     isminefilter filter = ISMINE_SPENDABLE;
     if (!params[2].isNull() && params[2].get_bool()) {
         filter = filter | ISMINE_WATCH_ONLY;
     }
 
     bool has_filtered_address = false;
     CTxDestination filtered_address = CNoDestination();
     if (!by_label && params.size() > 3) {
         if (!IsValidDestinationString(params[3].get_str(),
                                       config.GetChainParams())) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "address_filter parameter was invalid");
         }
         filtered_address =
             DecodeDestination(params[3].get_str(), config.GetChainParams());
         has_filtered_address = true;
     }
 
     // Tally
     std::map<CTxDestination, tallyitem> mapTally;
     for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
         const CWalletTx &wtx = pairWtx.second;
 
         CValidationState state;
         if (wtx.IsCoinBase() ||
             !ContextualCheckTransactionForCurrentBlock(
                 config.GetChainParams().GetConsensus(), *wtx.tx, state)) {
             continue;
         }
 
         int nDepth = wtx.GetDepthInMainChain(locked_chain);
         if (nDepth < nMinDepth) {
             continue;
         }
 
         for (const CTxOut &txout : wtx.tx->vout) {
             CTxDestination address;
             if (!ExtractDestination(txout.scriptPubKey, address)) {
                 continue;
             }
 
             if (has_filtered_address && !(filtered_address == address)) {
                 continue;
             }
 
             isminefilter mine = IsMine(*pwallet, address);
             if (!(mine & filter)) {
                 continue;
             }
 
             tallyitem &item = mapTally[address];
             item.nAmount += txout.nValue;
             item.nConf = std::min(item.nConf, nDepth);
             item.txids.push_back(wtx.GetId());
             if (mine & ISMINE_WATCH_ONLY) {
                 item.fIsWatchonly = true;
             }
         }
     }
 
     // Reply
     UniValue ret(UniValue::VARR);
     std::map<std::string, tallyitem> label_tally;
 
     // Create mapAddressBook iterator
     // If we aren't filtering, go from begin() to end()
     auto start = pwallet->mapAddressBook.begin();
     auto end = pwallet->mapAddressBook.end();
     // If we are filtering, find() the applicable entry
     if (has_filtered_address) {
         start = pwallet->mapAddressBook.find(filtered_address);
         if (start != end) {
             end = std::next(start);
         }
     }
 
     for (auto item_it = start; item_it != end; ++item_it) {
         const CTxDestination &address = item_it->first;
         const std::string &label = item_it->second.name;
         std::map<CTxDestination, tallyitem>::iterator it =
             mapTally.find(address);
         if (it == mapTally.end() && !fIncludeEmpty) {
             continue;
         }
 
         Amount nAmount = Amount::zero();
         int nConf = std::numeric_limits<int>::max();
         bool fIsWatchonly = false;
         if (it != mapTally.end()) {
             nAmount = (*it).second.nAmount;
             nConf = (*it).second.nConf;
             fIsWatchonly = (*it).second.fIsWatchonly;
         }
 
         if (by_label) {
             tallyitem &_item = label_tally[label];
             _item.nAmount += nAmount;
             _item.nConf = std::min(_item.nConf, nConf);
             _item.fIsWatchonly = fIsWatchonly;
         } else {
             UniValue obj(UniValue::VOBJ);
             if (fIsWatchonly) {
                 obj.pushKV("involvesWatchonly", true);
             }
             obj.pushKV("address", EncodeDestination(address, config));
             obj.pushKV("amount", ValueFromAmount(nAmount));
             obj.pushKV("confirmations",
                        (nConf == std::numeric_limits<int>::max() ? 0 : nConf));
             obj.pushKV("label", label);
             UniValue transactions(UniValue::VARR);
             if (it != mapTally.end()) {
                 for (const uint256 &_item : (*it).second.txids) {
                     transactions.push_back(_item.GetHex());
                 }
             }
             obj.pushKV("txids", transactions);
             ret.push_back(obj);
         }
     }
 
     if (by_label) {
         for (const auto &entry : label_tally) {
             Amount nAmount = entry.second.nAmount;
             int nConf = entry.second.nConf;
             UniValue obj(UniValue::VOBJ);
             if (entry.second.fIsWatchonly) {
                 obj.pushKV("involvesWatchonly", true);
             }
             obj.pushKV("amount", ValueFromAmount(nAmount));
             obj.pushKV("confirmations",
                        (nConf == std::numeric_limits<int>::max() ? 0 : nConf));
             obj.pushKV("label", entry.first);
             ret.push_back(obj);
         }
     }
 
     return ret;
 }
 
 static UniValue listreceivedbyaddress(const Config &config,
                                       const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 4) {
         throw std::runtime_error(
             RPCHelpMan{
                 "listreceivedbyaddress",
                 "\nList balances by receiving address.\n",
                 {
                     {"minconf", RPCArg::Type::NUM, /* opt */ true,
                      /* default_val */ "1",
                      "The minimum number of confirmations before payments are "
                      "included."},
                     {"include_empty", RPCArg::Type::BOOL, /* opt */ true,
                      /* default_val */ "false",
                      "Whether to include addresses that haven't received any "
                      "payments."},
                     {"include_watchonly", RPCArg::Type::BOOL, /* opt */ true,
                      /* default_val */ "false",
                      "Whether to include watch-only addresses (see "
                      "'importaddress')."},
                     {"address_filter", RPCArg::Type::STR, /* opt */ true,
                      /* default_val */ "",
                      "If present, only return information on this address."},
                 }}
                 .ToString() +
             "\nResult:\n"
             "[\n"
             "  {\n"
             "    \"involvesWatchonly\" : true,        (bool) Only returned if "
             "imported addresses were involved in transaction\n"
             "    \"address\" : \"receivingaddress\",  (string) The receiving "
             "address\n"
             "    \"amount\" : x.xxx,                  (numeric) The total "
             "amount in " +
             CURRENCY_UNIT +
             " received by the address\n"
             "    \"confirmations\" : n,               (numeric) The number of "
             "confirmations of the most recent transaction included\n"
             "    \"label\" : \"label\",               (string) The label of "
             "the receiving address. The default label is \"\".\n"
             "    \"txids\": [\n"
             "       \"txid\",                         (string) The ids of "
             "transactions received with the address \n"
             "       ...\n"
             "    ]\n"
             "  }\n"
             "  ,...\n"
             "]\n"
 
             "\nExamples:\n" +
             HelpExampleCli("listreceivedbyaddress", "") +
             HelpExampleCli("listreceivedbyaddress", "6 true") +
             HelpExampleRpc("listreceivedbyaddress", "6, true, true") +
             HelpExampleRpc(
                 "listreceivedbyaddress",
                 "6, true, true, \"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\""));
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     return ListReceived(config, *locked_chain, pwallet, request.params, false);
 }
 
 static UniValue listreceivedbylabel(const Config &config,
                                     const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 3) {
         throw std::runtime_error(
             RPCHelpMan{"listreceivedbylabel",
                        "\nList received transactions by label.\n",
                        {
                            {"minconf", RPCArg::Type::NUM, /* opt */ true,
                             /* default_val */ "1",
                             "The minimum number of confirmations before "
                             "payments are included."},
                            {"include_empty", RPCArg::Type::BOOL, /* opt */ true,
                             /* default_val */ "false",
                             "Whether to include labels that haven't received "
                             "any payments."},
                            {"include_watchonly", RPCArg::Type::BOOL,
                             /* opt */ true, /* default_val */ "false",
                             "Whether to include watch-only addresses (see "
                             "'importaddress')."},
                        }}
                 .ToString() +
             "\nResult:\n"
             "[\n"
             "  {\n"
             "    \"involvesWatchonly\" : true,   (bool) Only returned if "
             "imported addresses were involved in transaction\n"
             "    \"amount\" : x.xxx,             (numeric) The total amount "
             "received by addresses with this label\n"
             "    \"confirmations\" : n,          (numeric) The number of "
             "confirmations of the most recent transaction included\n"
             "    \"label\" : \"label\"           (string) The label of the "
             "receiving address. The default label is \"\".\n"
             "  }\n"
             "  ,...\n"
             "]\n"
 
             "\nExamples:\n" +
             HelpExampleCli("listreceivedbylabel", "") +
             HelpExampleCli("listreceivedbylabel", "6 true") +
             HelpExampleRpc("listreceivedbylabel", "6, true, true"));
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     return ListReceived(config, *locked_chain, pwallet, request.params, true);
 }
 
 static void MaybePushAddress(UniValue &entry, const CTxDestination &dest) {
     if (IsValidDestination(dest)) {
         entry.pushKV("address", EncodeDestination(dest, GetConfig()));
     }
 }
 
 /**
  * List transactions based on the given criteria.
  *
  * @param  pwallet        The wallet.
  * @param  wtx            The wallet transaction.
  * @param  nMinDepth      The minimum confirmation depth.
  * @param  fLong          Whether to include the JSON version of the
  * transaction.
  * @param  ret            The UniValue into which the result is stored.
  * @param  filter_ismine  The "is mine" filter flags.
  * @param  filter_label   Optional label string to filter incoming transactions.
  */
 static void ListTransactions(interfaces::Chain::Lock &locked_chain,
                              CWallet *const pwallet, const CWalletTx &wtx,
                              int nMinDepth, bool fLong, UniValue &ret,
                              const isminefilter &filter_ismine,
                              const std::string *filter_label) {
     Amount nFee;
     std::list<COutputEntry> listReceived;
     std::list<COutputEntry> listSent;
 
     wtx.GetAmounts(listReceived, listSent, nFee, filter_ismine);
 
     bool involvesWatchonly = wtx.IsFromMe(ISMINE_WATCH_ONLY);
 
     // Sent
     if (!filter_label) {
         for (const COutputEntry &s : listSent) {
             UniValue entry(UniValue::VOBJ);
             if (involvesWatchonly ||
                 (::IsMine(*pwallet, s.destination) & ISMINE_WATCH_ONLY)) {
                 entry.pushKV("involvesWatchonly", true);
             }
             MaybePushAddress(entry, s.destination);
             entry.pushKV("category", "send");
             entry.pushKV("amount", ValueFromAmount(-s.amount));
             if (pwallet->mapAddressBook.count(s.destination)) {
                 entry.pushKV("label",
                              pwallet->mapAddressBook[s.destination].name);
             }
             entry.pushKV("vout", s.vout);
             entry.pushKV("fee", ValueFromAmount(-1 * nFee));
             if (fLong) {
                 WalletTxToJSON(pwallet->chain(), locked_chain, wtx, entry);
             }
             entry.pushKV("abandoned", wtx.isAbandoned());
             ret.push_back(entry);
         }
     }
 
     // Received
     if (listReceived.size() > 0 &&
         wtx.GetDepthInMainChain(locked_chain) >= nMinDepth) {
         for (const COutputEntry &r : listReceived) {
             std::string label;
             if (pwallet->mapAddressBook.count(r.destination)) {
                 label = pwallet->mapAddressBook[r.destination].name;
             }
             if (filter_label && label != *filter_label) {
                 continue;
             }
             UniValue entry(UniValue::VOBJ);
             if (involvesWatchonly ||
                 (::IsMine(*pwallet, r.destination) & ISMINE_WATCH_ONLY)) {
                 entry.pushKV("involvesWatchonly", true);
             }
             MaybePushAddress(entry, r.destination);
             if (wtx.IsCoinBase()) {
                 if (wtx.GetDepthInMainChain(locked_chain) < 1) {
                     entry.pushKV("category", "orphan");
                 } else if (wtx.IsImmatureCoinBase(locked_chain)) {
                     entry.pushKV("category", "immature");
                 } else {
                     entry.pushKV("category", "generate");
                 }
             } else {
                 entry.pushKV("category", "receive");
             }
             entry.pushKV("amount", ValueFromAmount(r.amount));
             if (pwallet->mapAddressBook.count(r.destination)) {
                 entry.pushKV("label", label);
             }
             entry.pushKV("vout", r.vout);
             if (fLong) {
                 WalletTxToJSON(pwallet->chain(), locked_chain, wtx, entry);
             }
             ret.push_back(entry);
         }
     }
 }
 
 UniValue listtransactions(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 4) {
         throw std::runtime_error(
             RPCHelpMan{
                 "listtransactions",
                 "\nIf a label name is provided, this will return only incoming "
                 "transactions paying to addresses with the specified label.\n"
                 "\nReturns up to 'count' most recent transactions skipping the "
                 "first 'from' transactions.\n",
                 {
                     {"label", RPCArg::Type::STR, /* opt */ true,
                      /* default_val */ "",
                      "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, /* opt */ true,
                      /* default_val */ "10",
                      "The number of transactions to return"},
                     {"skip", RPCArg::Type::NUM, /* opt */ true,
                      /* default_val */ "0",
                      "The number of transactions to skip"},
                     {"include_watchonly", RPCArg::Type::BOOL, /* opt */ true,
                      /* default_val */ "false",
                      "Include transactions to watch-only addresses (see "
                      "'importaddress')"},
                 }}
                 .ToString() +
             "\nResult:\n"
             "[\n"
             "  {\n"
             "    \"address\":\"address\",    (string) The bitcoin address of "
             "the transaction.\n"
             "    \"category\":\"send|receive\", (string) The transaction "
             "category.\n"
             "    \"amount\": x.xxx,          (numeric) The amount in " +
             CURRENCY_UNIT +
             ". This is negative for the 'send' category, and is positive\n"
             "                                        for the 'receive' "
             "category,\n"
             "    \"label\": \"label\",       (string) A comment for the "
             "address/transaction, if any\n"
             "    \"vout\": n,                (numeric) the vout value\n"
             "    \"fee\": x.xxx,             (numeric) The amount of the fee "
             "in " +
             CURRENCY_UNIT +
             ". This is negative and only available for the \n"
             "                                         'send' category of "
             "transactions.\n"
             "    \"confirmations\": n,       (numeric) The number of "
             "confirmations for the transaction. Negative confirmations "
             "indicate the\n"
             "                                         transaction conflicts "
             "with the block chain\n"
             "    \"trusted\": xxx,           (bool) Whether we consider the "
             "outputs of this unconfirmed transaction safe to spend.\n"
             "    \"blockhash\": \"hashvalue\", (string) The block hash "
             "containing the transaction.\n"
             "    \"blockindex\": n,          (numeric) The index of the "
             "transaction in the block that includes it.\n"
             "    \"blocktime\": xxx,         (numeric) The block time in "
             "seconds since epoch (1 Jan 1970 GMT).\n"
             "    \"txid\": \"transactionid\", (string) The transaction id.\n"
             "    \"time\": xxx,              (numeric) The transaction time in "
             "seconds since epoch (midnight Jan 1 1970 GMT).\n"
             "    \"timereceived\": xxx,      (numeric) The time received in "
             "seconds since epoch (midnight Jan 1 1970 GMT).\n"
             "    \"comment\": \"...\",       (string) If a comment is "
             "associated with the transaction.\n"
             "    \"abandoned\": xxx          (bool) 'true' if the transaction "
             "has been abandoned (inputs are respendable). Only available for "
             "the \n"
             "                                         'send' category of "
             "transactions.\n"
             "  }\n"
             "]\n"
 
             "\nExamples:\n"
             "\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"));
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     const std::string *filter_label = nullptr;
     if (!request.params[0].isNull() && request.params[0].get_str() != "*") {
         filter_label = &request.params[0].get_str();
         if (filter_label->empty()) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Label argument must be a valid label name or \"*\".");
         }
     }
     int nCount = 10;
     if (!request.params[1].isNull()) {
         nCount = request.params[1].get_int();
     }
 
     int nFrom = 0;
     if (!request.params[2].isNull()) {
         nFrom = request.params[2].get_int();
     }
 
     isminefilter filter = ISMINE_SPENDABLE;
     if (!request.params[3].isNull() && request.params[3].get_bool()) {
         filter = filter | ISMINE_WATCH_ONLY;
     }
 
     if (nCount < 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative count");
     }
     if (nFrom < 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative from");
     }
     UniValue ret(UniValue::VARR);
 
     const CWallet::TxItems &txOrdered = pwallet->wtxOrdered;
 
     // iterate backwards until we have nCount items to return:
     for (CWallet::TxItems::const_reverse_iterator it = txOrdered.rbegin();
          it != txOrdered.rend(); ++it) {
         CWalletTx *const pwtx = (*it).second;
         ListTransactions(*locked_chain, pwallet, *pwtx, 0, true, ret, filter,
                          filter_label);
         if ((int)ret.size() >= (nCount + nFrom)) {
             break;
         }
     }
 
     // ret is newest to oldest
 
     if (nFrom > (int)ret.size()) {
         nFrom = ret.size();
     }
     if ((nFrom + nCount) > (int)ret.size()) {
         nCount = ret.size() - nFrom;
     }
 
     std::vector<UniValue> arrTmp = ret.getValues();
 
     std::vector<UniValue>::iterator first = arrTmp.begin();
     std::advance(first, nFrom);
     std::vector<UniValue>::iterator last = arrTmp.begin();
     std::advance(last, nFrom + nCount);
 
     if (last != arrTmp.end()) {
         arrTmp.erase(last, arrTmp.end());
     }
     if (first != arrTmp.begin()) {
         arrTmp.erase(arrTmp.begin(), first);
     }
 
     // Return oldest to newest
     std::reverse(arrTmp.begin(), arrTmp.end());
 
     ret.clear();
     ret.setArray();
     ret.push_backV(arrTmp);
 
     return ret;
 }
 
 static UniValue listsinceblock(const Config &config,
                                const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 4) {
         throw std::runtime_error(
             RPCHelpMan{
                 "listsinceblock",
                 "\nGet all transactions in blocks since block [blockhash], or "
                 "all transactions if omitted.\n"
                 "If \"blockhash\" is no longer a part of the main chain, "
                 "transactions from the fork point onward are included.\n"
                 "Additionally, if include_removed is set, transactions "
                 "affecting the wallet which were removed are returned in the "
                 "\"removed\" array.\n",
                 {
                     {"blockhash", RPCArg::Type::STR, /* opt */ true,
                      /* default_val */ "",
                      "The block hash to list transactions since"},
                     {"target_confirmations", RPCArg::Type::NUM, /* opt */ true,
                      /* default_val */ "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, /* opt */ true,
                      /* default_val */ "false",
                      "Include transactions to watch-only addresses (see "
                      "'importaddress')"},
                     {"include_removed", RPCArg::Type::BOOL, /* opt */ true,
                      /* default_val */ "true",
                      "Show transactions that were removed due to a reorg in "
                      "the \"removed\" array\n"
                      "                                                         "
                      "  (not guaranteed to work on pruned nodes)"},
                 }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"transactions\": [\n"
             "    \"address\":\"address\",    (string) The bitcoin address of "
             "the transaction. Not present for move transactions (category = "
             "move).\n"
             "    \"category\":\"send|receive\",     (string) The transaction "
             "category. 'send' has negative amounts, 'receive' has positive "
             "amounts.\n"
             "    \"amount\": x.xxx,          (numeric) The amount in " +
             CURRENCY_UNIT +
             ". This is negative for the 'send' category, and for the 'move' "
             "category for moves \n"
             "                                          outbound. It is "
             "positive for the 'receive' category, and for the 'move' category "
             "for inbound funds.\n"
             "    \"vout\" : n,               (numeric) the vout value\n"
             "    \"fee\": x.xxx,             (numeric) The amount of the fee "
             "in " +
             CURRENCY_UNIT +
             ". This is negative and only available for the 'send' category of "
             "transactions.\n"
             "    \"confirmations\": n,       (numeric) The number of "
             "confirmations for the transaction. Available for 'send' and "
             "'receive' category of transactions.\n"
             "                                          When it's < 0, it means "
             "the transaction conflicted that many blocks ago.\n"
             "    \"blockhash\": \"hashvalue\",     (string) The block hash "
             "containing the transaction. Available for 'send' and 'receive' "
             "category of transactions.\n"
             "    \"blockindex\": n,          (numeric) The index of the "
             "transaction in the block that includes it. Available for 'send' "
             "and 'receive' category of transactions.\n"
             "    \"blocktime\": xxx,         (numeric) The block time in "
             "seconds since epoch (1 Jan 1970 GMT).\n"
             "    \"txid\": \"transactionid\",  (string) The transaction id. "
             "Available for 'send' and 'receive' category of transactions.\n"
             "    \"time\": xxx,              (numeric) The transaction time in "
             "seconds since epoch (Jan 1 1970 GMT).\n"
             "    \"timereceived\": xxx,      (numeric) The time received in "
             "seconds since epoch (Jan 1 1970 GMT). Available for 'send' and "
             "'receive' category of transactions.\n"
             "    \"abandoned\": xxx,         (bool) 'true' if the transaction "
             "has been abandoned (inputs are respendable). Only available for "
             "the 'send' category of transactions.\n"
             "    \"comment\": \"...\",       (string) If a comment is "
             "associated with the transaction.\n"
             "    \"label\" : \"label\"       (string) A comment for the "
             "address/transaction, if any\n"
             "    \"to\": \"...\",            (string) If a comment to is "
             "associated with the transaction.\n"
             "  ],\n"
             "  \"removed\": [\n"
             "    <structure is the same as \"transactions\" above, only "
             "present if include_removed=true>\n"
             "    Note: transactions that were re-added in the active chain "
             "will appear as-is in this array, and may thus have a positive "
             "confirmation count.\n"
             "  ],\n"
             "  \"lastblock\": \"lastblockhash\"     (string) The hash of the "
             "block (target_confirmations-1) from the best block on the main "
             "chain. This is typically used to feed back into listsinceblock "
             "the next time you call it. So you would generally use a "
             "target_confirmations of say 6, so you will be continually "
             "re-notified of transactions until they've reached 6 confirmations "
             "plus any new ones\n"
             "}\n"
             "\nExamples:\n" +
             HelpExampleCli("listsinceblock", "") +
             HelpExampleCli("listsinceblock", "\"000000000000000bacf66f7497b7dc4"
                                              "5ef753ee9a7d38571037cdb1a57f663ad"
                                              "\" 6") +
             HelpExampleRpc("listsinceblock", "\"000000000000000bacf66f7497b7dc4"
                                              "5ef753ee9a7d38571037cdb1a57f663ad"
                                              "\", 6"));
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     // The way the 'height' is initialized is just a workaround for the gcc bug
     // #47679 since version 4.6.0. Height of the specified block or the common
     // ancestor, if the block provided was in a deactivated chain.
     Optional<int> height = MakeOptional(false, int());
 
     // Height of the specified block, even if it's in a deactivated chain.
     Optional<int> altheight;
     int target_confirms = 1;
     isminefilter filter = ISMINE_SPENDABLE;
 
     BlockHash blockId;
     if (!request.params[0].isNull() && !request.params[0].get_str().empty()) {
         blockId = BlockHash(ParseHashV(request.params[0], "blockhash"));
         height = locked_chain->findFork(blockId, &altheight);
         if (!height) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
     }
 
     if (!request.params[1].isNull()) {
         target_confirms = request.params[1].get_int();
 
         if (target_confirms < 1) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter");
         }
     }
 
     if (!request.params[2].isNull() && request.params[2].get_bool()) {
         filter = filter | ISMINE_WATCH_ONLY;
     }
 
     bool include_removed =
         (request.params[3].isNull() || request.params[3].get_bool());
 
     const Optional<int> tip_height = locked_chain->getHeight();
     int depth = tip_height && height ? (1 + *tip_height - *height) : -1;
 
     UniValue transactions(UniValue::VARR);
 
     for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
         CWalletTx tx = pairWtx.second;
 
         if (depth == -1 || tx.GetDepthInMainChain(*locked_chain) < depth) {
             ListTransactions(*locked_chain, pwallet, tx, 0, true, transactions,
                              filter, nullptr /* filter_label */);
         }
     }
 
     // when a reorg'd block is requested, we also list any relevant transactions
     // in the blocks of the chain that was detached
     UniValue removed(UniValue::VARR);
     while (include_removed && altheight && *altheight > *height) {
         CBlock block;
         if (!pwallet->chain().findBlock(blockId, &block) || block.IsNull()) {
             throw JSONRPCError(RPC_INTERNAL_ERROR,
                                "Can't read block from disk");
         }
         for (const CTransactionRef &tx : block.vtx) {
             auto it = pwallet->mapWallet.find(tx->GetId());
             if (it != pwallet->mapWallet.end()) {
                 // We want all transactions regardless of confirmation count to
                 // appear here, even negative confirmation ones, hence the big
                 // negative.
                 ListTransactions(*locked_chain, pwallet, it->second, -100000000,
                                  true, removed, filter,
                                  nullptr /* filter_label */);
             }
         }
         blockId = block.hashPrevBlock;
         --*altheight;
     }
 
     int last_height = tip_height ? *tip_height + 1 - target_confirms : -1;
     BlockHash lastblock = last_height >= 0
                               ? locked_chain->getBlockHash(last_height)
                               : BlockHash();
 
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("transactions", transactions);
     if (include_removed) {
         ret.pushKV("removed", removed);
     }
     ret.pushKV("lastblock", lastblock.GetHex());
 
     return ret;
 }
 
 static UniValue gettransaction(const Config &config,
                                const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{"gettransaction",
                        "\nGet detailed information about in-wallet transaction "
                        "<txid>\n",
                        {
                            {"txid", RPCArg::Type::STR, /* opt */ false,
                             /* default_val */ "", "The transaction id"},
                            {"include_watchonly", RPCArg::Type::BOOL,
                             /* opt */ true, /* default_val */ "false",
                             "Whether to include watch-only addresses in "
                             "balance calculation and details[]"},
                        }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"amount\" : x.xxx,        (numeric) The transaction amount "
             "in " +
             CURRENCY_UNIT +
             "\n"
             "  \"fee\": x.xxx,            (numeric) The amount of the fee in " +
             CURRENCY_UNIT +
             ". This is negative and only available for the \n"
             "                              'send' category of transactions.\n"
             "  \"confirmations\" : n,     (numeric) The number of "
             "confirmations\n"
             "  \"blockhash\" : \"hash\",  (string) The block hash\n"
             "  \"blockindex\" : xx,       (numeric) The index of the "
             "transaction in the block that includes it\n"
             "  \"blocktime\" : ttt,       (numeric) The time in seconds since "
             "epoch (1 Jan 1970 GMT)\n"
             "  \"txid\" : \"transactionid\",   (string) The transaction id.\n"
             "  \"time\" : ttt,            (numeric) The transaction time in "
             "seconds since epoch (1 Jan 1970 GMT)\n"
             "  \"timereceived\" : ttt,    (numeric) The time received in "
             "seconds since epoch (1 Jan 1970 GMT)\n"
             "  \"bip125-replaceable\": \"yes|no|unknown\",  (string) Whether "
             "this transaction could be replaced due to BIP125 "
             "(replace-by-fee);\n"
             "                                                   may be unknown "
             "for unconfirmed transactions not in the mempool\n"
             "  \"details\" : [\n"
             "    {\n"
             "      \"address\" : \"address\",          (string) The bitcoin "
             "address involved in the transaction\n"
             "      \"category\" : \"send|receive\",    (string) The category, "
             "either 'send' or 'receive'\n"
             "      \"amount\" : x.xxx,                 (numeric) The amount "
             "in " +
             CURRENCY_UNIT +
             "\n"
             "      \"label\" : \"label\",              "
             "(string) A comment for the address/transaction, "
             "if any\n"
             "      \"vout\" : n,                       "
             "(numeric) the vout value\n"
             "      \"fee\": x.xxx,                     "
             "(numeric) The amount of the fee in " +
             CURRENCY_UNIT +
             ". This is negative and only available for the \n"
             "                                           'send' category of "
             "transactions.\n"
             "      \"abandoned\": xxx                  (bool) 'true' if the "
             "transaction has been abandoned (inputs are respendable). Only "
             "available for the \n"
             "                                           'send' category of "
             "transactions.\n"
             "    }\n"
             "    ,...\n"
             "  ],\n"
             "  \"hex\" : \"data\"         (string) Raw data for transaction\n"
             "}\n"
 
             "\nExamples:\n" +
             HelpExampleCli("gettransaction", "\"1075db55d416d3ca199f55b6084e211"
                                              "5b9345e16c5cf302fc80e9d5fbf5d48d"
                                              "\"") +
             HelpExampleCli("gettransaction", "\"1075db55d416d3ca199f55b6084e211"
                                              "5b9345e16c5cf302fc80e9d5fbf5d48d"
                                              "\" true") +
             HelpExampleRpc("gettransaction", "\"1075db55d416d3ca199f55b6084e211"
                                              "5b9345e16c5cf302fc80e9d5fbf5d48d"
                                              "\""));
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     TxId txid(ParseHashV(request.params[0], "txid"));
 
     isminefilter filter = ISMINE_SPENDABLE;
     if (!request.params[1].isNull() && request.params[1].get_bool()) {
         filter = filter | ISMINE_WATCH_ONLY;
     }
 
     UniValue entry(UniValue::VOBJ);
     auto it = pwallet->mapWallet.find(txid);
     if (it == pwallet->mapWallet.end()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid or non-wallet transaction id");
     }
     const CWalletTx &wtx = it->second;
 
     Amount nCredit = wtx.GetCredit(*locked_chain, filter);
     Amount nDebit = wtx.GetDebit(filter);
     Amount nNet = nCredit - nDebit;
     Amount nFee = (wtx.IsFromMe(filter) ? wtx.tx->GetValueOut() - nDebit
                                         : Amount::zero());
 
     entry.pushKV("amount", ValueFromAmount(nNet - nFee));
     if (wtx.IsFromMe(filter)) {
         entry.pushKV("fee", ValueFromAmount(nFee));
     }
 
     WalletTxToJSON(pwallet->chain(), *locked_chain, wtx, entry);
 
     UniValue details(UniValue::VARR);
     ListTransactions(*locked_chain, pwallet, wtx, 0, false, details, filter,
                      nullptr /* filter_label */);
     entry.pushKV("details", details);
 
     std::string strHex = EncodeHexTx(*wtx.tx, RPCSerializationFlags());
     entry.pushKV("hex", strHex);
 
     return entry;
 }
 
 static UniValue abandontransaction(const Config &config,
                                    const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"abandontransaction",
                        "\nMark in-wallet transaction <txid> as abandoned\n"
                        "This will mark this transaction and all its in-wallet "
                        "descendants as abandoned which will allow\n"
                        "for their inputs to be respent.  It can be used to "
                        "replace \"stuck\" or evicted transactions.\n"
                        "It only works on transactions which are not included "
                        "in a block and are not currently in the mempool.\n"
                        "It has no effect on transactions which are already "
                        "abandoned.\n",
                        {
                            {"txid", RPCArg::Type::STR_HEX, /* opt */ false,
                             /* default_val */ "", "The transaction id"},
                        }}
                 .ToString() +
             "\nResult:\n"
             "\nExamples:\n" +
             HelpExampleCli("abandontransaction", "\"1075db55d416d3ca199f55b6084"
                                                  "e2115b9345e16c5cf302fc80e9d5f"
                                                  "bf5d48d\"") +
             HelpExampleRpc("abandontransaction", "\"1075db55d416d3ca199f55b6084"
                                                  "e2115b9345e16c5cf302fc80e9d5f"
                                                  "bf5d48d\""));
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     TxId txid(ParseHashV(request.params[0], "txid"));
 
     if (!pwallet->mapWallet.count(txid)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid or non-wallet transaction id");
     }
 
     if (!pwallet->AbandonTransaction(*locked_chain, txid)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Transaction not eligible for abandonment");
     }
 
     return NullUniValue;
 }
 
 static UniValue backupwallet(const Config &config,
                              const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{
                 "backupwallet",
                 "\nSafely copies current wallet file to destination, "
                 "which can be a directory or a path with filename.\n",
                 {
                     {"destination", RPCArg::Type::STR, /* opt */ false,
                      /* default_val */ "", "The destination directory or file"},
                 }}
                 .ToString() +
             "\nExamples:\n" + HelpExampleCli("backupwallet", "\"backup.dat\"") +
             HelpExampleRpc("backupwallet", "\"backup.dat\""));
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     std::string strDest = request.params[0].get_str();
     if (!pwallet->BackupWallet(strDest)) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Error: Wallet backup failed!");
     }
 
     return NullUniValue;
 }
 
 static UniValue keypoolrefill(const Config &config,
                               const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 1) {
         throw std::runtime_error(
             RPCHelpMan{"keypoolrefill",
                        "\nFills the keypool." +
                            HelpRequiringPassphrase(pwallet) + "\n",
                        {
                            {"newsize", RPCArg::Type::NUM, /* opt */ true,
                             /* default_val */ "100", "The new keypool size"},
                        }}
                 .ToString() +
             "\nExamples:\n" + HelpExampleCli("keypoolrefill", "") +
             HelpExampleRpc("keypoolrefill", ""));
     }
 
     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Error: Private keys are disabled for this wallet");
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     // 0 is interpreted by TopUpKeyPool() as the default keypool size given by
     // -keypool
     unsigned int kpSize = 0;
     if (!request.params[0].isNull()) {
         if (request.params[0].get_int() < 0) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, expected valid size.");
         }
         kpSize = (unsigned int)request.params[0].get_int();
     }
 
     EnsureWalletIsUnlocked(pwallet);
     pwallet->TopUpKeyPool(kpSize);
 
     if (pwallet->GetKeyPoolSize() < kpSize) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Error refreshing keypool.");
     }
 
     return NullUniValue;
 }
 
 static void LockWallet(CWallet *pWallet) {
     LOCK(pWallet->cs_wallet);
     pWallet->nRelockTime = 0;
     pWallet->Lock();
 }
 
 static UniValue walletpassphrase(const Config &config,
                                  const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (pwallet->IsCrypted() && (request.fHelp || request.params.size() != 2)) {
         throw std::runtime_error(
             RPCHelpMan{
                 "walletpassphrase",
                 "\nStores the wallet decryption key in memory for "
                 "'timeout' seconds.\n"
                 "This is needed prior to performing transactions "
                 "related to private keys such as sending bitcoins\n",
                 {
                     {"passphrase", RPCArg::Type::STR, /* opt */ false,
                      /* default_val */ "", "The wallet passphrase"},
                     {"timeout", RPCArg::Type::NUM, /* opt */ false,
                      /* default_val */ "",
                      "The time to keep the decryption key in seconds; capped "
                      "at 100000000 (~3 years)."},
                 }}
                 .ToString() +
             "\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"
             "\nExamples:\n"
             "\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"));
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     if (request.fHelp) {
         return true;
     }
 
     if (!pwallet->IsCrypted()) {
         throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE,
                            "Error: running with an unencrypted wallet, but "
                            "walletpassphrase was called.");
     }
 
     // Note that the walletpassphrase is stored in request.params[0] which is
     // not mlock()ed
     SecureString strWalletPass;
     strWalletPass.reserve(100);
     // TODO: get rid of this .c_str() by implementing
     // SecureString::operator=(std::string)
     // Alternately, find a way to make request.params[0] mlock()'d to begin
     // with.
     strWalletPass = request.params[0].get_str().c_str();
 
     // Get the timeout
     int64_t nSleepTime = request.params[1].get_int64();
     // Timeout cannot be negative, otherwise it will relock immediately
     if (nSleepTime < 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Timeout cannot be negative.");
     }
     // Clamp timeout
     // larger values trigger a macos/libevent bug?
     constexpr int64_t MAX_SLEEP_TIME = 100000000;
     if (nSleepTime > MAX_SLEEP_TIME) {
         nSleepTime = MAX_SLEEP_TIME;
     }
 
     if (strWalletPass.empty()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "passphrase can not be empty");
     }
 
     if (!pwallet->Unlock(strWalletPass)) {
         throw JSONRPCError(
             RPC_WALLET_PASSPHRASE_INCORRECT,
             "Error: The wallet passphrase entered was incorrect.");
     }
 
     pwallet->TopUpKeyPool();
 
     pwallet->nRelockTime = GetTime() + nSleepTime;
     RPCRunLater(strprintf("lockwallet(%s)", pwallet->GetName()),
                 std::bind(LockWallet, pwallet), nSleepTime);
 
     return NullUniValue;
 }
 
 static UniValue walletpassphrasechange(const Config &config,
                                        const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (pwallet->IsCrypted() && (request.fHelp || request.params.size() != 2)) {
         throw std::runtime_error(
             RPCHelpMan{"walletpassphrasechange",
                        "\nChanges the wallet passphrase from 'oldpassphrase' "
                        "to 'newpassphrase'.\n",
                        {
                            {"oldpassphrase", RPCArg::Type::STR, /* opt */ false,
                             /* default_val */ "", "The current passphrase"},
                            {"newpassphrase", RPCArg::Type::STR, /* opt */ false,
                             /* default_val */ "", "The new passphrase"},
                        }}
                 .ToString() +
             "\nExamples:\n" +
             HelpExampleCli("walletpassphrasechange",
                            "\"old one\" \"new one\"") +
             HelpExampleRpc("walletpassphrasechange",
                            "\"old one\", \"new one\""));
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     if (request.fHelp) {
         return true;
     }
     if (!pwallet->IsCrypted()) {
         throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE,
                            "Error: running with an unencrypted wallet, but "
                            "walletpassphrasechange was called.");
     }
 
     // TODO: get rid of these .c_str() calls by implementing
     // SecureString::operator=(std::string)
     // Alternately, find a way to make request.params[0] mlock()'d to begin
     // with.
     SecureString strOldWalletPass;
     strOldWalletPass.reserve(100);
     strOldWalletPass = request.params[0].get_str().c_str();
 
     SecureString strNewWalletPass;
     strNewWalletPass.reserve(100);
     strNewWalletPass = request.params[1].get_str().c_str();
 
     if (strOldWalletPass.empty() || strNewWalletPass.empty()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "passphrase can not be empty");
     }
 
     if (!pwallet->ChangeWalletPassphrase(strOldWalletPass, strNewWalletPass)) {
         throw JSONRPCError(
             RPC_WALLET_PASSPHRASE_INCORRECT,
             "Error: The wallet passphrase entered was incorrect.");
     }
 
     return NullUniValue;
 }
 
 static UniValue walletlock(const Config &config,
                            const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (pwallet->IsCrypted() && (request.fHelp || request.params.size() != 0)) {
         throw std::runtime_error(
             RPCHelpMan{"walletlock",
                        "\nRemoves the wallet encryption key from memory, "
                        "locking the wallet.\n"
                        "After calling this method, you will need to call "
                        "walletpassphrase again\n"
                        "before being able to call any methods which require "
                        "the wallet to be unlocked.\n",
                        {}}
                 .ToString() +
             "\nExamples:\n"
             "\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", ""));
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     if (request.fHelp) {
         return true;
     }
     if (!pwallet->IsCrypted()) {
         throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE,
                            "Error: running with an unencrypted wallet, but "
                            "walletlock was called.");
     }
 
     pwallet->Lock();
     pwallet->nRelockTime = 0;
 
     return NullUniValue;
 }
 
 static UniValue encryptwallet(const Config &config,
                               const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (!pwallet->IsCrypted() &&
         (request.fHelp || request.params.size() != 1)) {
         throw std::runtime_error(
             RPCHelpMan{
                 "encryptwallet",
                 "\nEncrypts the wallet with 'passphrase'. This is for "
                 "first time encryption.\n"
                 "After this, any calls that interact with private keys "
                 "such as sending or signing \n"
                 "will require the passphrase to be set prior the making "
                 "these calls.\n"
                 "Use the walletpassphrase call for this, and then "
                 "walletlock call.\n"
                 "If the wallet is already encrypted, use the "
                 "walletpassphrasechange call.\n",
                 {
                     {"passphrase", RPCArg::Type::STR, /* opt */ false,
                      /* default_val */ "",
                      "The pass phrase to encrypt the wallet with. It must be "
                      "at least 1 character, but should be long."},
                 }}
                 .ToString() +
             "\nExamples:\n"
             "\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\""));
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     if (request.fHelp) {
         return true;
     }
     if (pwallet->IsCrypted()) {
         throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE,
                            "Error: running with an encrypted wallet, but "
                            "encryptwallet was called.");
     }
 
     // TODO: get rid of this .c_str() by implementing
     // SecureString::operator=(std::string)
     // Alternately, find a way to make request.params[0] mlock()'d to begin
     // with.
     SecureString strWalletPass;
     strWalletPass.reserve(100);
     strWalletPass = request.params[0].get_str().c_str();
 
     if (strWalletPass.empty()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "passphrase can not be empty");
     }
 
     if (!pwallet->EncryptWallet(strWalletPass)) {
         throw JSONRPCError(RPC_WALLET_ENCRYPTION_FAILED,
                            "Error: Failed to encrypt the wallet.");
     }
 
     return "wallet encrypted; The keypool has been flushed and a new HD seed "
            "was generated (if you are using HD). You need to make a new "
            "backup.";
 }
 
 static UniValue lockunspent(const Config &config,
                             const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{
                 "lockunspent",
                 "\nUpdates list of temporarily unspendable outputs.\n"
                 "Temporarily lock (unlock=false) or unlock (unlock=true) "
                 "specified transaction outputs.\n"
                 "If no transaction outputs are specified when unlocking then "
                 "all current locked transaction outputs are unlocked.\n"
                 "A locked transaction output will not be chosen by automatic "
                 "coin selection, when spending bitcoins.\n"
                 "Locks are stored in memory only. Nodes start with zero locked "
                 "outputs, and the locked output list\n"
                 "is always cleared (by virtue of process exit) when a node "
                 "stops or fails.\n"
                 "Also see the listunspent call\n",
                 {
                     {"unlock", RPCArg::Type::BOOL, /* opt */ false,
                      /* default_val */ "",
                      "Whether to unlock (true) or lock (false) the specified "
                      "transactions"},
                     {
                         "transactions",
                         RPCArg::Type::ARR,
                         /* opt */ true,
                         /* default_val */ "",
                         "A json array of objects. Each object the txid "
                         "(string) vout (numeric)",
                         {
                             {
                                 "",
                                 RPCArg::Type::OBJ,
                                 /* opt */ true,
                                 /* default_val */ "",
                                 "",
                                 {
                                     {"txid", RPCArg::Type::STR_HEX,
                                      /* opt */ false, /* default_val */ "",
                                      "The transaction id"},
                                     {"vout", RPCArg::Type::NUM, /* opt */ false,
                                      /* default_val */ "", "The output number"},
                                 },
                             },
                         },
                     },
                 }}
                 .ToString() +
             "\nResult:\n"
             "true|false    (boolean) Whether the command was successful or "
             "not\n"
 
             "\nExamples:\n"
             "\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}]\""));
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     RPCTypeCheckArgument(request.params[0], UniValue::VBOOL);
 
     bool fUnlock = request.params[0].get_bool();
 
     if (request.params[1].isNull()) {
         if (fUnlock) {
             pwallet->UnlockAllCoins();
         }
         return true;
     }
 
     RPCTypeCheckArgument(request.params[1], UniValue::VARR);
 
     const UniValue &output_params = request.params[1];
 
     // Create and validate the COutPoints first.
 
     std::vector<COutPoint> outputs;
     outputs.reserve(output_params.size());
 
     for (size_t idx = 0; idx < output_params.size(); idx++) {
         const UniValue &o = output_params[idx].get_obj();
 
         RPCTypeCheckObj(o, {
                                {"txid", UniValueType(UniValue::VSTR)},
                                {"vout", UniValueType(UniValue::VNUM)},
                            });
 
         const int nOutput = find_value(o, "vout").get_int();
         if (nOutput < 0) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, vout must be positive");
         }
 
         const TxId txid(ParseHashO(o, "txid"));
         const auto it = pwallet->mapWallet.find(txid);
         if (it == pwallet->mapWallet.end()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, unknown transaction");
         }
 
         const COutPoint output(txid, nOutput);
         const CWalletTx &trans = it->second;
         if (output.GetN() >= trans.tx->vout.size()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, vout index out of bounds");
         }
 
         if (pwallet->IsSpent(*locked_chain, output)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, expected unspent output");
         }
 
         const bool is_locked = pwallet->IsLockedCoin(output);
         if (fUnlock && !is_locked) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, expected locked output");
         }
 
         if (!fUnlock && is_locked) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Invalid parameter, output already locked");
         }
 
         outputs.push_back(output);
     }
 
     // Atomically set (un)locked status for the outputs.
     for (const COutPoint &output : outputs) {
         if (fUnlock) {
             pwallet->UnlockCoin(output);
         } else {
             pwallet->LockCoin(output);
         }
     }
 
     return true;
 }
 
 static UniValue listlockunspent(const Config &config,
                                 const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 0) {
         throw std::runtime_error(
             RPCHelpMan{"listlockunspent",
                        "\nReturns list of temporarily unspendable outputs.\n"
                        "See the lockunspent call to lock and unlock "
                        "transactions for spending.\n",
                        {}}
                 .ToString() +
             "\nResult:\n"
             "[\n"
             "  {\n"
             "    \"txid\" : \"transactionid\",     (string) The transaction id "
             "locked\n"
             "    \"vout\" : n                      (numeric) The vout value\n"
             "  }\n"
             "  ,...\n"
             "]\n"
             "\nExamples:\n"
             "\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", ""));
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     std::vector<COutPoint> vOutpts;
     pwallet->ListLockedCoins(vOutpts);
 
     UniValue ret(UniValue::VARR);
 
     for (const COutPoint &output : vOutpts) {
         UniValue o(UniValue::VOBJ);
 
         o.pushKV("txid", output.GetTxId().GetHex());
         o.pushKV("vout", int(output.GetN()));
         ret.push_back(o);
     }
 
     return ret;
 }
 
 static UniValue settxfee(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 1) {
         throw std::runtime_error(
             RPCHelpMan{
                 "settxfee",
                 "\nSet the transaction fee per kB for this wallet. Overrides "
                 "the global -paytxfee command line parameter.\n",
                 {
                     {"amount", RPCArg::Type::AMOUNT, /* opt */ false,
                      /* default_val */ "",
                      "The transaction fee in " + CURRENCY_UNIT + "/kB"},
                 }}
                 .ToString() +
             "\nResult\n"
             "true|false        (boolean) Returns true if successful\n"
             "\nExamples:\n" +
             HelpExampleCli("settxfee", "0.00001") +
             HelpExampleRpc("settxfee", "0.00001"));
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     Amount nAmount = AmountFromValue(request.params[0]);
     CFeeRate tx_fee_rate(nAmount, 1000);
     if (tx_fee_rate == CFeeRate()) {
         // automatic selection
     } else if (tx_fee_rate < ::minRelayTxFee) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             strprintf("txfee cannot be less than min relay tx fee (%s)",
                       ::minRelayTxFee.ToString()));
     } else if (tx_fee_rate < pwallet->m_min_fee) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             strprintf("txfee cannot be less than wallet min fee (%s)",
                       pwallet->m_min_fee.ToString()));
     }
 
     pwallet->m_pay_tx_fee = tx_fee_rate;
     return true;
 }
 
 static UniValue getwalletinfo(const Config &config,
                               const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(
             RPCHelpMan{
                 "getwalletinfo",
                 "Returns an object containing various wallet state info.\n",
                 {}}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"walletname\": xxxxx,             (string) the wallet name\n"
             "  \"walletversion\": xxxxx,          (numeric) the wallet "
             "version\n"
             "  \"balance\": xxxxxxx,              (numeric) the total "
             "confirmed balance of the wallet in " +
             CURRENCY_UNIT +
             "\n"
             "  \"unconfirmed_balance\": xxx,      (numeric) "
             "the total unconfirmed balance of the wallet in " +
             CURRENCY_UNIT +
             "\n"
             "  \"immature_balance\": xxxxxx,      (numeric) "
             "the total immature balance of the wallet in " +
             CURRENCY_UNIT +
             "\n"
             "  \"txcount\": xxxxxxx,              (numeric) the total number "
             "of transactions in the wallet\n"
             "  \"keypoololdest\": xxxxxx,         (numeric) the timestamp "
             "(seconds since Unix epoch) of the oldest pre-generated key in the "
             "key pool\n"
             "  \"keypoolsize\": xxxx,             (numeric) how many new keys "
             "are pre-generated (only counts external keys)\n"
             "  \"keypoolsize_hd_internal\": xxxx, (numeric) how many new keys "
             "are pre-generated for internal use (used for change outputs, only "
             "appears if the wallet is using this feature, otherwise external "
             "keys are used)\n"
             "  \"unlocked_until\": ttt,           (numeric) the timestamp in "
             "seconds since epoch (midnight Jan 1 1970 GMT) that the wallet is "
             "unlocked for transfers, or 0 if the wallet is locked\n"
             "  \"paytxfee\": x.xxxx,              (numeric) the transaction "
             "fee configuration, set in " +
             CURRENCY_UNIT +
             "/kB\n"
             "  \"hdseedid\": \"<hash160>\"          (string, optional) the "
             "Hash160 of the HD seed (only present when HD is enabled)\n"
             "  \"hdmasterkeyid\": \"<hash160>\"     (string, optional) alias "
             "for hdseedid retained for backwards-compatibility. Will be "
             "removed in V0.21.\n"
             "  \"private_keys_enabled\": true|false (boolean) false if "
             "privatekeys are disabled for this wallet (enforced watch-only "
             "wallet)\n"
             "}\n"
             "\nExamples:\n" +
             HelpExampleCli("getwalletinfo", "") +
             HelpExampleRpc("getwalletinfo", ""));
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     UniValue obj(UniValue::VOBJ);
 
     size_t kpExternalSize = pwallet->KeypoolCountExternalKeys();
     obj.pushKV("walletname", pwallet->GetName());
     obj.pushKV("walletversion", pwallet->GetVersion());
     obj.pushKV("balance", ValueFromAmount(pwallet->GetBalance()));
     obj.pushKV("unconfirmed_balance",
                ValueFromAmount(pwallet->GetUnconfirmedBalance()));
     obj.pushKV("immature_balance",
                ValueFromAmount(pwallet->GetImmatureBalance()));
     obj.pushKV("txcount", (int)pwallet->mapWallet.size());
     obj.pushKV("keypoololdest", pwallet->GetOldestKeyPoolTime());
     obj.pushKV("keypoolsize", (int64_t)kpExternalSize);
     CKeyID seed_id = pwallet->GetHDChain().seed_id;
     if (!seed_id.IsNull() && pwallet->CanSupportFeature(FEATURE_HD_SPLIT)) {
         obj.pushKV("keypoolsize_hd_internal",
                    int64_t(pwallet->GetKeyPoolSize() - kpExternalSize));
     }
     if (pwallet->IsCrypted()) {
         obj.pushKV("unlocked_until", pwallet->nRelockTime);
     }
     obj.pushKV("paytxfee", ValueFromAmount(pwallet->m_pay_tx_fee.GetFeePerK()));
     if (!seed_id.IsNull()) {
         obj.pushKV("hdseedid", seed_id.GetHex());
         obj.pushKV("hdmasterkeyid", seed_id.GetHex());
     }
     obj.pushKV("private_keys_enabled",
                !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
     return obj;
 }
 
 static UniValue listwalletdir(const Config &config,
                               const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(
             RPCHelpMan{"listwalletdir",
                        "Returns a list of wallets in the wallet directory.\n",
                        {}}
                 .ToString() +
             "{\n"
             "  \"wallets\" : [                (json array of objects)\n"
             "    {\n"
             "      \"name\" : \"name\"          (string) The wallet name\n"
             "    }\n"
             "    ,...\n"
             "  ]\n"
             "}\n"
             "\nExamples:\n" +
             HelpExampleCli("listwalletdir", "") +
             HelpExampleRpc("listwalletdir", ""));
     }
 
     UniValue wallets(UniValue::VARR);
     for (const auto &path : ListWalletDir()) {
         UniValue wallet(UniValue::VOBJ);
         wallet.pushKV("name", path.string());
         wallets.push_back(wallet);
     }
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("wallets", wallets);
     return result;
 }
 
 static UniValue listwallets(const Config &config,
                             const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(
             RPCHelpMan{
                 "listwallets",
                 "Returns a list of currently loaded wallets.\n"
                 "For full information on the wallet, use \"getwalletinfo\"\n",
                 {}}
                 .ToString() +
             "\nResult:\n"
             "[                         (json array of strings)\n"
             "  \"walletname\"            (string) the wallet name\n"
             "   ...\n"
             "]\n"
             "\nExamples:\n" +
             HelpExampleCli("listwallets", "") +
             HelpExampleRpc("listwallets", ""));
     }
 
     UniValue obj(UniValue::VARR);
 
     for (const std::shared_ptr<CWallet> &wallet : GetWallets()) {
         if (!EnsureWalletIsAvailable(wallet.get(), request.fHelp)) {
             return NullUniValue;
         }
 
         LOCK(wallet->cs_wallet);
 
         obj.push_back(wallet->GetName());
     }
 
     return obj;
 }
 
 static UniValue loadwallet(const Config &config,
                            const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"loadwallet",
                        "\nLoads a wallet from a wallet file or directory."
                        "\nNote that all wallet command-line options used when "
                        "starting bitcoind will be"
                        "\napplied to the new wallet (eg -zapwallettxes, "
                        "upgradewallet, rescan, etc).\n",
                        {
                            {"filename", RPCArg::Type::STR, /* opt */ false,
                             /* default_val */ "",
                             "The wallet directory or .dat file."},
                        }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"name\" :    <wallet_name>,        (string) The wallet name if "
             "loaded successfully.\n"
             "  \"warning\" : <warning>,            (string) Warning message if "
             "wallet was not loaded cleanly.\n"
             "}\n"
             "\nExamples:\n" +
             HelpExampleCli("loadwallet", "\"test.dat\"") +
             HelpExampleRpc("loadwallet", "\"test.dat\""));
     }
 
     const CChainParams &chainParams = config.GetChainParams();
 
     WalletLocation location(request.params[0].get_str());
     std::string error;
 
     if (!location.Exists()) {
         throw JSONRPCError(RPC_WALLET_NOT_FOUND,
                            "Wallet " + location.GetName() + " not found.");
     } else if (fs::is_directory(location.GetPath())) {
         // The given filename is a directory. Check that there's a wallet.dat
         // file.
         fs::path wallet_dat_file = location.GetPath() / "wallet.dat";
         if (fs::symlink_status(wallet_dat_file).type() == fs::file_not_found) {
             throw JSONRPCError(RPC_WALLET_NOT_FOUND,
                                "Directory " + location.GetName() +
                                    " does not contain a wallet.dat file.");
         }
     }
 
     std::string warning;
     if (!CWallet::Verify(chainParams, *g_rpc_interfaces->chain, location, false,
                          error, warning)) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Wallet file verification failed: " + error);
     }
 
     std::shared_ptr<CWallet> const wallet = CWallet::CreateWalletFromFile(
         chainParams, *g_rpc_interfaces->chain, location);
     if (!wallet) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Wallet loading failed.");
     }
     AddWallet(wallet);
 
     wallet->postInitProcess();
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("name", wallet->GetName());
     obj.pushKV("warning", warning);
 
     return obj;
 }
 
 static UniValue createwallet(const Config &config,
                              const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 3) {
         throw std::runtime_error(
             RPCHelpMan{"createwallet",
                        "\nCreates and loads a new wallet.\n",
                        {
                            {"wallet_name", RPCArg::Type::STR, /* opt */ false,
                             /* default_val */ "",
                             "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,
                             /* opt */ true, /* default_val */ "false",
                             "Disable the possibility of private keys (only "
                             "watchonlys are possible in this mode)."},
                            {"blank", RPCArg::Type::BOOL, /* opt */ true,
                             /* default_val */ "false",
                             "Create a blank wallet. A blank wallet has no keys "
                             "or HD seed. One can be set using sethdseed.\n"},
                        }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"name\" :    <wallet_name>,        (string) The wallet name if "
             "created successfully. If the wallet was created using a full "
             "path, the wallet_name will be the full path.\n"
             "  \"warning\" : <warning>,            (string) Warning message if "
             "wallet was not loaded cleanly.\n"
             "}\n"
             "\nExamples:\n" +
             HelpExampleCli("createwallet", "\"testwallet\"") +
             HelpExampleRpc("createwallet", "\"testwallet\""));
     }
 
     const CChainParams &chainParams = config.GetChainParams();
 
     std::string error;
     std::string warning;
 
     uint64_t flags = 0;
     if (!request.params[1].isNull() && request.params[1].get_bool()) {
         flags |= WALLET_FLAG_DISABLE_PRIVATE_KEYS;
     }
 
     if (!request.params[2].isNull() && request.params[2].get_bool()) {
         flags |= WALLET_FLAG_BLANK_WALLET;
     }
 
     WalletLocation location(request.params[0].get_str());
     if (location.Exists()) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Wallet " + location.GetName() + " already exists.");
     }
 
     // Wallet::Verify will check if we're trying to create a wallet with a
     // duplicate name.
     if (!CWallet::Verify(chainParams, *g_rpc_interfaces->chain, location, false,
                          error, warning)) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Wallet file verification failed: " + error);
     }
 
     std::shared_ptr<CWallet> const wallet = CWallet::CreateWalletFromFile(
         chainParams, *g_rpc_interfaces->chain, location, flags);
     if (!wallet) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Wallet creation failed.");
     }
     AddWallet(wallet);
 
     wallet->postInitProcess();
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("name", wallet->GetName());
     obj.pushKV("warning", warning);
 
     return obj;
 }
 
 static UniValue unloadwallet(const Config &config,
                              const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() > 1) {
         throw std::runtime_error(
             RPCHelpMan{
                 "unloadwallet",
                 "Unloads the wallet referenced by the request endpoint "
                 "otherwise unloads the wallet specified in the argument.\n"
                 "Specifying the wallet name on a wallet endpoint is invalid.",
                 {
                     {"wallet_name", RPCArg::Type::STR, /* opt */ true,
                      /* default_val */ "", "The name of the wallet to unload."},
                 }}
                 .ToString() +
             "\nExamples:\n" + HelpExampleCli("unloadwallet", "wallet_name") +
             HelpExampleRpc("unloadwallet", "wallet_name"));
     }
 
     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 resendwallettransactions(const Config &config,
                                          const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 0) {
         throw std::runtime_error(
             RPCHelpMan{"resendwallettransactions",
                        "Immediately re-broadcast unconfirmed wallet "
                        "transactions to all peers.\n"
                        "Intended only for testing; the wallet code "
                        "periodically re-broadcasts\n",
                        {}}
                 .ToString() +
             "automatically.\n"
             "Returns an RPC error if -walletbroadcast is set to false.\n"
             "Returns array of transaction ids that were re-broadcast.\n");
     }
 
     if (!g_connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     if (!pwallet->GetBroadcastTransactions()) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Error: Wallet transaction "
                                              "broadcasting is disabled with "
                                              "-walletbroadcast");
     }
 
     std::vector<uint256> txids = pwallet->ResendWalletTransactionsBefore(
         *locked_chain, GetTime(), g_connman.get());
     UniValue result(UniValue::VARR);
     for (const uint256 &txid : txids) {
         result.push_back(txid.ToString());
     }
 
     return result;
 }
 
 static UniValue listunspent(const Config &config,
                             const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 5) {
         throw std::runtime_error(
             RPCHelpMan{
                 "listunspent",
                 "\nReturns array of unspent transaction outputs\n"
                 "with between minconf and maxconf (inclusive) confirmations.\n"
                 "Optionally filter to only include txouts paid to specified "
                 "addresses.\n",
                 {
                     {"minconf", RPCArg::Type::NUM, /* opt */ true,
                      /* default_val */ "1",
                      "The minimum confirmations to filter"},
                     {"maxconf", RPCArg::Type::NUM, /* opt */ true,
                      /* default_val */ "9999999",
                      "The maximum confirmations to filter"},
                     {
                         "addresses",
                         RPCArg::Type::ARR,
                         /* opt */ true,
                         /* default_val */ "",
                         "A json array of bitcoin addresses to filter",
                         {
                             {"address", RPCArg::Type::STR, /* opt */ true,
                              /* default_val */ "", "bitcoin address"},
                         },
                     },
                     {"include_unsafe", RPCArg::Type::BOOL, /* opt */ true,
                      /* default_val */ "true",
                      "Include outputs that are not safe to spend\n"
                      "                  See description of \"safe\" attribute "
                      "below."},
                     {"query_options",
                      RPCArg::Type::OBJ,
                      /* opt */ true,
                      /* default_val */ "",
                      "JSON with query options",
                      {
                          {"minimumAmount", RPCArg::Type::AMOUNT, /* opt */ true,
                           /* default_val */ "0",
                           "Minimum value of each UTXO in " + CURRENCY_UNIT +
                               ""},
                          {"maximumAmount", RPCArg::Type::AMOUNT, /* opt */ true,
                           /* default_val */ "unlimited",
                           "Maximum value of each UTXO in " + CURRENCY_UNIT +
                               ""},
                          {"maximumCount", RPCArg::Type::NUM, /* opt */ true,
                           /* default_val */ "unlimited",
                           "Maximum number of UTXOs"},
                          {"minimumSumAmount", RPCArg::Type::AMOUNT,
                           /* opt */ true, /* default_val */ "unlimited",
                           "Minimum sum value of all UTXOs in " + CURRENCY_UNIT +
                               ""},
                      },
                      "query_options"},
                 }}
                 .ToString() +
             "\nResult\n"
             "[                   (array of json object)\n"
             "  {\n"
             "    \"txid\" : \"txid\",          (string) the transaction id \n"
             "    \"vout\" : n,               (numeric) the vout value\n"
             "    \"address\" : \"address\",    (string) the bitcoin address\n"
             "    \"label\" : \"label\",        (string) The associated label, "
             "or \"\" for the default label\n"
             "    \"scriptPubKey\" : \"key\",   (string) the script key\n"
             "    \"amount\" : x.xxx,         (numeric) the transaction output "
             "amount in " +
             CURRENCY_UNIT +
             "\n"
             "    \"confirmations\" : n,      (numeric) The number of "
             "confirmations\n"
             "    \"redeemScript\" : n        (string) The redeemScript if "
             "scriptPubKey is P2SH\n"
             "    \"spendable\" : xxx,        (bool) Whether we have the "
             "private keys to spend this output\n"
             "    \"solvable\" : xxx,         (bool) Whether we know how to "
             "spend this output, ignoring the lack of keys\n"
             "    \"safe\" : xxx              (bool) Whether this output is "
             "considered safe to spend. Unconfirmed transactions\n"
             "                              from outside keys are considered "
             "unsafe and are not eligible for spending by\n"
             "                              fundrawtransaction and "
             "sendtoaddress.\n"
             "  }\n"
             "  ,...\n"
             "]\n"
 
             "\nExamples\n" +
             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 } "));
     }
 
     int nMinDepth = 1;
     if (!request.params[0].isNull()) {
         RPCTypeCheckArgument(request.params[0], UniValue::VNUM);
         nMinDepth = request.params[0].get_int();
     }
 
     int nMaxDepth = 9999999;
     if (!request.params[1].isNull()) {
         RPCTypeCheckArgument(request.params[1], UniValue::VNUM);
         nMaxDepth = request.params[1].get_int();
     }
 
     std::set<CTxDestination> destinations;
     if (!request.params[2].isNull()) {
         RPCTypeCheckArgument(request.params[2], UniValue::VARR);
         UniValue inputs = request.params[2].get_array();
         for (size_t idx = 0; idx < inputs.size(); idx++) {
             const UniValue &input = inputs[idx];
             CTxDestination dest =
                 DecodeDestination(input.get_str(), config.GetChainParams());
             if (!IsValidDestination(dest)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    std::string("Invalid Bitcoin address: ") +
                                        input.get_str());
             }
             if (!destinations.insert(dest).second) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     std::string("Invalid parameter, duplicated address: ") +
                         input.get_str());
             }
         }
     }
 
     bool include_unsafe = true;
     if (!request.params[3].isNull()) {
         RPCTypeCheckArgument(request.params[3], UniValue::VBOOL);
         include_unsafe = request.params[3].get_bool();
     }
 
     Amount nMinimumAmount = Amount::zero();
     Amount nMaximumAmount = MAX_MONEY;
     Amount nMinimumSumAmount = MAX_MONEY;
     uint64_t nMaximumCount = 0;
 
     if (!request.params[4].isNull()) {
         const UniValue &options = request.params[4].get_obj();
 
         if (options.exists("minimumAmount")) {
             nMinimumAmount = AmountFromValue(options["minimumAmount"]);
         }
 
         if (options.exists("maximumAmount")) {
             nMaximumAmount = AmountFromValue(options["maximumAmount"]);
         }
 
         if (options.exists("minimumSumAmount")) {
             nMinimumSumAmount = AmountFromValue(options["minimumSumAmount"]);
         }
 
         if (options.exists("maximumCount")) {
             nMaximumCount = options["maximumCount"].get_int64();
         }
     }
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     UniValue results(UniValue::VARR);
     std::vector<COutput> vecOutputs;
     {
         auto locked_chain = pwallet->chain().lock();
         LOCK(pwallet->cs_wallet);
         pwallet->AvailableCoins(*locked_chain, vecOutputs, !include_unsafe,
                                 nullptr, nMinimumAmount, nMaximumAmount,
                                 nMinimumSumAmount, nMaximumCount, nMinDepth,
                                 nMaxDepth);
     }
 
     LOCK(pwallet->cs_wallet);
 
     for (const COutput &out : vecOutputs) {
         CTxDestination address;
         const CScript &scriptPubKey = out.tx->tx->vout[out.i].scriptPubKey;
         bool fValidAddress = ExtractDestination(scriptPubKey, address);
 
         if (destinations.size() &&
             (!fValidAddress || !destinations.count(address))) {
             continue;
         }
 
         UniValue entry(UniValue::VOBJ);
         entry.pushKV("txid", out.tx->GetId().GetHex());
         entry.pushKV("vout", out.i);
 
         if (fValidAddress) {
             entry.pushKV("address", EncodeDestination(address, config));
 
             auto i = pwallet->mapAddressBook.find(address);
             if (i != pwallet->mapAddressBook.end()) {
                 entry.pushKV("label", i->second.name);
             }
 
             if (scriptPubKey.IsPayToScriptHash()) {
                 const CScriptID &hash = boost::get<CScriptID>(address);
                 CScript redeemScript;
                 if (pwallet->GetCScript(hash, redeemScript)) {
                     entry.pushKV("redeemScript", HexStr(redeemScript.begin(),
                                                         redeemScript.end()));
                 }
             }
         }
 
         entry.pushKV("scriptPubKey",
                      HexStr(scriptPubKey.begin(), scriptPubKey.end()));
         entry.pushKV("amount", ValueFromAmount(out.tx->tx->vout[out.i].nValue));
         entry.pushKV("confirmations", out.nDepth);
         entry.pushKV("spendable", out.fSpendable);
         entry.pushKV("solvable", out.fSolvable);
         entry.pushKV("safe", out.fSafe);
         results.push_back(entry);
     }
 
     return results;
 }
 
 void FundTransaction(CWallet *const pwallet, CMutableTransaction &tx,
                      Amount &fee_out, int &change_position, UniValue options) {
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     CCoinControl coinControl;
     change_position = -1;
     bool lockUnspents = false;
     UniValue subtractFeeFromOutputs;
     std::set<int> setSubtractFeeFromOutputs;
 
     if (!options.isNull()) {
         if (options.type() == UniValue::VBOOL) {
             // backward compatibility bool only fallback
             coinControl.fAllowWatchOnly = options.get_bool();
         } else {
             RPCTypeCheckArgument(options, UniValue::VOBJ);
             RPCTypeCheckObj(
                 options,
                 {
                     {"changeAddress", UniValueType(UniValue::VSTR)},
                     {"changePosition", UniValueType(UniValue::VNUM)},
                     {"includeWatching", UniValueType(UniValue::VBOOL)},
                     {"lockUnspents", UniValueType(UniValue::VBOOL)},
                     // will be checked below
                     {"feeRate", UniValueType()},
                     {"subtractFeeFromOutputs", UniValueType(UniValue::VARR)},
                 },
                 true, true);
 
             if (options.exists("changeAddress")) {
                 CTxDestination dest = DecodeDestination(
                     options["changeAddress"].get_str(), pwallet->chainParams);
 
                 if (!IsValidDestination(dest)) {
                     throw JSONRPCError(
                         RPC_INVALID_ADDRESS_OR_KEY,
                         "changeAddress must be a valid bitcoin address");
                 }
 
                 coinControl.destChange = dest;
             }
 
             if (options.exists("changePosition")) {
                 change_position = options["changePosition"].get_int();
             }
 
             if (options.exists("includeWatching")) {
                 coinControl.fAllowWatchOnly =
                     options["includeWatching"].get_bool();
             }
 
             if (options.exists("lockUnspents")) {
                 lockUnspents = options["lockUnspents"].get_bool();
             }
 
             if (options.exists("feeRate")) {
                 coinControl.m_feerate =
                     CFeeRate(AmountFromValue(options["feeRate"]));
                 coinControl.fOverrideFeeRate = true;
             }
 
             if (options.exists("subtractFeeFromOutputs")) {
                 subtractFeeFromOutputs =
                     options["subtractFeeFromOutputs"].get_array();
             }
         }
     }
 
     if (tx.vout.size() == 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "TX must have at least one output");
     }
 
     if (change_position != -1 &&
         (change_position < 0 ||
          (unsigned int)change_position > tx.vout.size())) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "changePosition out of bounds");
     }
 
     for (size_t idx = 0; idx < subtractFeeFromOutputs.size(); idx++) {
         int pos = subtractFeeFromOutputs[idx].get_int();
         if (setSubtractFeeFromOutputs.count(pos)) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Invalid parameter, duplicated position: %d", pos));
         }
         if (pos < 0) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Invalid parameter, negative position: %d", pos));
         }
         if (pos >= int(tx.vout.size())) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Invalid parameter, position too large: %d", pos));
         }
         setSubtractFeeFromOutputs.insert(pos);
     }
 
     std::string strFailReason;
 
     if (!pwallet->FundTransaction(tx, fee_out, change_position, strFailReason,
                                   lockUnspents, setSubtractFeeFromOutputs,
                                   coinControl)) {
         throw JSONRPCError(RPC_WALLET_ERROR, strFailReason);
     }
 }
 
 static UniValue fundrawtransaction(const Config &config,
                                    const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{
                 "fundrawtransaction",
                 "\nAdd inputs to a transaction until it has enough in value to "
                 "meet its out value.\n"
                 "This will not modify existing inputs, and will add at most "
                 "one change output to the outputs.\n"
                 "No existing outputs will be modified unless "
                 "\"subtractFeeFromOutputs\" is specified.\n"
                 "Note that inputs which were signed may need to be resigned "
                 "after completion since in/outputs have been added.\n"
                 "The inputs added will not be signed, use "
                 "signrawtransactionwithkey or signrawtransactionwithwallet for "
                 "that.\n"
                 "Note that all existing inputs must have their previous output "
                 "transaction be in the wallet.\n"
                 "Note that all inputs selected must be of standard form and "
                 "P2SH scripts must be\n"
                 "in the wallet using importaddress or addmultisigaddress (to "
                 "calculate fees).\n"
                 "You can see whether this is the case by checking the "
                 "\"solvable\" field in the listunspent output.\n"
                 "Only pay-to-pubkey, multisig, and P2SH versions thereof are "
                 "currently supported for watch-only\n",
                 {
                     {"hexstring", RPCArg::Type::STR_HEX, /* opt */ false,
                      /* default_val */ "",
                      "The hex string of the raw transaction"},
                     {"options",
                      RPCArg::Type::OBJ,
                      /* opt */ true,
                      /* default_val */ "",
                      "for backward compatibility: passing in a true instead of "
                      "an object will result in {\"includeWatching\":true}",
                      {
                          {"changeAddress", RPCArg::Type::STR, /* opt */ true,
                           /* default_val */ "pool address",
                           "The bitcoin address to receive the change"},
                          {"changePosition", RPCArg::Type::NUM, /* opt */ true,
                           /* default_val */ "",
                           "The index of the change output"},
                          {"includeWatching", RPCArg::Type::BOOL, /* opt */ true,
                           /* default_val */ "false",
                           "Also select inputs which are watch only"},
                          {"lockUnspents", RPCArg::Type::BOOL, /* opt */ true,
                           /* default_val */ "false",
                           "Lock selected unspent outputs"},
                          {"feeRate", RPCArg::Type::AMOUNT, /* opt */ true,
                           /* default_val */
                           "not set: makes wallet determine the fee",
                           "Set a specific fee rate in " + CURRENCY_UNIT +
                               "/kB"},
                          {
                              "subtractFeeFromOutputs",
                              RPCArg::Type::ARR,
                              /* opt */ true,
                              /* default_val */ "",
                              "A json array of integers.\n"
                              "                              The fee will be "
                              "equally deducted from the amount of each "
                              "specified output.\n"
                              "                              The outputs are "
                              "specified by their zero-based index, before any "
                              "change output is added.\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,
                                   /* opt */ true, /* default_val */ "",
                                   "The zero-based output index, before a "
                                   "change output is added."},
                              },
                          },
                      },
                      "options"},
                 }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"hex\":       \"value\", (string)  The resulting raw "
             "transaction (hex-encoded string)\n"
             "  \"fee\":       n,         (numeric) Fee in " +
             CURRENCY_UNIT +
             " the resulting transaction pays\n"
             "  \"changepos\": n          (numeric) The position of the added "
             "change output, or -1\n"
             "}\n"
             "\nExamples:\n"
             "\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\""));
     }
 
     RPCTypeCheck(request.params, {UniValue::VSTR, UniValueType()});
 
     // parse hex string from parameter
     CMutableTransaction tx;
     if (!DecodeHexTx(tx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     Amount fee;
     int change_position;
     FundTransaction(pwallet, tx, fee, change_position, request.params[1]);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("hex", EncodeHexTx(CTransaction(tx)));
     result.pushKV("fee", ValueFromAmount(fee));
     result.pushKV("changepos", change_position);
 
     return result;
 }
 
 UniValue signrawtransactionwithwallet(const Config &config,
                                       const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 3) {
         throw std::runtime_error(
             RPCHelpMan{
                 "signrawtransactionwithwallet",
                 "\nSign inputs for raw transaction (serialized, hex-encoded).\n"
                 "The second optional argument (may be null) is an array of "
                 "previous transaction outputs that\n"
                 "this transaction depends on but may not yet be in the block "
                 "chain.\n" +
                     HelpRequiringPassphrase(pwallet) + "\n",
                 {
                     {"hexstring", RPCArg::Type::STR, /* opt */ false,
                      /* default_val */ "", "The transaction hex string"},
                     {
                         "prevtxs",
                         RPCArg::Type::ARR,
                         /* opt */ true,
                         /* default_val */ "",
                         "A json array of previous dependent transaction "
                         "outputs",
                         {
                             {
                                 "",
                                 RPCArg::Type::OBJ,
                                 /* opt */ false,
                                 /* default_val */ "",
                                 "",
                                 {
                                     {"txid", RPCArg::Type::STR_HEX,
                                      /* opt */ false, /* default_val */ "",
                                      "The transaction id"},
                                     {"vout", RPCArg::Type::NUM, /* opt */ false,
                                      /* default_val */ "", "The output number"},
                                     {"scriptPubKey", RPCArg::Type::STR_HEX,
                                      /* opt */ false, /* default_val */ "",
                                      "script key"},
                                     {"redeemScript", RPCArg::Type::STR_HEX,
                                      /* opt */ true, /* default_val */ "",
                                      "(required for P2SH"},
                                     {"amount", RPCArg::Type::AMOUNT,
                                      /* opt */ false, /* default_val */ "",
                                      "The amount spent"},
                                 },
                             },
                         },
                     },
                     {"sighashtype", RPCArg::Type::STR, /* opt */ true,
                      /* default_val */ "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\""},
                 }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"hex\" : \"value\",                  (string) The hex-encoded "
             "raw transaction with signature(s)\n"
             "  \"complete\" : true|false,          (boolean) If the "
             "transaction has a complete set of signatures\n"
             "  \"errors\" : [                      (json array of objects) "
             "Script verification errors (if there are any)\n"
             "    {\n"
             "      \"txid\" : \"hash\",              (string) The hash of the "
             "referenced, previous transaction\n"
             "      \"vout\" : n,                   (numeric) The index of the "
             "output to spent and used as input\n"
             "      \"scriptSig\" : \"hex\",          (string) The hex-encoded "
             "signature script\n"
             "      \"sequence\" : n,               (numeric) Script sequence "
             "number\n"
             "      \"error\" : \"text\"              (string) Verification or "
             "signing error related to the input\n"
             "    }\n"
             "    ,...\n"
             "  ]\n"
             "}\n"
 
             "\nExamples:\n" +
             HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
             HelpExampleRpc("signrawtransactionwithwallet", "\"myhex\""));
     }
 
     RPCTypeCheck(request.params,
                  {UniValue::VSTR, UniValue::VARR, UniValue::VSTR}, true);
 
     CMutableTransaction mtx;
     if (!DecodeHexTx(mtx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
 
     // Sign the transaction
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
     EnsureWalletIsUnlocked(pwallet);
 
     return SignTransaction(pwallet->chain(), mtx, request.params[1], pwallet,
                            false, request.params[2]);
 }
 
 UniValue generate(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{"generate",
                        "\nMine up to nblocks blocks immediately (before the "
                        "RPC call returns) to an address in the wallet.\n",
                        {
                            {"nblocks", RPCArg::Type::NUM, /* opt */ false,
                             /* default_val */ "",
                             "How many blocks are generated immediately."},
                            {"maxtries", RPCArg::Type::NUM, /* opt */ true,
                             /* default_val */ "",
                             "How many iterations to try (default = 1000000)."},
                        }}
                 .ToString() +
             "\nResult:\n"
             "[ blockhashes ]     (array) hashes of blocks generated\n"
             "\nExamples:\n"
             "\nGenerate 11 blocks\n" +
             HelpExampleCli("generate", "11"));
     }
 
     int num_generate = request.params[0].get_int();
     uint64_t max_tries = 1000000;
     if (!request.params[1].isNull()) {
         max_tries = request.params[1].get_int();
     }
 
     std::shared_ptr<CReserveScript> coinbase_script;
     pwallet->GetScriptForMining(coinbase_script);
 
     // If the keypool is exhausted, no script is returned at all.  Catch this.
     if (!coinbase_script) {
         throw JSONRPCError(
             RPC_WALLET_KEYPOOL_RAN_OUT,
             "Error: Keypool ran out, please call keypoolrefill first");
     }
 
     // throw an error if no script was provided
     if (coinbase_script->reserveScript.empty()) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "No coinbase script available");
     }
 
     return generateBlocks(config, coinbase_script, num_generate, max_tries,
                           true);
 }
 
 UniValue rescanblockchain(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{"rescanblockchain",
                        "\nRescan the local blockchain for wallet related "
                        "transactions.\n",
                        {
                            {"start_height", RPCArg::Type::NUM, /* opt */ true,
                             /* default_val */ "",
                             "block height where the rescan should start"},
                            {"stop_height", RPCArg::Type::NUM, /* opt */ true,
                             /* default_val */ "",
                             "the last block height that should be scanned"},
                        }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"start_height\"     (numeric) The block height where the "
             "rescan has started. If omitted, rescan started from the genesis "
             "block.\n"
             "  \"stop_height\"      (numeric) The height of the last rescanned "
             "block. If omitted, rescan stopped at the chain tip.\n"
             "}\n"
             "\nExamples:\n" +
             HelpExampleCli("rescanblockchain", "100000 120000") +
             HelpExampleRpc("rescanblockchain", "100000 120000"));
     }
 
     WalletRescanReserver reserver(pwallet);
     if (!reserver.reserve()) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Wallet is currently rescanning. Abort existing rescan or wait.");
     }
 
     int start_height = 0;
     BlockHash start_block, stop_block;
     {
         auto locked_chain = pwallet->chain().lock();
         Optional<int> tip_height = locked_chain->getHeight();
 
         if (!request.params[0].isNull()) {
             start_height = request.params[0].get_int();
             if (start_height < 0 || !tip_height || start_height > *tip_height) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Invalid start_height");
             }
         }
 
         Optional<int> stop_height;
         if (!request.params[1].isNull()) {
             stop_height = request.params[1].get_int();
             if (*stop_height < 0 || !tip_height || *stop_height > *tip_height) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Invalid stop_height");
             } else if (*stop_height < start_height) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     "stop_height must be greater than start_height");
             }
         }
 
         // We can't rescan beyond non-pruned blocks, stop and throw an error
         if (locked_chain->findPruned(start_height, stop_height)) {
             throw JSONRPCError(
                 RPC_MISC_ERROR,
                 "Can't rescan beyond pruned data. Use RPC call "
                 "getblockchaininfo to determine your pruned height.");
         }
 
         if (tip_height) {
             start_block = locked_chain->getBlockHash(start_height);
 
             if (stop_height) {
                 stop_block = locked_chain->getBlockHash(*stop_height);
             }
         }
     }
 
     CWallet::ScanResult result = pwallet->ScanForWalletTransactions(
         start_block, stop_block, reserver, true /* fUpdate */);
     switch (result.status) {
         case CWallet::ScanResult::SUCCESS:
             break;
         case CWallet::ScanResult::FAILURE:
             throw JSONRPCError(
                 RPC_MISC_ERROR,
                 "Rescan failed. Potentially corrupted data files.");
         case CWallet::ScanResult::USER_ABORT:
             throw JSONRPCError(RPC_MISC_ERROR, "Rescan aborted.");
             // no default case, so the compiler can warn about missing cases
     }
     UniValue response(UniValue::VOBJ);
     response.pushKV("start_height", start_height);
     response.pushKV("stop_height",
                     result.stop_height ? *result.stop_height : UniValue());
     return response;
 }
 
 class DescribeWalletAddressVisitor : public boost::static_visitor<UniValue> {
 public:
     CWallet *const pwallet;
 
     void ProcessSubScript(const CScript &subscript, UniValue &obj,
                           bool include_addresses = false) const {
         // Always present: script type and redeemscript
         std::vector<std::vector<uint8_t>> solutions_data;
         txnouttype which_type = Solver(subscript, solutions_data);
         obj.pushKV("script", GetTxnOutputType(which_type));
         obj.pushKV("hex", HexStr(subscript.begin(), subscript.end()));
 
         CTxDestination embedded;
         UniValue a(UniValue::VARR);
         if (ExtractDestination(subscript, embedded)) {
             // Only when the script corresponds to an address.
             UniValue subobj(UniValue::VOBJ);
             UniValue detail = DescribeAddress(embedded);
             subobj.pushKVs(detail);
             UniValue wallet_detail = boost::apply_visitor(*this, embedded);
             subobj.pushKVs(wallet_detail);
             subobj.pushKV("address", EncodeDestination(embedded, GetConfig()));
             subobj.pushKV("scriptPubKey",
                           HexStr(subscript.begin(), subscript.end()));
             // Always report the pubkey at the top level, so that
             // `getnewaddress()['pubkey']` always works.
             if (subobj.exists("pubkey")) {
                 obj.pushKV("pubkey", subobj["pubkey"]);
             }
             obj.pushKV("embedded", std::move(subobj));
             if (include_addresses) {
                 a.push_back(EncodeDestination(embedded, GetConfig()));
             }
         } else if (which_type == TX_MULTISIG) {
             // Also report some information on multisig scripts (which do not
             // have a corresponding address).
             // TODO: abstract out the common functionality between this logic
             // and ExtractDestinations.
             obj.pushKV("sigsrequired", solutions_data[0][0]);
             UniValue pubkeys(UniValue::VARR);
             for (size_t i = 1; i < solutions_data.size() - 1; ++i) {
                 CPubKey key(solutions_data[i].begin(), solutions_data[i].end());
                 if (include_addresses) {
                     a.push_back(EncodeDestination(key.GetID(), GetConfig()));
                 }
                 pubkeys.push_back(HexStr(key.begin(), key.end()));
             }
             obj.pushKV("pubkeys", std::move(pubkeys));
         }
 
         // The "addresses" field is confusing because it refers to public keys
         // using their P2PKH address. For that reason, only add the 'addresses'
         // field when needed for backward compatibility. New applications can
         // use the 'pubkeys' field for inspecting multisig participants.
         if (include_addresses) {
             obj.pushKV("addresses", std::move(a));
         }
     }
 
     explicit DescribeWalletAddressVisitor(CWallet *_pwallet)
         : pwallet(_pwallet) {}
 
     UniValue operator()(const CNoDestination &dest) const {
         return UniValue(UniValue::VOBJ);
     }
 
     UniValue operator()(const CKeyID &keyID) const {
         UniValue obj(UniValue::VOBJ);
         CPubKey vchPubKey;
         if (pwallet && pwallet->GetPubKey(keyID, vchPubKey)) {
             obj.pushKV("pubkey", HexStr(vchPubKey));
             obj.pushKV("iscompressed", vchPubKey.IsCompressed());
         }
         return obj;
     }
 
     UniValue operator()(const CScriptID &scriptID) const {
         UniValue obj(UniValue::VOBJ);
         CScript subscript;
         if (pwallet && pwallet->GetCScript(scriptID, subscript)) {
             ProcessSubScript(subscript, obj, true);
         }
         return obj;
     }
 };
 
 static UniValue DescribeWalletAddress(CWallet *pwallet,
                                       const CTxDestination &dest) {
     UniValue ret(UniValue::VOBJ);
     UniValue detail = DescribeAddress(dest);
     ret.pushKVs(detail);
     ret.pushKVs(
         boost::apply_visitor(DescribeWalletAddressVisitor(pwallet), dest));
     return ret;
 }
 
 /** Convert CAddressBookData to JSON record.  */
 static UniValue AddressBookDataToJSON(const CAddressBookData &data,
                                       const bool verbose) {
     UniValue ret(UniValue::VOBJ);
     if (verbose) {
         ret.pushKV("name", data.name);
     }
     ret.pushKV("purpose", data.purpose);
     return ret;
 }
 
 UniValue getaddressinfo(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"getaddressinfo",
                        "\nReturn information about the given bitcoin address. "
                        "Some information requires the address\n"
                        "to be in the wallet.\n",
                        {
                            {"address", RPCArg::Type::STR, /* opt */ false,
                             /* default_val */ "",
                             "The bitcoin address to get the information of."},
                        }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"address\" : \"address\",        (string) The bitcoin address "
             "validated\n"
             "  \"scriptPubKey\" : \"hex\",       (string) The hex-encoded "
             "scriptPubKey generated by the address\n"
             "  \"ismine\" : true|false,        (boolean) If the address is "
             "yours or not\n"
             "  \"iswatchonly\" : true|false,   (boolean) If the address is "
             "watchonly\n"
             "  \"isscript\" : true|false,      (boolean) If the key is a "
             "script\n"
             "  \"ischange\" : true|false,      (boolean) If the address was "
             "used for change output\n"
             "  \"script\" : \"type\"             (string, optional) The output "
             "script type. Only if \"isscript\" is true and the redeemscript is "
             "known. Possible types: nonstandard, pubkey, pubkeyhash, "
             "scripthash, multisig, nulldata\n"
             "  \"hex\" : \"hex\",                (string, optional) The "
             "redeemscript for the p2sh address\n"
             "  \"pubkeys\"                     (string, optional) Array of "
             "pubkeys associated with the known redeemscript (only if "
             "\"script\" is \"multisig\")\n"
             "    [\n"
             "      \"pubkey\"\n"
             "      ,...\n"
             "    ]\n"
             "  \"sigsrequired\" : xxxxx        (numeric, optional) Number of "
             "signatures required to spend multisig output (only if \"script\" "
             "is \"multisig\")\n"
             "  \"pubkey\" : \"publickeyhex\",    (string, optional) The hex "
             "value of the raw public key, for single-key addresses (possibly "
             "embedded in P2SH or P2WSH)\n"
             "  \"embedded\" : {...},           (object, optional) Information "
             "about the address embedded in P2SH or P2WSH, if relevant and "
             "known. It includes all getaddressinfo output fields for the "
             "embedded address, excluding metadata (\"timestamp\", "
             "\"hdkeypath\", \"hdseedid\") and relation to the wallet "
             "(\"ismine\", \"iswatchonly\").\n"
             "  \"iscompressed\" : true|false,  (boolean) If the address is "
             "compressed\n"
             "  \"label\" :  \"label\"         (string) The label associated "
             "with the address, \"\" is the default label\n"
             "  \"timestamp\" : timestamp,      (number, optional) The creation "
             "time of the key if available in seconds since epoch (Jan 1 1970 "
             "GMT)\n"
             "  \"hdkeypath\" : \"keypath\"       (string, optional) The HD "
             "keypath if the key is HD and available\n"
             "  \"hdseedid\" : \"<hash160>\"      (string, optional) The "
             "Hash160 of the HD seed\n"
             "  \"hdmasterkeyid\" : \"<hash160>\" (string, optional) alias for "
             "hdseedid maintained for backwards compatibility. Will be removed "
             "in V0.21.\n"
             "  \"labels\"                      (object) Array of labels "
             "associated with the address.\n"
             "    [\n"
             "      { (json object of label data)\n"
             "        \"name\": \"labelname\" (string) The label\n"
             "        \"purpose\": \"string\" (string) Purpose of address "
             "(\"send\" for sending address, \"receive\" for receiving "
             "address)\n"
             "      },...\n"
             "    ]\n"
             "}\n"
             "\nExamples:\n" +
             HelpExampleCli("getaddressinfo",
                            "\"1PSSGeFHDnKNxiEyFrD1wcEaHr9hrQDDWc\"") +
             HelpExampleRpc("getaddressinfo",
                            "\"1PSSGeFHDnKNxiEyFrD1wcEaHr9hrQDDWc\""));
     }
 
     LOCK(pwallet->cs_wallet);
 
     UniValue ret(UniValue::VOBJ);
     CTxDestination dest =
         DecodeDestination(request.params[0].get_str(), config.GetChainParams());
 
     // Make sure the destination is valid
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
     }
 
     std::string currentAddress = EncodeDestination(dest, config);
     ret.pushKV("address", currentAddress);
 
     CScript scriptPubKey = GetScriptForDestination(dest);
     ret.pushKV("scriptPubKey",
                HexStr(scriptPubKey.begin(), scriptPubKey.end()));
 
     isminetype mine = IsMine(*pwallet, dest);
     ret.pushKV("ismine", bool(mine & ISMINE_SPENDABLE));
     ret.pushKV("iswatchonly", bool(mine & ISMINE_WATCH_ONLY));
     UniValue detail = DescribeWalletAddress(pwallet, dest);
     ret.pushKVs(detail);
     if (pwallet->mapAddressBook.count(dest)) {
         ret.pushKV("label", pwallet->mapAddressBook[dest].name);
     }
     ret.pushKV("ischange", pwallet->IsChange(scriptPubKey));
     const CKeyMetadata *meta = nullptr;
     CKeyID key_id = GetKeyForDestination(*pwallet, dest);
     if (!key_id.IsNull()) {
         auto it = pwallet->mapKeyMetadata.find(key_id);
         if (it != pwallet->mapKeyMetadata.end()) {
             meta = &it->second;
         }
     }
     if (!meta) {
         auto it = pwallet->m_script_metadata.find(CScriptID(scriptPubKey));
         if (it != pwallet->m_script_metadata.end()) {
             meta = &it->second;
         }
     }
     if (meta) {
         ret.pushKV("timestamp", meta->nCreateTime);
         if (!meta->hdKeypath.empty()) {
             ret.pushKV("hdkeypath", meta->hdKeypath);
             ret.pushKV("hdseedid", meta->hd_seed_id.GetHex());
             ret.pushKV("hdmasterkeyid", meta->hd_seed_id.GetHex());
         }
     }
 
     // Currently only one label can be associated with an address, return an
     // array so the API remains stable if we allow multiple labels to be
     // associated with an address.
     UniValue labels(UniValue::VARR);
     std::map<CTxDestination, CAddressBookData>::iterator mi =
         pwallet->mapAddressBook.find(dest);
     if (mi != pwallet->mapAddressBook.end()) {
         labels.push_back(AddressBookDataToJSON(mi->second, true));
     }
     ret.pushKV("labels", std::move(labels));
 
     return ret;
 }
 
 UniValue getaddressesbylabel(const Config &config,
                              const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             RPCHelpMan{"getaddressesbylabel",
                        "\nReturns the list of addresses assigned the specified "
                        "label.\n",
                        {
                            {"label", RPCArg::Type::STR, /* opt */ false,
                             /* default_val */ "", "The label."},
                        }}
                 .ToString() +
             "\nResult:\n"
             "{ (json object with addresses as keys)\n"
             "  \"address\": { (json object with information about address)\n"
             "    \"purpose\": \"string\" (string)  Purpose of address "
             "(\"send\" for sending address, \"receive\" for receiving "
             "address)\n"
             "  },...\n"
             "}\n"
             "\nExamples:\n" +
             HelpExampleCli("getaddressesbylabel", "\"tabby\"") +
             HelpExampleRpc("getaddressesbylabel", "\"tabby\""));
     }
 
     LOCK(pwallet->cs_wallet);
 
     std::string label = LabelFromValue(request.params[0]);
 
     // Find all addresses that have the given label
     UniValue ret(UniValue::VOBJ);
     for (const std::pair<const CTxDestination, CAddressBookData> &item :
          pwallet->mapAddressBook) {
         if (item.second.name == label) {
             ret.pushKV(EncodeDestination(item.first, config),
                        AddressBookDataToJSON(item.second, false));
         }
     }
 
     if (ret.empty()) {
         throw JSONRPCError(RPC_WALLET_INVALID_LABEL_NAME,
                            std::string("No addresses with label " + label));
     }
 
     return ret;
 }
 
 UniValue listlabels(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 1) {
         throw std::runtime_error(
             RPCHelpMan{"listlabels",
                        "\nReturns the list of all labels, or labels that are "
                        "assigned to addresses with a specific purpose.\n",
                        {
                            {"purpose", RPCArg::Type::STR, /* opt */ true,
                             /* default_val */ "",
                             "Address purpose to list labels for "
                             "('send','receive'). An empty string is the same "
                             "as not providing this argument."},
                        }}
                 .ToString() +
             "\nResult:\n"
             "[               (json array of string)\n"
             "  \"label\",      (string) Label name\n"
             "  ...\n"
             "]\n"
             "\nExamples:\n"
             "\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"));
     }
 
     LOCK(pwallet->cs_wallet);
 
     std::string purpose;
     if (!request.params[0].isNull()) {
         purpose = request.params[0].get_str();
     }
 
     // Add to a set to sort by label name, then insert into Univalue array
     std::set<std::string> label_set;
     for (const std::pair<const CTxDestination, CAddressBookData> &entry :
          pwallet->mapAddressBook) {
         if (purpose.empty() || entry.second.purpose == purpose) {
             label_set.insert(entry.second.name);
         }
     }
 
     UniValue ret(UniValue::VARR);
     for (const std::string &name : label_set) {
         ret.push_back(name);
     }
 
     return ret;
 }
 
 static UniValue sethdseed(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 2) {
         throw std::runtime_error(
             RPCHelpMan{
                 "sethdseed",
                 "\nSet or generate a new HD wallet seed. Non-HD wallets "
                 "will not be upgraded to being a HD wallet. Wallets "
                 "that are already\n"
                 "HD will have a new HD seed set so that new keys added "
                 "to the keypool will be derived from this new seed.\n"
                 "\nNote that you will need to MAKE A NEW BACKUP of your "
                 "wallet after setting the HD wallet seed.\n" +
                     HelpRequiringPassphrase(pwallet) + "\n",
                 {
                     {"newkeypool", RPCArg::Type::BOOL, /* opt */ true,
                      /* default_val */ "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, /* opt */ true,
                      /* default_val */ "",
                      "The WIF private key to use as the new HD seed; if not "
                      "provided a random seed will be used.\n"
                      "                             The seed value can be "
                      "retrieved using the dumpwallet command. It is the "
                      "private key marked hdseed=1"},
                 }}
                 .ToString() +
             "\nExamples:\n" + HelpExampleCli("sethdseed", "") +
             HelpExampleCli("sethdseed", "false") +
             HelpExampleCli("sethdseed", "true \"wifkey\"") +
             HelpExampleRpc("sethdseed", "true, \"wifkey\""));
     }
 
     if (IsInitialBlockDownload()) {
         throw JSONRPCError(
             RPC_CLIENT_IN_INITIAL_DOWNLOAD,
             "Cannot set a new HD seed while still in Initial Block Download");
     }
 
     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Cannot set a HD seed to a wallet with private keys disabled");
     }
 
     auto locked_chain = pwallet->chain().lock();
     LOCK(pwallet->cs_wallet);
 
     // Do not do anything to non-HD wallets
     if (!pwallet->CanSupportFeature(FEATURE_HD)) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Cannot set a HD seed on a non-HD wallet. Start with "
             "-upgradewallet in order to upgrade a non-HD wallet to HD");
     }
 
     EnsureWalletIsUnlocked(pwallet);
 
     bool flush_key_pool = true;
     if (!request.params[0].isNull()) {
         flush_key_pool = request.params[0].get_bool();
     }
 
     CPubKey master_pub_key;
     if (request.params[1].isNull()) {
         master_pub_key = pwallet->GenerateNewSeed();
     } else {
         CKey key = DecodeSecret(request.params[1].get_str());
         if (!key.IsValid()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid private key");
         }
 
         if (HaveKey(*pwallet, key)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Already have this key (either as an HD seed or "
                                "as a loose private key)");
         }
 
         master_pub_key = pwallet->DeriveNewSeed(key);
     }
 
     pwallet->SetHDSeed(master_pub_key);
     if (flush_key_pool) {
         pwallet->NewKeyPool();
     }
 
     return NullUniValue;
 }
 
 static UniValue walletprocesspsbt(const Config &config,
                                   const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 4) {
         throw std::runtime_error(
             RPCHelpMan{
                 "walletprocesspsbt",
                 "\nUpdate a PSBT with input information from our wallet "
                 "and then sign inputs that we can sign for." +
                     HelpRequiringPassphrase(pwallet) + "\n",
                 {
                     {"psbt", RPCArg::Type::STR, /* opt */ false,
                      /* default_val */ "", "The transaction base64 string"},
                     {"sign", RPCArg::Type::BOOL, /* opt */ true,
                      /* default_val */ "true",
                      "Also sign the transaction when updating"},
                     {"sighashtype", RPCArg::Type::STR, /* opt */ true,
                      /* default_val */ "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, /* opt */ true,
                      /* default_val */ "false",
                      "If true, includes the BIP 32 derivation paths for public "
                      "keys if we know them"},
                 }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"psbt\" : \"value\",          (string) The base64-encoded "
             "partially signed transaction\n"
             "  \"complete\" : true|false,   (boolean) If the transaction has a "
             "complete set of signatures\n"
             "  ]\n"
             "}\n"
 
             "\nExamples:\n" +
             HelpExampleCli("walletprocesspsbt", "\"psbt\""));
     }
 
     RPCTypeCheck(request.params,
                  {UniValue::VSTR, UniValue::VBOOL, UniValue::VSTR});
 
     // Unserialize the transaction
     PartiallySignedTransaction psbtx;
     std::string error;
     if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            strprintf("TX decode failed %s", error));
     }
 
     // Get the sighash type
     SigHashType nHashType = ParseSighashString(request.params[2]);
     if (!nHashType.hasForkId()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Signature must use SIGHASH_FORKID");
     }
 
     // Fill transaction with our data and also sign
     bool sign =
         request.params[1].isNull() ? true : request.params[1].get_bool();
     bool bip32derivs =
         request.params[3].isNull() ? false : request.params[3].get_bool();
-    bool complete = FillPSBT(pwallet, psbtx, nHashType, sign, bip32derivs);
+    bool complete = true;
+    TransactionError err;
+    if (!FillPSBT(pwallet, psbtx, err, complete, nHashType, sign,
+                  bip32derivs)) {
+        throw JSONRPCTransactionError(err);
+    }
 
     UniValue result(UniValue::VOBJ);
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
     result.pushKV("psbt", EncodeBase64(ssTx.str()));
     result.pushKV("complete", complete);
 
     return result;
 }
 
 static UniValue walletcreatefundedpsbt(const Config &config,
                                        const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 5) {
         throw std::runtime_error(
             RPCHelpMan{
                 "walletcreatefundedpsbt",
                 "\nCreates and funds a transaction in the Partially "
                 "Signed Transaction format. Inputs will be added if "
                 "supplied inputs are not enough\n"
                 "Implements the Creator and Updater roles.\n",
                 {
                     {
                         "inputs",
                         RPCArg::Type::ARR,
                         /* opt */ false,
                         /* default_val */ "",
                         "A json array of json objects",
                         {
                             {
                                 "",
                                 RPCArg::Type::OBJ,
                                 /* opt */ false,
                                 /* default_val */ "",
                                 "",
                                 {
                                     {"txid", RPCArg::Type::STR_HEX,
                                      /* opt */ false, /* default_val */ "",
                                      "The transaction id"},
                                     {"vout", RPCArg::Type::NUM, /* opt */ false,
                                      /* default_val */ "", "The output number"},
                                     {"sequence", RPCArg::Type::NUM,
                                      /* opt */ false, /* default_val */ "",
                                      "The sequence number"},
                                 },
                             },
                         },
                     },
                     {
                         "outputs",
                         RPCArg::Type::ARR,
                         /* opt */ false,
                         /* default_val */ "",
                         "a json array with outputs (key-value pairs).\n"
                         "For compatibility reasons, a dictionary, which holds "
                         "the key-value pairs directly, is also\n"
                         "                             accepted as second "
                         "parameter.",
                         {
                             {
                                 "",
                                 RPCArg::Type::OBJ,
                                 /* opt */ true,
                                 /* default_val */ "",
                                 "",
                                 {
                                     {"address", RPCArg::Type::AMOUNT,
                                      /* opt */ true, /* default_val */ "",
                                      "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,
                                 /* opt */ true,
                                 /* default_val */ "",
                                 "",
                                 {
                                     {"data", RPCArg::Type::STR_HEX,
                                      /* opt */ true, /* default_val */ "",
                                      "A key-value pair. The key must be "
                                      "\"data\", the value is hex-encoded data"},
                                 },
                             },
                         },
                     },
                     {"locktime", RPCArg::Type::NUM, /* opt */ true,
                      /* default_val */ "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,
                      /* opt */ true,
                      /* default_val */ "",
                      "",
                      {
                          {"changeAddress", RPCArg::Type::STR_HEX,
                           /* opt */ true, /* default_val */ "pool address",
                           "The bitcoin address to receive the change"},
                          {"changePosition", RPCArg::Type::NUM, /* opt */ true,
                           /* default_val */ "random",
                           "The index of the change output"},
                          {"includeWatching", RPCArg::Type::BOOL, /* opt */ true,
                           /* default_val */ "false",
                           "Also select inputs which are watch only"},
                          {"lockUnspents", RPCArg::Type::BOOL, /* opt */ true,
                           /* default_val */ "false",
                           "Lock selected unspent outputs"},
                          {"feeRate", RPCArg::Type::AMOUNT, /* opt */ true,
                           /* default_val */
                           "not set: makes wallet determine the fee",
                           "Set a specific fee rate in " + CURRENCY_UNIT +
                               "/kB"},
                          {
                              "subtractFeeFromOutputs",
                              RPCArg::Type::ARR,
                              /* opt */ true,
                              /* default_val */ "",
                              "A json array of integers.\n"
                              "                              The fee will be "
                              "equally deducted from the amount of each "
                              "specified output.\n"
                              "                              The outputs are "
                              "specified by their zero-based index, before any "
                              "change output is added.\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,
                                   /* opt */ true, /* default_val */ "", ""},
                              },
                          },
                      },
                      "options"},
                     {"bip32derivs", RPCArg::Type::BOOL, /* opt */ true,
                      /* default_val */ "false",
                      "If true, includes the BIP 32 derivation paths for public "
                      "keys if we know them"},
                 }}
                 .ToString() +
             "\nResult:\n"
             "{\n"
             "  \"psbt\": \"value\",        (string)  The resulting raw "
             "transaction (base64-encoded string)\n"
             "  \"fee\":       n,         (numeric) Fee in " +
             CURRENCY_UNIT +
             " the resulting transaction pays\n"
             "  \"changepos\": n          (numeric) The position of the added "
             "change output, or -1\n"
             "}\n"
             "\nExamples:\n"
             "\nCreate a transaction with no inputs\n" +
             HelpExampleCli("walletcreatefundedpsbt",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" "
                            "\"[{\\\"data\\\":\\\"00010203\\\"}]\""));
     }
 
     RPCTypeCheck(request.params,
                  {UniValue::VARR,
                   UniValueType(), // ARR or OBJ, checked later
                   UniValue::VNUM, UniValue::VOBJ},
                  true);
 
     Amount fee;
     int change_position;
     CMutableTransaction rawTx =
         ConstructTransaction(config.GetChainParams(), request.params[0],
                              request.params[1], request.params[2]);
     FundTransaction(pwallet, rawTx, fee, change_position, request.params[3]);
 
     // Make a blank psbt
     const CTransaction tx = CTransaction(rawTx);
     PartiallySignedTransaction psbtx(tx);
 
     // Fill transaction with out data but don't sign
     bool bip32derivs =
         request.params[4].isNull() ? false : request.params[4].get_bool();
-    FillPSBT(pwallet, psbtx, SigHashType().withForkId(), false, bip32derivs);
+    bool complete = true;
+    TransactionError err;
+    if (!FillPSBT(pwallet, psbtx, err, complete, SigHashType().withForkId(),
+                  false, bip32derivs)) {
+        throw JSONRPCTransactionError(err);
+    }
 
     // Serialize the PSBT
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("psbt", EncodeBase64(ssTx.str()));
     result.pushKV("fee", ValueFromAmount(fee));
     result.pushKV("changepos", change_position);
     return result;
 }
 
 // clang-format off
 static const ContextFreeRPCCommand commands[] = {
     //  category            name                            actor (function)              argNames
     //  ------------------- ------------------------        ----------------------        ----------
     { "generating",         "generate",                     generate,                     {"nblocks","maxtries"} },
     { "hidden",             "resendwallettransactions",     resendwallettransactions,     {} },
     { "rawtransactions",    "fundrawtransaction",           fundrawtransaction,           {"hexstring","options"} },
     { "wallet",             "abandontransaction",           abandontransaction,           {"txid"} },
     { "wallet",             "addmultisigaddress",           addmultisigaddress,           {"nrequired","keys","label"} },
     { "wallet",             "backupwallet",                 backupwallet,                 {"destination"} },
     { "wallet",             "createwallet",                 createwallet,                 {"wallet_name", "disable_private_keys", "blank"} },
     { "wallet",             "encryptwallet",                encryptwallet,                {"passphrase"} },
     { "wallet",             "getaddressesbylabel",          getaddressesbylabel,          {"label"} },
     { "wallet",             "getaddressinfo",               getaddressinfo,               {"address"} },
     { "wallet",             "getbalance",                   getbalance,                   {"dummy","minconf","include_watchonly"} },
     { "wallet",             "getnewaddress",                getnewaddress,                {"label", "address_type"} },
     { "wallet",             "getrawchangeaddress",          getrawchangeaddress,          {"address_type"} },
     { "wallet",             "getreceivedbyaddress",         getreceivedbyaddress,         {"address","minconf"} },
     { "wallet",             "getreceivedbylabel",           getreceivedbylabel,           {"label","minconf"} },
     { "wallet",             "gettransaction",               gettransaction,               {"txid","include_watchonly"} },
     { "wallet",             "getunconfirmedbalance",        getunconfirmedbalance,        {} },
     { "wallet",             "getwalletinfo",                getwalletinfo,                {} },
     { "wallet",             "keypoolrefill",                keypoolrefill,                {"newsize"} },
     { "wallet",             "listaddressgroupings",         listaddressgroupings,         {} },
     { "wallet",             "listlabels",                   listlabels,                   {"purpose"} },
     { "wallet",             "listlockunspent",              listlockunspent,              {} },
     { "wallet",             "listreceivedbyaddress",        listreceivedbyaddress,        {"minconf","include_empty","include_watchonly","address_filter"} },
     { "wallet",             "listreceivedbylabel",          listreceivedbylabel,          {"minconf","include_empty","include_watchonly"} },
     { "wallet",             "listsinceblock",               listsinceblock,               {"blockhash","target_confirmations","include_watchonly","include_removed"} },
     { "wallet",             "listtransactions",             listtransactions,             {"label|dummy","count","skip","include_watchonly"} },
     { "wallet",             "listunspent",                  listunspent,                  {"minconf","maxconf","addresses","include_unsafe","query_options"} },
     { "wallet",             "listwalletdir",                listwalletdir,                {} },
     { "wallet",             "listwallets",                  listwallets,                  {} },
     { "wallet",             "loadwallet",                   loadwallet,                   {"filename"} },
     { "wallet",             "lockunspent",                  lockunspent,                  {"unlock","transactions"} },
     { "wallet",             "rescanblockchain",             rescanblockchain,             {"start_height", "stop_height"} },
     { "wallet",             "sendmany",                     sendmany,                     {"dummy","amounts","minconf","comment","subtractfeefrom"} },
     { "wallet",             "sendtoaddress",                sendtoaddress,                {"address","amount","comment","comment_to","subtractfeefromamount"} },
     { "wallet",             "sethdseed",                    sethdseed,                    {"newkeypool","seed"} },
     { "wallet",             "setlabel",                     setlabel,                     {"address","label"} },
     { "wallet",             "settxfee",                     settxfee,                     {"amount"} },
     { "wallet",             "signmessage",                  signmessage,                  {"address","message"} },
     { "wallet",             "signrawtransactionwithwallet", signrawtransactionwithwallet, {"hextring","prevtxs","sighashtype"} },
     { "wallet",             "unloadwallet",                 unloadwallet,                 {"wallet_name"} },
     { "wallet",             "walletcreatefundedpsbt",       walletcreatefundedpsbt,       {"inputs","outputs","locktime","options","bip32derivs"} },
     { "wallet",             "walletlock",                   walletlock,                   {} },
     { "wallet",             "walletpassphrase",             walletpassphrase,             {"passphrase","timeout"} },
     { "wallet",             "walletpassphrasechange",       walletpassphrasechange,       {"oldpassphrase","newpassphrase"} },
     { "wallet",             "walletprocesspsbt",            walletprocesspsbt,            {"psbt","sign","sighashtype","bip32derivs"} },
 };
 // clang-format on
 
 void RegisterWalletRPCCommands(CRPCTable &t) {
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/src/wallet/test/psbt_wallet_tests.cpp b/src/wallet/test/psbt_wallet_tests.cpp
index d73bce39a..0041a3e7c 100644
--- a/src/wallet/test/psbt_wallet_tests.cpp
+++ b/src/wallet/test/psbt_wallet_tests.cpp
@@ -1,212 +1,214 @@
 // Copyright (c) 2017 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <key_io.h>
 #include <util/strencodings.h>
 #include <wallet/psbtwallet.h>
 #include <wallet/test/wallet_test_fixture.h>
 #include <wallet/wallet.h>
 
 #include <test/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(psbt_wallet_tests, WalletTestingSetup)
 
 BOOST_AUTO_TEST_CASE(psbt_updater_test) {
     LOCK(m_wallet.cs_wallet);
 
     // Create prevtxs and add to wallet
     CDataStream s_prev_tx1(
         ParseHex("020000000158e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f54"
                  "5887bb2abdd7501000000171600145f275f436b09a8cc9a2eb2a2f528485c"
                  "68a56323feffffff02d8231f1b0100000017a914aed962d6654f9a2b36608"
                  "eb9d64d2b260db4f1118700c2eb0b0000000017a914f6539307e3a48d1e01"
                  "36d061f5d1fe19e1a240898765000000"),
         SER_NETWORK, PROTOCOL_VERSION);
 
     CTransactionRef prev_tx1;
     s_prev_tx1 >> prev_tx1;
     CWalletTx prev_wtx1(&m_wallet, prev_tx1);
     m_wallet.mapWallet.emplace(prev_wtx1.GetId(), std::move(prev_wtx1));
 
     CDataStream s_prev_tx2(
         ParseHex(
             "0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71"
             "ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd3013"
             "5aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f"
             "0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9"
             "463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74"
             "f8a08f81999428185c97b5d852e4063f618765000000"),
         SER_NETWORK, PROTOCOL_VERSION);
     CTransactionRef prev_tx2;
     s_prev_tx2 >> prev_tx2;
     CWalletTx prev_wtx2(&m_wallet, prev_tx2);
     m_wallet.mapWallet.emplace(prev_wtx2.GetId(), std::move(prev_wtx2));
 
     // Add scripts
     CScript rs1;
     CDataStream s_rs1(
         ParseHex("475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c218"
                  "3f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54"
                  "dae4dba2fbfef536d752ae"),
         SER_NETWORK, PROTOCOL_VERSION);
     s_rs1 >> rs1;
     m_wallet.AddCScript(rs1);
 
     CScript rs2;
     CDataStream s_rs2(
         ParseHex("47522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1"
                  "b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e8"
                  "6151926860221f0e7352ae"),
         SER_NETWORK, PROTOCOL_VERSION);
     s_rs2 >> rs2;
     m_wallet.AddCScript(rs2);
 
     // Add hd seed
     // Mainnet and uncompressed form of
     // cUkG8i1RFfWGWy5ziR11zJ5V4U4W3viSFCfyJmZnvQaUsd1xuF3T
     CKey key =
         DecodeSecret("5KSSJQ7UNfFGwVgpCZDSHm5rVNhMFcFtvWM3zQ8mW4qNDEN7LFd");
     CPubKey master_pub_key = m_wallet.DeriveNewSeed(key);
     m_wallet.SetHDSeed(master_pub_key);
     m_wallet.NewKeyPool();
 
     // Call FillPSBT
     PartiallySignedTransaction psbtx;
     CDataStream ssData(
         ParseHex("70736274ff0100a0020000000258e87a21b56daf0c23be8e7070456c336f7"
                  "cbaa5c8757924f545887bb2abdd750000000000ffffffff6b04ec37326fba"
                  "c8e468a73bf952c8877f84f96c3f9deadeab246455e34fe0cd0100000000f"
                  "fffffff0270aaf008000000001976a914d85c2b71d0060b09c9886aeb815e"
                  "50991dda124d88ac00e1f505000000001976a91400aea9a2e5f0f876a588d"
                  "f5546e8742d1d87008f88ac000000000000000000"),
         SER_NETWORK, PROTOCOL_VERSION);
     ssData >> psbtx;
 
     // FIXME: input 2 hd path is missing.
     // The path missing comes from the HD masterkey.
 
     // Fill transaction with our data
-    FillPSBT(&m_wallet, psbtx, SigHashType(), false, true);
+    TransactionError err;
+    bool complete = true;
+    FillPSBT(&m_wallet, psbtx, err, complete, SigHashType(), false, true);
 
     // Get the final tx
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
     std::string final_hex = HexStr(ssTx.begin(), ssTx.end());
     BOOST_CHECK_EQUAL(
         final_hex,
         "70736274ff0100a0020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c875"
         "7924f545887bb2abdd750000000000ffffffff6b04ec37326fbac8e468a73bf952c887"
         "7f84f96c3f9deadeab246455e34fe0cd0100000000ffffffff0270aaf0080000000019"
         "76a914d85c2b71d0060b09c9886aeb815e50991dda124d88ac00e1f505000000001976"
         "a91400aea9a2e5f0f876a588df5546e8742d1d87008f88ac000000000001002080f0fa"
         "020000000017a9140fb9463421696b82c833af241c78c17ddbde493487010447522102"
         "9583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102da"
         "b61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae2206"
         "029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f10d9"
         "0c6a4f000000800000008000000080220602dab61ff49a14db6a7d02b0cd1fbb78fc4b"
         "18312b5b4e54dae4dba2fbfef536d710d90c6a4f000000800000008001000080000100"
         "2000c2eb0b0000000017a914f6539307e3a48d1e0136d061f5d1fe19e1a24089870104"
         "47522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02"
         "dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e73"
         "52ae2206023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f"
         "0e7310d90c6a4f000000800000008003000080220603089dc10c7ac6db54f91329af61"
         "7333db388cead0c231f723379d1b99030b02dc10d90c6a4f0000008000000080020000"
         "8000220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5"
         "877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02"
         "c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500"
         "008000");
 }
 
 BOOST_AUTO_TEST_CASE(parse_hd_keypath) {
     std::vector<uint32_t> keypath;
 
     BOOST_CHECK(ParseHDKeypath(
         "1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1", keypath));
     BOOST_CHECK(!ParseHDKeypath("///////////////////////////", keypath));
 
     BOOST_CHECK(ParseHDKeypath(
         "1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1'/1", keypath));
     BOOST_CHECK(!ParseHDKeypath("//////////////////////////'/", keypath));
 
     BOOST_CHECK(ParseHDKeypath(
         "1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/", keypath));
     BOOST_CHECK(!ParseHDKeypath("1///////////////////////////", keypath));
 
     BOOST_CHECK(ParseHDKeypath(
         "1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1'/", keypath));
     BOOST_CHECK(!ParseHDKeypath("1/'//////////////////////////", keypath));
 
     BOOST_CHECK(ParseHDKeypath("", keypath));
     BOOST_CHECK(!ParseHDKeypath(" ", keypath));
 
     BOOST_CHECK(ParseHDKeypath("0", keypath));
     BOOST_CHECK(!ParseHDKeypath("O", keypath));
 
     BOOST_CHECK(ParseHDKeypath("0000'/0000'/0000'", keypath));
     BOOST_CHECK(!ParseHDKeypath("0000,/0000,/0000,", keypath));
 
     BOOST_CHECK(ParseHDKeypath("01234", keypath));
     BOOST_CHECK(!ParseHDKeypath("0x1234", keypath));
 
     BOOST_CHECK(ParseHDKeypath("1", keypath));
     BOOST_CHECK(!ParseHDKeypath(" 1", keypath));
 
     BOOST_CHECK(ParseHDKeypath("42", keypath));
     BOOST_CHECK(!ParseHDKeypath("m42", keypath));
 
     // 4294967295 == 0xFFFFFFFF (uint32_t max)
     BOOST_CHECK(ParseHDKeypath("4294967295", keypath));
     // 4294967296 == 0xFFFFFFFF (uint32_t max) + 1
     BOOST_CHECK(!ParseHDKeypath("4294967296", keypath));
 
     BOOST_CHECK(ParseHDKeypath("m", keypath));
     BOOST_CHECK(!ParseHDKeypath("n", keypath));
 
     BOOST_CHECK(ParseHDKeypath("m/", keypath));
     BOOST_CHECK(!ParseHDKeypath("n/", keypath));
 
     BOOST_CHECK(ParseHDKeypath("m/0", keypath));
     BOOST_CHECK(!ParseHDKeypath("n/0", keypath));
 
     BOOST_CHECK(ParseHDKeypath("m/0'", keypath));
     BOOST_CHECK(!ParseHDKeypath("m/0''", keypath));
 
     BOOST_CHECK(ParseHDKeypath("m/0'/0'", keypath));
     BOOST_CHECK(!ParseHDKeypath("m/'0/0'", keypath));
 
     BOOST_CHECK(ParseHDKeypath("m/0/0", keypath));
     BOOST_CHECK(!ParseHDKeypath("n/0/0", keypath));
 
     BOOST_CHECK(ParseHDKeypath("m/0/0/00", keypath));
     BOOST_CHECK(!ParseHDKeypath("m/0/0/f00", keypath));
 
     BOOST_CHECK(ParseHDKeypath("m/0/0/"
                                "00000000000000000000000000000000000000000000000"
                                "0000000000000000000000000000000000000",
                                keypath));
     BOOST_CHECK(!ParseHDKeypath("m/1/1/"
                                 "1111111111111111111111111111111111111111111111"
                                 "11111111111111111111111111111111111111",
                                 keypath));
 
     BOOST_CHECK(ParseHDKeypath("m/0/00/0", keypath));
     BOOST_CHECK(!ParseHDKeypath("m/0'/00/'0", keypath));
 
     BOOST_CHECK(ParseHDKeypath("m/1/", keypath));
     BOOST_CHECK(!ParseHDKeypath("m/1//", keypath));
 
     // 4294967295 == 0xFFFFFFFF (uint32_t max)
     BOOST_CHECK(ParseHDKeypath("m/0/4294967295", keypath));
     // 4294967296 == 0xFFFFFFFF (uint32_t max) + 1
     BOOST_CHECK(!ParseHDKeypath("m/0/4294967296", keypath));
 
     // 4294967295 == 0xFFFFFFFF (uint32_t max)
     BOOST_CHECK(ParseHDKeypath("m/4294967295", keypath));
     // 4294967296 == 0xFFFFFFFF (uint32_t max) + 1
     BOOST_CHECK(!ParseHDKeypath("m/4294967296", keypath));
 }
 
 BOOST_AUTO_TEST_SUITE_END()