diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index 5d1f063a1..3f90976cc 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -1,588 +1,593 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <interfaces/wallet.h>
 
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/amount.h>
 #include <consensus/validation.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
 #include <script/standard.h>
 #include <support/allocators/secure.h>
 #include <sync.h>
 #include <util/check.h>
 #include <util/system.h>
 #include <util/ui_change_type.h>
 #include <wallet/context.h>
 #include <wallet/fees.h>
 #include <wallet/ismine.h>
 #include <wallet/load.h>
 #include <wallet/receive.h>
 #include <wallet/rpc/backup.h>
 #include <wallet/rpc/encrypt.h>
 #include <wallet/spend.h>
 #include <wallet/wallet.h>
 
 using interfaces::Chain;
 using interfaces::FoundBlock;
 using interfaces::Handler;
 using interfaces::MakeHandler;
 using interfaces::Wallet;
 using interfaces::WalletAddress;
 using interfaces::WalletBalances;
 using interfaces::WalletClient;
 using interfaces::WalletOrderForm;
 using interfaces::WalletTx;
 using interfaces::WalletTxOut;
 using interfaces::WalletTxStatus;
 using interfaces::WalletValueMap;
 
 namespace wallet {
 namespace {
 
     //! Construct wallet tx struct.
     WalletTx MakeWalletTx(CWallet &wallet, const CWalletTx &wtx) {
         LOCK(wallet.cs_wallet);
         WalletTx result;
         result.tx = wtx.tx;
         result.txin_is_mine.reserve(wtx.tx->vin.size());
         for (const auto &txin : wtx.tx->vin) {
             result.txin_is_mine.emplace_back(InputIsMine(wallet, txin));
         }
         result.txout_is_mine.reserve(wtx.tx->vout.size());
         result.txout_address.reserve(wtx.tx->vout.size());
         result.txout_address_is_mine.reserve(wtx.tx->vout.size());
         for (const auto &txout : wtx.tx->vout) {
             result.txout_is_mine.emplace_back(wallet.IsMine(txout));
             result.txout_address.emplace_back();
             result.txout_address_is_mine.emplace_back(
                 ExtractDestination(txout.scriptPubKey,
                                    result.txout_address.back())
                     ? wallet.IsMine(result.txout_address.back())
                     : ISMINE_NO);
         }
         result.credit = CachedTxGetCredit(wallet, wtx, ISMINE_ALL);
         result.debit = CachedTxGetDebit(wallet, wtx, ISMINE_ALL);
         result.change = CachedTxGetChange(wallet, wtx);
         result.time = wtx.GetTxTime();
         result.value_map = wtx.mapValue;
         result.is_coinbase = wtx.IsCoinBase();
         return result;
     }
 
     //! Construct wallet tx status struct.
     WalletTxStatus MakeWalletTxStatus(const CWallet &wallet,
-                                      const CWalletTx &wtx) {
+                                      const CWalletTx &wtx)
+        EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) {
+        AssertLockHeld(wallet.cs_wallet);
+
         WalletTxStatus result;
         result.block_height = wtx.m_confirm.block_height > 0
                                   ? wtx.m_confirm.block_height
                                   : std::numeric_limits<int>::max();
         result.blocks_to_maturity = wallet.GetTxBlocksToMaturity(wtx);
         result.depth_in_main_chain = wallet.GetTxDepthInMainChain(wtx);
         result.time_received = wtx.nTimeReceived;
         result.lock_time = wtx.tx->nLockTime;
         TxValidationState state;
         result.is_final =
             wallet.chain().contextualCheckTransactionForCurrentBlock(*wtx.tx,
                                                                      state);
         result.is_trusted = CachedTxIsTrusted(wallet, wtx);
         result.is_abandoned = wtx.isAbandoned();
         result.is_coinbase = wtx.IsCoinBase();
         result.is_in_main_chain = wallet.IsTxInMainChain(wtx);
         return result;
     }
 
     //! Construct wallet TxOut struct.
     WalletTxOut MakeWalletTxOut(const CWallet &wallet, const CWalletTx &wtx,
                                 int n, int depth)
         EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) {
+        AssertLockHeld(wallet.cs_wallet);
+
         WalletTxOut result;
         result.txout = wtx.tx->vout[n];
         result.time = wtx.GetTxTime();
         result.depth_in_main_chain = depth;
         result.is_spent = wallet.IsSpent(COutPoint(wtx.GetId(), n));
         return result;
     }
 
     class WalletImpl : public Wallet {
     public:
         explicit WalletImpl(const std::shared_ptr<CWallet> &wallet)
             : m_wallet(wallet) {}
 
         bool encryptWallet(const SecureString &wallet_passphrase) override {
             return m_wallet->EncryptWallet(wallet_passphrase);
         }
         bool isCrypted() override { return m_wallet->IsCrypted(); }
         bool lock() override { return m_wallet->Lock(); }
         bool unlock(const SecureString &wallet_passphrase) override {
             return m_wallet->Unlock(wallet_passphrase);
         }
         bool isLocked() override { return m_wallet->IsLocked(); }
         bool changeWalletPassphrase(
             const SecureString &old_wallet_passphrase,
             const SecureString &new_wallet_passphrase) override {
             return m_wallet->ChangeWalletPassphrase(old_wallet_passphrase,
                                                     new_wallet_passphrase);
         }
         void abortRescan() override { m_wallet->AbortRescan(); }
         bool backupWallet(const std::string &filename) override {
             return m_wallet->BackupWallet(filename);
         }
         std::string getWalletName() override { return m_wallet->GetName(); }
         std::set<CTxDestination>
         getLabelAddresses(const std::string &label) override {
             return m_wallet->GetLabelAddresses(label);
         };
         bool getNewDestination(const OutputType type, const std::string label,
                                CTxDestination &dest) override {
             LOCK(m_wallet->cs_wallet);
             std::string error;
             return m_wallet->GetNewDestination(type, label, dest, error);
         }
         const CChainParams &getChainParams() override {
             return m_wallet->GetChainParams();
         }
         bool getPubKey(const CScript &script, const CKeyID &address,
                        CPubKey &pub_key) override {
             std::unique_ptr<SigningProvider> provider =
                 m_wallet->GetSolvingProvider(script);
             if (provider) {
                 return provider->GetPubKey(address, pub_key);
             }
             return false;
         }
         SigningResult signMessage(const std::string &message,
                                   const PKHash &pkhash,
                                   std::string &str_sig) override {
             return m_wallet->SignMessage(message, pkhash, str_sig);
         }
         bool isSpendable(const CTxDestination &dest) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->IsMine(dest) & ISMINE_SPENDABLE;
         }
         bool haveWatchOnly() override {
             auto spk_man = m_wallet->GetLegacyScriptPubKeyMan();
             if (spk_man) {
                 return spk_man->HaveWatchOnly();
             }
             return false;
         };
         bool setAddressBook(const CTxDestination &dest, const std::string &name,
                             const std::string &purpose) override {
             return m_wallet->SetAddressBook(dest, name, purpose);
         }
         bool delAddressBook(const CTxDestination &dest) override {
             return m_wallet->DelAddressBook(dest);
         }
         bool getAddress(const CTxDestination &dest, std::string *name,
                         isminetype *is_mine, std::string *purpose) override {
             LOCK(m_wallet->cs_wallet);
             auto it = m_wallet->m_address_book.find(dest);
             if (it == m_wallet->m_address_book.end() || it->second.IsChange()) {
                 return false;
             }
             if (name) {
                 *name = it->second.GetLabel();
             }
             if (is_mine) {
                 *is_mine = m_wallet->IsMine(dest);
             }
             if (purpose) {
                 *purpose = it->second.purpose;
             }
             return true;
         }
         std::vector<WalletAddress> getAddresses() override {
             LOCK(m_wallet->cs_wallet);
             std::vector<WalletAddress> result;
             for (const auto &item : m_wallet->m_address_book) {
                 if (item.second.IsChange()) {
                     continue;
                 }
                 result.emplace_back(item.first, m_wallet->IsMine(item.first),
                                     item.second.GetLabel(),
                                     item.second.purpose);
             }
             return result;
         }
         bool addDestData(const CTxDestination &dest, const std::string &key,
                          const std::string &value) override {
             LOCK(m_wallet->cs_wallet);
             WalletBatch batch{m_wallet->GetDatabase()};
             return m_wallet->AddDestData(batch, dest, key, value);
         }
         bool eraseDestData(const CTxDestination &dest,
                            const std::string &key) override {
             LOCK(m_wallet->cs_wallet);
             WalletBatch batch{m_wallet->GetDatabase()};
             return m_wallet->EraseDestData(batch, dest, key);
         }
         std::vector<std::string>
         getDestValues(const std::string &prefix) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->GetDestValues(prefix);
         }
         void lockCoin(const COutPoint &output) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->LockCoin(output);
         }
         void unlockCoin(const COutPoint &output) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->UnlockCoin(output);
         }
         bool isLockedCoin(const COutPoint &output) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->IsLockedCoin(output);
         }
         void listLockedCoins(std::vector<COutPoint> &outputs) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->ListLockedCoins(outputs);
         }
         CTransactionRef
         createTransaction(const std::vector<CRecipient> &recipients,
                           const CCoinControl &coin_control, bool sign,
                           int &change_pos, Amount &fee,
                           bilingual_str &fail_reason) override {
             LOCK(m_wallet->cs_wallet);
             CTransactionRef tx;
             if (!CreateTransaction(*m_wallet, recipients, tx, fee, change_pos,
                                    fail_reason, coin_control, sign)) {
                 return {};
             }
             return tx;
         }
         void commitTransaction(CTransactionRef tx, WalletValueMap value_map,
                                WalletOrderForm order_form) override {
             LOCK(m_wallet->cs_wallet);
             m_wallet->CommitTransaction(std::move(tx), std::move(value_map),
                                         std::move(order_form));
         }
         bool transactionCanBeAbandoned(const TxId &txid) override {
             return m_wallet->TransactionCanBeAbandoned(txid);
         }
         bool abandonTransaction(const TxId &txid) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->AbandonTransaction(txid);
         }
         CTransactionRef getTx(const TxId &txid) override {
             LOCK(m_wallet->cs_wallet);
             auto mi = m_wallet->mapWallet.find(txid);
             if (mi != m_wallet->mapWallet.end()) {
                 return mi->second.tx;
             }
             return {};
         }
         WalletTx getWalletTx(const TxId &txid) override {
             LOCK(m_wallet->cs_wallet);
             auto mi = m_wallet->mapWallet.find(txid);
             if (mi != m_wallet->mapWallet.end()) {
                 return MakeWalletTx(*m_wallet, mi->second);
             }
             return {};
         }
         std::vector<WalletTx> getWalletTxs() override {
             LOCK(m_wallet->cs_wallet);
             std::vector<WalletTx> result;
             result.reserve(m_wallet->mapWallet.size());
             for (const auto &entry : m_wallet->mapWallet) {
                 result.emplace_back(MakeWalletTx(*m_wallet, entry.second));
             }
             return result;
         }
         bool tryGetTxStatus(const TxId &txid,
                             interfaces::WalletTxStatus &tx_status,
                             int &num_blocks, int64_t &block_time) override {
             TRY_LOCK(m_wallet->cs_wallet, locked_wallet);
             if (!locked_wallet) {
                 return false;
             }
             auto mi = m_wallet->mapWallet.find(txid);
             if (mi == m_wallet->mapWallet.end()) {
                 return false;
             }
             num_blocks = m_wallet->GetLastBlockHeight();
             block_time = -1;
             CHECK_NONFATAL(m_wallet->chain().findBlock(
                 m_wallet->GetLastBlockHash(), FoundBlock().time(block_time)));
             tx_status = MakeWalletTxStatus(*m_wallet, mi->second);
             return true;
         }
         WalletTx getWalletTxDetails(const TxId &txid, WalletTxStatus &tx_status,
                                     WalletOrderForm &order_form,
                                     bool &in_mempool,
                                     int &num_blocks) override {
             LOCK(m_wallet->cs_wallet);
             auto mi = m_wallet->mapWallet.find(txid);
             if (mi != m_wallet->mapWallet.end()) {
                 num_blocks = m_wallet->GetLastBlockHeight();
                 in_mempool = mi->second.InMempool();
                 order_form = mi->second.vOrderForm;
                 tx_status = MakeWalletTxStatus(*m_wallet, mi->second);
                 return MakeWalletTx(*m_wallet, mi->second);
             }
             return {};
         }
         TransactionError fillPSBT(SigHashType sighash_type, bool sign,
                                   bool bip32derivs,
                                   PartiallySignedTransaction &psbtx,
                                   bool &complete) const override {
             return m_wallet->FillPSBT(psbtx, complete, sighash_type, sign,
                                       bip32derivs);
         }
         WalletBalances getBalances() override {
             const auto bal = GetBalance(*m_wallet);
             WalletBalances result;
             result.balance = bal.m_mine_trusted;
             result.unconfirmed_balance = bal.m_mine_untrusted_pending;
             result.immature_balance = bal.m_mine_immature;
             result.have_watch_only = haveWatchOnly();
             if (result.have_watch_only) {
                 result.watch_only_balance = bal.m_watchonly_trusted;
                 result.unconfirmed_watch_only_balance =
                     bal.m_watchonly_untrusted_pending;
                 result.immature_watch_only_balance = bal.m_watchonly_immature;
             }
             return result;
         }
         bool tryGetBalances(WalletBalances &balances,
                             BlockHash &block_hash) override {
             TRY_LOCK(m_wallet->cs_wallet, locked_wallet);
             if (!locked_wallet) {
                 return false;
             }
             block_hash = m_wallet->GetLastBlockHash();
             balances = getBalances();
             return true;
         }
         Amount getBalance() override {
             return GetBalance(*m_wallet).m_mine_trusted;
         }
         Amount getAvailableBalance(const CCoinControl &coin_control) override {
             return GetAvailableBalance(*m_wallet, &coin_control);
         }
         isminetype txinIsMine(const CTxIn &txin) override {
             LOCK(m_wallet->cs_wallet);
             return InputIsMine(*m_wallet, txin);
         }
         isminetype txoutIsMine(const CTxOut &txout) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->IsMine(txout);
         }
         Amount getDebit(const CTxIn &txin, isminefilter filter) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->GetDebit(txin, filter);
         }
         Amount getCredit(const CTxOut &txout, isminefilter filter) override {
             LOCK(m_wallet->cs_wallet);
             return OutputGetCredit(*m_wallet, txout, filter);
         }
         CoinsList listCoins() override {
             LOCK(m_wallet->cs_wallet);
             CoinsList result;
             for (const auto &entry : ListCoins(*m_wallet)) {
                 auto &group = result[entry.first];
                 for (const auto &coin : entry.second) {
                     group.emplace_back(COutPoint(coin.tx->GetId(), coin.i),
                                        MakeWalletTxOut(*m_wallet, *coin.tx,
                                                        coin.i, coin.nDepth));
                 }
             }
             return result;
         }
         std::vector<WalletTxOut>
         getCoins(const std::vector<COutPoint> &outputs) override {
             LOCK(m_wallet->cs_wallet);
             std::vector<WalletTxOut> result;
             result.reserve(outputs.size());
             for (const auto &output : outputs) {
                 result.emplace_back();
                 auto it = m_wallet->mapWallet.find(output.GetTxId());
                 if (it != m_wallet->mapWallet.end()) {
                     int depth = m_wallet->GetTxDepthInMainChain(it->second);
                     if (depth >= 0) {
                         result.back() = MakeWalletTxOut(*m_wallet, it->second,
                                                         output.GetN(), depth);
                     }
                 }
             }
             return result;
         }
         bool hdEnabled() override { return m_wallet->IsHDEnabled(); }
         OutputType getDefaultAddressType() override {
             return m_wallet->m_default_address_type;
         }
         bool canGetAddresses() const override {
             return m_wallet->CanGetAddresses();
         }
         bool privateKeysDisabled() override {
             return m_wallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
         }
         Amount getDefaultMaxTxFee() override {
             return m_wallet->m_default_max_tx_fee;
         }
         void remove() override {
             RemoveWallet(m_wallet, false /* load_on_start */);
         }
         bool isLegacy() override { return m_wallet->IsLegacy(); }
         std::unique_ptr<Handler> handleUnload(UnloadFn fn) override {
             return MakeHandler(m_wallet->NotifyUnload.connect(fn));
         }
         std::unique_ptr<Handler>
         handleShowProgress(ShowProgressFn fn) override {
             return MakeHandler(m_wallet->ShowProgress.connect(fn));
         }
         std::unique_ptr<Handler>
         handleStatusChanged(StatusChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyStatusChanged.connect(
                 [fn](CWallet *) { fn(); }));
         }
         std::unique_ptr<Handler>
         handleAddressBookChanged(AddressBookChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyAddressBookChanged.connect(
                 [fn](CWallet *, const CTxDestination &address,
                      const std::string &label, bool is_mine,
                      const std::string &purpose, ChangeType status) {
                     fn(address, label, is_mine, purpose, status);
                 }));
         }
         std::unique_ptr<Handler>
         handleTransactionChanged(TransactionChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyTransactionChanged.connect(
                 [fn](CWallet *, const TxId &txid, ChangeType status) {
                     fn(txid, status);
                 }));
         }
         std::unique_ptr<Handler>
         handleWatchOnlyChanged(WatchOnlyChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyWatchonlyChanged.connect(fn));
         }
         std::unique_ptr<Handler>
         handleCanGetAddressesChanged(CanGetAddressesChangedFn fn) override {
             return MakeHandler(
                 m_wallet->NotifyCanGetAddressesChanged.connect(fn));
         }
         Amount getRequiredFee(unsigned int tx_bytes) override {
             return GetRequiredFee(*m_wallet, tx_bytes);
         }
         Amount getMinimumFee(unsigned int tx_bytes,
                              const CCoinControl &coin_control) override {
             return GetMinimumFee(*m_wallet, tx_bytes, coin_control);
         }
         CWallet *wallet() override { return m_wallet.get(); }
 
         std::shared_ptr<CWallet> m_wallet;
     };
 
     class WalletClientImpl : public WalletClient {
     public:
         WalletClientImpl(Chain &chain, ArgsManager &args) {
             m_context.chain = &chain;
             m_context.args = &args;
         }
         ~WalletClientImpl() override { UnloadWallets(); }
 
         //! ChainClient methods
         void registerRpcs(const Span<const CRPCCommand> &commands) {
             for (const CRPCCommand &command : commands) {
                 m_rpc_commands.emplace_back(
                     command.category, command.name,
                     [this, &command](const Config &config,
                                      const JSONRPCRequest &request,
                                      UniValue &result, bool last_handler) {
                         JSONRPCRequest wallet_request = request;
                         wallet_request.context = &m_context;
                         return command.actor(config, wallet_request, result,
                                              last_handler);
                     },
                     command.argNames, command.unique_id);
                 m_rpc_handlers.emplace_back(
                     m_context.chain->handleRpc(m_rpc_commands.back()));
             }
         }
 
         void registerRpcs() override {
             registerRpcs(GetWalletRPCCommands());
             registerRpcs(GetWalletDumpRPCCommands());
             registerRpcs(GetWalletEncryptRPCCommands());
         }
         bool verify() override { return VerifyWallets(*m_context.chain); }
         bool load() override { return LoadWallets(*m_context.chain); }
         void start(CScheduler &scheduler) override {
             return StartWallets(scheduler, *Assert(m_context.args));
         }
         void flush() override { return FlushWallets(); }
         void stop() override { return StopWallets(); }
         void setMockTime(int64_t time) override { return SetMockTime(time); }
 
         //! WalletClient methods
         std::unique_ptr<Wallet>
         createWallet(const std::string &name, const SecureString &passphrase,
                      uint64_t wallet_creation_flags, bilingual_str &error,
                      std::vector<bilingual_str> &warnings) override {
             std::shared_ptr<CWallet> wallet;
             DatabaseOptions options;
             DatabaseStatus status;
             options.require_create = true;
             options.create_flags = wallet_creation_flags;
             options.create_passphrase = passphrase;
 
             return MakeWallet(CreateWallet(*m_context.chain, name,
                                            true /* load_on_start */, options,
                                            status, error, warnings));
         }
         std::unique_ptr<Wallet>
         loadWallet(const std::string &name, bilingual_str &error,
                    std::vector<bilingual_str> &warnings) override {
             DatabaseOptions options;
             DatabaseStatus status;
             options.require_existing = true;
             return MakeWallet(LoadWallet(*m_context.chain, name,
                                          true /* load_on_start */, options,
                                          status, error, warnings));
         }
         std::string getWalletDir() override {
             return fs::PathToString(GetWalletDir());
         }
         std::vector<std::string> listWalletDir() override {
             std::vector<std::string> paths;
             for (auto &path : ListWalletDir()) {
                 paths.push_back(fs::PathToString(path));
             }
             return paths;
         }
 
         std::vector<std::unique_ptr<Wallet>> getWallets() override {
             std::vector<std::unique_ptr<Wallet>> wallets;
             for (const auto &wallet : GetWallets()) {
                 wallets.emplace_back(MakeWallet(wallet));
             }
             return wallets;
         }
 
         std::unique_ptr<Handler> handleLoadWallet(LoadWalletFn fn) override {
             return HandleLoadWallet(std::move(fn));
         }
 
         WalletContext m_context;
         const std::vector<std::string> m_wallet_filenames;
         std::vector<std::unique_ptr<Handler>> m_rpc_handlers;
         std::list<CRPCCommand> m_rpc_commands;
     };
 } // namespace
 } // namespace wallet
 
 namespace interfaces {
 std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet> &wallet) {
     return wallet ? std::make_unique<wallet::WalletImpl>(wallet) : nullptr;
 }
 
 std::unique_ptr<WalletClient> MakeWalletClient(Chain &chain,
                                                ArgsManager &args) {
     return std::make_unique<wallet::WalletClientImpl>(chain, args);
 }
 } // namespace interfaces
diff --git a/src/wallet/receive.cpp b/src/wallet/receive.cpp
index be5121046..a2691845e 100644
--- a/src/wallet/receive.cpp
+++ b/src/wallet/receive.cpp
@@ -1,554 +1,562 @@
 // Copyright (c) 2021 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/receive.h>
 
 #include <consensus/validation.h>
 #include <wallet/transaction.h>
 #include <wallet/wallet.h>
 
 isminetype InputIsMine(const CWallet &wallet, const CTxIn &txin) {
     AssertLockHeld(wallet.cs_wallet);
     std::map<TxId, CWalletTx>::const_iterator mi =
         wallet.mapWallet.find(txin.prevout.GetTxId());
     if (mi != wallet.mapWallet.end()) {
         const CWalletTx &prev = (*mi).second;
         if (txin.prevout.GetN() < prev.tx->vout.size()) {
             return wallet.IsMine(prev.tx->vout[txin.prevout.GetN()]);
         }
     }
 
     return ISMINE_NO;
 }
 
 bool AllInputsMine(const CWallet &wallet, const CTransaction &tx,
                    const isminefilter &filter) {
     LOCK(wallet.cs_wallet);
 
     for (const CTxIn &txin : tx.vin) {
         auto mi = wallet.mapWallet.find(txin.prevout.GetTxId());
         if (mi == wallet.mapWallet.end()) {
             // Any unknown inputs can't be from us.
             return false;
         }
 
         const CWalletTx &prev = (*mi).second;
 
         if (txin.prevout.GetN() >= prev.tx->vout.size()) {
             // Invalid input!
             return false;
         }
 
         if (!(wallet.IsMine(prev.tx->vout[txin.prevout.GetN()]) & filter)) {
             return false;
         }
     }
 
     return true;
 }
 
 Amount OutputGetCredit(const CWallet &wallet, const CTxOut &txout,
                        const isminefilter &filter) {
     if (!MoneyRange(txout.nValue)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": value out of range");
     }
     LOCK(wallet.cs_wallet);
     return ((wallet.IsMine(txout) & filter) ? txout.nValue : Amount::zero());
 }
 
 Amount TxGetCredit(const CWallet &wallet, const CTransaction &tx,
                    const isminefilter &filter) {
     Amount nCredit = Amount::zero();
     for (const CTxOut &txout : tx.vout) {
         nCredit += OutputGetCredit(wallet, txout, filter);
         if (!MoneyRange(nCredit)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": value out of range");
         }
     }
 
     return nCredit;
 }
 
 bool ScriptIsChange(const CWallet &wallet, const CScript &script) {
     // TODO: fix handling of 'change' outputs. The assumption is that any
     // payment to a script that is ours, but is not in the address book is
     // change. That assumption is likely to break when we implement
     // multisignature wallets that return change back into a
     // multi-signature-protected address; a better way of identifying which
     // outputs are 'the send' and which are 'the change' will need to be
     // implemented (maybe extend CWalletTx to remember which output, if any, was
     // change).
     AssertLockHeld(wallet.cs_wallet);
     if (wallet.IsMine(script)) {
         CTxDestination address;
         if (!ExtractDestination(script, address)) {
             return true;
         }
         if (!wallet.FindAddressBookEntry(address)) {
             return true;
         }
     }
 
     return false;
 }
 
 bool OutputIsChange(const CWallet &wallet, const CTxOut &txout) {
     return ScriptIsChange(wallet, txout.scriptPubKey);
 }
 
 Amount OutputGetChange(const CWallet &wallet, const CTxOut &txout) {
     AssertLockHeld(wallet.cs_wallet);
     if (!MoneyRange(txout.nValue)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": value out of range");
     }
     return (OutputIsChange(wallet, txout) ? txout.nValue : Amount::zero());
 }
 
 Amount TxGetChange(const CWallet &wallet, const CTransaction &tx) {
     LOCK(wallet.cs_wallet);
     Amount nChange = Amount::zero();
     for (const CTxOut &txout : tx.vout) {
         nChange += OutputGetChange(wallet, txout);
         if (!MoneyRange(nChange)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": value out of range");
         }
     }
 
     return nChange;
 }
 
 static Amount GetCachableAmount(const CWallet &wallet, const CWalletTx &wtx,
                                 CWalletTx::AmountType type,
                                 const isminefilter &filter,
                                 bool recalculate = false) {
     auto &amount = wtx.m_amounts[type];
     if (recalculate || !amount.m_cached[filter]) {
         amount.Set(filter, type == CWalletTx::DEBIT
                                ? wallet.GetDebit(*wtx.tx, filter)
                                : TxGetCredit(wallet, *wtx.tx, filter));
         wtx.m_is_cache_empty = false;
     }
     return amount.m_value[filter];
 }
 
 Amount CachedTxGetCredit(const CWallet &wallet, const CWalletTx &wtx,
                          const isminefilter &filter) {
+    AssertLockHeld(wallet.cs_wallet);
+
     // Must wait until coinbase is safely deep enough in the chain before
     // valuing it.
     if (wallet.IsTxImmatureCoinBase(wtx)) {
         return Amount::zero();
     }
 
     Amount credit = Amount::zero();
     if (filter & ISMINE_SPENDABLE) {
         // GetBalance can assume transactions in mapWallet won't change.
         credit +=
             GetCachableAmount(wallet, wtx, CWalletTx::CREDIT, ISMINE_SPENDABLE);
     }
 
     if (filter & ISMINE_WATCH_ONLY) {
         credit += GetCachableAmount(wallet, wtx, CWalletTx::CREDIT,
                                     ISMINE_WATCH_ONLY);
     }
 
     return credit;
 }
 
 Amount CachedTxGetDebit(const CWallet &wallet, const CWalletTx &wtx,
                         const isminefilter &filter) {
     if (wtx.tx->vin.empty()) {
         return Amount::zero();
     }
 
     Amount debit = Amount::zero();
     if (filter & ISMINE_SPENDABLE) {
         debit +=
             GetCachableAmount(wallet, wtx, CWalletTx::DEBIT, ISMINE_SPENDABLE);
     }
     if (filter & ISMINE_WATCH_ONLY) {
         debit +=
             GetCachableAmount(wallet, wtx, CWalletTx::DEBIT, ISMINE_WATCH_ONLY);
     }
 
     return debit;
 }
 
 Amount CachedTxGetChange(const CWallet &wallet, const CWalletTx &wtx) {
     if (wtx.fChangeCached) {
         return wtx.nChangeCached;
     }
     wtx.nChangeCached = TxGetChange(wallet, *wtx.tx);
     wtx.fChangeCached = true;
     return wtx.nChangeCached;
 }
 
 Amount CachedTxGetImmatureCredit(const CWallet &wallet, const CWalletTx &wtx,
                                  bool fUseCache) {
+    AssertLockHeld(wallet.cs_wallet);
+
     if (wallet.IsTxImmatureCoinBase(wtx) && wallet.IsTxInMainChain(wtx)) {
         return GetCachableAmount(wallet, wtx, CWalletTx::IMMATURE_CREDIT,
                                  ISMINE_SPENDABLE, !fUseCache);
     }
 
     return Amount::zero();
 }
 
 Amount CachedTxGetImmatureWatchOnlyCredit(const CWallet &wallet,
                                           const CWalletTx &wtx,
                                           const bool fUseCache) {
+    AssertLockHeld(wallet.cs_wallet);
+
     if (wallet.IsTxImmatureCoinBase(wtx) && wallet.IsTxInMainChain(wtx)) {
         return GetCachableAmount(wallet, wtx, CWalletTx::IMMATURE_CREDIT,
                                  ISMINE_WATCH_ONLY, !fUseCache);
     }
 
     return Amount::zero();
 }
 
 Amount CachedTxGetAvailableCredit(const CWallet &wallet, const CWalletTx &wtx,
                                   bool fUseCache, const isminefilter &filter) {
+    AssertLockHeld(wallet.cs_wallet);
+
     // Avoid caching ismine for NO or ALL cases (could remove this check and
     // simplify in the future).
     bool allow_cache =
         (filter & ISMINE_ALL) && (filter & ISMINE_ALL) != ISMINE_ALL;
 
     // Must wait until coinbase is safely deep enough in the chain before
     // valuing it.
     if (wallet.IsTxImmatureCoinBase(wtx)) {
         return Amount::zero();
     }
 
     if (fUseCache && allow_cache &&
         wtx.m_amounts[CWalletTx::AVAILABLE_CREDIT].m_cached[filter]) {
         return wtx.m_amounts[CWalletTx::AVAILABLE_CREDIT].m_value[filter];
     }
 
     bool allow_used_addresses =
         (filter & ISMINE_USED) ||
         !wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE);
     Amount nCredit = Amount::zero();
     const TxId txid = wtx.GetId();
     for (uint32_t i = 0; i < wtx.tx->vout.size(); i++) {
         if (!wallet.IsSpent(COutPoint(txid, i)) &&
             (allow_used_addresses || !wallet.IsSpentKey(txid, i))) {
             const CTxOut &txout = wtx.tx->vout[i];
             nCredit += OutputGetCredit(wallet, txout, filter);
             if (!MoneyRange(nCredit)) {
                 throw std::runtime_error(std::string(__func__) +
                                          " : value out of range");
             }
         }
     }
 
     if (allow_cache) {
         wtx.m_amounts[CWalletTx::AVAILABLE_CREDIT].Set(filter, nCredit);
         wtx.m_is_cache_empty = false;
     }
 
     return nCredit;
 }
 
 void CachedTxGetAmounts(const CWallet &wallet, const CWalletTx &wtx,
                         std::list<COutputEntry> &listReceived,
                         std::list<COutputEntry> &listSent, Amount &nFee,
                         const isminefilter &filter) {
     nFee = Amount::zero();
     listReceived.clear();
     listSent.clear();
 
     // Compute fee:
     Amount nDebit = CachedTxGetDebit(wallet, wtx, filter);
     // debit>0 means we signed/sent this transaction
     if (nDebit > Amount::zero()) {
         Amount nValueOut = wtx.tx->GetValueOut();
         nFee = nDebit - nValueOut;
     }
 
     LOCK(wallet.cs_wallet);
     // Sent/received.
     for (unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {
         const CTxOut &txout = wtx.tx->vout[i];
         isminetype fIsMine = wallet.IsMine(txout);
         // Only need to handle txouts if AT LEAST one of these is true:
         //   1) they debit from us (sent)
         //   2) the output is to us (received)
         if (nDebit > Amount::zero()) {
             // Don't report 'change' txouts
             if (OutputIsChange(wallet, txout)) {
                 continue;
             }
         } else if (!(fIsMine & filter)) {
             continue;
         }
 
         // In either case, we need to get the destination address.
         CTxDestination address;
 
         if (!ExtractDestination(txout.scriptPubKey, address) &&
             !txout.scriptPubKey.IsUnspendable()) {
             wallet.WalletLogPrintf("CWalletTx::GetAmounts: Unknown transaction "
                                    "type found, txid %s\n",
                                    wtx.GetId().ToString());
             address = CNoDestination();
         }
 
         COutputEntry output = {address, txout.nValue, (int)i};
 
         // If we are debited by the transaction, add the output as a "sent"
         // entry.
         if (nDebit > Amount::zero()) {
             listSent.push_back(output);
         }
 
         // If we are receiving the output, add it as a "received" entry.
         if (fIsMine & filter) {
             listReceived.push_back(output);
         }
     }
 }
 
 bool CachedTxIsFromMe(const CWallet &wallet, const CWalletTx &wtx,
                       const isminefilter &filter) {
     return CachedTxGetDebit(wallet, wtx, filter) > Amount::zero();
 }
 
 bool CachedTxIsTrusted(const CWallet &wallet, const CWalletTx &wtx,
                        std::set<TxId> &trusted_parents) {
     AssertLockHeld(wallet.cs_wallet);
     // Quick answer in most cases
     TxValidationState state;
     if (!wallet.chain().contextualCheckTransactionForCurrentBlock(*wtx.tx,
                                                                   state)) {
         return false;
     }
 
     int nDepth = wallet.GetTxDepthInMainChain(wtx);
     if (nDepth >= 1) {
         return true;
     }
 
     if (nDepth < 0) {
         return false;
     }
 
     // using wtx's cached debit
     if (!wallet.m_spend_zero_conf_change ||
         !CachedTxIsFromMe(wallet, wtx, ISMINE_ALL)) {
         return false;
     }
 
     // Don't trust unconfirmed transactions from us unless they are in the
     // mempool.
     if (!wtx.InMempool()) {
         return false;
     }
 
     // Trusted if all inputs are from us and are in the mempool:
     for (const CTxIn &txin : wtx.tx->vin) {
         // Transactions not sent by us: not trusted
         const CWalletTx *parent = wallet.GetWalletTx(txin.prevout.GetTxId());
         if (parent == nullptr) {
             return false;
         }
 
         const CTxOut &parentOut = parent->tx->vout[txin.prevout.GetN()];
         // Check that this specific input being spent is trusted
         if (wallet.IsMine(parentOut) != ISMINE_SPENDABLE) {
             return false;
         }
         // If we've already trusted this parent, continue
         if (trusted_parents.count(parent->GetId())) {
             continue;
         }
         // Recurse to check that the parent is also trusted
         if (!CachedTxIsTrusted(wallet, *parent, trusted_parents)) {
             return false;
         }
         trusted_parents.insert(parent->GetId());
     }
 
     return true;
 }
 
 bool CachedTxIsTrusted(const CWallet &wallet, const CWalletTx &wtx) {
     std::set<TxId> trusted_parents;
     LOCK(wallet.cs_wallet);
     return CachedTxIsTrusted(wallet, wtx, trusted_parents);
 }
 
 Balance GetBalance(const CWallet &wallet, const int min_depth,
                    bool avoid_reuse) {
     Balance ret;
     isminefilter reuse_filter = avoid_reuse ? ISMINE_NO : ISMINE_USED;
     LOCK(wallet.cs_wallet);
     std::set<TxId> trusted_parents;
     for (const auto &entry : wallet.mapWallet) {
         const CWalletTx &wtx = entry.second;
         const bool is_trusted{CachedTxIsTrusted(wallet, wtx, trusted_parents)};
         const int tx_depth{wallet.GetTxDepthInMainChain(wtx)};
         const Amount tx_credit_mine{CachedTxGetAvailableCredit(
             wallet, wtx, /*fUseCache=*/true, ISMINE_SPENDABLE | reuse_filter)};
         const Amount tx_credit_watchonly{CachedTxGetAvailableCredit(
             wallet, wtx, /*fUseCache=*/true, ISMINE_WATCH_ONLY | reuse_filter)};
         if (is_trusted && tx_depth >= min_depth) {
             ret.m_mine_trusted += tx_credit_mine;
             ret.m_watchonly_trusted += tx_credit_watchonly;
         }
         if (!is_trusted && tx_depth == 0 && wtx.InMempool()) {
             ret.m_mine_untrusted_pending += tx_credit_mine;
             ret.m_watchonly_untrusted_pending += tx_credit_watchonly;
         }
         ret.m_mine_immature += CachedTxGetImmatureCredit(wallet, wtx);
         ret.m_watchonly_immature +=
             CachedTxGetImmatureWatchOnlyCredit(wallet, wtx);
     }
     return ret;
 }
 
 std::map<CTxDestination, Amount> GetAddressBalances(const CWallet &wallet) {
     std::map<CTxDestination, Amount> balances;
 
     LOCK(wallet.cs_wallet);
     std::set<TxId> trusted_parents;
     for (const auto &walletEntry : wallet.mapWallet) {
         const CWalletTx &wtx = walletEntry.second;
 
         if (!CachedTxIsTrusted(wallet, wtx, trusted_parents)) {
             continue;
         }
 
         if (wallet.IsTxImmatureCoinBase(wtx)) {
             continue;
         }
 
         int nDepth = wallet.GetTxDepthInMainChain(wtx);
         if (nDepth < (CachedTxIsFromMe(wallet, wtx, ISMINE_ALL) ? 0 : 1)) {
             continue;
         }
 
         for (uint32_t i = 0; i < wtx.tx->vout.size(); i++) {
             CTxDestination addr;
             if (!wallet.IsMine(wtx.tx->vout[i])) {
                 continue;
             }
             if (!ExtractDestination(wtx.tx->vout[i].scriptPubKey, addr)) {
                 continue;
             }
 
             Amount n = wallet.IsSpent(COutPoint(walletEntry.first, i))
                            ? Amount::zero()
                            : wtx.tx->vout[i].nValue;
             balances[addr] += n;
         }
     }
 
     return balances;
 }
 
 std::set<std::set<CTxDestination>> GetAddressGroupings(const CWallet &wallet) {
     AssertLockHeld(wallet.cs_wallet);
     std::set<std::set<CTxDestination>> groupings;
     std::set<CTxDestination> grouping;
 
     for (const auto &walletEntry : wallet.mapWallet) {
         const CWalletTx &wtx = walletEntry.second;
 
         if (wtx.tx->vin.size() > 0) {
             bool any_mine = false;
             // Group all input addresses with each other.
             for (const auto &txin : wtx.tx->vin) {
                 CTxDestination address;
                 // If this input isn't mine, ignore it.
                 if (!InputIsMine(wallet, txin)) {
                     continue;
                 }
 
                 if (!ExtractDestination(
                         wallet.mapWallet.at(txin.prevout.GetTxId())
                             .tx->vout[txin.prevout.GetN()]
                             .scriptPubKey,
                         address)) {
                     continue;
                 }
 
                 grouping.insert(address);
                 any_mine = true;
             }
 
             // Group change with input addresses.
             if (any_mine) {
                 for (const auto &txout : wtx.tx->vout) {
                     if (OutputIsChange(wallet, txout)) {
                         CTxDestination txoutAddr;
                         if (!ExtractDestination(txout.scriptPubKey,
                                                 txoutAddr)) {
                             continue;
                         }
 
                         grouping.insert(txoutAddr);
                     }
                 }
             }
 
             if (grouping.size() > 0) {
                 groupings.insert(grouping);
                 grouping.clear();
             }
         }
 
         // Group lone addrs by themselves.
         for (const auto &txout : wtx.tx->vout) {
             if (wallet.IsMine(txout)) {
                 CTxDestination address;
                 if (!ExtractDestination(txout.scriptPubKey, address)) {
                     continue;
                 }
 
                 grouping.insert(address);
                 groupings.insert(grouping);
                 grouping.clear();
             }
         }
     }
 
     // A set of pointers to groups of addresses.
     std::set<std::set<CTxDestination> *> uniqueGroupings;
     // Map addresses to the unique group containing it.
     std::map<CTxDestination, std::set<CTxDestination> *> setmap;
     for (std::set<CTxDestination> _grouping : groupings) {
         // Make a set of all the groups hit by this new group.
         std::set<std::set<CTxDestination> *> hits;
         std::map<CTxDestination, std::set<CTxDestination> *>::iterator it;
         for (const CTxDestination &address : _grouping) {
             if ((it = setmap.find(address)) != setmap.end()) {
                 hits.insert((*it).second);
             }
         }
 
         // Merge all hit groups into a new single group and delete old groups.
         std::set<CTxDestination> *merged =
             new std::set<CTxDestination>(_grouping);
         for (std::set<CTxDestination> *hit : hits) {
             merged->insert(hit->begin(), hit->end());
             uniqueGroupings.erase(hit);
             delete hit;
         }
         uniqueGroupings.insert(merged);
 
         // Update setmap.
         for (const CTxDestination &element : *merged) {
             setmap[element] = merged;
         }
     }
 
     std::set<std::set<CTxDestination>> ret;
     for (const std::set<CTxDestination> *uniqueGrouping : uniqueGroupings) {
         ret.insert(*uniqueGrouping);
         delete uniqueGrouping;
     }
 
     return ret;
 }
diff --git a/src/wallet/receive.h b/src/wallet/receive.h
index e1ddc9006..0007b1ddb 100644
--- a/src/wallet/receive.h
+++ b/src/wallet/receive.h
@@ -1,87 +1,88 @@
 // Copyright (c) 2021 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_RECEIVE_H
 #define BITCOIN_WALLET_RECEIVE_H
 
 #include <consensus/amount.h>
 #include <wallet/ismine.h>
 #include <wallet/transaction.h>
 #include <wallet/wallet.h>
 
 isminetype InputIsMine(const CWallet &wallet, const CTxIn &txin)
     EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
 
 /** Returns whether all of the inputs match the filter */
 bool AllInputsMine(const CWallet &wallet, const CTransaction &tx,
                    const isminefilter &filter);
 
 Amount OutputGetCredit(const CWallet &wallet, const CTxOut &txout,
                        const isminefilter &filter);
 Amount TxGetCredit(const CWallet &wallet, const CTransaction &tx,
                    const isminefilter &filter);
 
 bool ScriptIsChange(const CWallet &wallet, const CScript &script)
     EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
 bool OutputIsChange(const CWallet &wallet, const CTxOut &txout)
     EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
 Amount OutputGetChange(const CWallet &wallet, const CTxOut &txout)
     EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
 Amount TxGetChange(const CWallet &wallet, const CTransaction &tx);
 
 Amount CachedTxGetCredit(const CWallet &wallet, const CWalletTx &wtx,
-                         const isminefilter &filter);
+                         const isminefilter &filter)
+    EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
 //! filter decides which addresses will count towards the debit
 Amount CachedTxGetDebit(const CWallet &wallet, const CWalletTx &wtx,
                         const isminefilter &filter);
 Amount CachedTxGetChange(const CWallet &wallet, const CWalletTx &wtx);
 Amount CachedTxGetImmatureCredit(const CWallet &wallet, const CWalletTx &wtx,
-                                 bool fUseCache = true);
+                                 bool fUseCache = true)
+    EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
 Amount CachedTxGetImmatureWatchOnlyCredit(const CWallet &wallet,
                                           const CWalletTx &wtx,
-                                          const bool fUseCache = true);
-// TODO: Remove "NO_THREAD_SAFETY_ANALYSIS" and replace it with the correct
-// annotation "EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)". The
-// annotation "NO_THREAD_SAFETY_ANALYSIS" was temporarily added to avoid
-// having to resolve the issue of member access into incomplete type CWallet.
-Amount CachedTxGetAvailableCredit(
-    const CWallet &wallet, const CWalletTx &wtx, bool fUseCache = true,
-    const isminefilter &filter = ISMINE_SPENDABLE) NO_THREAD_SAFETY_ANALYSIS;
+                                          const bool fUseCache = true)
+    EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
+Amount CachedTxGetAvailableCredit(const CWallet &wallet, const CWalletTx &wtx,
+                                  bool fUseCache = true,
+                                  const isminefilter &filter = ISMINE_SPENDABLE)
+    EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
+;
 
 struct COutputEntry {
     CTxDestination destination;
     Amount amount;
     int vout;
 };
 void CachedTxGetAmounts(const CWallet &wallet, const CWalletTx &wtx,
                         std::list<COutputEntry> &listReceived,
                         std::list<COutputEntry> &listSent, Amount &nFee,
                         const isminefilter &filter);
 bool CachedTxIsFromMe(const CWallet &wallet, const CWalletTx &wtx,
                       const isminefilter &filter);
 bool CachedTxIsTrusted(const CWallet &wallet, const CWalletTx &wtx,
                        std::set<TxId> &trusted_parents)
     EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
 bool CachedTxIsTrusted(const CWallet &wallet, const CWalletTx &wtx);
 
 struct Balance {
     //! Trusted, at depth=GetBalance.min_depth or more
     Amount m_mine_trusted{Amount::zero()};
     //! Untrusted, but in mempool (pending)
     Amount m_mine_untrusted_pending{Amount::zero()};
     //! Immature coinbases in the main chain
     Amount m_mine_immature{Amount::zero()};
     Amount m_watchonly_trusted{Amount::zero()};
     Amount m_watchonly_untrusted_pending{Amount::zero()};
     Amount m_watchonly_immature{Amount::zero()};
 };
 
 Balance GetBalance(const CWallet &wallet, int min_depth = 0,
                    bool avoid_reuse = true);
 
 std::map<CTxDestination, Amount> GetAddressBalances(const CWallet &wallet);
 std::set<std::set<CTxDestination>> GetAddressGroupings(const CWallet &wallet)
     EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
 
 #endif // BITCOIN_WALLET_RECEIVE_H
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index ea085eb8d..5c295ec2f 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -1,4927 +1,4928 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h> // for GetConsensus.
 #include <coins.h>
 #include <config.h>
 #include <consensus/amount.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
 #include <node/context.h>
 #include <outputtype.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <rpc/rawtransaction_util.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <util/bip32.h>
 #include <util/error.h>
 #include <util/moneystr.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <util/url.h>
 #include <util/vector.h>
 #include <wallet/coincontrol.h>
 #include <wallet/context.h>
 #include <wallet/load.h>
 #include <wallet/receive.h>
 #include <wallet/rpc/util.h>
 #include <wallet/rpcwallet.h>
 #include <wallet/spend.h>
 #include <wallet/wallet.h>
 #include <wallet/walletdb.h>
 #include <wallet/walletutil.h>
 
 #include <univalue.h>
 
 #include <event2/http.h>
 
 #include <optional>
 
 using interfaces::FoundBlock;
 
 /**
  * Checks if a CKey is in the given CWallet compressed or otherwise
  */
 bool HaveKey(const SigningProvider &wallet, const CKey &key) {
     CKey key2;
     key2.Set(key.begin(), key.end(), !key.IsCompressed());
     return wallet.HaveKey(key.GetPubKey().GetID()) ||
            wallet.HaveKey(key2.GetPubKey().GetID());
 }
 
 static void WalletTxToJSON(const CWallet &wallet, const CWalletTx &wtx,
-                           UniValue &entry) {
+                           UniValue &entry)
+    EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) {
     interfaces::Chain &chain = wallet.chain();
     int confirms = wallet.GetTxDepthInMainChain(wtx);
     entry.pushKV("confirmations", confirms);
     if (wtx.IsCoinBase()) {
         entry.pushKV("generated", true);
     }
     if (confirms > 0) {
         entry.pushKV("blockhash", wtx.m_confirm.hashBlock.GetHex());
         entry.pushKV("blockheight", wtx.m_confirm.block_height);
         entry.pushKV("blockindex", wtx.m_confirm.nIndex);
         int64_t block_time;
         CHECK_NONFATAL(chain.findBlock(wtx.m_confirm.hashBlock,
                                        FoundBlock().time(block_time)));
         entry.pushKV("blocktime", block_time);
     } else {
         entry.pushKV("trusted", CachedTxIsTrusted(wallet, wtx));
     }
     uint256 hash = wtx.GetId();
     entry.pushKV("txid", hash.GetHex());
     UniValue conflicts(UniValue::VARR);
     for (const uint256 &conflict : wallet.GetTxConflicts(wtx)) {
         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 RPCHelpMan getnewaddress() {
     return RPCHelpMan{
         "getnewaddress",
         "Returns a new Bitcoin address for receiving payments.\n"
         "If 'label' is specified, it is added to the address book \n"
         "so payments received with the address will be associated with "
         "'label'.\n",
         {
             {"label", RPCArg::Type::STR, /* default */ "null",
              "The label name for the address to be linked to. If not provided, "
              "the default label \"\" is used. It can also be set to the empty "
              "string \"\" to represent the default label. The label does not "
              "need to exist, it will be created if there is no label by the "
              "given name."},
             {"address_type", RPCArg::Type::STR,
              /* default */ "set by -addresstype",
              "The address type to use. Options are \"legacy\"."},
         },
         RPCResult{RPCResult::Type::STR, "address", "The new bitcoin address"},
         RPCExamples{HelpExampleCli("getnewaddress", "") +
                     HelpExampleRpc("getnewaddress", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             if (!pwallet->CanGetAddresses()) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Error: This wallet has no available keys");
             }
 
             // Parse the label first so we don't generate a key if there's an
             // error
             std::string label;
             if (!request.params[0].isNull()) {
                 label = LabelFromValue(request.params[0]);
             }
 
             OutputType output_type = pwallet->m_default_address_type;
             if (!request.params[1].isNull()) {
                 if (!ParseOutputType(request.params[1].get_str(),
                                      output_type)) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        strprintf("Unknown address type '%s'",
                                                  request.params[1].get_str()));
                 }
             }
 
             CTxDestination dest;
             std::string error;
             if (!pwallet->GetNewDestination(output_type, label, dest, error)) {
                 throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, error);
             }
 
             return EncodeDestination(dest, config);
         },
     };
 }
 
 static RPCHelpMan getrawchangeaddress() {
     return RPCHelpMan{
         "getrawchangeaddress",
         "Returns a new Bitcoin address, for receiving change.\n"
         "This is for use with raw transactions, NOT normal use.\n",
         {},
         RPCResult{RPCResult::Type::STR, "address", "The address"},
         RPCExamples{HelpExampleCli("getrawchangeaddress", "") +
                     HelpExampleRpc("getrawchangeaddress", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             if (!pwallet->CanGetAddresses(true)) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Error: This wallet has no available keys");
             }
 
             OutputType output_type = pwallet->m_default_change_type.value_or(
                 pwallet->m_default_address_type);
             if (!request.params[0].isNull()) {
                 if (!ParseOutputType(request.params[0].get_str(),
                                      output_type)) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        strprintf("Unknown address type '%s'",
                                                  request.params[0].get_str()));
                 }
             }
 
             CTxDestination dest;
             std::string error;
             if (!pwallet->GetNewChangeDestination(output_type, dest, error)) {
                 throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, error);
             }
             return EncodeDestination(dest, config);
         },
     };
 }
 
 static RPCHelpMan setlabel() {
     return RPCHelpMan{
         "setlabel",
         "Sets the label associated with the given address.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address to be associated with a label."},
             {"label", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The label to assign to the address."},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{
             HelpExampleCli("setlabel",
                            "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"tabby\"") +
             HelpExampleRpc(
                 "setlabel",
                 "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\", \"tabby\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             CTxDestination dest = DecodeDestination(request.params[0].get_str(),
                                                     wallet->GetChainParams());
             if (!IsValidDestination(dest)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Invalid Bitcoin address");
             }
 
             std::string label = LabelFromValue(request.params[1]);
 
             if (pwallet->IsMine(dest)) {
                 pwallet->SetAddressBook(dest, label, "receive");
             } else {
                 pwallet->SetAddressBook(dest, label, "send");
             }
 
             return NullUniValue;
         },
     };
 }
 
 void ParseRecipients(const UniValue &address_amounts,
                      const UniValue &subtract_fee_outputs,
                      std::vector<CRecipient> &recipients,
                      const CChainParams &chainParams) {
     std::set<CTxDestination> destinations;
     int i = 0;
     for (const std::string &address : address_amounts.getKeys()) {
         CTxDestination dest = DecodeDestination(address, chainParams);
         if (!IsValidDestination(dest)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                std::string("Invalid Bitcoin address: ") +
                                    address);
         }
 
         if (destinations.count(dest)) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 std::string("Invalid parameter, duplicated address: ") +
                     address);
         }
         destinations.insert(dest);
 
         CScript script_pub_key = GetScriptForDestination(dest);
         Amount amount = AmountFromValue(address_amounts[i++]);
 
         bool subtract_fee = false;
         for (unsigned int idx = 0; idx < subtract_fee_outputs.size(); idx++) {
             const UniValue &addr = subtract_fee_outputs[idx];
             if (addr.get_str() == address) {
                 subtract_fee = true;
             }
         }
 
         CRecipient recipient = {script_pub_key, amount, subtract_fee};
         recipients.push_back(recipient);
     }
 }
 
 UniValue SendMoney(CWallet *const pwallet, const CCoinControl &coin_control,
                    std::vector<CRecipient> &recipients, mapValue_t map_value) {
     EnsureWalletIsUnlocked(pwallet);
 
     // Shuffle recipient list
     std::shuffle(recipients.begin(), recipients.end(), FastRandomContext());
 
     // Send
     Amount nFeeRequired = Amount::zero();
     int nChangePosRet = -1;
     bilingual_str error;
     CTransactionRef tx;
     bool fCreated = CreateTransaction(
         *pwallet, recipients, tx, nFeeRequired, nChangePosRet, error,
         coin_control,
         !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
     if (!fCreated) {
         throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, error.original);
     }
     pwallet->CommitTransaction(tx, std::move(map_value), {} /* orderForm */);
     return tx->GetId().GetHex();
 }
 
 static RPCHelpMan sendtoaddress() {
     return RPCHelpMan{
         "sendtoaddress",
         "Send an amount to a given address.\n" + HELP_REQUIRING_PASSPHRASE,
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address to send to."},
             {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO,
              "The amount in " + Currency::get().ticker + " to send. eg 0.1"},
             {"comment", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              "A comment used to store what the transaction is for.\n"
              "                             This is not part of the "
              "transaction, just kept in your wallet."},
             {"comment_to", RPCArg::Type::STR,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "A comment to store the name of the person or organization\n"
              "                             to which you're sending the "
              "transaction. This is not part of the \n"
              "                             transaction, just kept in "
              "your wallet."},
             {"subtractfeefromamount", RPCArg::Type::BOOL,
              /* default */ "false",
              "The fee will be deducted from the amount being sent.\n"
              "                             The recipient will receive "
              "less bitcoins than you enter in the amount field."},
             {"avoid_reuse", RPCArg::Type::BOOL,
              /* default */ "true",
              "(only available if avoid_reuse wallet flag is set) Avoid "
              "spending from dirty addresses; addresses are considered\n"
              "                             dirty if they have previously "
              "been used in a transaction."},
         },
         RPCResult{RPCResult::Type::STR_HEX, "txid", "The transaction id."},
         RPCExamples{
             HelpExampleCli("sendtoaddress",
                            "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 100000") +
             HelpExampleCli("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvay"
                                             "dd\" 100000 \"donation\" \"seans "
                                             "outpost\"") +
             HelpExampleCli("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44"
                                             "Jvaydd\" 100000 \"\" \"\" true") +
             HelpExampleRpc("sendtoaddress",
                            "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvay"
                            "dd\", 100000, \"donation\", \"seans "
                            "outpost\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             // Wallet comments
             mapValue_t mapValue;
             if (!request.params[2].isNull() &&
                 !request.params[2].get_str().empty()) {
                 mapValue["comment"] = request.params[2].get_str();
             }
             if (!request.params[3].isNull() &&
                 !request.params[3].get_str().empty()) {
                 mapValue["to"] = request.params[3].get_str();
             }
 
             bool fSubtractFeeFromAmount = false;
             if (!request.params[4].isNull()) {
                 fSubtractFeeFromAmount = request.params[4].get_bool();
             }
 
             CCoinControl coin_control;
             coin_control.m_avoid_address_reuse =
                 GetAvoidReuseFlag(pwallet, request.params[5]);
             // We also enable partial spend avoidance if reuse avoidance is set.
             coin_control.m_avoid_partial_spends |=
                 coin_control.m_avoid_address_reuse;
 
             EnsureWalletIsUnlocked(pwallet);
 
             UniValue address_amounts(UniValue::VOBJ);
             const std::string address = request.params[0].get_str();
             address_amounts.pushKV(address, request.params[1]);
             UniValue subtractFeeFromAmount(UniValue::VARR);
             if (fSubtractFeeFromAmount) {
                 subtractFeeFromAmount.push_back(address);
             }
 
             std::vector<CRecipient> recipients;
             ParseRecipients(address_amounts, subtractFeeFromAmount, recipients,
                             wallet->GetChainParams());
 
             return SendMoney(pwallet, coin_control, recipients, mapValue);
         },
     };
 }
 
 static RPCHelpMan listaddressgroupings() {
     return RPCHelpMan{
         "listaddressgroupings",
         "Lists groups of addresses which have had their common ownership\n"
         "made public by common use as inputs or as the resulting change\n"
         "in past transactions\n",
         {},
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::ARR,
                        "",
                        "",
                        {
                            {RPCResult::Type::ARR,
                             "",
                             "",
                             {
                                 {RPCResult::Type::STR, "address",
                                  "The bitcoin address"},
                                 {RPCResult::Type::STR_AMOUNT, "amount",
                                  "The amount in " + Currency::get().ticker},
                                 {RPCResult::Type::STR, "label",
                                  /* optional */ true, "The label"},
                             }},
                        }},
                   }},
         RPCExamples{HelpExampleCli("listaddressgroupings", "") +
                     HelpExampleRpc("listaddressgroupings", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             UniValue jsonGroupings(UniValue::VARR);
             std::map<CTxDestination, Amount> balances =
                 GetAddressBalances(*pwallet);
             for (const std::set<CTxDestination> &grouping :
                  GetAddressGroupings(*pwallet)) {
                 UniValue jsonGrouping(UniValue::VARR);
                 for (const CTxDestination &address : grouping) {
                     UniValue addressInfo(UniValue::VARR);
                     addressInfo.push_back(EncodeDestination(address, config));
                     addressInfo.push_back(balances[address]);
 
                     const auto *address_book_entry =
                         pwallet->FindAddressBookEntry(address);
                     if (address_book_entry) {
                         addressInfo.push_back(address_book_entry->GetLabel());
                     }
                     jsonGrouping.push_back(addressInfo);
                 }
                 jsonGroupings.push_back(jsonGrouping);
             }
 
             return jsonGroupings;
         },
     };
 }
 
 static Amount GetReceived(const CWallet &wallet, const UniValue &params,
                           bool by_label)
     EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) {
     std::set<CTxDestination> address_set;
 
     if (by_label) {
         // Get the set of addresses assigned to label
         std::string label = LabelFromValue(params[0]);
         address_set = wallet.GetLabelAddresses(label);
     } else {
         // Get the address
         CTxDestination dest =
             DecodeDestination(params[0].get_str(), wallet.GetChainParams());
         if (!IsValidDestination(dest)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid Bitcoin address");
         }
         CScript script_pub_key = GetScriptForDestination(dest);
         if (!wallet.IsMine(script_pub_key)) {
             throw JSONRPCError(RPC_WALLET_ERROR, "Address not found in wallet");
         }
         address_set.insert(dest);
     }
 
     // Minimum confirmations
     int min_depth = 1;
     if (!params[1].isNull()) {
         min_depth = params[1].get_int();
     }
 
     // Tally
     Amount amount = Amount::zero();
     for (const std::pair<const TxId, CWalletTx> &wtx_pair : wallet.mapWallet) {
         const CWalletTx &wtx = wtx_pair.second;
         TxValidationState txState;
         if (wtx.IsCoinBase() ||
             !wallet.chain().contextualCheckTransactionForCurrentBlock(
                 *wtx.tx, txState) ||
             wallet.GetTxDepthInMainChain(wtx) < min_depth) {
             continue;
         }
 
         for (const CTxOut &txout : wtx.tx->vout) {
             CTxDestination address;
             if (ExtractDestination(txout.scriptPubKey, address) &&
                 wallet.IsMine(address) && address_set.count(address)) {
                 amount += txout.nValue;
             }
         }
     }
 
     return amount;
 }
 
 static RPCHelpMan getreceivedbyaddress() {
     return RPCHelpMan{
         "getreceivedbyaddress",
         "Returns the total amount received by the given address in "
         "transactions with at least minconf confirmations.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address for transactions."},
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "Only include transactions confirmed at least this many times."},
         },
         RPCResult{RPCResult::Type::STR_AMOUNT, "amount",
                   "The total amount in " + Currency::get().ticker +
                       " received at this address."},
         RPCExamples{
             "\nThe amount from transactions with at least 1 confirmation\n" +
             HelpExampleCli("getreceivedbyaddress",
                            "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\"") +
             "\nThe amount including unconfirmed transactions, zero "
             "confirmations\n" +
             HelpExampleCli("getreceivedbyaddress",
                            "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" 0") +
             "\nThe amount with at least 6 confirmations\n" +
             HelpExampleCli("getreceivedbyaddress",
                            "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" 6") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("getreceivedbyaddress",
                            "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\", 6")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             return GetReceived(*pwallet, request.params,
                                /* by_label */ false);
         },
     };
 }
 
 static RPCHelpMan getreceivedbylabel() {
     return RPCHelpMan{
         "getreceivedbylabel",
         "Returns the total amount received by addresses with <label> in "
         "transactions with at least [minconf] confirmations.\n",
         {
             {"label", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The selected label, may be the default label using \"\"."},
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "Only include transactions confirmed at least this many times."},
         },
         RPCResult{RPCResult::Type::STR_AMOUNT, "amount",
                   "The total amount in " + Currency::get().ticker +
                       " received for this label."},
         RPCExamples{"\nAmount received by the default label with at least 1 "
                     "confirmation\n" +
                     HelpExampleCli("getreceivedbylabel", "\"\"") +
                     "\nAmount received at the tabby label including "
                     "unconfirmed amounts with zero confirmations\n" +
                     HelpExampleCli("getreceivedbylabel", "\"tabby\" 0") +
                     "\nThe amount with at least 6 confirmations\n" +
                     HelpExampleCli("getreceivedbylabel", "\"tabby\" 6") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc("getreceivedbylabel", "\"tabby\", 6")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             return GetReceived(*pwallet, request.params,
                                /* by_label */ true);
         },
     };
 }
 
 static RPCHelpMan getbalance() {
     return RPCHelpMan{
         "getbalance",
         "Returns the total available balance.\n"
         "The available balance is what the wallet considers currently "
         "spendable, and is\n"
         "thus affected by options which limit spendability such as "
         "-spendzeroconfchange.\n",
         {
             {"dummy", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              "Remains for backward compatibility. Must be excluded or set to "
              "\"*\"."},
             {"minconf", RPCArg::Type::NUM, /* default */ "0",
              "Only include transactions confirmed at least this many times."},
             {"include_watchonly", RPCArg::Type::BOOL,
              /* default */ "true for watch-only wallets, otherwise false",
              "Also include balance in watch-only addresses (see "
              "'importaddress')"},
             {"avoid_reuse", RPCArg::Type::BOOL,
              /* default */ "true",
              "(only available if avoid_reuse wallet flag is set) Do not "
              "include balance in dirty outputs; addresses are considered dirty "
              "if they have previously been used in a transaction."},
         },
         RPCResult{RPCResult::Type::STR_AMOUNT, "amount",
                   "The total amount in " + Currency::get().ticker +
                       " received for this wallet."},
         RPCExamples{
             "\nThe total amount in the wallet with 0 or more confirmations\n" +
             HelpExampleCli("getbalance", "") +
             "\nThe total amount in the wallet with at least 6 confirmations\n" +
             HelpExampleCli("getbalance", "\"*\" 6") + "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("getbalance", "\"*\", 6")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             const UniValue &dummy_value = request.params[0];
             if (!dummy_value.isNull() && dummy_value.get_str() != "*") {
                 throw JSONRPCError(
                     RPC_METHOD_DEPRECATED,
                     "dummy first argument must be excluded or set to \"*\".");
             }
 
             int min_depth = 0;
             if (!request.params[1].isNull()) {
                 min_depth = request.params[1].get_int();
             }
 
             bool include_watchonly =
                 ParseIncludeWatchonly(request.params[2], *pwallet);
 
             bool avoid_reuse = GetAvoidReuseFlag(pwallet, request.params[3]);
 
             const auto bal = GetBalance(*pwallet, min_depth, avoid_reuse);
 
             return bal.m_mine_trusted + (include_watchonly
                                              ? bal.m_watchonly_trusted
                                              : Amount::zero());
         },
     };
 }
 
 static RPCHelpMan getunconfirmedbalance() {
     return RPCHelpMan{
         "getunconfirmedbalance",
         "DEPRECATED\nIdentical to getbalances().mine.untrusted_pending\n",
         {},
         RPCResult{RPCResult::Type::NUM, "", "The balance"},
         RPCExamples{""},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             return GetBalance(*pwallet).m_mine_untrusted_pending;
         },
     };
 }
 
 static RPCHelpMan sendmany() {
     return RPCHelpMan{
         "sendmany",
         "Send multiple times. Amounts are double-precision "
         "floating point numbers." +
             HELP_REQUIRING_PASSPHRASE,
         {
             {"dummy", RPCArg::Type::STR, RPCArg::Optional::NO,
              "Must be set to \"\" for backwards compatibility.", "\"\""},
             {
                 "amounts",
                 RPCArg::Type::OBJ,
                 RPCArg::Optional::NO,
                 "The addresses and amounts",
                 {
                     {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO,
                      "The bitcoin address is the key, the numeric amount (can "
                      "be string) in " +
                          Currency::get().ticker + " is the value"},
                 },
             },
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "Only use the balance confirmed at least this many times."},
             {"comment", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              "A comment"},
             {
                 "subtractfeefrom",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::OMITTED_NAMED_ARG,
                 "The addresses.\n"
                 "                           The fee will be equally deducted "
                 "from the amount of each selected address.\n"
                 "                           Those recipients will receive less "
                 "bitcoins than you enter in their corresponding amount field.\n"
                 "                           If no addresses are specified "
                 "here, the sender pays the fee.",
                 {
                     {"address", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                      "Subtract fee from this address"},
                 },
             },
         },
         RPCResult{RPCResult::Type::STR_HEX, "txid",
                   "The transaction id for the send. Only 1 transaction is "
                   "created regardless of the number of addresses."},
         RPCExamples{
             "\nSend two amounts to two different addresses:\n" +
             HelpExampleCli(
                 "sendmany",
                 "\"\" "
                 "\"{\\\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\\\":"
                 "0.01,"
                 "\\\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\\\":0."
                 "02}\"") +
             "\nSend two amounts to two different addresses setting the "
             "confirmation and comment:\n" +
             HelpExampleCli(
                 "sendmany",
                 "\"\" "
                 "\"{\\\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\\\":"
                 "0.01,"
                 "\\\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\\\":0."
                 "02}\" "
                 "6 \"testing\"") +
             "\nSend two amounts to two different addresses, subtract fee "
             "from amount:\n" +
             HelpExampleCli(
                 "sendmany",
                 "\"\" "
                 "\"{\\\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\\\":"
                 "0.01,"
                 "\\\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\\\":0."
                 "02}\" 1 \"\" "
                 "\"[\\\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\\\","
                 "\\\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\\\"]"
                 "\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc(
                 "sendmany",
                 "\"\", "
                 "{\"bchtest:qplljx455cznj2yrtdhj0jcm7syxlzqnaqt0ku5kjl\":0.01,"
                 "\"bchtest:qzmnuh8t24yrxq4mvjakt84r7j3f9tunlvm2p7qef9\":0.02}, "
                 "6, "
                 "\"testing\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             if (!request.params[0].isNull() &&
                 !request.params[0].get_str().empty()) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Dummy value must be set to \"\"");
             }
             UniValue sendTo = request.params[1].get_obj();
 
             mapValue_t mapValue;
             if (!request.params[3].isNull() &&
                 !request.params[3].get_str().empty()) {
                 mapValue["comment"] = request.params[3].get_str();
             }
 
             UniValue subtractFeeFromAmount(UniValue::VARR);
             if (!request.params[4].isNull()) {
                 subtractFeeFromAmount = request.params[4].get_array();
             }
 
             std::vector<CRecipient> recipients;
             ParseRecipients(sendTo, subtractFeeFromAmount, recipients,
                             wallet->GetChainParams());
 
             CCoinControl coin_control;
             return SendMoney(pwallet, coin_control, recipients,
                              std::move(mapValue));
         },
     };
 }
 
 static RPCHelpMan addmultisigaddress() {
     return RPCHelpMan{
         "addmultisigaddress",
         "Add an nrequired-to-sign multisignature address to the wallet. "
         "Requires a new wallet backup.\n"
         "Each key is a Bitcoin address or hex-encoded public key.\n"
         "This functionality is only intended for use with non-watchonly "
         "addresses.\n"
         "See `importaddress` for watchonly p2sh address support.\n"
         "If 'label' is specified (DEPRECATED), assign address to that label.\n",
         {
             {"nrequired", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The number of required signatures out of the n keys or "
              "addresses."},
             {
                 "keys",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The bitcoin addresses or hex-encoded public keys",
                 {
                     {"key", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                      "bitcoin address or hex-encoded public key"},
                 },
             },
             {"label", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              "A label to assign the addresses to."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "address",
                        "The value of the new multisig address"},
                       {RPCResult::Type::STR_HEX, "redeemScript",
                        "The string value of the hex-encoded redemption script"},
                       {RPCResult::Type::STR, "descriptor",
                        "The descriptor for this multisig"},
                   }},
         RPCExamples{
             "\nAdd a multisig address from 2 addresses\n" +
             HelpExampleCli("addmultisigaddress",
                            "2 "
                            "\"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\","
                            "\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("addmultisigaddress",
                            "2, "
                            "\"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\","
                            "\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             LegacyScriptPubKeyMan &spk_man =
                 EnsureLegacyScriptPubKeyMan(*pwallet);
 
             LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);
 
             std::string label;
             if (!request.params[2].isNull()) {
                 label = LabelFromValue(request.params[2]);
             }
 
             int required = request.params[0].get_int();
 
             // Get the public keys
             const UniValue &keys_or_addrs = request.params[1].get_array();
             std::vector<CPubKey> pubkeys;
             for (size_t i = 0; i < keys_or_addrs.size(); ++i) {
                 if (IsHex(keys_or_addrs[i].get_str()) &&
                     (keys_or_addrs[i].get_str().length() == 66 ||
                      keys_or_addrs[i].get_str().length() == 130)) {
                     pubkeys.push_back(HexToPubKey(keys_or_addrs[i].get_str()));
                 } else {
                     pubkeys.push_back(AddrToPubKey(wallet->GetChainParams(),
                                                    spk_man,
                                                    keys_or_addrs[i].get_str()));
                 }
             }
 
             OutputType output_type = pwallet->m_default_address_type;
 
             // Construct using pay-to-script-hash:
             CScript inner;
             CTxDestination dest = AddAndGetMultisigDestination(
                 required, pubkeys, output_type, spk_man, inner);
             pwallet->SetAddressBook(dest, label, "send");
 
             // Make the descriptor
             std::unique_ptr<Descriptor> descriptor =
                 InferDescriptor(GetScriptForDestination(dest), spk_man);
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("address", EncodeDestination(dest, config));
             result.pushKV("redeemScript", HexStr(inner));
             result.pushKV("descriptor", descriptor->ToString());
             return result;
         },
     };
 }
 
 struct tallyitem {
     Amount nAmount{Amount::zero()};
     int nConf{std::numeric_limits<int>::max()};
     std::vector<uint256> txids;
     bool fIsWatchonly{false};
     tallyitem() {}
 };
 
 static UniValue ListReceived(const Config &config, const CWallet *const pwallet,
                              const UniValue &params, bool by_label)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     // Minimum confirmations
     int nMinDepth = 1;
     if (!params[0].isNull()) {
         nMinDepth = params[0].get_int();
     }
 
     // Whether to include empty labels
     bool fIncludeEmpty = false;
     if (!params[1].isNull()) {
         fIncludeEmpty = params[1].get_bool();
     }
 
     isminefilter filter = ISMINE_SPENDABLE;
     if (ParseIncludeWatchonly(params[2], *pwallet)) {
         filter |= ISMINE_WATCH_ONLY;
     }
 
     bool has_filtered_address = false;
     CTxDestination filtered_address = CNoDestination();
     if (!by_label && params.size() > 3) {
         if (!IsValidDestinationString(params[3].get_str(),
                                       pwallet->GetChainParams())) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "address_filter parameter was invalid");
         }
         filtered_address =
             DecodeDestination(params[3].get_str(), pwallet->GetChainParams());
         has_filtered_address = true;
     }
 
     // Tally
     std::map<CTxDestination, tallyitem> mapTally;
     for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
         const CWalletTx &wtx = pairWtx.second;
 
         TxValidationState state;
         if (wtx.IsCoinBase() ||
             !pwallet->chain().contextualCheckTransactionForCurrentBlock(
                 *wtx.tx, state)) {
             continue;
         }
 
         int nDepth = pwallet->GetTxDepthInMainChain(wtx);
         if (nDepth < nMinDepth) {
             continue;
         }
 
         for (const CTxOut &txout : wtx.tx->vout) {
             CTxDestination address;
             if (!ExtractDestination(txout.scriptPubKey, address)) {
                 continue;
             }
 
             if (has_filtered_address && !(filtered_address == address)) {
                 continue;
             }
 
             isminefilter mine = pwallet->IsMine(address);
             if (!(mine & filter)) {
                 continue;
             }
 
             tallyitem &item = mapTally[address];
             item.nAmount += txout.nValue;
             item.nConf = std::min(item.nConf, nDepth);
             item.txids.push_back(wtx.GetId());
             if (mine & ISMINE_WATCH_ONLY) {
                 item.fIsWatchonly = true;
             }
         }
     }
 
     // Reply
     UniValue ret(UniValue::VARR);
     std::map<std::string, tallyitem> label_tally;
 
     // Create m_address_book iterator
     // If we aren't filtering, go from begin() to end()
     auto start = pwallet->m_address_book.begin();
     auto end = pwallet->m_address_book.end();
     // If we are filtering, find() the applicable entry
     if (has_filtered_address) {
         start = pwallet->m_address_book.find(filtered_address);
         if (start != end) {
             end = std::next(start);
         }
     }
 
     for (auto item_it = start; item_it != end; ++item_it) {
         if (item_it->second.IsChange()) {
             continue;
         }
         const CTxDestination &address = item_it->first;
         const std::string &label = item_it->second.GetLabel();
         std::map<CTxDestination, tallyitem>::iterator it =
             mapTally.find(address);
         if (it == mapTally.end() && !fIncludeEmpty) {
             continue;
         }
 
         Amount nAmount = Amount::zero();
         int nConf = std::numeric_limits<int>::max();
         bool fIsWatchonly = false;
         if (it != mapTally.end()) {
             nAmount = (*it).second.nAmount;
             nConf = (*it).second.nConf;
             fIsWatchonly = (*it).second.fIsWatchonly;
         }
 
         if (by_label) {
             tallyitem &_item = label_tally[label];
             _item.nAmount += nAmount;
             _item.nConf = std::min(_item.nConf, nConf);
             _item.fIsWatchonly = fIsWatchonly;
         } else {
             UniValue obj(UniValue::VOBJ);
             if (fIsWatchonly) {
                 obj.pushKV("involvesWatchonly", true);
             }
             obj.pushKV("address", EncodeDestination(address, config));
             obj.pushKV("amount", 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", nAmount);
             obj.pushKV("confirmations",
                        (nConf == std::numeric_limits<int>::max() ? 0 : nConf));
             obj.pushKV("label", entry.first);
             ret.push_back(obj);
         }
     }
 
     return ret;
 }
 
 static RPCHelpMan listreceivedbyaddress() {
     return RPCHelpMan{
         "listreceivedbyaddress",
         "List balances by receiving address.\n",
         {
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "The minimum number of confirmations before payments are "
              "included."},
             {"include_empty", RPCArg::Type::BOOL, /* default */ "false",
              "Whether to include addresses that haven't received any "
              "payments."},
             {"include_watchonly", RPCArg::Type::BOOL,
              /* default */ "true for watch-only wallets, otherwise false",
              "Whether to include watch-only addresses (see 'importaddress')."},
             {"address_filter", RPCArg::Type::STR,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "If present, only return information on this address."},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "",
                  "",
                  {
                      {RPCResult::Type::BOOL, "involvesWatchonly",
                       "Only returns true if imported addresses were involved "
                       "in transaction"},
                      {RPCResult::Type::STR, "address", "The receiving address"},
                      {RPCResult::Type::STR_AMOUNT, "amount",
                       "The total amount in " + Currency::get().ticker +
                           " received by the address"},
                      {RPCResult::Type::NUM, "confirmations",
                       "The number of confirmations of the most recent "
                       "transaction included"},
                      {RPCResult::Type::STR, "label",
                       "The label of the receiving address. The default label "
                       "is \"\""},
                      {RPCResult::Type::ARR,
                       "txids",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "txid",
                            "The ids of transactions received with the address"},
                       }},
                  }},
             }},
         RPCExamples{
             HelpExampleCli("listreceivedbyaddress", "") +
             HelpExampleCli("listreceivedbyaddress", "6 true") +
             HelpExampleRpc("listreceivedbyaddress", "6, true, true") +
             HelpExampleRpc(
                 "listreceivedbyaddress",
                 "6, true, true, \"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             return ListReceived(config, pwallet, request.params, false);
         },
     };
 }
 
 static RPCHelpMan listreceivedbylabel() {
     return RPCHelpMan{
         "listreceivedbylabel",
         "List received transactions by label.\n",
         {
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "The minimum number of confirmations before payments are "
              "included."},
             {"include_empty", RPCArg::Type::BOOL, /* default */ "false",
              "Whether to include labels that haven't received any payments."},
             {"include_watchonly", RPCArg::Type::BOOL,
              /* default */ "true for watch-only wallets, otherwise false",
              "Whether to include watch-only addresses (see 'importaddress')."},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "",
                  "",
                  {
                      {RPCResult::Type::BOOL, "involvesWatchonly",
                       "Only returns true if imported addresses were involved "
                       "in transaction"},
                      {RPCResult::Type::STR_AMOUNT, "amount",
                       "The total amount received by addresses with this label"},
                      {RPCResult::Type::NUM, "confirmations",
                       "The number of confirmations of the most recent "
                       "transaction included"},
                      {RPCResult::Type::STR, "label",
                       "The label of the receiving address. The default label "
                       "is \"\""},
                  }},
             }},
         RPCExamples{HelpExampleCli("listreceivedbylabel", "") +
                     HelpExampleCli("listreceivedbylabel", "6 true") +
                     HelpExampleRpc("listreceivedbylabel", "6, true, true")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             return ListReceived(config, pwallet, request.params, true);
         },
     };
 }
 
 static void MaybePushAddress(UniValue &entry, const CTxDestination &dest) {
     if (IsValidDestination(dest)) {
         entry.pushKV("address", EncodeDestination(dest, GetConfig()));
     }
 }
 
 /**
  * List transactions based on the given criteria.
  *
  * @param  pwallet        The wallet.
  * @param  wtx            The wallet transaction.
  * @param  nMinDepth      The minimum confirmation depth.
  * @param  fLong          Whether to include the JSON version of the
  * transaction.
  * @param  ret            The UniValue into which the result is stored.
  * @param  filter_ismine  The "is mine" filter flags.
  * @param  filter_label   Optional label string to filter incoming transactions.
  */
 static void ListTransactions(const CWallet *const pwallet, const CWalletTx &wtx,
                              int nMinDepth, bool fLong, UniValue &ret,
                              const isminefilter &filter_ismine,
                              const std::string *filter_label)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     Amount nFee;
     std::list<COutputEntry> listReceived;
     std::list<COutputEntry> listSent;
 
     CachedTxGetAmounts(*pwallet, wtx, listReceived, listSent, nFee,
                        filter_ismine);
 
     bool involvesWatchonly = CachedTxIsFromMe(*pwallet, wtx, ISMINE_WATCH_ONLY);
 
     // Sent
     if (!filter_label) {
         for (const COutputEntry &s : listSent) {
             UniValue entry(UniValue::VOBJ);
             if (involvesWatchonly ||
                 (pwallet->IsMine(s.destination) & ISMINE_WATCH_ONLY)) {
                 entry.pushKV("involvesWatchonly", true);
             }
             MaybePushAddress(entry, s.destination);
             entry.pushKV("category", "send");
             entry.pushKV("amount", -s.amount);
             const auto *address_book_entry =
                 pwallet->FindAddressBookEntry(s.destination);
             if (address_book_entry) {
                 entry.pushKV("label", address_book_entry->GetLabel());
             }
             entry.pushKV("vout", s.vout);
             entry.pushKV("fee", -1 * nFee);
             if (fLong) {
                 WalletTxToJSON(*pwallet, wtx, entry);
             }
             entry.pushKV("abandoned", wtx.isAbandoned());
             ret.push_back(entry);
         }
     }
 
     // Received
     if (listReceived.size() > 0 &&
         pwallet->GetTxDepthInMainChain(wtx) >= nMinDepth) {
         for (const COutputEntry &r : listReceived) {
             std::string label;
             const auto *address_book_entry =
                 pwallet->FindAddressBookEntry(r.destination);
             if (address_book_entry) {
                 label = address_book_entry->GetLabel();
             }
             if (filter_label && label != *filter_label) {
                 continue;
             }
             UniValue entry(UniValue::VOBJ);
             if (involvesWatchonly ||
                 (pwallet->IsMine(r.destination) & ISMINE_WATCH_ONLY)) {
                 entry.pushKV("involvesWatchonly", true);
             }
             MaybePushAddress(entry, r.destination);
             if (wtx.IsCoinBase()) {
                 if (pwallet->GetTxDepthInMainChain(wtx) < 1) {
                     entry.pushKV("category", "orphan");
                 } else if (pwallet->IsTxImmatureCoinBase(wtx)) {
                     entry.pushKV("category", "immature");
                 } else {
                     entry.pushKV("category", "generate");
                 }
             } else {
                 entry.pushKV("category", "receive");
             }
             entry.pushKV("amount", r.amount);
             if (address_book_entry) {
                 entry.pushKV("label", label);
             }
             entry.pushKV("vout", r.vout);
             if (fLong) {
                 WalletTxToJSON(*pwallet, wtx, entry);
             }
             ret.push_back(entry);
         }
     }
 }
 
 static const std::vector<RPCResult> TransactionDescriptionString() {
     return {
         {RPCResult::Type::NUM, "confirmations",
          "The number of confirmations for the transaction. Negative "
          "confirmations means the\n"
          "transaction conflicted that many blocks ago."},
         {RPCResult::Type::BOOL, "generated",
          "Only present if transaction only input is a coinbase one."},
         {RPCResult::Type::BOOL, "trusted",
          "Only present if we consider transaction to be trusted and so safe to "
          "spend from."},
         {RPCResult::Type::STR_HEX, "blockhash",
          "The block hash containing the transaction."},
         {RPCResult::Type::NUM, "blockheight",
          "The block height containing the transaction."},
         {RPCResult::Type::NUM, "blockindex",
          "The index of the transaction in the block that includes it."},
         {RPCResult::Type::NUM_TIME, "blocktime",
          "The block time expressed in " + UNIX_EPOCH_TIME + "."},
         {RPCResult::Type::STR_HEX, "txid", "The transaction id."},
         {RPCResult::Type::ARR,
          "walletconflicts",
          "Conflicting transaction ids.",
          {
              {RPCResult::Type::STR_HEX, "txid", "The transaction id."},
          }},
         {RPCResult::Type::NUM_TIME, "time",
          "The transaction time expressed in " + UNIX_EPOCH_TIME + "."},
         {RPCResult::Type::NUM_TIME, "timereceived",
          "The time received expressed in " + UNIX_EPOCH_TIME + "."},
         {RPCResult::Type::STR, "comment",
          "If a comment is associated with the transaction, only present if not "
          "empty."},
     };
 }
 
 RPCHelpMan listtransactions() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "listtransactions",
         "If a label name is provided, this will return only incoming "
         "transactions paying to addresses with the specified label.\n"
         "\nReturns up to 'count' most recent transactions skipping the first "
         "'from' transactions.\n",
         {
             {"label|dummy", RPCArg::Type::STR,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "If set, should be a valid label name to return only incoming "
              "transactions with the specified label, or \"*\" to disable "
              "filtering and return all transactions."},
             {"count", RPCArg::Type::NUM, /* default */ "10",
              "The number of transactions to return"},
             {"skip", RPCArg::Type::NUM, /* default */ "0",
              "The number of transactions to skip"},
             {"include_watchonly", RPCArg::Type::BOOL,
              /* default */ "true for watch-only wallets, otherwise false",
              "Include transactions to watch-only addresses (see "
              "'importaddress')"},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ, "", "",
                  Cat(Cat<std::vector<RPCResult>>(
                          {
                              {RPCResult::Type::BOOL, "involvesWatchonly",
                               "Only returns true if imported addresses were "
                               "involved in transaction."},
                              {RPCResult::Type::STR, "address",
                               "The bitcoin address of the transaction."},
                              {RPCResult::Type::STR, "category",
                               "The transaction category.\n"
                               "\"send\"                  Transactions sent.\n"
                               "\"receive\"               Non-coinbase "
                               "transactions received.\n"
                               "\"generate\"              Coinbase transactions "
                               "received with more than 100 confirmations.\n"
                               "\"immature\"              Coinbase transactions "
                               "received with 100 or fewer confirmations.\n"
                               "\"orphan\"                Orphaned coinbase "
                               "transactions received."},
                              {RPCResult::Type::STR_AMOUNT, "amount",
                               "The amount in " + ticker +
                                   ". This is negative for the 'send' category, "
                                   "and is positive\n"
                                   "for all other categories"},
                              {RPCResult::Type::STR, "label",
                               "A comment for the address/transaction, if any"},
                              {RPCResult::Type::NUM, "vout", "the vout value"},
                              {RPCResult::Type::STR_AMOUNT, "fee",
                               "The amount of the fee in " + ticker +
                                   ". This is negative and only available for "
                                   "the\n"
                                   "'send' category of transactions."},
                          },
                          TransactionDescriptionString()),
                      {
                          {RPCResult::Type::BOOL, "abandoned",
                           "'true' if the transaction has been abandoned "
                           "(inputs are respendable). Only available for the \n"
                           "'send' category of transactions."},
                      })},
             }},
         RPCExamples{"\nList the most recent 10 transactions in the systems\n" +
                     HelpExampleCli("listtransactions", "") +
                     "\nList transactions 100 to 120\n" +
                     HelpExampleCli("listtransactions", "\"*\" 20 100") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc("listtransactions", "\"*\", 20, 100")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             const std::string *filter_label = nullptr;
             if (!request.params[0].isNull() &&
                 request.params[0].get_str() != "*") {
                 filter_label = &request.params[0].get_str();
                 if (filter_label->empty()) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Label argument must be a valid label name or \"*\".");
                 }
             }
             int nCount = 10;
             if (!request.params[1].isNull()) {
                 nCount = request.params[1].get_int();
             }
 
             int nFrom = 0;
             if (!request.params[2].isNull()) {
                 nFrom = request.params[2].get_int();
             }
 
             isminefilter filter = ISMINE_SPENDABLE;
             if (ParseIncludeWatchonly(request.params[3], *pwallet)) {
                 filter |= ISMINE_WATCH_ONLY;
             }
 
             if (nCount < 0) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative count");
             }
             if (nFrom < 0) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative from");
             }
             UniValue ret(UniValue::VARR);
 
             {
                 LOCK(pwallet->cs_wallet);
 
                 const CWallet::TxItems &txOrdered = pwallet->wtxOrdered;
 
                 // iterate backwards until we have nCount items to return:
                 for (CWallet::TxItems::const_reverse_iterator it =
                          txOrdered.rbegin();
                      it != txOrdered.rend(); ++it) {
                     CWalletTx *const pwtx = (*it).second;
                     ListTransactions(pwallet, *pwtx, 0, true, ret, filter,
                                      filter_label);
                     if (int(ret.size()) >= (nCount + nFrom)) {
                         break;
                     }
                 }
             }
 
             // ret is newest to oldest
 
             if (nFrom > (int)ret.size()) {
                 nFrom = ret.size();
             }
             if ((nFrom + nCount) > (int)ret.size()) {
                 nCount = ret.size() - nFrom;
             }
 
             const std::vector<UniValue> &txs = ret.getValues();
             UniValue result{UniValue::VARR};
             // Return oldest to newest
             result.push_backV(
                 {txs.rend() - nFrom - nCount, txs.rend() - nFrom});
             return result;
         },
     };
 }
 
 static RPCHelpMan listsinceblock() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "listsinceblock",
         "Get all transactions in blocks since block [blockhash], or all "
         "transactions if omitted.\n"
         "If \"blockhash\" is no longer a part of the main chain, transactions "
         "from the fork point onward are included.\n"
         "Additionally, if include_removed is set, transactions affecting the "
         "wallet which were removed are returned in the \"removed\" array.\n",
         {
             {"blockhash", RPCArg::Type::STR,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "If set, the block hash to list transactions since, otherwise "
              "list all transactions."},
             {"target_confirmations", RPCArg::Type::NUM, /* default */ "1",
              "Return the nth block hash from the main chain. e.g. 1 would mean "
              "the best block hash. Note: this is not used as a filter, but "
              "only affects [lastblock] in the return value"},
             {"include_watchonly", RPCArg::Type::BOOL,
              /* default */ "true for watch-only wallets, otherwise false",
              "Include transactions to watch-only addresses (see "
              "'importaddress')"},
             {"include_removed", RPCArg::Type::BOOL, /* default */ "true",
              "Show transactions that were removed due to a reorg in the "
              "\"removed\" array\n"
              "                                                           (not "
              "guaranteed to work on pruned nodes)"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::ARR,
                  "transactions",
                  "",
                  {
                      {RPCResult::Type::OBJ, "", "",
                       Cat(Cat<std::vector<RPCResult>>(
                               {
                                   {RPCResult::Type::BOOL, "involvesWatchonly",
                                    "Only returns true if imported addresses "
                                    "were involved in transaction."},
                                   {RPCResult::Type::STR, "address",
                                    "The bitcoin address of the transaction."},
                                   {RPCResult::Type::STR, "category",
                                    "The transaction category.\n"
                                    "\"send\"                  Transactions "
                                    "sent.\n"
                                    "\"receive\"               Non-coinbase "
                                    "transactions received.\n"
                                    "\"generate\"              Coinbase "
                                    "transactions received with more than 100 "
                                    "confirmations.\n"
                                    "\"immature\"              Coinbase "
                                    "transactions received with 100 or fewer "
                                    "confirmations.\n"
                                    "\"orphan\"                Orphaned "
                                    "coinbase transactions received."},
                                   {RPCResult::Type::STR_AMOUNT, "amount",
                                    "The amount in " + ticker +
                                        ". This is negative for the 'send' "
                                        "category, and is positive\n"
                                        "for all other categories"},
                                   {RPCResult::Type::NUM, "vout",
                                    "the vout value"},
                                   {RPCResult::Type::STR_AMOUNT, "fee",
                                    "The amount of the fee in " + ticker +
                                        ". This is negative and only available "
                                        "for the\n"
                                        "'send' category of transactions."},
                               },
                               TransactionDescriptionString()),
                           {
                               {RPCResult::Type::BOOL, "abandoned",
                                "'true' if the transaction has been abandoned "
                                "(inputs are respendable). Only available for "
                                "the \n"
                                "'send' category of transactions."},
                               {RPCResult::Type::STR, "comment",
                                "If a comment is associated with the "
                                "transaction."},
                               {RPCResult::Type::STR, "label",
                                "A comment for the address/transaction, if any"},
                               {RPCResult::Type::STR, "to",
                                "If a comment to is associated with the "
                                "transaction."},
                           })},
                  }},
                 {RPCResult::Type::ARR,
                  "removed",
                  "<structure is the same as \"transactions\" above, only "
                  "present if include_removed=true>\n"
                  "Note: transactions that were re-added in the active chain "
                  "will appear as-is in this array, and may thus have a "
                  "positive confirmation count.",
                  {
                      {RPCResult::Type::ELISION, "", ""},
                  }},
                 {RPCResult::Type::STR_HEX, "lastblock",
                  "The hash of the block (target_confirmations-1) from the best "
                  "block on the main chain, or the genesis hash if the "
                  "referenced block does not exist yet. This is typically used "
                  "to feed back into listsinceblock the next time you call it. "
                  "So you would generally use a target_confirmations of say 6, "
                  "so you will be continually re-notified of transactions until "
                  "they've reached 6 confirmations plus any new ones"},
             }},
         RPCExamples{HelpExampleCli("listsinceblock", "") +
                     HelpExampleCli("listsinceblock",
                                    "\"000000000000000bacf66f7497b7dc45ef753ee9a"
                                    "7d38571037cdb1a57f663ad\" 6") +
                     HelpExampleRpc("listsinceblock",
                                    "\"000000000000000bacf66f7497b7dc45ef753ee9a"
                                    "7d38571037cdb1a57f663ad\", 6")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const pwallet =
                 GetWalletForJSONRPCRequest(request);
 
             if (!pwallet) {
                 return NullUniValue;
             }
 
             const CWallet &wallet = *pwallet;
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             wallet.BlockUntilSyncedToCurrentChain();
 
             LOCK(wallet.cs_wallet);
 
             // Height of the specified block or the common ancestor, if the
             // block provided was in a deactivated chain.
             std::optional<int> height;
 
             // Height of the specified block, even if it's in a deactivated
             // chain.
             std::optional<int> altheight;
             int target_confirms = 1;
             isminefilter filter = ISMINE_SPENDABLE;
 
             BlockHash blockId;
             if (!request.params[0].isNull() &&
                 !request.params[0].get_str().empty()) {
                 blockId = BlockHash(ParseHashV(request.params[0], "blockhash"));
                 height = int{};
                 altheight = int{};
                 if (!wallet.chain().findCommonAncestor(
                         blockId, wallet.GetLastBlockHash(),
                         /* ancestor out */ FoundBlock().height(*height),
                         /* blockId out */ FoundBlock().height(*altheight))) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Block not found");
                 }
             }
 
             if (!request.params[1].isNull()) {
                 target_confirms = request.params[1].get_int();
 
                 if (target_confirms < 1) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Invalid parameter");
                 }
             }
 
             if (ParseIncludeWatchonly(request.params[2], wallet)) {
                 filter |= ISMINE_WATCH_ONLY;
             }
 
             bool include_removed =
                 (request.params[3].isNull() || request.params[3].get_bool());
 
             int depth = height ? wallet.GetLastBlockHeight() + 1 - *height : -1;
 
             UniValue transactions(UniValue::VARR);
 
             for (const std::pair<const TxId, CWalletTx> &pairWtx :
                  wallet.mapWallet) {
                 const CWalletTx &tx = pairWtx.second;
 
                 if (depth == -1 || wallet.GetTxDepthInMainChain(tx) < depth) {
                     ListTransactions(&wallet, tx, 0, true, transactions, filter,
                                      nullptr /* filter_label */);
                 }
             }
 
             // when a reorg'd block is requested, we also list any relevant
             // transactions in the blocks of the chain that was detached
             UniValue removed(UniValue::VARR);
             while (include_removed && altheight && *altheight > *height) {
                 CBlock block;
                 if (!wallet.chain().findBlock(blockId,
                                               FoundBlock().data(block)) ||
                     block.IsNull()) {
                     throw JSONRPCError(RPC_INTERNAL_ERROR,
                                        "Can't read block from disk");
                 }
                 for (const CTransactionRef &tx : block.vtx) {
                     auto it = wallet.mapWallet.find(tx->GetId());
                     if (it != wallet.mapWallet.end()) {
                         // We want all transactions regardless of confirmation
                         // count to appear here, even negative confirmation
                         // ones, hence the big negative.
                         ListTransactions(&wallet, it->second, -100000000, true,
                                          removed, filter,
                                          nullptr /* filter_label */);
                     }
                 }
                 blockId = block.hashPrevBlock;
                 --*altheight;
             }
 
             BlockHash lastblock;
             target_confirms =
                 std::min(target_confirms, wallet.GetLastBlockHeight() + 1);
             CHECK_NONFATAL(wallet.chain().findAncestorByHeight(
                 wallet.GetLastBlockHash(),
                 wallet.GetLastBlockHeight() + 1 - target_confirms,
                 FoundBlock().hash(lastblock)));
 
             UniValue ret(UniValue::VOBJ);
             ret.pushKV("transactions", transactions);
             if (include_removed) {
                 ret.pushKV("removed", removed);
             }
             ret.pushKV("lastblock", lastblock.GetHex());
 
             return ret;
         },
     };
 }
 
 static RPCHelpMan gettransaction() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "gettransaction",
         "Get detailed information about in-wallet transaction <txid>\n",
         {
             {"txid", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The transaction id"},
             {"include_watchonly", RPCArg::Type::BOOL,
              /* default */ "true for watch-only wallets, otherwise false",
              "Whether to include watch-only addresses in balance calculation "
              "and details[]"},
             {"verbose", RPCArg::Type::BOOL, /* default */ "false",
              "Whether to include a `decoded` field containing the decoded "
              "transaction (equivalent to RPC decoderawtransaction)"},
         },
         RPCResult{
             RPCResult::Type::OBJ, "", "",
             Cat(Cat<std::vector<RPCResult>>(
                     {
                         {RPCResult::Type::STR_AMOUNT, "amount",
                          "The amount in " + ticker},
                         {RPCResult::Type::STR_AMOUNT, "fee",
                          "The amount of the fee in " + ticker +
                              ". This is negative and only available for the\n"
                              "'send' category of transactions."},
                     },
                     TransactionDescriptionString()),
                 {
                     {RPCResult::Type::ARR,
                      "details",
                      "",
                      {
                          {RPCResult::Type::OBJ,
                           "",
                           "",
                           {
                               {RPCResult::Type::BOOL, "involvesWatchonly",
                                "Only returns true if imported addresses were "
                                "involved in transaction."},
                               {RPCResult::Type::STR, "address",
                                "The bitcoin address involved in the "
                                "transaction."},
                               {RPCResult::Type::STR, "category",
                                "The transaction category.\n"
                                "\"send\"                  Transactions sent.\n"
                                "\"receive\"               Non-coinbase "
                                "transactions received.\n"
                                "\"generate\"              Coinbase "
                                "transactions received with more than 100 "
                                "confirmations.\n"
                                "\"immature\"              Coinbase "
                                "transactions received with 100 or fewer "
                                "confirmations.\n"
                                "\"orphan\"                Orphaned coinbase "
                                "transactions received."},
                               {RPCResult::Type::STR_AMOUNT, "amount",
                                "The amount in " + ticker},
                               {RPCResult::Type::STR, "label",
                                "A comment for the address/transaction, if any"},
                               {RPCResult::Type::NUM, "vout", "the vout value"},
                               {RPCResult::Type::STR_AMOUNT, "fee",
                                "The amount of the fee in " + ticker +
                                    ". This is negative and only available for "
                                    "the \n"
                                    "'send' category of transactions."},
                               {RPCResult::Type::BOOL, "abandoned",
                                "'true' if the transaction has been abandoned "
                                "(inputs are respendable). Only available for "
                                "the \n"
                                "'send' category of transactions."},
                           }},
                      }},
                     {RPCResult::Type::STR_HEX, "hex",
                      "Raw data for transaction"},
                     {RPCResult::Type::OBJ,
                      "decoded",
                      "Optional, the decoded transaction (only present when "
                      "`verbose` is passed)",
                      {
                          {RPCResult::Type::ELISION, "",
                           "Equivalent to the RPC decoderawtransaction method, "
                           "or the RPC getrawtransaction method when `verbose` "
                           "is passed."},
                      }},
                 })},
         RPCExamples{HelpExampleCli("gettransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\"") +
                     HelpExampleCli("gettransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\" true") +
                     HelpExampleCli("gettransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\" false true") +
                     HelpExampleRpc("gettransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             TxId txid(ParseHashV(request.params[0], "txid"));
 
             isminefilter filter = ISMINE_SPENDABLE;
             if (ParseIncludeWatchonly(request.params[1], *pwallet)) {
                 filter |= ISMINE_WATCH_ONLY;
             }
 
             bool verbose = request.params[2].isNull()
                                ? false
                                : request.params[2].get_bool();
 
             UniValue entry(UniValue::VOBJ);
             auto it = pwallet->mapWallet.find(txid);
             if (it == pwallet->mapWallet.end()) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Invalid or non-wallet transaction id");
             }
             const CWalletTx &wtx = it->second;
 
             Amount nCredit = CachedTxGetCredit(*pwallet, wtx, filter);
             Amount nDebit = CachedTxGetDebit(*pwallet, wtx, filter);
             Amount nNet = nCredit - nDebit;
             Amount nFee = (CachedTxIsFromMe(*pwallet, wtx, filter)
                                ? wtx.tx->GetValueOut() - nDebit
                                : Amount::zero());
 
             entry.pushKV("amount", nNet - nFee);
             if (CachedTxIsFromMe(*pwallet, wtx, filter)) {
                 entry.pushKV("fee", nFee);
             }
 
             WalletTxToJSON(*pwallet, wtx, entry);
 
             UniValue details(UniValue::VARR);
             ListTransactions(pwallet, wtx, 0, false, details, filter,
                              nullptr /* filter_label */);
             entry.pushKV("details", details);
 
             std::string strHex =
                 EncodeHexTx(*wtx.tx, pwallet->chain().rpcSerializationFlags());
             entry.pushKV("hex", strHex);
 
             if (verbose) {
                 UniValue decoded(UniValue::VOBJ);
                 TxToUniv(*wtx.tx, BlockHash(), decoded, false);
                 entry.pushKV("decoded", decoded);
             }
 
             return entry;
         },
     };
 }
 
 static RPCHelpMan abandontransaction() {
     return RPCHelpMan{
         "abandontransaction",
         "Mark in-wallet transaction <txid> as abandoned\n"
         "This will mark this transaction and all its in-wallet descendants as "
         "abandoned which will allow\n"
         "for their inputs to be respent.  It can be used to replace \"stuck\" "
         "or evicted transactions.\n"
         "It only works on transactions which are not included in a block and "
         "are not currently in the mempool.\n"
         "It has no effect on transactions which are already abandoned.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("abandontransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\"") +
                     HelpExampleRpc("abandontransaction",
                                    "\"1075db55d416d3ca199f55b6084e2115b9345e16c"
                                    "5cf302fc80e9d5fbf5d48d\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             TxId txid(ParseHashV(request.params[0], "txid"));
 
             if (!pwallet->mapWallet.count(txid)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Invalid or non-wallet transaction id");
             }
 
             if (!pwallet->AbandonTransaction(txid)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Transaction not eligible for abandonment");
             }
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan keypoolrefill() {
     return RPCHelpMan{
         "keypoolrefill",
         "Fills the keypool." + HELP_REQUIRING_PASSPHRASE,
         {
             {"newsize", RPCArg::Type::NUM, /* default */ "100",
              "The new keypool size"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("keypoolrefill", "") +
                     HelpExampleRpc("keypoolrefill", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             if (pwallet->IsLegacy() &&
                 pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
                 throw JSONRPCError(
                     RPC_WALLET_ERROR,
                     "Error: Private keys are disabled for this wallet");
             }
 
             LOCK(pwallet->cs_wallet);
 
             // 0 is interpreted by TopUpKeyPool() as the default keypool size
             // given by -keypool
             unsigned int kpSize = 0;
             if (!request.params[0].isNull()) {
                 if (request.params[0].get_int() < 0) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Invalid parameter, expected valid size.");
                 }
                 kpSize = (unsigned int)request.params[0].get_int();
             }
 
             EnsureWalletIsUnlocked(pwallet);
             pwallet->TopUpKeyPool(kpSize);
 
             if (pwallet->GetKeyPoolSize() < kpSize) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Error refreshing keypool.");
             }
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan lockunspent() {
     return RPCHelpMan{
         "lockunspent",
         "Updates list of temporarily unspendable outputs.\n"
         "Temporarily lock (unlock=false) or unlock (unlock=true) specified "
         "transaction outputs.\n"
         "If no transaction outputs are specified when unlocking then all "
         "current locked transaction outputs are unlocked.\n"
         "A locked transaction output will not be chosen by automatic coin "
         "selection, when spending bitcoins.\n"
         "Manually selected coins are automatically unlocked.\n"
         "Locks are stored in memory only. Nodes start with zero locked "
         "outputs, and the locked output list\n"
         "is always cleared (by virtue of process exit) when a node stops or "
         "fails.\n"
         "Also see the listunspent call\n",
         {
             {"unlock", RPCArg::Type::BOOL, RPCArg::Optional::NO,
              "Whether to unlock (true) or lock (false) the specified "
              "transactions"},
             {
                 "transactions",
                 RPCArg::Type::ARR,
                 /* default */ "empty array",
                 "The transaction outputs and within each, txid (string) vout "
                 "(numeric).",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                         },
                     },
                 },
             },
         },
         RPCResult{RPCResult::Type::BOOL, "",
                   "Whether the command was successful or not"},
         RPCExamples{
             "\nList the unspent transactions\n" +
             HelpExampleCli("listunspent", "") +
             "\nLock an unspent transaction\n" +
             HelpExampleCli("lockunspent", "false "
                                           "\"[{\\\"txid\\\":"
                                           "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                           "b764ed838b5655e72f463568df1aadf0\\\""
                                           ",\\\"vout\\\":1}]\"") +
             "\nList the locked transactions\n" +
             HelpExampleCli("listlockunspent", "") +
             "\nUnlock the transaction again\n" +
             HelpExampleCli("lockunspent", "true "
                                           "\"[{\\\"txid\\\":"
                                           "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                           "b764ed838b5655e72f463568df1aadf0\\\""
                                           ",\\\"vout\\\":1}]\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("lockunspent", "false, "
                                           "\"[{\\\"txid\\\":"
                                           "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                           "b764ed838b5655e72f463568df1aadf0\\\""
                                           ",\\\"vout\\\":1}]\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             RPCTypeCheckArgument(request.params[0], UniValue::VBOOL);
 
             bool fUnlock = request.params[0].get_bool();
 
             if (request.params[1].isNull()) {
                 if (fUnlock) {
                     pwallet->UnlockAllCoins();
                 }
                 return true;
             }
 
             RPCTypeCheckArgument(request.params[1], UniValue::VARR);
 
             const UniValue &output_params = request.params[1];
 
             // Create and validate the COutPoints first.
 
             std::vector<COutPoint> outputs;
             outputs.reserve(output_params.size());
 
             for (size_t idx = 0; idx < output_params.size(); idx++) {
                 const UniValue &o = output_params[idx].get_obj();
 
                 RPCTypeCheckObj(o, {
                                        {"txid", UniValueType(UniValue::VSTR)},
                                        {"vout", UniValueType(UniValue::VNUM)},
                                    });
 
                 const int nOutput = find_value(o, "vout").get_int();
                 if (nOutput < 0) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Invalid parameter, vout cannot be negative");
                 }
 
                 const TxId txid(ParseHashO(o, "txid"));
                 const auto it = pwallet->mapWallet.find(txid);
                 if (it == pwallet->mapWallet.end()) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Invalid parameter, unknown transaction");
                 }
 
                 const COutPoint output(txid, nOutput);
                 const CWalletTx &trans = it->second;
                 if (output.GetN() >= trans.tx->vout.size()) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Invalid parameter, vout index out of bounds");
                 }
 
                 if (pwallet->IsSpent(output)) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Invalid parameter, expected unspent output");
                 }
 
                 const bool is_locked = pwallet->IsLockedCoin(output);
                 if (fUnlock && !is_locked) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Invalid parameter, expected locked output");
                 }
 
                 if (!fUnlock && is_locked) {
                     throw JSONRPCError(
                         RPC_INVALID_PARAMETER,
                         "Invalid parameter, output already locked");
                 }
 
                 outputs.push_back(output);
             }
 
             // Atomically set (un)locked status for the outputs.
             for (const COutPoint &output : outputs) {
                 if (fUnlock) {
                     pwallet->UnlockCoin(output);
                 } else {
                     pwallet->LockCoin(output);
                 }
             }
 
             return true;
         },
     };
 }
 
 static RPCHelpMan listlockunspent() {
     return RPCHelpMan{
         "listlockunspent",
         "Returns list of temporarily unspendable outputs.\n"
         "See the lockunspent call to lock and unlock transactions for "
         "spending.\n",
         {},
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::OBJ,
                        "",
                        "",
                        {
                            {RPCResult::Type::STR_HEX, "txid",
                             "The transaction id locked"},
                            {RPCResult::Type::NUM, "vout", "The vout value"},
                        }},
                   }},
         RPCExamples{
             "\nList the unspent transactions\n" +
             HelpExampleCli("listunspent", "") +
             "\nLock an unspent transaction\n" +
             HelpExampleCli("lockunspent", "false "
                                           "\"[{\\\"txid\\\":"
                                           "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                           "b764ed838b5655e72f463568df1aadf0\\\""
                                           ",\\\"vout\\\":1}]\"") +
             "\nList the locked transactions\n" +
             HelpExampleCli("listlockunspent", "") +
             "\nUnlock the transaction again\n" +
             HelpExampleCli("lockunspent", "true "
                                           "\"[{\\\"txid\\\":"
                                           "\\\"a08e6907dbbd3d809776dbfc5d82e371"
                                           "b764ed838b5655e72f463568df1aadf0\\\""
                                           ",\\\"vout\\\":1}]\"") +
             "\nAs a JSON-RPC call\n" + HelpExampleRpc("listlockunspent", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             std::vector<COutPoint> vOutpts;
             pwallet->ListLockedCoins(vOutpts);
 
             UniValue ret(UniValue::VARR);
 
             for (const COutPoint &output : vOutpts) {
                 UniValue o(UniValue::VOBJ);
 
                 o.pushKV("txid", output.GetTxId().GetHex());
                 o.pushKV("vout", int(output.GetN()));
                 ret.push_back(o);
             }
 
             return ret;
         },
     };
 }
 
 static RPCHelpMan settxfee() {
     return RPCHelpMan{
         "settxfee",
         "Set the transaction fee per kB for this wallet. Overrides the "
         "global -paytxfee command line parameter.\n"
         "Can be deactivated by passing 0 as the fee. In that case automatic "
         "fee selection will be used by default.\n",
         {
             {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO,
              "The transaction fee in " + Currency::get().ticker + "/kB"},
         },
         RPCResult{RPCResult::Type::BOOL, "", "Returns true if successful"},
         RPCExamples{HelpExampleCli("settxfee", "0.00001") +
                     HelpExampleRpc("settxfee", "0.00001")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             Amount nAmount = AmountFromValue(request.params[0]);
             CFeeRate tx_fee_rate(nAmount, 1000);
             CFeeRate max_tx_fee_rate(pwallet->m_default_max_tx_fee, 1000);
             if (tx_fee_rate == CFeeRate()) {
                 // automatic selection
             } else if (tx_fee_rate < pwallet->chain().relayMinFee()) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf("txfee cannot be less than min relay tx fee (%s)",
                               pwallet->chain().relayMinFee().ToString()));
             } else if (tx_fee_rate < pwallet->m_min_fee) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf("txfee cannot be less than wallet min fee (%s)",
                               pwallet->m_min_fee.ToString()));
             } else if (tx_fee_rate > max_tx_fee_rate) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf(
                         "txfee cannot be more than wallet max tx fee (%s)",
                         max_tx_fee_rate.ToString()));
             }
 
             pwallet->m_pay_tx_fee = tx_fee_rate;
             return true;
         },
     };
 }
 
 static RPCHelpMan getbalances() {
     return RPCHelpMan{
         "getbalances",
         "Returns an object with all balances in " + Currency::get().ticker +
             ".\n",
         {},
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::OBJ,
                        "mine",
                        "balances from outputs that the wallet can sign",
                        {
                            {RPCResult::Type::STR_AMOUNT, "trusted",
                             "trusted balance (outputs created by the wallet or "
                             "confirmed outputs)"},
                            {RPCResult::Type::STR_AMOUNT, "untrusted_pending",
                             "untrusted pending balance (outputs created by "
                             "others that are in the mempool)"},
                            {RPCResult::Type::STR_AMOUNT, "immature",
                             "balance from immature coinbase outputs"},
                            {RPCResult::Type::STR_AMOUNT, "used",
                             "(only present if avoid_reuse is set) balance from "
                             "coins sent to addresses that were previously "
                             "spent from (potentially privacy violating)"},
                        }},
                       {RPCResult::Type::OBJ,
                        "watchonly",
                        "watchonly balances (not present if wallet does not "
                        "watch anything)",
                        {
                            {RPCResult::Type::STR_AMOUNT, "trusted",
                             "trusted balance (outputs created by the wallet or "
                             "confirmed outputs)"},
                            {RPCResult::Type::STR_AMOUNT, "untrusted_pending",
                             "untrusted pending balance (outputs created by "
                             "others that are in the mempool)"},
                            {RPCResult::Type::STR_AMOUNT, "immature",
                             "balance from immature coinbase outputs"},
                        }},
                   }},
         RPCExamples{HelpExampleCli("getbalances", "") +
                     HelpExampleRpc("getbalances", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const rpc_wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!rpc_wallet) {
                 return NullUniValue;
             }
             CWallet &wallet = *rpc_wallet;
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             wallet.BlockUntilSyncedToCurrentChain();
 
             LOCK(wallet.cs_wallet);
 
             const auto bal = GetBalance(wallet);
             UniValue balances{UniValue::VOBJ};
             {
                 UniValue balances_mine{UniValue::VOBJ};
                 balances_mine.pushKV("trusted", bal.m_mine_trusted);
                 balances_mine.pushKV("untrusted_pending",
                                      bal.m_mine_untrusted_pending);
                 balances_mine.pushKV("immature", bal.m_mine_immature);
                 if (wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
                     // If the AVOID_REUSE flag is set, bal has been set to just
                     // the un-reused address balance. Get the total balance, and
                     // then subtract bal to get the reused address balance.
                     const auto full_bal = GetBalance(wallet, 0, false);
                     balances_mine.pushKV("used",
                                          full_bal.m_mine_trusted +
                                              full_bal.m_mine_untrusted_pending -
                                              bal.m_mine_trusted -
                                              bal.m_mine_untrusted_pending);
                 }
                 balances.pushKV("mine", balances_mine);
             }
             auto spk_man = wallet.GetLegacyScriptPubKeyMan();
             if (spk_man && spk_man->HaveWatchOnly()) {
                 UniValue balances_watchonly{UniValue::VOBJ};
                 balances_watchonly.pushKV("trusted", bal.m_watchonly_trusted);
                 balances_watchonly.pushKV("untrusted_pending",
                                           bal.m_watchonly_untrusted_pending);
                 balances_watchonly.pushKV("immature", bal.m_watchonly_immature);
                 balances.pushKV("watchonly", balances_watchonly);
             }
             return balances;
         },
     };
 }
 
 static RPCHelpMan getwalletinfo() {
     return RPCHelpMan{
         "getwalletinfo",
         "Returns an object containing various wallet state info.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {{
                 {RPCResult::Type::STR, "walletname", "the wallet name"},
                 {RPCResult::Type::NUM, "walletversion", "the wallet version"},
                 {RPCResult::Type::STR_AMOUNT, "balance",
                  "DEPRECATED. Identical to getbalances().mine.trusted"},
                 {RPCResult::Type::STR_AMOUNT, "unconfirmed_balance",
                  "DEPRECATED. Identical to "
                  "getbalances().mine.untrusted_pending"},
                 {RPCResult::Type::STR_AMOUNT, "immature_balance",
                  "DEPRECATED. Identical to getbalances().mine.immature"},
                 {RPCResult::Type::NUM, "txcount",
                  "the total number of transactions in the wallet"},
                 {RPCResult::Type::NUM_TIME, "keypoololdest",
                  "the " + UNIX_EPOCH_TIME +
                      " of the oldest pre-generated key in the key pool. Legacy "
                      "wallets only."},
                 {RPCResult::Type::NUM, "keypoolsize",
                  "how many new keys are pre-generated (only counts external "
                  "keys)"},
                 {RPCResult::Type::NUM, "keypoolsize_hd_internal",
                  "how many new keys are pre-generated for internal use (used "
                  "for change outputs, only appears if the wallet is using this "
                  "feature, otherwise external keys are used)"},
                 {RPCResult::Type::NUM_TIME, "unlocked_until",
                  /* optional */ true,
                  "the " + UNIX_EPOCH_TIME +
                      " until which the wallet is unlocked for transfers, or 0 "
                      "if the wallet is locked (only present for "
                      "passphrase-encrypted wallets)"},
                 {RPCResult::Type::STR_AMOUNT, "paytxfee",
                  "the transaction fee configuration, set in " +
                      Currency::get().ticker + "/kB"},
                 {RPCResult::Type::STR_HEX, "hdseedid", /* optional */ true,
                  "the Hash160 of the HD seed (only present when HD is "
                  "enabled)"},
                 {RPCResult::Type::BOOL, "private_keys_enabled",
                  "false if privatekeys are disabled for this wallet (enforced "
                  "watch-only wallet)"},
                 {RPCResult::Type::OBJ,
                  "scanning",
                  "current scanning details, or false if no scan is in progress",
                  {
                      {RPCResult::Type::NUM, "duration",
                       "elapsed seconds since scan start"},
                      {RPCResult::Type::NUM, "progress",
                       "scanning progress percentage [0.0, 1.0]"},
                  }},
                 {RPCResult::Type::BOOL, "avoid_reuse",
                  "whether this wallet tracks clean/dirty coins in terms of "
                  "reuse"},
                 {RPCResult::Type::BOOL, "descriptors",
                  "whether this wallet uses descriptors for scriptPubKey "
                  "management"},
             }},
         },
         RPCExamples{HelpExampleCli("getwalletinfo", "") +
                     HelpExampleRpc("getwalletinfo", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             UniValue obj(UniValue::VOBJ);
 
             size_t kpExternalSize = pwallet->KeypoolCountExternalKeys();
             const auto bal = GetBalance(*pwallet);
             int64_t kp_oldest = pwallet->GetOldestKeyPoolTime();
             obj.pushKV("walletname", pwallet->GetName());
             obj.pushKV("walletversion", pwallet->GetVersion());
             obj.pushKV("balance", bal.m_mine_trusted);
             obj.pushKV("unconfirmed_balance", bal.m_mine_untrusted_pending);
             obj.pushKV("immature_balance", bal.m_mine_immature);
             obj.pushKV("txcount", (int)pwallet->mapWallet.size());
             if (kp_oldest > 0) {
                 obj.pushKV("keypoololdest", kp_oldest);
             }
             obj.pushKV("keypoolsize", (int64_t)kpExternalSize);
 
             LegacyScriptPubKeyMan *spk_man =
                 pwallet->GetLegacyScriptPubKeyMan();
             if (spk_man) {
                 CKeyID seed_id = spk_man->GetHDChain().seed_id;
                 if (!seed_id.IsNull()) {
                     obj.pushKV("hdseedid", seed_id.GetHex());
                 }
             }
 
             if (pwallet->CanSupportFeature(FEATURE_HD_SPLIT)) {
                 obj.pushKV("keypoolsize_hd_internal",
                            int64_t(pwallet->GetKeyPoolSize() - kpExternalSize));
             }
             if (pwallet->IsCrypted()) {
                 obj.pushKV("unlocked_until", pwallet->nRelockTime);
             }
             obj.pushKV("paytxfee", pwallet->m_pay_tx_fee.GetFeePerK());
             obj.pushKV(
                 "private_keys_enabled",
                 !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
             if (pwallet->IsScanning()) {
                 UniValue scanning(UniValue::VOBJ);
                 scanning.pushKV("duration", pwallet->ScanningDuration() / 1000);
                 scanning.pushKV("progress", pwallet->ScanningProgress());
                 obj.pushKV("scanning", scanning);
             } else {
                 obj.pushKV("scanning", false);
             }
             obj.pushKV("avoid_reuse",
                        pwallet->IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE));
             obj.pushKV("descriptors",
                        pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
             return obj;
         },
     };
 }
 
 static RPCHelpMan listwalletdir() {
     return RPCHelpMan{
         "listwalletdir",
         "Returns a list of wallets in the wallet directory.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::ARR,
                  "wallets",
                  "",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR, "name", "The wallet name"},
                       }},
                  }},
             }},
         RPCExamples{HelpExampleCli("listwalletdir", "") +
                     HelpExampleRpc("listwalletdir", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             UniValue wallets(UniValue::VARR);
             for (const auto &path : ListWalletDir()) {
                 UniValue wallet(UniValue::VOBJ);
                 wallet.pushKV("name", path.u8string());
                 wallets.push_back(wallet);
             }
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("wallets", wallets);
             return result;
         },
     };
 }
 
 static RPCHelpMan listwallets() {
     return RPCHelpMan{
         "listwallets",
         "Returns a list of currently loaded wallets.\n"
         "For full information on the wallet, use \"getwalletinfo\"\n",
         {},
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "walletname", "the wallet name"},
                   }},
         RPCExamples{HelpExampleCli("listwallets", "") +
                     HelpExampleRpc("listwallets", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             UniValue obj(UniValue::VARR);
 
             for (const std::shared_ptr<CWallet> &wallet : GetWallets()) {
                 LOCK(wallet->cs_wallet);
                 obj.push_back(wallet->GetName());
             }
 
             return obj;
         },
     };
 }
 
 static RPCHelpMan loadwallet() {
     return RPCHelpMan{
         "loadwallet",
         "Loads a wallet from a wallet file or directory."
         "\nNote that all wallet command-line options used when starting "
         "bitcoind will be"
         "\napplied to the new wallet (eg -rescan, etc).\n",
         {
             {"filename", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The wallet directory or .dat file."},
             {"load_on_startup", RPCArg::Type::BOOL, /* default */ "null",
              "Save wallet name to persistent settings and load on startup. "
              "True to add wallet to startup list, false to remove, null to "
              "leave unchanged."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "name",
                        "The wallet name if loaded successfully."},
                       {RPCResult::Type::STR, "warning",
                        "Warning message if wallet was not loaded cleanly."},
                   }},
         RPCExamples{HelpExampleCli("loadwallet", "\"test.dat\"") +
                     HelpExampleRpc("loadwallet", "\"test.dat\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             WalletContext &context = EnsureWalletContext(request.context);
             const std::string name(request.params[0].get_str());
 
             auto [wallet, warnings] =
                 LoadWalletHelper(context, request.params[1], name);
 
             UniValue obj(UniValue::VOBJ);
             obj.pushKV("name", wallet->GetName());
             obj.pushKV("warning", Join(warnings, Untranslated("\n")).original);
 
             return obj;
         },
     };
 }
 
 static RPCHelpMan setwalletflag() {
     std::string flags = "";
     for (auto &it : WALLET_FLAG_MAP) {
         if (it.second & MUTABLE_WALLET_FLAGS) {
             flags += (flags == "" ? "" : ", ") + it.first;
         }
     }
     return RPCHelpMan{
         "setwalletflag",
         "Change the state of the given wallet flag for a wallet.\n",
         {
             {"flag", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The name of the flag to change. Current available flags: " +
                  flags},
             {"value", RPCArg::Type::BOOL, /* default */ "true",
              "The new state."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "flag_name",
                        "The name of the flag that was modified"},
                       {RPCResult::Type::BOOL, "flag_state",
                        "The new state of the flag"},
                       {RPCResult::Type::STR, "warnings",
                        "Any warnings associated with the change"},
                   }},
         RPCExamples{HelpExampleCli("setwalletflag", "avoid_reuse") +
                     HelpExampleRpc("setwalletflag", "\"avoid_reuse\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             std::string flag_str = request.params[0].get_str();
             bool value =
                 request.params[1].isNull() || request.params[1].get_bool();
 
             if (!WALLET_FLAG_MAP.count(flag_str)) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf("Unknown wallet flag: %s", flag_str));
             }
 
             auto flag = WALLET_FLAG_MAP.at(flag_str);
 
             if (!(flag & MUTABLE_WALLET_FLAGS)) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf("Wallet flag is immutable: %s", flag_str));
             }
 
             UniValue res(UniValue::VOBJ);
 
             if (pwallet->IsWalletFlagSet(flag) == value) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     strprintf("Wallet flag is already set to %s: %s",
                               value ? "true" : "false", flag_str));
             }
 
             res.pushKV("flag_name", flag_str);
             res.pushKV("flag_state", value);
 
             if (value) {
                 pwallet->SetWalletFlag(flag);
             } else {
                 pwallet->UnsetWalletFlag(flag);
             }
 
             if (flag && value && WALLET_FLAG_CAVEATS.count(flag)) {
                 res.pushKV("warnings", WALLET_FLAG_CAVEATS.at(flag));
             }
 
             return res;
         },
     };
 }
 
 static RPCHelpMan createwallet() {
     return RPCHelpMan{
         "createwallet",
         "Creates and loads a new wallet.\n",
         {
             {"wallet_name", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The name for the new wallet. If this is a path, the wallet will "
              "be created at the path location."},
             {"disable_private_keys", RPCArg::Type::BOOL, /* default */ "false",
              "Disable the possibility of private keys (only watchonlys are "
              "possible in this mode)."},
             {"blank", RPCArg::Type::BOOL, /* default */ "false",
              "Create a blank wallet. A blank wallet has no keys or HD seed. "
              "One can be set using sethdseed."},
             {"passphrase", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
              "Encrypt the wallet with this passphrase."},
             {"avoid_reuse", RPCArg::Type::BOOL, /* default */ "false",
              "Keep track of coin reuse, and treat dirty and clean coins "
              "differently with privacy considerations in mind."},
             {"descriptors", RPCArg::Type::BOOL, /* default */ "false",
              "Create a native descriptor wallet. The wallet will use "
              "descriptors internally to handle address creation"},
             {"load_on_startup", RPCArg::Type::BOOL, /* default */ "null",
              "Save wallet name to persistent settings and load on startup. "
              "True to add wallet to startup list, false to remove, null to "
              "leave unchanged."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "name",
                        "The wallet name if created successfully. If the wallet "
                        "was created using a full path, the wallet_name will be "
                        "the full path."},
                       {RPCResult::Type::STR, "warning",
                        "Warning message if wallet was not loaded cleanly."},
                   }},
         RPCExamples{
             HelpExampleCli("createwallet", "\"testwallet\"") +
             HelpExampleRpc("createwallet", "\"testwallet\"") +
             HelpExampleCliNamed("createwallet", {{"wallet_name", "descriptors"},
                                                  {"avoid_reuse", true},
                                                  {"descriptors", true},
                                                  {"load_on_startup", true}}) +
             HelpExampleRpcNamed("createwallet", {{"wallet_name", "descriptors"},
                                                  {"avoid_reuse", true},
                                                  {"descriptors", true},
                                                  {"load_on_startup", true}})},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             WalletContext &context = EnsureWalletContext(request.context);
             uint64_t flags = 0;
             if (!request.params[1].isNull() && request.params[1].get_bool()) {
                 flags |= WALLET_FLAG_DISABLE_PRIVATE_KEYS;
             }
 
             if (!request.params[2].isNull() && request.params[2].get_bool()) {
                 flags |= WALLET_FLAG_BLANK_WALLET;
             }
 
             SecureString passphrase;
             passphrase.reserve(100);
             std::vector<bilingual_str> warnings;
             if (!request.params[3].isNull()) {
                 passphrase = request.params[3].get_str().c_str();
                 if (passphrase.empty()) {
                     // Empty string means unencrypted
                     warnings.emplace_back(Untranslated(
                         "Empty string given as passphrase, wallet will "
                         "not be encrypted."));
                 }
             }
 
             if (!request.params[4].isNull() && request.params[4].get_bool()) {
                 flags |= WALLET_FLAG_AVOID_REUSE;
             }
             if (!request.params[5].isNull() && request.params[5].get_bool()) {
                 flags |= WALLET_FLAG_DESCRIPTORS;
                 warnings.emplace_back(Untranslated(
                     "Wallet is an experimental descriptor wallet"));
             }
 
             DatabaseOptions options;
             DatabaseStatus status;
             options.require_create = true;
             options.create_flags = flags;
             options.create_passphrase = passphrase;
             bilingual_str error;
             std::optional<bool> load_on_start =
                 request.params[6].isNull()
                     ? std::nullopt
                     : std::make_optional<bool>(request.params[6].get_bool());
             std::shared_ptr<CWallet> wallet =
                 CreateWallet(*context.chain, request.params[0].get_str(),
                              load_on_start, options, status, error, warnings);
             if (!wallet) {
                 RPCErrorCode code = status == DatabaseStatus::FAILED_ENCRYPT
                                         ? RPC_WALLET_ENCRYPTION_FAILED
                                         : RPC_WALLET_ERROR;
                 throw JSONRPCError(code, error.original);
             }
 
             UniValue obj(UniValue::VOBJ);
             obj.pushKV("name", wallet->GetName());
             obj.pushKV("warning", Join(warnings, Untranslated("\n")).original);
 
             return obj;
         },
     };
 }
 
 static RPCHelpMan unloadwallet() {
     return RPCHelpMan{
         "unloadwallet",
         "Unloads the wallet referenced by the request endpoint otherwise "
         "unloads the wallet specified in the argument.\n"
         "Specifying the wallet name on a wallet endpoint is invalid.",
         {
             {"wallet_name", RPCArg::Type::STR,
              /* default */ "the wallet name from the RPC request",
              "The name of the wallet to unload."},
             {"load_on_startup", RPCArg::Type::BOOL, /* default */ "null",
              "Save wallet name to persistent settings and load on startup. "
              "True to add wallet to startup list, false to remove, null to "
              "leave unchanged."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "warning",
                        "Warning message if wallet was not unloaded cleanly."},
                   }},
         RPCExamples{HelpExampleCli("unloadwallet", "wallet_name") +
                     HelpExampleRpc("unloadwallet", "wallet_name")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             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).
             std::vector<bilingual_str> warnings;
             std::optional<bool> load_on_start =
                 request.params[1].isNull()
                     ? std::nullopt
                     : std::make_optional<bool>(request.params[1].get_bool());
             if (!RemoveWallet(wallet, load_on_start, warnings)) {
                 throw JSONRPCError(RPC_MISC_ERROR,
                                    "Requested wallet already unloaded");
             }
 
             UnloadWallet(std::move(wallet));
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("warning",
                           Join(warnings, Untranslated("\n")).original);
             return result;
         },
     };
 }
 
 static RPCHelpMan listunspent() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "listunspent",
         "Returns array of unspent transaction outputs\n"
         "with between minconf and maxconf (inclusive) confirmations.\n"
         "Optionally filter to only include txouts paid to specified "
         "addresses.\n",
         {
             {"minconf", RPCArg::Type::NUM, /* default */ "1",
              "The minimum confirmations to filter"},
             {"maxconf", RPCArg::Type::NUM, /* default */ "9999999",
              "The maximum confirmations to filter"},
             {
                 "addresses",
                 RPCArg::Type::ARR,
                 /* default */ "empty array",
                 "The bitcoin addresses to filter",
                 {
                     {"address", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                      "bitcoin address"},
                 },
             },
             {"include_unsafe", RPCArg::Type::BOOL, /* default */ "true",
              "Include outputs that are not safe to spend\n"
              "                  See description of \"safe\" attribute below."},
             {"query_options",
              RPCArg::Type::OBJ,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "JSON with query options",
              {
                  {"minimumAmount", RPCArg::Type::AMOUNT, /* default */ "0",
                   "Minimum value of each UTXO in " + ticker + ""},
                  {"maximumAmount", RPCArg::Type::AMOUNT,
                   /* default */ "unlimited",
                   "Maximum value of each UTXO in " + ticker + ""},
                  {"maximumCount", RPCArg::Type::NUM, /* default */ "unlimited",
                   "Maximum number of UTXOs"},
                  {"minimumSumAmount", RPCArg::Type::AMOUNT,
                   /* default */ "unlimited",
                   "Minimum sum value of all UTXOs in " + ticker + ""},
              },
              "query_options"},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "",
                  "",
                  {
                      {RPCResult::Type::STR_HEX, "txid", "the transaction id"},
                      {RPCResult::Type::NUM, "vout", "the vout value"},
                      {RPCResult::Type::STR, "address", "the bitcoin address"},
                      {RPCResult::Type::STR, "label",
                       "The associated label, or \"\" for the default label"},
                      {RPCResult::Type::STR, "scriptPubKey", "the script key"},
                      {RPCResult::Type::STR_AMOUNT, "amount",
                       "the transaction output amount in " + ticker},
                      {RPCResult::Type::NUM, "confirmations",
                       "The number of confirmations"},
                      {RPCResult::Type::NUM, "ancestorcount",
                       /* optional */ true,
                       "The number of in-mempool ancestor transactions, "
                       "including this one (if transaction is in the mempool)"},
                      {RPCResult::Type::NUM, "ancestorsize", /* optional */ true,
                       "The virtual transaction size of in-mempool ancestors, "
                       "including this one (if transaction is in the mempool)"},
                      {RPCResult::Type::STR_AMOUNT, "ancestorfees",
                       /* optional */ true,
                       "The total fees of in-mempool ancestors (including this "
                       "one) with fee deltas used for mining priority in " +
                           ticker + " (if transaction is in the mempool)"},
                      {RPCResult::Type::STR_HEX, "redeemScript",
                       "The redeemScript if scriptPubKey is P2SH"},
                      {RPCResult::Type::BOOL, "spendable",
                       "Whether we have the private keys to spend this output"},
                      {RPCResult::Type::BOOL, "solvable",
                       "Whether we know how to spend this output, ignoring the "
                       "lack of keys"},
                      {RPCResult::Type::BOOL, "reused",
                       "(only present if avoid_reuse is set) Whether this "
                       "output is reused/dirty (sent to an address that was "
                       "previously spent from)"},
                      {RPCResult::Type::STR, "desc",
                       "(only when solvable) A descriptor for spending this "
                       "output"},
                      {RPCResult::Type::BOOL, "safe",
                       "Whether this output is considered safe to spend. "
                       "Unconfirmed transactions\n"
                       "from outside keys and unconfirmed replacement "
                       "transactions are considered unsafe\n"
                       "and are not eligible for spending by fundrawtransaction "
                       "and sendtoaddress."},
                  }},
             }},
         RPCExamples{
             HelpExampleCli("listunspent", "") +
             HelpExampleCli("listunspent",
                            "6 9999999 "
                            "\"[\\\"1PGFqEzfmQch1gKD3ra4k18PNj3tTUUSqg\\\","
                            "\\\"1LtvqCaApEdUGFkpKMM4MstjcaL4dKg8SP\\\"]\"") +
             HelpExampleRpc("listunspent",
                            "6, 9999999 "
                            "\"[\\\"1PGFqEzfmQch1gKD3ra4k18PNj3tTUUSqg\\\","
                            "\\\"1LtvqCaApEdUGFkpKMM4MstjcaL4dKg8SP\\\"]\"") +
             HelpExampleCli(
                 "listunspent",
                 "6 9999999 '[]' true '{ \"minimumAmount\": 0.005 }'") +
             HelpExampleRpc(
                 "listunspent",
                 "6, 9999999, [] , true, { \"minimumAmount\": 0.005 } ")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             int nMinDepth = 1;
             if (!request.params[0].isNull()) {
                 RPCTypeCheckArgument(request.params[0], UniValue::VNUM);
                 nMinDepth = request.params[0].get_int();
             }
 
             int nMaxDepth = 9999999;
             if (!request.params[1].isNull()) {
                 RPCTypeCheckArgument(request.params[1], UniValue::VNUM);
                 nMaxDepth = request.params[1].get_int();
             }
 
             std::set<CTxDestination> destinations;
             if (!request.params[2].isNull()) {
                 RPCTypeCheckArgument(request.params[2], UniValue::VARR);
                 UniValue inputs = request.params[2].get_array();
                 for (size_t idx = 0; idx < inputs.size(); idx++) {
                     const UniValue &input = inputs[idx];
                     CTxDestination dest = DecodeDestination(
                         input.get_str(), wallet->GetChainParams());
                     if (!IsValidDestination(dest)) {
                         throw JSONRPCError(
                             RPC_INVALID_ADDRESS_OR_KEY,
                             std::string("Invalid Bitcoin address: ") +
                                 input.get_str());
                     }
                     if (!destinations.insert(dest).second) {
                         throw JSONRPCError(
                             RPC_INVALID_PARAMETER,
                             std::string(
                                 "Invalid parameter, duplicated address: ") +
                                 input.get_str());
                     }
                 }
             }
 
             bool include_unsafe = true;
             if (!request.params[3].isNull()) {
                 RPCTypeCheckArgument(request.params[3], UniValue::VBOOL);
                 include_unsafe = request.params[3].get_bool();
             }
 
             Amount nMinimumAmount = Amount::zero();
             Amount nMaximumAmount = MAX_MONEY;
             Amount nMinimumSumAmount = MAX_MONEY;
             uint64_t nMaximumCount = 0;
 
             if (!request.params[4].isNull()) {
                 const UniValue &options = request.params[4].get_obj();
 
                 RPCTypeCheckObj(
                     options,
                     {
                         {"minimumAmount", UniValueType()},
                         {"maximumAmount", UniValueType()},
                         {"minimumSumAmount", UniValueType()},
                         {"maximumCount", UniValueType(UniValue::VNUM)},
                     },
                     true, true);
 
                 if (options.exists("minimumAmount")) {
                     nMinimumAmount = AmountFromValue(options["minimumAmount"]);
                 }
 
                 if (options.exists("maximumAmount")) {
                     nMaximumAmount = AmountFromValue(options["maximumAmount"]);
                 }
 
                 if (options.exists("minimumSumAmount")) {
                     nMinimumSumAmount =
                         AmountFromValue(options["minimumSumAmount"]);
                 }
 
                 if (options.exists("maximumCount")) {
                     nMaximumCount = options["maximumCount"].get_int64();
                 }
             }
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             UniValue results(UniValue::VARR);
             std::vector<COutput> vecOutputs;
             {
                 CCoinControl cctl;
                 cctl.m_avoid_address_reuse = false;
                 cctl.m_min_depth = nMinDepth;
                 cctl.m_max_depth = nMaxDepth;
                 LOCK(pwallet->cs_wallet);
                 AvailableCoins(*pwallet, vecOutputs, !include_unsafe, &cctl,
                                nMinimumAmount, nMaximumAmount,
                                nMinimumSumAmount, nMaximumCount);
             }
 
             LOCK(pwallet->cs_wallet);
 
             const bool avoid_reuse =
                 pwallet->IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE);
 
             for (const COutput &out : vecOutputs) {
                 CTxDestination address;
                 const CScript &scriptPubKey =
                     out.tx->tx->vout[out.i].scriptPubKey;
                 bool fValidAddress = ExtractDestination(scriptPubKey, address);
                 bool reused =
                     avoid_reuse && pwallet->IsSpentKey(out.tx->GetId(), out.i);
 
                 if (destinations.size() &&
                     (!fValidAddress || !destinations.count(address))) {
                     continue;
                 }
 
                 UniValue entry(UniValue::VOBJ);
                 entry.pushKV("txid", out.tx->GetId().GetHex());
                 entry.pushKV("vout", out.i);
 
                 if (fValidAddress) {
                     entry.pushKV("address", EncodeDestination(address, config));
 
                     const auto *address_book_entry =
                         pwallet->FindAddressBookEntry(address);
                     if (address_book_entry) {
                         entry.pushKV("label", address_book_entry->GetLabel());
                     }
 
                     std::unique_ptr<SigningProvider> provider =
                         pwallet->GetSolvingProvider(scriptPubKey);
                     if (provider) {
                         if (scriptPubKey.IsPayToScriptHash()) {
                             const CScriptID &hash =
                                 CScriptID(boost::get<ScriptHash>(address));
                             CScript redeemScript;
                             if (provider->GetCScript(hash, redeemScript)) {
                                 entry.pushKV("redeemScript",
                                              HexStr(redeemScript));
                             }
                         }
                     }
                 }
 
                 entry.pushKV("scriptPubKey", HexStr(scriptPubKey));
                 entry.pushKV("amount", out.tx->tx->vout[out.i].nValue);
                 entry.pushKV("confirmations", out.nDepth);
                 if (!out.nDepth) {
                     size_t ancestor_count, descendant_count, ancestor_size;
                     Amount ancestor_fees;
                     pwallet->chain().getTransactionAncestry(
                         out.tx->GetId(), ancestor_count, descendant_count,
                         &ancestor_size, &ancestor_fees);
                     if (ancestor_count) {
                         entry.pushKV("ancestorcount", uint64_t(ancestor_count));
                         entry.pushKV("ancestorsize", uint64_t(ancestor_size));
                         entry.pushKV("ancestorfees", ancestor_fees);
                     }
                 }
                 entry.pushKV("spendable", out.fSpendable);
                 entry.pushKV("solvable", out.fSolvable);
                 if (out.fSolvable) {
                     std::unique_ptr<SigningProvider> provider =
                         pwallet->GetSolvingProvider(scriptPubKey);
                     if (provider) {
                         auto descriptor =
                             InferDescriptor(scriptPubKey, *provider);
                         entry.pushKV("desc", descriptor->ToString());
                     }
                 }
                 if (avoid_reuse) {
                     entry.pushKV("reused", reused);
                 }
                 entry.pushKV("safe", out.fSafe);
                 results.push_back(entry);
             }
 
             return results;
         },
     };
 }
 
 void FundTransaction(CWallet *const pwallet, CMutableTransaction &tx,
                      Amount &fee_out, int &change_position,
                      const UniValue &options, CCoinControl &coinControl) {
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
     pwallet->BlockUntilSyncedToCurrentChain();
 
     change_position = -1;
     bool lockUnspents = false;
     UniValue subtractFeeFromOutputs;
     std::set<int> setSubtractFeeFromOutputs;
 
     if (!options.isNull()) {
         if (options.type() == UniValue::VBOOL) {
             // backward compatibility bool only fallback
             coinControl.fAllowWatchOnly = options.get_bool();
         } else {
             RPCTypeCheckArgument(options, UniValue::VOBJ);
             RPCTypeCheckObj(
                 options,
                 {
                     {"add_inputs", UniValueType(UniValue::VBOOL)},
                     {"add_to_wallet", UniValueType(UniValue::VBOOL)},
                     {"changeAddress", UniValueType(UniValue::VSTR)},
                     {"change_address", UniValueType(UniValue::VSTR)},
                     {"changePosition", UniValueType(UniValue::VNUM)},
                     {"change_position", UniValueType(UniValue::VNUM)},
                     {"includeWatching", UniValueType(UniValue::VBOOL)},
                     {"include_watching", UniValueType(UniValue::VBOOL)},
                     {"inputs", UniValueType(UniValue::VARR)},
                     {"lockUnspents", UniValueType(UniValue::VBOOL)},
                     {"lock_unspents", UniValueType(UniValue::VBOOL)},
                     {"locktime", UniValueType(UniValue::VNUM)},
                     // will be checked below
                     {"feeRate", UniValueType()},
                     {"fee_rate", UniValueType()},
                     {"psbt", UniValueType(UniValue::VBOOL)},
                     {"subtractFeeFromOutputs", UniValueType(UniValue::VARR)},
                     {"subtract_fee_from_outputs", UniValueType(UniValue::VARR)},
                 },
                 true, true);
 
             if (options.exists("add_inputs")) {
                 coinControl.m_add_inputs = options["add_inputs"].get_bool();
             }
 
             if (options.exists("changeAddress") ||
                 options.exists("change_address")) {
                 const std::string change_address_str =
                     (options.exists("change_address")
                          ? options["change_address"]
                          : options["changeAddress"])
                         .get_str();
                 CTxDestination dest = DecodeDestination(
                     change_address_str, pwallet->GetChainParams());
 
                 if (!IsValidDestination(dest)) {
                     throw JSONRPCError(
                         RPC_INVALID_ADDRESS_OR_KEY,
                         "Change address must be a valid bitcoin address");
                 }
 
                 coinControl.destChange = dest;
             }
 
             if (options.exists("changePosition") ||
                 options.exists("change_position")) {
                 change_position = (options.exists("change_position")
                                        ? options["change_position"]
                                        : options["changePosition"])
                                       .get_int();
             }
 
             const UniValue include_watching_option =
                 options.exists("include_watching") ? options["include_watching"]
                                                    : options["includeWatching"];
             coinControl.fAllowWatchOnly =
                 ParseIncludeWatchonly(include_watching_option, *pwallet);
 
             if (options.exists("lockUnspents") ||
                 options.exists("lock_unspents")) {
                 lockUnspents =
                     (options.exists("lock_unspents") ? options["lock_unspents"]
                                                      : options["lockUnspents"])
                         .get_bool();
             }
 
             if (options.exists("feeRate") || options.exists("fee_rate")) {
                 coinControl.m_feerate = CFeeRate(AmountFromValue(
                     options.exists("fee_rate") ? options["fee_rate"]
                                                : options["feeRate"]));
                 coinControl.fOverrideFeeRate = true;
             }
 
             if (options.exists("subtractFeeFromOutputs") ||
                 options.exists("subtract_fee_from_outputs")) {
                 subtractFeeFromOutputs =
                     (options.exists("subtract_fee_from_outputs")
                          ? options["subtract_fee_from_outputs"]
                          : options["subtractFeeFromOutputs"])
                         .get_array();
             }
         }
     } else {
         // if options is null and not a bool
         coinControl.fAllowWatchOnly =
             ParseIncludeWatchonly(NullUniValue, *pwallet);
     }
 
     if (tx.vout.size() == 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "TX must have at least one output");
     }
 
     if (change_position != -1 &&
         (change_position < 0 ||
          (unsigned int)change_position > tx.vout.size())) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "changePosition out of bounds");
     }
 
     for (size_t idx = 0; idx < subtractFeeFromOutputs.size(); idx++) {
         int pos = subtractFeeFromOutputs[idx].get_int();
         if (setSubtractFeeFromOutputs.count(pos)) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Invalid parameter, duplicated position: %d", pos));
         }
         if (pos < 0) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Invalid parameter, negative position: %d", pos));
         }
         if (pos >= int(tx.vout.size())) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 strprintf("Invalid parameter, position too large: %d", pos));
         }
         setSubtractFeeFromOutputs.insert(pos);
     }
 
     bilingual_str error;
 
     if (!FundTransaction(*pwallet, tx, fee_out, change_position, error,
                          lockUnspents, setSubtractFeeFromOutputs,
                          coinControl)) {
         throw JSONRPCError(RPC_WALLET_ERROR, error.original);
     }
 }
 
 static RPCHelpMan fundrawtransaction() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "fundrawtransaction",
         "If the transaction has no inputs, they will be automatically selected "
         "to meet its out value.\n"
         "It will add at most one change output to the outputs.\n"
         "No existing outputs will be modified unless "
         "\"subtractFeeFromOutputs\" is specified.\n"
         "Note that inputs which were signed may need to be resigned after "
         "completion since in/outputs have been added.\n"
         "The inputs added will not be signed, use signrawtransactionwithkey or "
         "signrawtransactionwithwallet for that.\n"
         "Note that all existing inputs must have their previous output "
         "transaction be in the wallet.\n"
         "Note that all inputs selected must be of standard form and P2SH "
         "scripts must be\n"
         "in the wallet using importaddress or addmultisigaddress (to calculate "
         "fees).\n"
         "You can see whether this is the case by checking the \"solvable\" "
         "field in the listunspent output.\n"
         "Only pay-to-pubkey, multisig, and P2SH versions thereof are currently "
         "supported for watch-only\n",
         {
             {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hex string of the raw transaction"},
             {"options",
              RPCArg::Type::OBJ,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "for backward compatibility: passing in a true instead of an "
              "object will result in {\"includeWatching\":true}",
              {
                  {"add_inputs", RPCArg::Type::BOOL, /* default */ "true",
                   "For a transaction with existing inputs, automatically "
                   "include more if they are not enough."},
                  {"changeAddress", RPCArg::Type::STR,
                   /* default */ "pool address",
                   "The bitcoin address to receive the change"},
                  {"changePosition", RPCArg::Type::NUM, /* default */ "",
                   "The index of the change output"},
                  {"includeWatching", RPCArg::Type::BOOL,
                   /* default */ "true for watch-only wallets, otherwise false",
                   "Also select inputs which are watch only.\n"
                   "Only solvable inputs can be used. Watch-only destinations "
                   "are solvable if the public key and/or output script was "
                   "imported,\n"
                   "e.g. with 'importpubkey' or 'importmulti' with the "
                   "'pubkeys' or 'desc' field."},
                  {"lockUnspents", RPCArg::Type::BOOL, /* default */ "false",
                   "Lock selected unspent outputs"},
                  {"feeRate", RPCArg::Type::AMOUNT, /* default */
                   "not set: makes wallet determine the fee",
                   "Set a specific fee rate in " + ticker + "/kB"},
                  {
                      "subtractFeeFromOutputs",
                      RPCArg::Type::ARR,
                      /* default */ "empty array",
                      "The integers.\n"
                      "                              The fee will be equally "
                      "deducted from the amount of each specified output.\n"
                      "                              Those recipients will "
                      "receive less bitcoins than you enter in their "
                      "corresponding amount field.\n"
                      "                              If no outputs are "
                      "specified here, the sender pays the fee.",
                      {
                          {"vout_index", RPCArg::Type::NUM,
                           RPCArg::Optional::OMITTED,
                           "The zero-based output index, before a change output "
                           "is added."},
                      },
                  },
              },
              "options"},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR_HEX, "hex",
                        "The resulting raw transaction (hex-encoded string)"},
                       {RPCResult::Type::STR_AMOUNT, "fee",
                        "Fee in " + ticker + " the resulting transaction pays"},
                       {RPCResult::Type::NUM, "changepos",
                        "The position of the added change output, or -1"},
                   }},
         RPCExamples{
             "\nCreate a transaction with no inputs\n" +
             HelpExampleCli("createrawtransaction",
                            "\"[]\" \"{\\\"myaddress\\\":10000}\"") +
             "\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\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             RPCTypeCheck(request.params, {UniValue::VSTR, UniValueType()});
 
             // parse hex string from parameter
             CMutableTransaction tx;
             if (!DecodeHexTx(tx, request.params[0].get_str())) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    "TX decode failed");
             }
 
             Amount fee;
             int change_position;
             CCoinControl coin_control;
             // Automatically select (additional) coins. Can be overridden by
             // options.add_inputs.
             coin_control.m_add_inputs = true;
             FundTransaction(pwallet, tx, fee, change_position,
                             request.params[1], coin_control);
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("hex", EncodeHexTx(CTransaction(tx)));
             result.pushKV("fee", fee);
             result.pushKV("changepos", change_position);
 
             return result;
         },
     };
 }
 
 RPCHelpMan signrawtransactionwithwallet() {
     return RPCHelpMan{
         "signrawtransactionwithwallet",
         "Sign inputs for raw transaction (serialized, hex-encoded).\n"
         "The second optional argument (may be null) is an array of previous "
         "transaction outputs that\n"
         "this transaction depends on but may not yet be in the block chain.\n" +
             HELP_REQUIRING_PASSPHRASE,
         {
             {"hexstring", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The transaction hex string"},
             {
                 "prevtxs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::OMITTED_NAMED_ARG,
                 "The previous dependent transaction outputs",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                             {"scriptPubKey", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "script key"},
                             {"redeemScript", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::OMITTED, "(required for P2SH)"},
                             {"amount", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO, "The amount spent"},
                         },
                     },
                 },
             },
             {"sighashtype", RPCArg::Type::STR, /* default */ "ALL|FORKID",
              "The signature hash type. Must be one of\n"
              "       \"ALL|FORKID\"\n"
              "       \"NONE|FORKID\"\n"
              "       \"SINGLE|FORKID\"\n"
              "       \"ALL|FORKID|ANYONECANPAY\"\n"
              "       \"NONE|FORKID|ANYONECANPAY\"\n"
              "       \"SINGLE|FORKID|ANYONECANPAY\""},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR_HEX, "hex",
                  "The hex-encoded raw transaction with signature(s)"},
                 {RPCResult::Type::BOOL, "complete",
                  "If the transaction has a complete set of signatures"},
                 {RPCResult::Type::ARR,
                  "errors",
                  /* optional */ true,
                  "Script verification errors (if there are any)",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "txid",
                            "The hash of the referenced, previous transaction"},
                           {RPCResult::Type::NUM, "vout",
                            "The index of the output to spent and used as "
                            "input"},
                           {RPCResult::Type::STR_HEX, "scriptSig",
                            "The hex-encoded signature script"},
                           {RPCResult::Type::NUM, "sequence",
                            "Script sequence number"},
                           {RPCResult::Type::STR, "error",
                            "Verification or signing error related to the "
                            "input"},
                       }},
                  }},
             }},
         RPCExamples{
             HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
             HelpExampleRpc("signrawtransactionwithwallet", "\"myhex\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             RPCTypeCheck(request.params,
                          {UniValue::VSTR, UniValue::VARR, UniValue::VSTR},
                          true);
 
             CMutableTransaction mtx;
             if (!DecodeHexTx(mtx, request.params[0].get_str())) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    "TX decode failed");
             }
 
             // Sign the transaction
             LOCK(pwallet->cs_wallet);
             EnsureWalletIsUnlocked(pwallet);
 
             // Fetch previous transactions (inputs):
             std::map<COutPoint, Coin> coins;
             for (const CTxIn &txin : mtx.vin) {
                 // Create empty map entry keyed by prevout.
                 coins[txin.prevout];
             }
             pwallet->chain().findCoins(coins);
 
             // Parse the prevtxs array
             ParsePrevouts(request.params[1], nullptr, coins);
 
             SigHashType nHashType = ParseSighashString(request.params[2]);
             if (!nHashType.hasForkId()) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Signature must use SIGHASH_FORKID");
             }
 
             // Script verification errors
             std::map<int, std::string> input_errors;
 
             bool complete =
                 pwallet->SignTransaction(mtx, coins, nHashType, input_errors);
             UniValue result(UniValue::VOBJ);
             SignTransactionResultToJSON(mtx, complete, coins, input_errors,
                                         result);
             return result;
         },
     };
 }
 
 RPCHelpMan rescanblockchain() {
     return RPCHelpMan{
         "rescanblockchain",
         "Rescan the local blockchain for wallet related transactions.\n"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\n",
         {
             {"start_height", RPCArg::Type::NUM, /* default */ "0",
              "block height where the rescan should start"},
             {"stop_height", RPCArg::Type::NUM,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "the last block height that should be scanned"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "start_height",
                  "The block height where the rescan started (the requested "
                  "height or 0)"},
                 {RPCResult::Type::NUM, "stop_height",
                  "The height of the last rescanned block. May be null in rare "
                  "cases if there was a reorg and the call didn't scan any "
                  "blocks because they were already scanned in the background."},
             }},
         RPCExamples{HelpExampleCli("rescanblockchain", "100000 120000") +
                     HelpExampleRpc("rescanblockchain", "100000, 120000")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             WalletRescanReserver reserver(*pwallet);
             if (!reserver.reserve()) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Wallet is currently rescanning. Abort "
                                    "existing rescan or wait.");
             }
 
             int start_height = 0;
             std::optional<int> stop_height;
             BlockHash start_block;
             {
                 LOCK(pwallet->cs_wallet);
                 int tip_height = pwallet->GetLastBlockHeight();
 
                 if (!request.params[0].isNull()) {
                     start_height = request.params[0].get_int();
                     if (start_height < 0 || start_height > tip_height) {
                         throw JSONRPCError(RPC_INVALID_PARAMETER,
                                            "Invalid start_height");
                     }
                 }
 
                 if (!request.params[1].isNull()) {
                     stop_height = request.params[1].get_int();
                     if (*stop_height < 0 || *stop_height > tip_height) {
                         throw JSONRPCError(RPC_INVALID_PARAMETER,
                                            "Invalid stop_height");
                     } else if (*stop_height < start_height) {
                         throw JSONRPCError(
                             RPC_INVALID_PARAMETER,
                             "stop_height must be greater than start_height");
                     }
                 }
 
                 // We can't rescan beyond non-pruned blocks, stop and throw an
                 // error
                 if (!pwallet->chain().hasBlocks(pwallet->GetLastBlockHash(),
                                                 start_height, stop_height)) {
                     throw JSONRPCError(
                         RPC_MISC_ERROR,
                         "Can't rescan beyond pruned data. Use RPC call "
                         "getblockchaininfo to determine your pruned height.");
                 }
 
                 CHECK_NONFATAL(pwallet->chain().findAncestorByHeight(
                     pwallet->GetLastBlockHash(), start_height,
                     FoundBlock().hash(start_block)));
             }
 
             CWallet::ScanResult result = pwallet->ScanForWalletTransactions(
                 start_block, start_height, stop_height, reserver,
                 true /* fUpdate */);
             switch (result.status) {
                 case CWallet::ScanResult::SUCCESS:
                     break;
                 case CWallet::ScanResult::FAILURE:
                     throw JSONRPCError(
                         RPC_MISC_ERROR,
                         "Rescan failed. Potentially corrupted data files.");
                 case CWallet::ScanResult::USER_ABORT:
                     throw JSONRPCError(RPC_MISC_ERROR, "Rescan aborted.");
                     // no default case, so the compiler can warn about missing
                     // cases
             }
             UniValue response(UniValue::VOBJ);
             response.pushKV("start_height", start_height);
             response.pushKV("stop_height", result.last_scanned_height
                                                ? *result.last_scanned_height
                                                : UniValue());
             return response;
         },
     };
 }
 
 class DescribeWalletAddressVisitor : public boost::static_visitor<UniValue> {
 public:
     const SigningProvider *const provider;
 
     void ProcessSubScript(const CScript &subscript, UniValue &obj) const {
         // Always present: script type and redeemscript
         std::vector<std::vector<uint8_t>> solutions_data;
         TxoutType which_type = Solver(subscript, solutions_data);
         obj.pushKV("script", GetTxnOutputType(which_type));
         obj.pushKV("hex", HexStr(subscript));
 
         CTxDestination embedded;
         if (ExtractDestination(subscript, embedded)) {
             // Only when the script corresponds to an address.
             UniValue subobj(UniValue::VOBJ);
             UniValue detail = DescribeAddress(embedded);
             subobj.pushKVs(detail);
             UniValue wallet_detail = boost::apply_visitor(*this, embedded);
             subobj.pushKVs(wallet_detail);
             subobj.pushKV("address", EncodeDestination(embedded, GetConfig()));
             subobj.pushKV("scriptPubKey", HexStr(subscript));
             // Always report the pubkey at the top level, so that
             // `getnewaddress()['pubkey']` always works.
             if (subobj.exists("pubkey")) {
                 obj.pushKV("pubkey", subobj["pubkey"]);
             }
             obj.pushKV("embedded", std::move(subobj));
         } else if (which_type == TxoutType::MULTISIG) {
             // Also report some information on multisig scripts (which do not
             // have a corresponding address).
             // TODO: abstract out the common functionality between this logic
             // and ExtractDestinations.
             obj.pushKV("sigsrequired", solutions_data[0][0]);
             UniValue pubkeys(UniValue::VARR);
             for (size_t i = 1; i < solutions_data.size() - 1; ++i) {
                 CPubKey key(solutions_data[i].begin(), solutions_data[i].end());
                 pubkeys.push_back(HexStr(key));
             }
             obj.pushKV("pubkeys", std::move(pubkeys));
         }
     }
 
     explicit DescribeWalletAddressVisitor(const SigningProvider *_provider)
         : provider(_provider) {}
 
     UniValue operator()(const CNoDestination &dest) const {
         return UniValue(UniValue::VOBJ);
     }
 
     UniValue operator()(const PKHash &pkhash) const {
         CKeyID keyID(ToKeyID(pkhash));
         UniValue obj(UniValue::VOBJ);
         CPubKey vchPubKey;
         if (provider && provider->GetPubKey(keyID, vchPubKey)) {
             obj.pushKV("pubkey", HexStr(vchPubKey));
             obj.pushKV("iscompressed", vchPubKey.IsCompressed());
         }
         return obj;
     }
 
     UniValue operator()(const ScriptHash &scripthash) const {
         CScriptID scriptID(scripthash);
         UniValue obj(UniValue::VOBJ);
         CScript subscript;
         if (provider && provider->GetCScript(scriptID, subscript)) {
             ProcessSubScript(subscript, obj);
         }
         return obj;
     }
 };
 
 static UniValue DescribeWalletAddress(const CWallet *const pwallet,
                                       const CTxDestination &dest) {
     UniValue ret(UniValue::VOBJ);
     UniValue detail = DescribeAddress(dest);
     CScript script = GetScriptForDestination(dest);
     std::unique_ptr<SigningProvider> provider = nullptr;
     if (pwallet) {
         provider = pwallet->GetSolvingProvider(script);
     }
     ret.pushKVs(detail);
     ret.pushKVs(boost::apply_visitor(
         DescribeWalletAddressVisitor(provider.get()), dest));
     return ret;
 }
 
 /** Convert CAddressBookData to JSON record.  */
 static UniValue AddressBookDataToJSON(const CAddressBookData &data,
                                       const bool verbose) {
     UniValue ret(UniValue::VOBJ);
     if (verbose) {
         ret.pushKV("name", data.GetLabel());
     }
     ret.pushKV("purpose", data.purpose);
     return ret;
 }
 
 RPCHelpMan getaddressinfo() {
     return RPCHelpMan{
         "getaddressinfo",
         "Return information about the given bitcoin address.\n"
         "Some of the information will only be present if the address is in the "
         "active wallet.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address for which to get information."},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR, "address",
                  "The bitcoin address validated."},
                 {RPCResult::Type::STR_HEX, "scriptPubKey",
                  "The hex-encoded scriptPubKey generated by the address."},
                 {RPCResult::Type::BOOL, "ismine", "If the address is yours."},
                 {RPCResult::Type::BOOL, "iswatchonly",
                  "If the address is watchonly."},
                 {RPCResult::Type::BOOL, "solvable",
                  "If we know how to spend coins sent to this address, ignoring "
                  "the possible lack of private keys."},
                 {RPCResult::Type::STR, "desc", /* optional */ true,
                  "A descriptor for spending coins sent to this address (only "
                  "when solvable)."},
                 {RPCResult::Type::BOOL, "isscript", "If the key is a script."},
                 {RPCResult::Type::BOOL, "ischange",
                  "If the address was used for change output."},
                 {RPCResult::Type::STR, "script", /* optional */ true,
                  "The output script type. Only if isscript is true and the "
                  "redeemscript is known. Possible\n"
                  "                                                         "
                  "types: nonstandard, pubkey, pubkeyhash, scripthash, "
                  "multisig, nulldata."},
                 {RPCResult::Type::STR_HEX, "hex", /* optional */ true,
                  "The redeemscript for the p2sh address."},
                 {RPCResult::Type::ARR,
                  "pubkeys",
                  /* optional */ true,
                  "Array of pubkeys associated with the known redeemscript "
                  "(only if script is multisig).",
                  {
                      {RPCResult::Type::STR, "pubkey", ""},
                  }},
                 {RPCResult::Type::NUM, "sigsrequired", /* optional */ true,
                  "The number of signatures required to spend multisig output "
                  "(only if script is multisig)."},
                 {RPCResult::Type::STR_HEX, "pubkey", /* optional */ true,
                  "The hex value of the raw public key for single-key addresses "
                  "(possibly embedded in P2SH)."},
                 {RPCResult::Type::OBJ,
                  "embedded",
                  /* optional */ true,
                  "Information about the address embedded in P2SH, if "
                  "relevant and known.",
                  {
                      {RPCResult::Type::ELISION, "",
                       "Includes all getaddressinfo output fields for the "
                       "embedded address excluding metadata (timestamp, "
                       "hdkeypath, hdseedid)\n"
                       "and relation to the wallet (ismine, iswatchonly)."},
                  }},
                 {RPCResult::Type::BOOL, "iscompressed", /* optional */ true,
                  "If the pubkey is compressed."},
                 {RPCResult::Type::NUM_TIME, "timestamp", /* optional */ true,
                  "The creation time of the key, if available, expressed in " +
                      UNIX_EPOCH_TIME + "."},
                 {RPCResult::Type::STR, "hdkeypath", /* optional */ true,
                  "The HD keypath, if the key is HD and available."},
                 {RPCResult::Type::STR_HEX, "hdseedid", /* optional */ true,
                  "The Hash160 of the HD seed."},
                 {RPCResult::Type::STR_HEX, "hdmasterfingerprint",
                  /* optional */ true, "The fingerprint of the master key."},
                 {RPCResult::Type::ARR,
                  "labels",
                  "Array of labels associated with the address. Currently "
                  "limited to one label but returned\n"
                  "as an array to keep the API stable if multiple labels are "
                  "enabled in the future.",
                  {
                      {RPCResult::Type::STR, "label name",
                       "Label name (defaults to \"\")."},
                  }},
             }},
         RPCExamples{HelpExampleCli("getaddressinfo", EXAMPLE_ADDRESS) +
                     HelpExampleRpc("getaddressinfo", EXAMPLE_ADDRESS)},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             UniValue ret(UniValue::VOBJ);
             CTxDestination dest = DecodeDestination(request.params[0].get_str(),
                                                     wallet->GetChainParams());
             // Make sure the destination is valid
             if (!IsValidDestination(dest)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Invalid address");
             }
 
             std::string currentAddress = EncodeDestination(dest, config);
             ret.pushKV("address", currentAddress);
 
             CScript scriptPubKey = GetScriptForDestination(dest);
             ret.pushKV("scriptPubKey", HexStr(scriptPubKey));
 
             std::unique_ptr<SigningProvider> provider =
                 pwallet->GetSolvingProvider(scriptPubKey);
 
             isminetype mine = pwallet->IsMine(dest);
             ret.pushKV("ismine", bool(mine & ISMINE_SPENDABLE));
 
             bool solvable = provider && IsSolvable(*provider, scriptPubKey);
             ret.pushKV("solvable", solvable);
 
             if (solvable) {
                 ret.pushKV(
                     "desc",
                     InferDescriptor(scriptPubKey, *provider)->ToString());
             }
 
             ret.pushKV("iswatchonly", bool(mine & ISMINE_WATCH_ONLY));
 
             UniValue detail = DescribeWalletAddress(pwallet, dest);
             ret.pushKVs(detail);
 
             ret.pushKV("ischange", ScriptIsChange(*pwallet, scriptPubKey));
 
             ScriptPubKeyMan *spk_man =
                 pwallet->GetScriptPubKeyMan(scriptPubKey);
             if (spk_man) {
                 if (const std::unique_ptr<CKeyMetadata> meta =
                         spk_man->GetMetadata(dest)) {
                     ret.pushKV("timestamp", meta->nCreateTime);
                     if (meta->has_key_origin) {
                         ret.pushKV("hdkeypath",
                                    WriteHDKeypath(meta->key_origin.path));
                         ret.pushKV("hdseedid", meta->hd_seed_id.GetHex());
                         ret.pushKV("hdmasterfingerprint",
                                    HexStr(meta->key_origin.fingerprint));
                     }
                 }
             }
 
             // Return a `labels` array containing the label associated with the
             // address, equivalent to the `label` field above. Currently only
             // one label can be associated with an address, but we return an
             // array so the API remains stable if we allow multiple labels to be
             // associated with an address in the future.
             UniValue labels(UniValue::VARR);
             const auto *address_book_entry =
                 pwallet->FindAddressBookEntry(dest);
             if (address_book_entry) {
                 labels.push_back(address_book_entry->GetLabel());
             }
             ret.pushKV("labels", std::move(labels));
 
             return ret;
         },
     };
 }
 
 RPCHelpMan getaddressesbylabel() {
     return RPCHelpMan{
         "getaddressesbylabel",
         "Returns the list of addresses assigned the specified label.\n",
         {
             {"label", RPCArg::Type::STR, RPCArg::Optional::NO, "The label."},
         },
         RPCResult{RPCResult::Type::OBJ_DYN,
                   "",
                   "json object with addresses as keys",
                   {
                       {RPCResult::Type::OBJ,
                        "address",
                        "Information about address",
                        {
                            {RPCResult::Type::STR, "purpose",
                             "Purpose of address (\"send\" for sending address, "
                             "\"receive\" for receiving address)"},
                        }},
                   }},
         RPCExamples{HelpExampleCli("getaddressesbylabel", "\"tabby\"") +
                     HelpExampleRpc("getaddressesbylabel", "\"tabby\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             std::string label = LabelFromValue(request.params[0]);
 
             // Find all addresses that have the given label
             UniValue ret(UniValue::VOBJ);
             std::set<std::string> addresses;
             for (const std::pair<const CTxDestination, CAddressBookData> &item :
                  pwallet->m_address_book) {
                 if (item.second.IsChange()) {
                     continue;
                 }
                 if (item.second.GetLabel() == label) {
                     std::string address = EncodeDestination(item.first, config);
                     // CWallet::m_address_book is not expected to contain
                     // duplicate address strings, but build a separate set as a
                     // precaution just in case it does.
                     bool unique = addresses.emplace(address).second;
                     CHECK_NONFATAL(unique);
                     // UniValue::pushKV checks if the key exists in O(N)
                     // and since duplicate addresses are unexpected (checked
                     // with std::set in O(log(N))), UniValue::__pushKV is used
                     // instead, which currently is O(1).
                     ret.__pushKV(address,
                                  AddressBookDataToJSON(item.second, false));
                 }
             }
 
             if (ret.empty()) {
                 throw JSONRPCError(
                     RPC_WALLET_INVALID_LABEL_NAME,
                     std::string("No addresses with label " + label));
             }
 
             return ret;
         },
     };
 }
 
 RPCHelpMan listlabels() {
     return RPCHelpMan{
         "listlabels",
         "Returns the list of all labels, or labels that are assigned to "
         "addresses with a specific purpose.\n",
         {
             {"purpose", RPCArg::Type::STR, RPCArg::Optional::OMITTED_NAMED_ARG,
              "Address purpose to list labels for ('send','receive'). An empty "
              "string is the same as not providing this argument."},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "label", "Label name"},
                   }},
         RPCExamples{"\nList all labels\n" + HelpExampleCli("listlabels", "") +
                     "\nList labels that have receiving addresses\n" +
                     HelpExampleCli("listlabels", "receive") +
                     "\nList labels that have sending addresses\n" +
                     HelpExampleCli("listlabels", "send") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc("listlabels", "receive")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             std::string purpose;
             if (!request.params[0].isNull()) {
                 purpose = request.params[0].get_str();
             }
 
             // Add to a set to sort by label name, then insert into Univalue
             // array
             std::set<std::string> label_set;
             for (const std::pair<const CTxDestination, CAddressBookData>
                      &entry : pwallet->m_address_book) {
                 if (entry.second.IsChange()) {
                     continue;
                 }
                 if (purpose.empty() || entry.second.purpose == purpose) {
                     label_set.insert(entry.second.GetLabel());
                 }
             }
 
             UniValue ret(UniValue::VARR);
             for (const std::string &name : label_set) {
                 ret.push_back(name);
             }
 
             return ret;
         },
     };
 }
 
 static RPCHelpMan send() {
     return RPCHelpMan{
         "send",
         "EXPERIMENTAL warning: this call may be changed in future releases.\n"
         "\nSend a transaction.\n",
         {
             {
                 "outputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "A JSON array with outputs (key-value pairs), where none of "
                 "the keys are duplicated.\n"
                 "That is, each address can only appear once and there can only "
                 "be one 'data' object.\n"
                 "For convenience, a dictionary, which holds the key-value "
                 "pairs directly, is also accepted.",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"address", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key (string) is the "
                              "bitcoin address, the value (float or string) is "
                              "the amount in " +
                                  Currency::get().ticker + ""},
                         },
                     },
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"data", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key must be \"data\", the "
                              "value is hex-encoded data"},
                         },
                     },
                 },
             },
             {"options",
              RPCArg::Type::OBJ,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "",
              {
                  {"add_inputs", RPCArg::Type::BOOL, /* default */ "false",
                   "If inputs are specified, automatically include more if they "
                   "are not enough."},
                  {"add_to_wallet", RPCArg::Type::BOOL, /* default */ "true",
                   "When false, returns a serialized transaction which will not "
                   "be added to the wallet or broadcast"},
                  {"change_address", RPCArg::Type::STR_HEX,
                   /* default */ "pool address",
                   "The bitcoin address to receive the change"},
                  {"change_position", RPCArg::Type::NUM, /* default */ "random",
                   "The index of the change output"},
                  {"fee_rate", RPCArg::Type::AMOUNT, /* default */
                   "not set: makes wallet determine the fee",
                   "Set a specific fee rate in " + Currency::get().ticker +
                       "/kB"},
                  {"include_watching", RPCArg::Type::BOOL,
                   /* default */ "true for watch-only wallets, otherwise false",
                   "Also select inputs which are watch only.\n"
                   "Only solvable inputs can be used. Watch-only destinations "
                   "are solvable if the public key and/or output script was "
                   "imported,\n"
                   "e.g. with 'importpubkey' or 'importmulti' with the "
                   "'pubkeys' or 'desc' field."},
                  {
                      "inputs",
                      RPCArg::Type::ARR,
                      /* default */ "empty array",
                      "Specify inputs instead of adding them automatically. A "
                      "JSON array of JSON objects",
                      {
                          {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
                           "The transaction id"},
                          {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                           "The output number"},
                          {"sequence", RPCArg::Type::NUM, RPCArg::Optional::NO,
                           "The sequence number"},
                      },
                  },
                  {"locktime", RPCArg::Type::NUM, /* default */ "0",
                   "Raw locktime. Non-0 value also locktime-activates inputs"},
                  {"lock_unspents", RPCArg::Type::BOOL, /* default */ "false",
                   "Lock selected unspent outputs"},
                  {"psbt", RPCArg::Type::BOOL, /* default */ "automatic",
                   "Always return a PSBT, implies add_to_wallet=false."},
                  {
                      "subtract_fee_from_outputs",
                      RPCArg::Type::ARR,
                      /* default */ "empty array",
                      "Outputs to subtract the fee from, specified as integer "
                      "indices.\n"
                      "The fee will be equally deducted from the amount of each "
                      "specified output.\n"
                      "Those recipients will receive less bitcoins than you "
                      "enter in their corresponding amount field.\n"
                      "If no outputs are specified here, the sender pays the "
                      "fee.",
                      {
                          {"vout_index", RPCArg::Type::NUM,
                           RPCArg::Optional::OMITTED,
                           "The zero-based output index, before a change output "
                           "is added."},
                      },
                  },
              },
              "options"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {{RPCResult::Type::BOOL, "complete",
               "If the transaction has a complete set of signatures"},
              {RPCResult::Type::STR_HEX, "txid",
               "The transaction id for the send. Only 1 transaction is created "
               "regardless of the number of addresses."},
              {RPCResult::Type::STR_HEX, "hex",
               "If add_to_wallet is false, the hex-encoded raw transaction with "
               "signature(s)"},
              {RPCResult::Type::STR, "psbt",
               "If more signatures are needed, or if add_to_wallet is false, "
               "the base64-encoded (partially) signed transaction"}}},
         RPCExamples{
             ""
             "\nSend with a fee rate of 10 XEC/kB\n" +
             HelpExampleCli("send", "'{\"" + EXAMPLE_ADDRESS +
                                        "\": 100000}' '{\"fee_rate\": 10}'\n") +
             "\nCreate a transaction with a specific input, and return "
             "result without adding to wallet or broadcasting to the "
             "network\n" +
             HelpExampleCli("send",
                            "'{\"" + EXAMPLE_ADDRESS +
                                "\": 100000}' '{\"add_to_wallet\": "
                                "false, \"inputs\": "
                                "[{\"txid\":"
                                "\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b565"
                                "5e72f463568df1aadf0\", \"vout\":1}]}'")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             RPCTypeCheck(request.params,
                          {// ARR or OBJ, checked later
                           UniValueType(), UniValue::VOBJ},
                          true);
 
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             UniValue options = request.params[1];
             if (options.exists("changeAddress")) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Use change_address");
             }
             if (options.exists("changePosition")) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Use change_position");
             }
             if (options.exists("includeWatching")) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Use include_watching");
             }
             if (options.exists("lockUnspents")) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Use lock_unspents");
             }
             if (options.exists("subtractFeeFromOutputs")) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Use subtract_fee_from_outputs");
             }
             if (options.exists("feeRate")) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Use fee_rate");
             }
 
             const bool psbt_opt_in =
                 options.exists("psbt") && options["psbt"].get_bool();
 
             Amount fee;
             int change_position;
             CMutableTransaction rawTx = ConstructTransaction(
                 wallet->GetChainParams(), options["inputs"], request.params[0],
                 options["locktime"]);
             CCoinControl coin_control;
             // Automatically select coins, unless at least one is manually
             // selected. Can be overridden by options.add_inputs.
             coin_control.m_add_inputs = rawTx.vin.size() == 0;
             FundTransaction(pwallet, rawTx, fee, change_position, options,
                             coin_control);
 
             bool add_to_wallet = true;
             if (options.exists("add_to_wallet")) {
                 add_to_wallet = options["add_to_wallet"].get_bool();
             }
 
             // Make a blank psbt
             PartiallySignedTransaction psbtx(rawTx);
 
             // Fill transaction with our data and sign
             bool complete = true;
             const TransactionError err = pwallet->FillPSBT(
                 psbtx, complete, SigHashType().withForkId(), true, false);
             if (err != TransactionError::OK) {
                 throw JSONRPCTransactionError(err);
             }
 
             CMutableTransaction mtx;
             complete = FinalizeAndExtractPSBT(psbtx, mtx);
 
             UniValue result(UniValue::VOBJ);
 
             if (psbt_opt_in || !complete || !add_to_wallet) {
                 // Serialize the PSBT
                 CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
                 ssTx << psbtx;
                 result.pushKV("psbt", EncodeBase64(ssTx.str()));
             }
 
             if (complete) {
                 std::string err_string;
                 std::string hex = EncodeHexTx(CTransaction(mtx));
                 CTransactionRef tx(MakeTransactionRef(std::move(mtx)));
                 result.pushKV("txid", tx->GetHash().GetHex());
                 if (add_to_wallet && !psbt_opt_in) {
                     pwallet->CommitTransaction(tx, {}, {} /* orderForm */);
                 } else {
                     result.pushKV("hex", hex);
                 }
             }
             result.pushKV("complete", complete);
 
             return result;
         }};
 }
 
 static RPCHelpMan sethdseed() {
     return RPCHelpMan{
         "sethdseed",
         "Set or generate a new HD wallet seed. Non-HD wallets will not be "
         "upgraded to being a HD wallet. Wallets that are already\n"
         "HD will have a new HD seed set so that new keys added to the keypool "
         "will be derived from this new seed.\n"
         "\nNote that you will need to MAKE A NEW BACKUP of your wallet after "
         "setting the HD wallet seed.\n" +
             HELP_REQUIRING_PASSPHRASE,
         {
             {"newkeypool", RPCArg::Type::BOOL, /* default */ "true",
              "Whether to flush old unused addresses, including change "
              "addresses, from the keypool and regenerate it.\n"
              "                             If true, the next address from "
              "getnewaddress and change address from getrawchangeaddress will "
              "be from this new seed.\n"
              "                             If false, addresses (including "
              "change addresses if the wallet already had HD Chain Split "
              "enabled) from the existing\n"
              "                             keypool will be used until it has "
              "been depleted."},
             {"seed", RPCArg::Type::STR, /* default */ "random seed",
              "The WIF private key to use as the new HD seed.\n"
              "                             The seed value can be retrieved "
              "using the dumpwallet command. It is the private key marked "
              "hdseed=1"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("sethdseed", "") +
                     HelpExampleCli("sethdseed", "false") +
                     HelpExampleCli("sethdseed", "true \"wifkey\"") +
                     HelpExampleRpc("sethdseed", "true, \"wifkey\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             LegacyScriptPubKeyMan &spk_man =
                 EnsureLegacyScriptPubKeyMan(*pwallet, true);
 
             if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Cannot set a HD seed to a wallet with "
                                    "private keys disabled");
             }
 
             LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);
 
             // Do not do anything to non-HD wallets
             if (!pwallet->CanSupportFeature(FEATURE_HD)) {
                 throw JSONRPCError(
                     RPC_WALLET_ERROR,
                     "Cannot set a HD seed on a non-HD wallet. Use the "
                     "upgradewallet RPC in order to upgrade a non-HD wallet "
                     "to HD");
             }
 
             EnsureWalletIsUnlocked(pwallet);
 
             bool flush_key_pool = true;
             if (!request.params[0].isNull()) {
                 flush_key_pool = request.params[0].get_bool();
             }
 
             CPubKey master_pub_key;
             if (request.params[1].isNull()) {
                 master_pub_key = spk_man.GenerateNewSeed();
             } else {
                 CKey key = DecodeSecret(request.params[1].get_str());
                 if (!key.IsValid()) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Invalid private key");
                 }
 
                 if (HaveKey(spk_man, key)) {
                     throw JSONRPCError(
                         RPC_INVALID_ADDRESS_OR_KEY,
                         "Already have this key (either as an HD seed or "
                         "as a loose private key)");
                 }
 
                 master_pub_key = spk_man.DeriveNewSeed(key);
             }
 
             spk_man.SetHDSeed(master_pub_key);
             if (flush_key_pool) {
                 spk_man.NewKeyPool();
             }
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan walletprocesspsbt() {
     return RPCHelpMan{
         "walletprocesspsbt",
         "Update a PSBT with input information from our wallet and then sign "
         "inputs that we can sign for." +
             HELP_REQUIRING_PASSPHRASE,
         {
             {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The transaction base64 string"},
             {"sign", RPCArg::Type::BOOL, /* default */ "true",
              "Also sign the transaction when updating"},
             {"sighashtype", RPCArg::Type::STR, /* default */ "ALL|FORKID",
              "The signature hash type to sign with if not specified by "
              "the PSBT. Must be one of\n"
              "       \"ALL|FORKID\"\n"
              "       \"NONE|FORKID\"\n"
              "       \"SINGLE|FORKID\"\n"
              "       \"ALL|FORKID|ANYONECANPAY\"\n"
              "       \"NONE|FORKID|ANYONECANPAY\"\n"
              "       \"SINGLE|FORKID|ANYONECANPAY\""},
             {"bip32derivs", RPCArg::Type::BOOL, /* default */ "true",
              "Includes the BIP 32 derivation paths for public keys if we know "
              "them"},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "psbt",
                        "The base64-encoded partially signed transaction"},
                       {RPCResult::Type::BOOL, "complete",
                        "If the transaction has a complete set of signatures"},
                   }},
         RPCExamples{HelpExampleCli("walletprocesspsbt", "\"psbt\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             RPCTypeCheck(request.params,
                          {UniValue::VSTR, UniValue::VBOOL, UniValue::VSTR});
 
             // Unserialize the transaction
             PartiallySignedTransaction psbtx;
             std::string error;
             if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    strprintf("TX decode failed %s", error));
             }
 
             // Get the sighash type
             SigHashType nHashType = ParseSighashString(request.params[2]);
             if (!nHashType.hasForkId()) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Signature must use SIGHASH_FORKID");
             }
 
             // Fill transaction with our data and also sign
             bool sign = request.params[1].isNull()
                             ? true
                             : request.params[1].get_bool();
             bool bip32derivs = request.params[3].isNull()
                                    ? true
                                    : request.params[3].get_bool();
             bool complete = true;
             const TransactionError err = pwallet->FillPSBT(
                 psbtx, complete, nHashType, sign, bip32derivs);
             if (err != TransactionError::OK) {
                 throw JSONRPCTransactionError(err);
             }
 
             UniValue result(UniValue::VOBJ);
             CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
             ssTx << psbtx;
             result.pushKV("psbt", EncodeBase64(ssTx.str()));
             result.pushKV("complete", complete);
 
             return result;
         },
     };
 }
 
 static RPCHelpMan walletcreatefundedpsbt() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "walletcreatefundedpsbt",
         "Creates and funds a transaction in the Partially Signed Transaction "
         "format.\n"
         "Implements the Creator and Updater roles.\n",
         {
             {
                 "inputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::OMITTED_NAMED_ARG,
                 "Leave empty to add inputs automatically. See add_inputs "
                 "option.",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"txid", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO, "The transaction id"},
                             {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
                              "The output number"},
                             {"sequence", RPCArg::Type::NUM,
                              /* default */
                              "depends on the value of the 'locktime' and "
                              "'options.replaceable' arguments",
                              "The sequence number"},
                         },
                     },
                 },
             },
             {
                 "outputs",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "The outputs (key-value pairs), where none of "
                 "the keys are duplicated.\n"
                 "That is, each address can only appear once and there can only "
                 "be one 'data' object.\n"
                 "For compatibility reasons, a dictionary, which holds the "
                 "key-value pairs directly, is also\n"
                 "                             accepted as second parameter.",
                 {
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"address", RPCArg::Type::AMOUNT,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key (string) is the "
                              "bitcoin address, the value (float or string) is "
                              "the amount in " +
                                  ticker + ""},
                         },
                     },
                     {
                         "",
                         RPCArg::Type::OBJ,
                         RPCArg::Optional::OMITTED,
                         "",
                         {
                             {"data", RPCArg::Type::STR_HEX,
                              RPCArg::Optional::NO,
                              "A key-value pair. The key must be \"data\", the "
                              "value is hex-encoded data"},
                         },
                     },
                 },
             },
             {"locktime", RPCArg::Type::NUM, /* default */ "0",
              "Raw locktime. Non-0 value also locktime-activates inputs\n"
              "                             Allows this transaction to be "
              "replaced by a transaction with higher fees. If provided, it is "
              "an error if explicit sequence numbers are incompatible."},
             {"options",
              RPCArg::Type::OBJ,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "",
              {
                  {"add_inputs", RPCArg::Type::BOOL, /* default */ "false",
                   "If inputs are specified, automatically include more if they "
                   "are not enough."},
                  {"changeAddress", RPCArg::Type::STR_HEX,
                   /* default */ "pool address",
                   "The bitcoin address to receive the change"},
                  {"changePosition", RPCArg::Type::NUM,
                   /* default */ "random", "The index of the change output"},
                  {"includeWatching", RPCArg::Type::BOOL,
                   /* default */ "true for watch-only wallets, otherwise false",
                   "Also select inputs which are watch only"},
                  {"lockUnspents", RPCArg::Type::BOOL, /* default */ "false",
                   "Lock selected unspent outputs"},
                  {"feeRate", RPCArg::Type::AMOUNT, /* default */
                   "not set: makes wallet determine the fee",
                   "Set a specific fee rate in " + ticker + "/kB"},
                  {
                      "subtractFeeFromOutputs",
                      RPCArg::Type::ARR,
                      /* default */ "empty array",
                      "The outputs to subtract the fee from.\n"
                      "                              The fee will be equally "
                      "deducted from the amount of each specified output.\n"
                      "                              Those recipients will "
                      "receive less bitcoins than you enter in their "
                      "corresponding amount field.\n"
                      "                              If no outputs are "
                      "specified here, the sender pays the fee.",
                      {
                          {"vout_index", RPCArg::Type::NUM,
                           RPCArg::Optional::OMITTED,
                           "The zero-based output index, before a change output "
                           "is added."},
                      },
                  },
              },
              "options"},
             {"bip32derivs", RPCArg::Type::BOOL, /* default */ "true",
              "Includes the BIP 32 derivation paths for public keys if we know "
              "them"},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "psbt",
                        "The resulting raw transaction (base64-encoded string)"},
                       {RPCResult::Type::STR_AMOUNT, "fee",
                        "Fee in " + ticker + " the resulting transaction pays"},
                       {RPCResult::Type::NUM, "changepos",
                        "The position of the added change output, or -1"},
                   }},
         RPCExamples{
             "\nCreate a transaction with no inputs\n" +
             HelpExampleCli("walletcreatefundedpsbt",
                            "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" "
                            "\"[{\\\"data\\\":\\\"00010203\\\"}]\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             RPCTypeCheck(request.params,
                          {UniValue::VARR,
                           UniValueType(), // ARR or OBJ, checked later
                           UniValue::VNUM, UniValue::VOBJ},
                          true);
 
             Amount fee;
             int change_position;
             CMutableTransaction rawTx = ConstructTransaction(
                 wallet->GetChainParams(), request.params[0], request.params[1],
                 request.params[2]);
             CCoinControl coin_control;
             // Automatically select coins, unless at least one is manually
             // selected. Can be overridden by options.add_inputs.
             coin_control.m_add_inputs = rawTx.vin.size() == 0;
             FundTransaction(pwallet, rawTx, fee, change_position,
                             request.params[3], coin_control);
 
             // Make a blank psbt
             PartiallySignedTransaction psbtx(rawTx);
 
             // Fill transaction with out data but don't sign
             bool bip32derivs = request.params[4].isNull()
                                    ? true
                                    : request.params[4].get_bool();
             bool complete = true;
             const TransactionError err =
                 pwallet->FillPSBT(psbtx, complete, SigHashType().withForkId(),
                                   false, bip32derivs);
             if (err != TransactionError::OK) {
                 throw JSONRPCTransactionError(err);
             }
 
             // Serialize the PSBT
             CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
             ssTx << psbtx;
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("psbt", EncodeBase64(ssTx.str()));
             result.pushKV("fee", fee);
             result.pushKV("changepos", change_position);
             return result;
         },
     };
 }
 
 static RPCHelpMan upgradewallet() {
     return RPCHelpMan{
         "upgradewallet",
         "Upgrade the wallet. Upgrades to the latest version if no "
         "version number is specified\n"
         "New keys may be generated and a new wallet backup will need to "
         "be made.",
         {{"version", RPCArg::Type::NUM,
           /* default */ strprintf("%d", FEATURE_LATEST),
           "The version number to upgrade to. Default is the latest "
           "wallet version"}},
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("upgradewallet", "200300") +
                     HelpExampleRpc("upgradewallet", "200300")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             RPCTypeCheck(request.params, {UniValue::VNUM}, true);
 
             EnsureWalletIsUnlocked(pwallet);
 
             int version = 0;
             if (!request.params[0].isNull()) {
                 version = request.params[0].get_int();
             }
             bilingual_str error;
             if (!pwallet->UpgradeWallet(version, error)) {
                 throw JSONRPCError(RPC_WALLET_ERROR, error.original);
             }
             return error.original;
         },
     };
 }
 
 RPCHelpMan signmessage();
 
 Span<const CRPCCommand> GetWalletRPCCommands() {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            actor (function)
         //  ------------------  ----------------------
         { "rawtransactions",    fundrawtransaction,            },
         { "wallet",             abandontransaction,            },
         { "wallet",             addmultisigaddress,            },
         { "wallet",             createwallet,                  },
         { "wallet",             getaddressesbylabel,           },
         { "wallet",             getaddressinfo,                },
         { "wallet",             getbalance,                    },
         { "wallet",             getnewaddress,                 },
         { "wallet",             getrawchangeaddress,           },
         { "wallet",             getreceivedbyaddress,          },
         { "wallet",             getreceivedbylabel,            },
         { "wallet",             gettransaction,                },
         { "wallet",             getunconfirmedbalance,         },
         { "wallet",             getbalances,                   },
         { "wallet",             getwalletinfo,                 },
         { "wallet",             keypoolrefill,                 },
         { "wallet",             listaddressgroupings,          },
         { "wallet",             listlabels,                    },
         { "wallet",             listlockunspent,               },
         { "wallet",             listreceivedbyaddress,         },
         { "wallet",             listreceivedbylabel,           },
         { "wallet",             listsinceblock,                },
         { "wallet",             listtransactions,              },
         { "wallet",             listunspent,                   },
         { "wallet",             listwalletdir,                 },
         { "wallet",             listwallets,                   },
         { "wallet",             loadwallet,                    },
         { "wallet",             lockunspent,                   },
         { "wallet",             rescanblockchain,              },
         { "wallet",             send,                          },
         { "wallet",             sendmany,                      },
         { "wallet",             sendtoaddress,                 },
         { "wallet",             sethdseed,                     },
         { "wallet",             setlabel,                      },
         { "wallet",             settxfee,                      },
         { "wallet",             setwalletflag,                 },
         { "wallet",             signmessage,                   },
         { "wallet",             signrawtransactionwithwallet,  },
         { "wallet",             unloadwallet,                  },
         { "wallet",             upgradewallet,                 },
         { "wallet",             walletcreatefundedpsbt,        },
         { "wallet",             walletprocesspsbt,             },
     };
     // clang-format on
 
     return MakeSpan(commands);
 }
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index cceb42de1..5e22ed695 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -1,3472 +1,3484 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <wallet/wallet.h>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
 #include <fs.h>
 #include <interfaces/wallet.h>
 #include <key.h>
 #include <key_io.h>
 #include <policy/mempool.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/sighashtype.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
 #include <txmempool.h>
 #include <univalue.h>
 #include <util/bip32.h>
 #include <util/check.h>
 #include <util/error.h>
 #include <util/moneystr.h>
 #include <util/string.h>
 #include <util/translation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/fees.h>
 
 #include <boost/algorithm/string/replace.hpp>
 
 using interfaces::FoundBlock;
 
 const std::map<uint64_t, std::string> WALLET_FLAG_CAVEATS{
     {WALLET_FLAG_AVOID_REUSE,
      "You need to rescan the blockchain in order to correctly mark used "
      "destinations in the past. Until this is done, some destinations may "
      "be considered unused, even if the opposite is the case."},
 };
 
 RecursiveMutex cs_wallets;
 static std::vector<std::shared_ptr<CWallet>> vpwallets GUARDED_BY(cs_wallets);
 static std::list<LoadWalletFn> g_load_wallet_fns GUARDED_BY(cs_wallets);
 
 bool AddWalletSetting(interfaces::Chain &chain,
                       const std::string &wallet_name) {
     util::SettingsValue setting_value = chain.getRwSetting("wallet");
     if (!setting_value.isArray()) {
         setting_value.setArray();
     }
     for (const util::SettingsValue &value : setting_value.getValues()) {
         if (value.isStr() && value.get_str() == wallet_name) {
             return true;
         }
     }
     setting_value.push_back(wallet_name);
     return chain.updateRwSetting("wallet", setting_value);
 }
 
 bool RemoveWalletSetting(interfaces::Chain &chain,
                          const std::string &wallet_name) {
     util::SettingsValue setting_value = chain.getRwSetting("wallet");
     if (!setting_value.isArray()) {
         return true;
     }
     util::SettingsValue new_value(util::SettingsValue::VARR);
     for (const util::SettingsValue &value : setting_value.getValues()) {
         if (!value.isStr() || value.get_str() != wallet_name) {
             new_value.push_back(value);
         }
     }
     if (new_value.size() == setting_value.size()) {
         return true;
     }
     return chain.updateRwSetting("wallet", new_value);
 }
 
 static void UpdateWalletSetting(interfaces::Chain &chain,
                                 const std::string &wallet_name,
                                 std::optional<bool> load_on_startup,
                                 std::vector<bilingual_str> &warnings) {
     if (!load_on_startup) {
         return;
     }
     if (load_on_startup.value() && !AddWalletSetting(chain, wallet_name)) {
         warnings.emplace_back(
             Untranslated("Wallet load on startup setting could not be updated, "
                          "so wallet may not be loaded next node startup."));
     } else if (!load_on_startup.value() &&
                !RemoveWalletSetting(chain, wallet_name)) {
         warnings.emplace_back(
             Untranslated("Wallet load on startup setting could not be updated, "
                          "so wallet may still be loaded next node startup."));
     }
 }
 
 bool AddWallet(const std::shared_ptr<CWallet> &wallet) {
     LOCK(cs_wallets);
     assert(wallet);
     std::vector<std::shared_ptr<CWallet>>::const_iterator i =
         std::find(vpwallets.begin(), vpwallets.end(), wallet);
     if (i != vpwallets.end()) {
         return false;
     }
     vpwallets.push_back(wallet);
     wallet->ConnectScriptPubKeyManNotifiers();
     wallet->NotifyCanGetAddressesChanged();
     return true;
 }
 
 bool RemoveWallet(const std::shared_ptr<CWallet> &wallet,
                   std::optional<bool> load_on_start,
                   std::vector<bilingual_str> &warnings) {
     assert(wallet);
 
     interfaces::Chain &chain = wallet->chain();
     std::string name = wallet->GetName();
 
     // Unregister with the validation interface which also drops shared ponters.
     wallet->m_chain_notifications_handler.reset();
     LOCK(cs_wallets);
     std::vector<std::shared_ptr<CWallet>>::iterator i =
         std::find(vpwallets.begin(), vpwallets.end(), wallet);
     if (i == vpwallets.end()) {
         return false;
     }
     vpwallets.erase(i);
 
     // Write the wallet setting
     UpdateWalletSetting(chain, name, load_on_start, warnings);
 
     return true;
 }
 
 bool RemoveWallet(const std::shared_ptr<CWallet> &wallet,
                   std::optional<bool> load_on_start) {
     std::vector<bilingual_str> warnings;
     return RemoveWallet(wallet, load_on_start, warnings);
 }
 
 std::vector<std::shared_ptr<CWallet>> GetWallets() {
     LOCK(cs_wallets);
     return vpwallets;
 }
 
 std::shared_ptr<CWallet> GetWallet(const std::string &name) {
     LOCK(cs_wallets);
     for (const std::shared_ptr<CWallet> &wallet : vpwallets) {
         if (wallet->GetName() == name) {
             return wallet;
         }
     }
     return nullptr;
 }
 
 std::unique_ptr<interfaces::Handler>
 HandleLoadWallet(LoadWalletFn load_wallet) {
     LOCK(cs_wallets);
     auto it = g_load_wallet_fns.emplace(g_load_wallet_fns.end(),
                                         std::move(load_wallet));
     return interfaces::MakeHandler([it] {
         LOCK(cs_wallets);
         g_load_wallet_fns.erase(it);
     });
 }
 
 static Mutex g_loading_wallet_mutex;
 static Mutex g_wallet_release_mutex;
 static std::condition_variable g_wallet_release_cv;
 static std::set<std::string>
     g_loading_wallet_set GUARDED_BY(g_loading_wallet_mutex);
 static std::set<std::string>
     g_unloading_wallet_set GUARDED_BY(g_wallet_release_mutex);
 
 // Custom deleter for shared_ptr<CWallet>.
 static void ReleaseWallet(CWallet *wallet) {
     const std::string name = wallet->GetName();
     wallet->WalletLogPrintf("Releasing wallet\n");
     wallet->Flush();
     delete wallet;
     // Wallet is now released, notify UnloadWallet, if any.
     {
         LOCK(g_wallet_release_mutex);
         if (g_unloading_wallet_set.erase(name) == 0) {
             // UnloadWallet was not called for this wallet, all done.
             return;
         }
     }
     g_wallet_release_cv.notify_all();
 }
 
 void UnloadWallet(std::shared_ptr<CWallet> &&wallet) {
     // Mark wallet for unloading.
     const std::string name = wallet->GetName();
     {
         LOCK(g_wallet_release_mutex);
         auto it = g_unloading_wallet_set.insert(name);
         assert(it.second);
     }
     // The wallet can be in use so it's not possible to explicitly unload here.
     // Notify the unload intent so that all remaining shared pointers are
     // released.
     wallet->NotifyUnload();
 
     // Time to ditch our shared_ptr and wait for ReleaseWallet call.
     wallet.reset();
     {
         WAIT_LOCK(g_wallet_release_mutex, lock);
         while (g_unloading_wallet_set.count(name) == 1) {
             g_wallet_release_cv.wait(lock);
         }
     }
 }
 
 namespace {
 std::shared_ptr<CWallet>
 LoadWalletInternal(interfaces::Chain &chain, const std::string &name,
                    std::optional<bool> load_on_start,
                    const DatabaseOptions &options, DatabaseStatus &status,
                    bilingual_str &error, std::vector<bilingual_str> &warnings) {
     try {
         std::unique_ptr<WalletDatabase> database =
             MakeWalletDatabase(name, options, status, error);
         if (!database) {
             error = Untranslated("Wallet file verification failed.") +
                     Untranslated(" ") + error;
             return nullptr;
         }
 
         std::shared_ptr<CWallet> wallet =
             CWallet::Create(chain, name, std::move(database),
                             options.create_flags, error, warnings);
         if (!wallet) {
             error = Untranslated("Wallet loading failed.") + Untranslated(" ") +
                     error;
             status = DatabaseStatus::FAILED_LOAD;
             return nullptr;
         }
         AddWallet(wallet);
         wallet->postInitProcess();
 
         // Write the wallet setting
         UpdateWalletSetting(chain, name, load_on_start, warnings);
 
         return wallet;
     } catch (const std::runtime_error &e) {
         error = Untranslated(e.what());
         status = DatabaseStatus::FAILED_LOAD;
         return nullptr;
     }
 }
 } // namespace
 
 std::shared_ptr<CWallet>
 LoadWallet(interfaces::Chain &chain, const std::string &name,
            std::optional<bool> load_on_start, const DatabaseOptions &options,
            DatabaseStatus &status, bilingual_str &error,
            std::vector<bilingual_str> &warnings) {
     auto result = WITH_LOCK(g_loading_wallet_mutex,
                             return g_loading_wallet_set.insert(name));
     if (!result.second) {
         error = Untranslated("Wallet already being loading.");
         status = DatabaseStatus::FAILED_LOAD;
         return nullptr;
     }
     auto wallet = LoadWalletInternal(chain, name, load_on_start, options,
                                      status, error, warnings);
     WITH_LOCK(g_loading_wallet_mutex, g_loading_wallet_set.erase(result.first));
     return wallet;
 }
 
 std::shared_ptr<CWallet>
 CreateWallet(interfaces::Chain &chain, const std::string &name,
              std::optional<bool> load_on_start, const DatabaseOptions &options,
              DatabaseStatus &status, bilingual_str &error,
              std::vector<bilingual_str> &warnings) {
     uint64_t wallet_creation_flags = options.create_flags;
     const SecureString &passphrase = options.create_passphrase;
 
     // Indicate that the wallet is actually supposed to be blank and not just
     // blank to make it encrypted
     bool create_blank = (wallet_creation_flags & WALLET_FLAG_BLANK_WALLET);
 
     // Born encrypted wallets need to be created blank first.
     if (!passphrase.empty()) {
         wallet_creation_flags |= WALLET_FLAG_BLANK_WALLET;
     }
 
     // Wallet::Verify will check if we're trying to create a wallet with a
     // duplicate name.
     std::unique_ptr<WalletDatabase> database =
         MakeWalletDatabase(name, options, status, error);
     if (!database) {
         error = Untranslated("Wallet file verification failed.") +
                 Untranslated(" ") + error;
         status = DatabaseStatus::FAILED_VERIFY;
         return nullptr;
     }
 
     // Do not allow a passphrase when private keys are disabled
     if (!passphrase.empty() &&
         (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         error = Untranslated(
             "Passphrase provided but private keys are disabled. A passphrase "
             "is only used to encrypt private keys, so cannot be used for "
             "wallets with private keys disabled.");
         status = DatabaseStatus::FAILED_CREATE;
         return nullptr;
     }
 
     // Make the wallet
     std::shared_ptr<CWallet> wallet =
         CWallet::Create(chain, name, std::move(database), wallet_creation_flags,
                         error, warnings);
     if (!wallet) {
         error =
             Untranslated("Wallet creation failed.") + Untranslated(" ") + error;
         status = DatabaseStatus::FAILED_CREATE;
         return nullptr;
     }
 
     // Encrypt the wallet
     if (!passphrase.empty() &&
         !(wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         if (!wallet->EncryptWallet(passphrase)) {
             error =
                 Untranslated("Error: Wallet created but failed to encrypt.");
             status = DatabaseStatus::FAILED_ENCRYPT;
             return nullptr;
         }
         if (!create_blank) {
             // Unlock the wallet
             if (!wallet->Unlock(passphrase)) {
                 error = Untranslated(
                     "Error: Wallet was encrypted but could not be unlocked");
                 status = DatabaseStatus::FAILED_ENCRYPT;
                 return nullptr;
             }
 
             // Set a seed for the wallet
             {
                 LOCK(wallet->cs_wallet);
                 if (wallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
                     wallet->SetupDescriptorScriptPubKeyMans();
                 } else {
                     for (auto spk_man : wallet->GetActiveScriptPubKeyMans()) {
                         if (!spk_man->SetupGeneration()) {
                             error =
                                 Untranslated("Unable to generate initial keys");
                             status = DatabaseStatus::FAILED_CREATE;
                             return nullptr;
                         }
                     }
                 }
             }
 
             // Relock the wallet
             wallet->Lock();
         }
     }
     AddWallet(wallet);
     wallet->postInitProcess();
 
     // Write the wallet settings
     UpdateWalletSetting(chain, name, load_on_start, warnings);
 
     status = DatabaseStatus::SUCCESS;
     return wallet;
 }
 
 /** @defgroup mapWallet
  *
  * @{
  */
 
 const CChainParams &CWallet::GetChainParams() const {
     // Get CChainParams from interfaces::Chain, unless wallet doesn't have a
     // chain (i.e. bitcoin-wallet), in which case return global Params()
     return m_chain ? m_chain->params() : Params();
 }
 
 const CWalletTx *CWallet::GetWalletTx(const TxId &txid) const {
     AssertLockHeld(cs_wallet);
     std::map<TxId, CWalletTx>::const_iterator it = mapWallet.find(txid);
     if (it == mapWallet.end()) {
         return nullptr;
     }
 
     return &(it->second);
 }
 
 void CWallet::UpgradeKeyMetadata() {
     if (IsLocked() || IsWalletFlagSet(WALLET_FLAG_KEY_ORIGIN_METADATA)) {
         return;
     }
 
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return;
     }
 
     spk_man->UpgradeKeyMetadata();
     SetWalletFlag(WALLET_FLAG_KEY_ORIGIN_METADATA);
 }
 
 bool CWallet::Unlock(const SecureString &strWalletPassphrase,
                      bool accept_no_keys) {
     CCrypter crypter;
     CKeyingMaterial _vMasterKey;
 
     {
         LOCK(cs_wallet);
         for (const MasterKeyMap::value_type &pMasterKey : mapMasterKeys) {
             if (!crypter.SetKeyFromPassphrase(
                     strWalletPassphrase, pMasterKey.second.vchSalt,
                     pMasterKey.second.nDeriveIterations,
                     pMasterKey.second.nDerivationMethod)) {
                 return false;
             }
             if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey,
                                  _vMasterKey)) {
                 // try another master key
                 continue;
             }
             if (Unlock(_vMasterKey, accept_no_keys)) {
                 // Now that we've unlocked, upgrade the key metadata
                 UpgradeKeyMetadata();
                 return true;
             }
         }
     }
 
     return false;
 }
 
 bool CWallet::ChangeWalletPassphrase(
     const SecureString &strOldWalletPassphrase,
     const SecureString &strNewWalletPassphrase) {
     bool fWasLocked = IsLocked();
 
     LOCK(cs_wallet);
     Lock();
 
     CCrypter crypter;
     CKeyingMaterial _vMasterKey;
     for (MasterKeyMap::value_type &pMasterKey : mapMasterKeys) {
         if (!crypter.SetKeyFromPassphrase(
                 strOldWalletPassphrase, pMasterKey.second.vchSalt,
                 pMasterKey.second.nDeriveIterations,
                 pMasterKey.second.nDerivationMethod)) {
             return false;
         }
 
         if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, _vMasterKey)) {
             return false;
         }
 
         if (Unlock(_vMasterKey)) {
             int64_t nStartTime = GetTimeMillis();
             crypter.SetKeyFromPassphrase(strNewWalletPassphrase,
                                          pMasterKey.second.vchSalt,
                                          pMasterKey.second.nDeriveIterations,
                                          pMasterKey.second.nDerivationMethod);
             pMasterKey.second.nDeriveIterations = static_cast<unsigned int>(
                 pMasterKey.second.nDeriveIterations *
                 (100 / ((double)(GetTimeMillis() - nStartTime))));
 
             nStartTime = GetTimeMillis();
             crypter.SetKeyFromPassphrase(strNewWalletPassphrase,
                                          pMasterKey.second.vchSalt,
                                          pMasterKey.second.nDeriveIterations,
                                          pMasterKey.second.nDerivationMethod);
             pMasterKey.second.nDeriveIterations =
                 (pMasterKey.second.nDeriveIterations +
                  static_cast<unsigned int>(
                      pMasterKey.second.nDeriveIterations * 100 /
                      double(GetTimeMillis() - nStartTime))) /
                 2;
 
             if (pMasterKey.second.nDeriveIterations < 25000) {
                 pMasterKey.second.nDeriveIterations = 25000;
             }
 
             WalletLogPrintf(
                 "Wallet passphrase changed to an nDeriveIterations of %i\n",
                 pMasterKey.second.nDeriveIterations);
 
             if (!crypter.SetKeyFromPassphrase(
                     strNewWalletPassphrase, pMasterKey.second.vchSalt,
                     pMasterKey.second.nDeriveIterations,
                     pMasterKey.second.nDerivationMethod)) {
                 return false;
             }
 
             if (!crypter.Encrypt(_vMasterKey,
                                  pMasterKey.second.vchCryptedKey)) {
                 return false;
             }
 
             WalletBatch(*database).WriteMasterKey(pMasterKey.first,
                                                   pMasterKey.second);
             if (fWasLocked) {
                 Lock();
             }
 
             return true;
         }
     }
 
     return false;
 }
 
 void CWallet::chainStateFlushed(const CBlockLocator &loc) {
     WalletBatch batch(*database);
     batch.WriteBestBlock(loc);
 }
 
 void CWallet::SetMinVersion(enum WalletFeature nVersion, WalletBatch *batch_in,
                             bool fExplicit) {
     LOCK(cs_wallet);
     if (nWalletVersion >= nVersion) {
         return;
     }
 
     // When doing an explicit upgrade, if we pass the max version permitted,
     // upgrade all the way.
     if (fExplicit && nVersion > nWalletMaxVersion) {
         nVersion = FEATURE_LATEST;
     }
 
     nWalletVersion = nVersion;
 
     if (nVersion > nWalletMaxVersion) {
         nWalletMaxVersion = nVersion;
     }
 
     WalletBatch *batch = batch_in ? batch_in : new WalletBatch(*database);
     if (nWalletVersion > 40000) {
         batch->WriteMinVersion(nWalletVersion);
     }
     if (!batch_in) {
         delete batch;
     }
 }
 
 bool CWallet::SetMaxVersion(int nVersion) {
     LOCK(cs_wallet);
 
     // Cannot downgrade below current version
     if (nWalletVersion > nVersion) {
         return false;
     }
 
     nWalletMaxVersion = nVersion;
 
     return true;
 }
 
 std::set<TxId> CWallet::GetConflicts(const TxId &txid) const {
     std::set<TxId> result;
     AssertLockHeld(cs_wallet);
 
     std::map<TxId, CWalletTx>::const_iterator it = mapWallet.find(txid);
     if (it == mapWallet.end()) {
         return result;
     }
 
     const CWalletTx &wtx = it->second;
 
     std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
 
     for (const CTxIn &txin : wtx.tx->vin) {
         if (mapTxSpends.count(txin.prevout) <= 1) {
             // No conflict if zero or one spends.
             continue;
         }
 
         range = mapTxSpends.equal_range(txin.prevout);
         for (TxSpends::const_iterator _it = range.first; _it != range.second;
              ++_it) {
             result.insert(_it->second);
         }
     }
 
     return result;
 }
 
 bool CWallet::HasWalletSpend(const TxId &txid) const {
     AssertLockHeld(cs_wallet);
     auto iter = mapTxSpends.lower_bound(COutPoint(txid, 0));
     return (iter != mapTxSpends.end() && iter->first.GetTxId() == txid);
 }
 
 void CWallet::Flush() {
     database->Flush();
 }
 
 void CWallet::Close() {
     database->Close();
 }
 
 void CWallet::SyncMetaData(
     std::pair<TxSpends::iterator, TxSpends::iterator> range) {
     // We want all the wallet transactions in range to have the same metadata as
     // the oldest (smallest nOrderPos).
     // So: find smallest nOrderPos:
 
     int nMinOrderPos = std::numeric_limits<int>::max();
     const CWalletTx *copyFrom = nullptr;
     for (TxSpends::iterator it = range.first; it != range.second; ++it) {
         const CWalletTx *wtx = &mapWallet.at(it->second);
         if (wtx->nOrderPos < nMinOrderPos) {
             nMinOrderPos = wtx->nOrderPos;
             copyFrom = wtx;
         }
     }
 
     if (!copyFrom) {
         return;
     }
 
     // Now copy data from copyFrom to rest:
     for (TxSpends::iterator it = range.first; it != range.second; ++it) {
         const TxId &txid = it->second;
         CWalletTx *copyTo = &mapWallet.at(txid);
         if (copyFrom == copyTo) {
             continue;
         }
 
         assert(
             copyFrom &&
             "Oldest wallet transaction in range assumed to have been found.");
 
         if (!copyFrom->IsEquivalentTo(*copyTo)) {
             continue;
         }
 
         copyTo->mapValue = copyFrom->mapValue;
         copyTo->vOrderForm = copyFrom->vOrderForm;
         // fTimeReceivedIsTxTime not copied on purpose nTimeReceived not copied
         // on purpose.
         copyTo->nTimeSmart = copyFrom->nTimeSmart;
         copyTo->fFromMe = copyFrom->fFromMe;
         // nOrderPos not copied on purpose cached members not copied on purpose.
     }
 }
 
 /**
  * Outpoint is spent if any non-conflicted transaction, spends it:
  */
 bool CWallet::IsSpent(const COutPoint &outpoint) const {
+    AssertLockHeld(cs_wallet);
+
     std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range =
         mapTxSpends.equal_range(outpoint);
 
     for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
         const TxId &wtxid = it->second;
         std::map<TxId, CWalletTx>::const_iterator mit = mapWallet.find(wtxid);
         if (mit != mapWallet.end()) {
             int depth = GetTxDepthInMainChain(mit->second);
             if (depth > 0 || (depth == 0 && !mit->second.isAbandoned())) {
                 // Spent
                 return true;
             }
         }
     }
 
     return false;
 }
 
 void CWallet::AddToSpends(const COutPoint &outpoint, const TxId &wtxid) {
     mapTxSpends.insert(std::make_pair(outpoint, wtxid));
 
     setLockedCoins.erase(outpoint);
 
     std::pair<TxSpends::iterator, TxSpends::iterator> range;
     range = mapTxSpends.equal_range(outpoint);
     SyncMetaData(range);
 }
 
 void CWallet::AddToSpends(const TxId &wtxid) {
     auto it = mapWallet.find(wtxid);
     assert(it != mapWallet.end());
     const CWalletTx &thisTx = it->second;
     // Coinbases don't spend anything!
     if (thisTx.IsCoinBase()) {
         return;
     }
 
     for (const CTxIn &txin : thisTx.tx->vin) {
         AddToSpends(txin.prevout, wtxid);
     }
 }
 
 bool CWallet::EncryptWallet(const SecureString &strWalletPassphrase) {
     if (IsCrypted()) {
         return false;
     }
 
     CKeyingMaterial _vMasterKey;
 
     _vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
     GetStrongRandBytes(&_vMasterKey[0], WALLET_CRYPTO_KEY_SIZE);
 
     CMasterKey kMasterKey;
 
     kMasterKey.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
     GetStrongRandBytes(&kMasterKey.vchSalt[0], WALLET_CRYPTO_SALT_SIZE);
 
     CCrypter crypter;
     int64_t nStartTime = GetTimeMillis();
     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000,
                                  kMasterKey.nDerivationMethod);
     kMasterKey.nDeriveIterations = static_cast<unsigned int>(
         2500000 / double(GetTimeMillis() - nStartTime));
 
     nStartTime = GetTimeMillis();
     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt,
                                  kMasterKey.nDeriveIterations,
                                  kMasterKey.nDerivationMethod);
     kMasterKey.nDeriveIterations =
         (kMasterKey.nDeriveIterations +
          static_cast<unsigned int>(kMasterKey.nDeriveIterations * 100 /
                                    double(GetTimeMillis() - nStartTime))) /
         2;
 
     if (kMasterKey.nDeriveIterations < 25000) {
         kMasterKey.nDeriveIterations = 25000;
     }
 
     WalletLogPrintf("Encrypting Wallet with an nDeriveIterations of %i\n",
                     kMasterKey.nDeriveIterations);
 
     if (!crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt,
                                       kMasterKey.nDeriveIterations,
                                       kMasterKey.nDerivationMethod)) {
         return false;
     }
 
     if (!crypter.Encrypt(_vMasterKey, kMasterKey.vchCryptedKey)) {
         return false;
     }
 
     {
         LOCK(cs_wallet);
         mapMasterKeys[++nMasterKeyMaxID] = kMasterKey;
         WalletBatch *encrypted_batch = new WalletBatch(*database);
         if (!encrypted_batch->TxnBegin()) {
             delete encrypted_batch;
             encrypted_batch = nullptr;
             return false;
         }
         encrypted_batch->WriteMasterKey(nMasterKeyMaxID, kMasterKey);
 
         for (const auto &spk_man_pair : m_spk_managers) {
             auto spk_man = spk_man_pair.second.get();
             if (!spk_man->Encrypt(_vMasterKey, encrypted_batch)) {
                 encrypted_batch->TxnAbort();
                 delete encrypted_batch;
                 encrypted_batch = nullptr;
                 // We now probably have half of our keys encrypted in memory,
                 // and half not... die and let the user reload the unencrypted
                 // wallet.
                 assert(false);
             }
         }
 
         // Encryption was introduced in version 0.4.0
         SetMinVersion(FEATURE_WALLETCRYPT, encrypted_batch, true);
 
         if (!encrypted_batch->TxnCommit()) {
             delete encrypted_batch;
             encrypted_batch = nullptr;
             // We now have keys encrypted in memory, but not on disk...
             // die to avoid confusion and let the user reload the unencrypted
             // wallet.
             assert(false);
         }
 
         delete encrypted_batch;
         encrypted_batch = nullptr;
 
         Lock();
         Unlock(strWalletPassphrase);
 
         // If we are using descriptors, make new descriptors with a new seed
         if (IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS) &&
             !IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET)) {
             SetupDescriptorScriptPubKeyMans();
         } else if (auto spk_man = GetLegacyScriptPubKeyMan()) {
             // if we are using HD, replace the HD seed with a new one
             if (spk_man->IsHDEnabled()) {
                 if (!spk_man->SetupGeneration(true)) {
                     return false;
                 }
             }
         }
         Lock();
 
         // Need to completely rewrite the wallet file; if we don't, bdb might
         // keep bits of the unencrypted private key in slack space in the
         // database file.
         database->Rewrite();
 
         // BDB seems to have a bad habit of writing old data into
         // slack space in .dat files; that is bad if the old data is
         // unencrypted private keys. So:
         database->ReloadDbEnv();
     }
 
     NotifyStatusChanged(this);
     return true;
 }
 
 DBErrors CWallet::ReorderTransactions() {
     LOCK(cs_wallet);
     WalletBatch batch(*database);
 
     // Old wallets didn't have any defined order for transactions. Probably a
     // bad idea to change the output of this.
 
     // First: get all CWalletTx into a sorted-by-time
     // multimap.
     TxItems txByTime;
 
     for (auto &entry : mapWallet) {
         CWalletTx *wtx = &entry.second;
         txByTime.insert(std::make_pair(wtx->nTimeReceived, wtx));
     }
 
     nOrderPosNext = 0;
     std::vector<int64_t> nOrderPosOffsets;
     for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it) {
         CWalletTx *const pwtx = (*it).second;
         int64_t &nOrderPos = pwtx->nOrderPos;
 
         if (nOrderPos == -1) {
             nOrderPos = nOrderPosNext++;
             nOrderPosOffsets.push_back(nOrderPos);
 
             if (!batch.WriteTx(*pwtx)) {
                 return DBErrors::LOAD_FAIL;
             }
         } else {
             int64_t nOrderPosOff = 0;
             for (const int64_t &nOffsetStart : nOrderPosOffsets) {
                 if (nOrderPos >= nOffsetStart) {
                     ++nOrderPosOff;
                 }
             }
 
             nOrderPos += nOrderPosOff;
             nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1);
 
             if (!nOrderPosOff) {
                 continue;
             }
 
             // Since we're changing the order, write it back.
             if (!batch.WriteTx(*pwtx)) {
                 return DBErrors::LOAD_FAIL;
             }
         }
     }
 
     batch.WriteOrderPosNext(nOrderPosNext);
 
     return DBErrors::LOAD_OK;
 }
 
 int64_t CWallet::IncOrderPosNext(WalletBatch *batch) {
     AssertLockHeld(cs_wallet);
     int64_t nRet = nOrderPosNext++;
     if (batch) {
         batch->WriteOrderPosNext(nOrderPosNext);
     } else {
         WalletBatch(*database).WriteOrderPosNext(nOrderPosNext);
     }
 
     return nRet;
 }
 
 void CWallet::MarkDirty() {
     LOCK(cs_wallet);
     for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
         item.second.MarkDirty();
     }
 }
 
 void CWallet::SetSpentKeyState(WalletBatch &batch, const TxId &txid,
                                unsigned int n, bool used,
                                std::set<CTxDestination> &tx_destinations) {
     AssertLockHeld(cs_wallet);
     const CWalletTx *srctx = GetWalletTx(txid);
     if (!srctx) {
         return;
     }
 
     CTxDestination dst;
     if (ExtractDestination(srctx->tx->vout[n].scriptPubKey, dst)) {
         if (IsMine(dst)) {
             if (used && !GetDestData(dst, "used", nullptr)) {
                 // p for "present", opposite of absent (null)
                 if (AddDestData(batch, dst, "used", "p")) {
                     tx_destinations.insert(dst);
                 }
             } else if (!used && GetDestData(dst, "used", nullptr)) {
                 EraseDestData(batch, dst, "used");
             }
         }
     }
 }
 
 bool CWallet::IsSpentKey(const TxId &txid, unsigned int n) const {
     AssertLockHeld(cs_wallet);
     const CWalletTx *srctx = GetWalletTx(txid);
     if (srctx) {
         assert(srctx->tx->vout.size() > n);
         CTxDestination dest;
         if (!ExtractDestination(srctx->tx->vout[n].scriptPubKey, dest)) {
             return false;
         }
         if (GetDestData(dest, "used", nullptr)) {
             return true;
         }
         if (IsLegacy()) {
             LegacyScriptPubKeyMan *spk_man = GetLegacyScriptPubKeyMan();
             assert(spk_man != nullptr);
             for (const auto &keyid :
                  GetAffectedKeys(srctx->tx->vout[n].scriptPubKey, *spk_man)) {
                 PKHash pkh_dest(keyid);
                 if (GetDestData(pkh_dest, "used", nullptr)) {
                     return true;
                 }
             }
         }
     }
     return false;
 }
 
 CWalletTx *CWallet::AddToWallet(CTransactionRef tx,
                                 const CWalletTx::Confirmation &confirm,
                                 const UpdateWalletTxFn &update_wtx,
                                 bool fFlushOnClose) {
     LOCK(cs_wallet);
 
     WalletBatch batch(*database, fFlushOnClose);
 
     const TxId &txid = tx->GetId();
 
     if (IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
         // Mark used destinations
         std::set<CTxDestination> tx_destinations;
 
         for (const CTxIn &txin : tx->vin) {
             const COutPoint &op = txin.prevout;
             SetSpentKeyState(batch, op.GetTxId(), op.GetN(), true,
                              tx_destinations);
         }
 
         MarkDestinationsDirty(tx_destinations);
     }
 
     // Inserts only if not already there, returns tx inserted or tx found.
     auto ret =
         mapWallet.emplace(std::piecewise_construct, std::forward_as_tuple(txid),
                           std::forward_as_tuple(tx));
     CWalletTx &wtx = (*ret.first).second;
     bool fInsertedNew = ret.second;
     bool fUpdated = update_wtx && update_wtx(wtx, fInsertedNew);
     if (fInsertedNew) {
         wtx.m_confirm = confirm;
         wtx.nTimeReceived = chain().getAdjustedTime();
         wtx.nOrderPos = IncOrderPosNext(&batch);
         wtx.m_it_wtxOrdered =
             wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
         wtx.nTimeSmart = ComputeTimeSmart(wtx);
         AddToSpends(txid);
     }
 
     if (!fInsertedNew) {
         if (confirm.status != wtx.m_confirm.status) {
             wtx.m_confirm.status = confirm.status;
             wtx.m_confirm.nIndex = confirm.nIndex;
             wtx.m_confirm.hashBlock = confirm.hashBlock;
             wtx.m_confirm.block_height = confirm.block_height;
             fUpdated = true;
         } else {
             assert(wtx.m_confirm.nIndex == confirm.nIndex);
             assert(wtx.m_confirm.hashBlock == confirm.hashBlock);
             assert(wtx.m_confirm.block_height == confirm.block_height);
         }
     }
 
     //// debug print
     WalletLogPrintf("AddToWallet %s  %s%s\n", txid.ToString(),
                     (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));
 
     // Write to disk
     if ((fInsertedNew || fUpdated) && !batch.WriteTx(wtx)) {
         return nullptr;
     }
 
     // Break debit/credit balance caches:
     wtx.MarkDirty();
 
     // Notify UI of new or updated transaction.
     NotifyTransactionChanged(this, txid, fInsertedNew ? CT_NEW : CT_UPDATED);
 
 #if defined(HAVE_SYSTEM)
     // Notify an external script when a wallet transaction comes in or is
     // updated.
     std::string strCmd = gArgs.GetArg("-walletnotify", "");
 
     if (!strCmd.empty()) {
         boost::replace_all(strCmd, "%s", txid.GetHex());
 #ifndef WIN32
         // Substituting the wallet name isn't currently supported on windows
         // because windows shell escaping has not been implemented yet:
         // https://github.com/bitcoin/bitcoin/pull/13339#issuecomment-537384875
         // A few ways it could be implemented in the future are described in:
         // https://github.com/bitcoin/bitcoin/pull/13339#issuecomment-461288094
         boost::replace_all(strCmd, "%w", ShellEscape(GetName()));
 #endif
 
         std::thread t(runCommand, strCmd);
         // Thread runs free.
         t.detach();
     }
 #endif
 
     return &wtx;
 }
 
 bool CWallet::LoadToWallet(const TxId &txid, const UpdateWalletTxFn &fill_wtx) {
     const auto &ins =
         mapWallet.emplace(std::piecewise_construct, std::forward_as_tuple(txid),
                           std::forward_as_tuple(nullptr));
     CWalletTx &wtx = ins.first->second;
     if (!fill_wtx(wtx, ins.second)) {
         return false;
     }
     // If wallet doesn't have a chain (e.g wallet-tool), don't bother to update
     // txn.
     if (HaveChain()) {
         bool active;
         int height;
         if (chain().findBlock(
                 wtx.m_confirm.hashBlock,
                 FoundBlock().inActiveChain(active).height(height)) &&
             active) {
             // Update cached block height variable since it not stored in the
             // serialized transaction.
             wtx.m_confirm.block_height = height;
         } else if (wtx.isConflicted() || wtx.isConfirmed()) {
             // If tx block (or conflicting block) was reorged out of chain
             // while the wallet was shutdown, change tx status to UNCONFIRMED
             // and reset block height, hash, and index. ABANDONED tx don't have
             // associated blocks and don't need to be updated. The case where a
             // transaction was reorged out while online and then reconfirmed
             // while offline is covered by the rescan logic.
             wtx.setUnconfirmed();
             wtx.m_confirm.hashBlock = BlockHash();
             wtx.m_confirm.block_height = 0;
             wtx.m_confirm.nIndex = 0;
         }
     }
     if (/* insertion took place */ ins.second) {
         wtx.m_it_wtxOrdered =
             wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
     }
     AddToSpends(txid);
     for (const CTxIn &txin : wtx.tx->vin) {
         auto it = mapWallet.find(txin.prevout.GetTxId());
         if (it != mapWallet.end()) {
             CWalletTx &prevtx = it->second;
             if (prevtx.isConflicted()) {
                 MarkConflicted(prevtx.m_confirm.hashBlock,
                                prevtx.m_confirm.block_height, wtx.GetId());
             }
         }
     }
     return true;
 }
 
 bool CWallet::AddToWalletIfInvolvingMe(const CTransactionRef &ptx,
                                        CWalletTx::Confirmation confirm,
                                        bool fUpdate) {
     const CTransaction &tx = *ptx;
     AssertLockHeld(cs_wallet);
 
     if (!confirm.hashBlock.IsNull()) {
         for (const CTxIn &txin : tx.vin) {
             std::pair<TxSpends::const_iterator, TxSpends::const_iterator>
                 range = mapTxSpends.equal_range(txin.prevout);
             while (range.first != range.second) {
                 if (range.first->second != tx.GetId()) {
                     WalletLogPrintf(
                         "Transaction %s (in block %s) conflicts with wallet "
                         "transaction %s (both spend %s:%i)\n",
                         tx.GetId().ToString(), confirm.hashBlock.ToString(),
                         range.first->second.ToString(),
                         range.first->first.GetTxId().ToString(),
                         range.first->first.GetN());
                     MarkConflicted(confirm.hashBlock, confirm.block_height,
                                    range.first->second);
                 }
                 range.first++;
             }
         }
     }
 
     bool fExisted = mapWallet.count(tx.GetId()) != 0;
     if (fExisted && !fUpdate) {
         return false;
     }
     if (fExisted || IsMine(tx) || IsFromMe(tx)) {
         /**
          * Check if any keys in the wallet keypool that were supposed to be
          * unused have appeared in a new transaction. If so, remove those keys
          * from the keypool. This can happen when restoring an old wallet backup
          * that does not contain the mostly recently created transactions from
          * newer versions of the wallet.
          */
 
         // loop though all outputs
         for (const CTxOut &txout : tx.vout) {
             for (const auto &spk_man_pair : m_spk_managers) {
                 spk_man_pair.second->MarkUnusedAddresses(txout.scriptPubKey);
             }
         }
 
         // Block disconnection override an abandoned tx as unconfirmed
         // which means user may have to call abandontransaction again
         return AddToWallet(MakeTransactionRef(tx), confirm,
                            /* update_wtx= */ nullptr,
                            /* fFlushOnClose= */ false);
     }
     return false;
 }
 
 bool CWallet::TransactionCanBeAbandoned(const TxId &txid) const {
     LOCK(cs_wallet);
     const CWalletTx *wtx = GetWalletTx(txid);
     return wtx && !wtx->isAbandoned() && GetTxDepthInMainChain(*wtx) == 0 &&
            !wtx->InMempool();
 }
 
 void CWallet::MarkInputsDirty(const CTransactionRef &tx) {
     for (const CTxIn &txin : tx->vin) {
         auto it = mapWallet.find(txin.prevout.GetTxId());
         if (it != mapWallet.end()) {
             it->second.MarkDirty();
         }
     }
 }
 
 bool CWallet::AbandonTransaction(const TxId &txid) {
     LOCK(cs_wallet);
 
     WalletBatch batch(*database);
 
     std::set<TxId> todo;
     std::set<TxId> done;
 
     // Can't mark abandoned if confirmed or in mempool
     auto it = mapWallet.find(txid);
     assert(it != mapWallet.end());
     const CWalletTx &origtx = it->second;
     if (GetTxDepthInMainChain(origtx) != 0 || origtx.InMempool()) {
         return false;
     }
 
     todo.insert(txid);
 
     while (!todo.empty()) {
         const TxId now = *todo.begin();
         todo.erase(now);
         done.insert(now);
         it = mapWallet.find(now);
         assert(it != mapWallet.end());
         CWalletTx &wtx = it->second;
         int currentconfirm = GetTxDepthInMainChain(wtx);
         // If the orig tx was not in block, none of its spends can be.
         assert(currentconfirm <= 0);
         // If (currentconfirm < 0) {Tx and spends are already conflicted, no
         // need to abandon}
         if (currentconfirm == 0 && !wtx.isAbandoned()) {
             // If the orig tx was not in block/mempool, none of its spends can
             // be in mempool.
             assert(!wtx.InMempool());
             wtx.setAbandoned();
             wtx.MarkDirty();
             batch.WriteTx(wtx);
             NotifyTransactionChanged(this, wtx.GetId(), CT_UPDATED);
             // Iterate over all its outputs, and mark transactions in the wallet
             // that spend them abandoned too.
             TxSpends::const_iterator iter =
                 mapTxSpends.lower_bound(COutPoint(now, 0));
             while (iter != mapTxSpends.end() && iter->first.GetTxId() == now) {
                 if (!done.count(iter->second)) {
                     todo.insert(iter->second);
                 }
                 iter++;
             }
 
             // If a transaction changes 'conflicted' state, that changes the
             // balance available of the outputs it spends. So force those to be
             // recomputed.
             MarkInputsDirty(wtx.tx);
         }
     }
 
     return true;
 }
 
 void CWallet::MarkConflicted(const BlockHash &hashBlock, int conflicting_height,
                              const TxId &txid) {
     LOCK(cs_wallet);
 
     int conflictconfirms =
         (m_last_block_processed_height - conflicting_height + 1) * -1;
 
     // If number of conflict confirms cannot be determined, this means that the
     // block is still unknown or not yet part of the main chain, for example
     // when loading the wallet during a reindex. Do nothing in that case.
     if (conflictconfirms >= 0) {
         return;
     }
 
     // Do not flush the wallet here for performance reasons.
     WalletBatch batch(*database, false);
 
     std::set<TxId> todo;
     std::set<TxId> done;
 
     todo.insert(txid);
 
     while (!todo.empty()) {
         const TxId now = *todo.begin();
         todo.erase(now);
         done.insert(now);
         auto it = mapWallet.find(now);
         assert(it != mapWallet.end());
         CWalletTx &wtx = it->second;
         int currentconfirm = GetTxDepthInMainChain(wtx);
         if (conflictconfirms < currentconfirm) {
             // Block is 'more conflicted' than current confirm; update.
             // Mark transaction as conflicted with this block.
             wtx.m_confirm.nIndex = 0;
             wtx.m_confirm.hashBlock = hashBlock;
             wtx.m_confirm.block_height = conflicting_height;
             wtx.setConflicted();
             wtx.MarkDirty();
             batch.WriteTx(wtx);
             // Iterate over all its outputs, and mark transactions in the wallet
             // that spend them conflicted too.
             TxSpends::const_iterator iter =
                 mapTxSpends.lower_bound(COutPoint(now, 0));
             while (iter != mapTxSpends.end() && iter->first.GetTxId() == now) {
                 if (!done.count(iter->second)) {
                     todo.insert(iter->second);
                 }
                 iter++;
             }
             // If a transaction changes 'conflicted' state, that changes the
             // balance available of the outputs it spends. So force those to be
             // recomputed.
             MarkInputsDirty(wtx.tx);
         }
     }
 }
 
 void CWallet::SyncTransaction(const CTransactionRef &ptx,
                               CWalletTx::Confirmation confirm, bool update_tx) {
     if (!AddToWalletIfInvolvingMe(ptx, confirm, update_tx)) {
         // Not one of ours
         return;
     }
 
     // If a transaction changes 'conflicted' state, that changes the balance
     // available of the outputs it spends. So force those to be
     // recomputed, also:
     MarkInputsDirty(ptx);
 }
 
 void CWallet::transactionAddedToMempool(const CTransactionRef &tx,
                                         uint64_t mempool_sequence) {
     LOCK(cs_wallet);
 
     SyncTransaction(tx, {CWalletTx::Status::UNCONFIRMED, /* block_height */ 0,
                          BlockHash(), /* nIndex */ 0});
 
     auto it = mapWallet.find(tx->GetId());
     if (it != mapWallet.end()) {
         it->second.fInMempool = true;
     }
 }
 
 void CWallet::transactionRemovedFromMempool(const CTransactionRef &tx,
                                             MemPoolRemovalReason reason,
                                             uint64_t mempool_sequence) {
     LOCK(cs_wallet);
     auto it = mapWallet.find(tx->GetId());
     if (it != mapWallet.end()) {
         it->second.fInMempool = false;
     }
     // Handle transactions that were removed from the mempool because they
     // conflict with transactions in a newly connected block.
     if (reason == MemPoolRemovalReason::CONFLICT) {
         // Call SyncNotifications, so external -walletnotify notifications will
         // be triggered for these transactions. Set Status::UNCONFIRMED instead
         // of Status::CONFLICTED for a few reasons:
         //
         // 1. The transactionRemovedFromMempool callback does not currently
         //    provide the conflicting block's hash and height, and for backwards
         //    compatibility reasons it may not be not safe to store conflicted
         //    wallet transactions with a null block hash. See
         //    https://github.com/bitcoin/bitcoin/pull/18600#discussion_r420195993.
         // 2. For most of these transactions, the wallet's internal conflict
         //    detection in the blockConnected handler will subsequently call
         //    MarkConflicted and update them with CONFLICTED status anyway. This
         //    applies to any wallet transaction that has inputs spent in the
         //    block, or that has ancestors in the wallet with inputs spent by
         //    the block.
         // 3. Longstanding behavior since the sync implementation in
         //    https://github.com/bitcoin/bitcoin/pull/9371 and the prior sync
         //    implementation before that was to mark these transactions
         //    unconfirmed rather than conflicted.
         //
         // Nothing described above should be seen as an unchangeable requirement
         // when improving this code in the future. The wallet's heuristics for
         // distinguishing between conflicted and unconfirmed transactions are
         // imperfect, and could be improved in general, see
         // https://github.com/bitcoin-core/bitcoin-devwiki/wiki/Wallet-Transaction-Conflict-Tracking
         SyncTransaction(tx,
                         {CWalletTx::Status::UNCONFIRMED, /* block height  */ 0,
                          BlockHash(), /* index */ 0});
     }
 }
 
 void CWallet::blockConnected(const CBlock &block, int height) {
     const BlockHash &block_hash = block.GetHash();
     LOCK(cs_wallet);
 
     m_last_block_processed_height = height;
     m_last_block_processed = block_hash;
     for (size_t index = 0; index < block.vtx.size(); index++) {
         SyncTransaction(block.vtx[index], {CWalletTx::Status::CONFIRMED, height,
                                            block_hash, int(index)});
         transactionRemovedFromMempool(block.vtx[index],
                                       MemPoolRemovalReason::BLOCK,
                                       0 /* mempool_sequence */);
     }
 }
 
 void CWallet::blockDisconnected(const CBlock &block, int height) {
     LOCK(cs_wallet);
 
     // At block disconnection, this will change an abandoned transaction to
     // be unconfirmed, whether or not the transaction is added back to the
     // mempool. User may have to call abandontransaction again. It may be
     // addressed in the future with a stickier abandoned state or even removing
     // abandontransaction call.
     m_last_block_processed_height = height - 1;
     m_last_block_processed = block.hashPrevBlock;
     for (const CTransactionRef &ptx : block.vtx) {
         SyncTransaction(ptx,
                         {CWalletTx::Status::UNCONFIRMED, /* block_height */ 0,
                          BlockHash(), /* nIndex */ 0});
     }
 }
 
 void CWallet::updatedBlockTip() {
     m_best_block_time = GetTime();
 }
 
 void CWallet::BlockUntilSyncedToCurrentChain() const {
     AssertLockNotHeld(cs_wallet);
     // Skip the queue-draining stuff if we know we're caught up with
     // chain().Tip(), otherwise put a callback in the validation interface
     // queue and wait for the queue to drain enough to execute it (indicating we
     // are caught up at least with the time we entered this function).
     const BlockHash last_block_hash =
         WITH_LOCK(cs_wallet, return m_last_block_processed);
     chain().waitForNotificationsIfTipChanged(last_block_hash);
 }
 
 // Note that this function doesn't distinguish between a 0-valued input, and a
 // not-"is mine" (according to the filter) input.
 Amount CWallet::GetDebit(const CTxIn &txin, const isminefilter &filter) const {
     LOCK(cs_wallet);
     std::map<TxId, CWalletTx>::const_iterator mi =
         mapWallet.find(txin.prevout.GetTxId());
     if (mi != mapWallet.end()) {
         const CWalletTx &prev = (*mi).second;
         if (txin.prevout.GetN() < prev.tx->vout.size()) {
             if (IsMine(prev.tx->vout[txin.prevout.GetN()]) & filter) {
                 return prev.tx->vout[txin.prevout.GetN()].nValue;
             }
         }
     }
 
     return Amount::zero();
 }
 
 isminetype CWallet::IsMine(const CTxOut &txout) const {
     AssertLockHeld(cs_wallet);
     return IsMine(txout.scriptPubKey);
 }
 
 isminetype CWallet::IsMine(const CTxDestination &dest) const {
     AssertLockHeld(cs_wallet);
     return IsMine(GetScriptForDestination(dest));
 }
 
 isminetype CWallet::IsMine(const CScript &script) const {
     AssertLockHeld(cs_wallet);
     isminetype result = ISMINE_NO;
     for (const auto &spk_man_pair : m_spk_managers) {
         result = std::max(result, spk_man_pair.second->IsMine(script));
     }
     return result;
 }
 
 bool CWallet::IsMine(const CTransaction &tx) const {
     AssertLockHeld(cs_wallet);
     for (const CTxOut &txout : tx.vout) {
         if (IsMine(txout)) {
             return true;
         }
     }
 
     return false;
 }
 
 bool CWallet::IsFromMe(const CTransaction &tx) const {
     return GetDebit(tx, ISMINE_ALL) > Amount::zero();
 }
 
 Amount CWallet::GetDebit(const CTransaction &tx,
                          const isminefilter &filter) const {
     Amount nDebit = Amount::zero();
     for (const CTxIn &txin : tx.vin) {
         nDebit += GetDebit(txin, filter);
         if (!MoneyRange(nDebit)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": value out of range");
         }
     }
 
     return nDebit;
 }
 
 bool CWallet::IsHDEnabled() const {
     // All Active ScriptPubKeyMans must be HD for this to be true
     bool result = true;
     for (const auto &spk_man : GetActiveScriptPubKeyMans()) {
         result &= spk_man->IsHDEnabled();
     }
     return result;
 }
 
 bool CWallet::CanGetAddresses(bool internal) const {
     LOCK(cs_wallet);
     if (m_spk_managers.empty()) {
         return false;
     }
     for (OutputType t : OUTPUT_TYPES) {
         auto spk_man = GetScriptPubKeyMan(t, internal);
         if (spk_man && spk_man->CanGetAddresses(internal)) {
             return true;
         }
     }
     return false;
 }
 
 void CWallet::SetWalletFlag(uint64_t flags) {
     LOCK(cs_wallet);
     m_wallet_flags |= flags;
     if (!WalletBatch(*database).WriteWalletFlags(m_wallet_flags)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing wallet flags failed");
     }
 }
 
 void CWallet::UnsetWalletFlag(uint64_t flag) {
     WalletBatch batch(*database);
     UnsetWalletFlagWithDB(batch, flag);
 }
 
 void CWallet::UnsetWalletFlagWithDB(WalletBatch &batch, uint64_t flag) {
     LOCK(cs_wallet);
     m_wallet_flags &= ~flag;
     if (!batch.WriteWalletFlags(m_wallet_flags)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing wallet flags failed");
     }
 }
 
 void CWallet::UnsetBlankWalletFlag(WalletBatch &batch) {
     UnsetWalletFlagWithDB(batch, WALLET_FLAG_BLANK_WALLET);
 }
 
 bool CWallet::IsWalletFlagSet(uint64_t flag) const {
     return (m_wallet_flags & flag);
 }
 
 bool CWallet::LoadWalletFlags(uint64_t flags) {
     LOCK(cs_wallet);
     if (((flags & KNOWN_WALLET_FLAGS) >> 32) ^ (flags >> 32)) {
         // contains unknown non-tolerable wallet flags
         return false;
     }
     m_wallet_flags = flags;
 
     return true;
 }
 
 bool CWallet::AddWalletFlags(uint64_t flags) {
     LOCK(cs_wallet);
     // We should never be writing unknown non-tolerable wallet flags
     assert(((flags & KNOWN_WALLET_FLAGS) >> 32) == (flags >> 32));
     if (!WalletBatch(*database).WriteWalletFlags(flags)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing wallet flags failed");
     }
 
     return LoadWalletFlags(flags);
 }
 
 // Helper for producing a max-sized low-S low-R signature (eg 71 bytes)
 // or a max-sized low-S signature (e.g. 72 bytes) if use_max_sig is true
 bool CWallet::DummySignInput(CTxIn &tx_in, const CTxOut &txout,
                              bool use_max_sig) const {
     // Fill in dummy signatures for fee calculation.
     const CScript &scriptPubKey = txout.scriptPubKey;
     SignatureData sigdata;
 
     std::unique_ptr<SigningProvider> provider =
         GetSolvingProvider(scriptPubKey);
     if (!provider) {
         // We don't know about this scriptpbuKey;
         return false;
     }
 
     if (!ProduceSignature(*provider,
                           use_max_sig ? DUMMY_MAXIMUM_SIGNATURE_CREATOR
                                       : DUMMY_SIGNATURE_CREATOR,
                           scriptPubKey, sigdata)) {
         return false;
     }
 
     UpdateInput(tx_in, sigdata);
     return true;
 }
 
 // Helper for producing a bunch of max-sized low-S low-R signatures (eg 71
 // bytes)
 bool CWallet::DummySignTx(CMutableTransaction &txNew,
                           const std::vector<CTxOut> &txouts,
                           bool use_max_sig) const {
     // Fill in dummy signatures for fee calculation.
     int nIn = 0;
     for (const auto &txout : txouts) {
         if (!DummySignInput(txNew.vin[nIn], txout, use_max_sig)) {
             return false;
         }
 
         nIn++;
     }
     return true;
 }
 
 bool CWallet::ImportScripts(const std::set<CScript> scripts,
                             int64_t timestamp) {
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return false;
     }
     LOCK(spk_man->cs_KeyStore);
     return spk_man->ImportScripts(scripts, timestamp);
 }
 
 bool CWallet::ImportPrivKeys(const std::map<CKeyID, CKey> &privkey_map,
                              const int64_t timestamp) {
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return false;
     }
     LOCK(spk_man->cs_KeyStore);
     return spk_man->ImportPrivKeys(privkey_map, timestamp);
 }
 
 bool CWallet::ImportPubKeys(
     const std::vector<CKeyID> &ordered_pubkeys,
     const std::map<CKeyID, CPubKey> &pubkey_map,
     const std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> &key_origins,
     const bool add_keypool, const bool internal, const int64_t timestamp) {
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return false;
     }
     LOCK(spk_man->cs_KeyStore);
     return spk_man->ImportPubKeys(ordered_pubkeys, pubkey_map, key_origins,
                                   add_keypool, internal, timestamp);
 }
 
 bool CWallet::ImportScriptPubKeys(const std::string &label,
                                   const std::set<CScript> &script_pub_keys,
                                   const bool have_solving_data,
                                   const bool apply_label,
                                   const int64_t timestamp) {
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return false;
     }
     LOCK(spk_man->cs_KeyStore);
     if (!spk_man->ImportScriptPubKeys(script_pub_keys, have_solving_data,
                                       timestamp)) {
         return false;
     }
     if (apply_label) {
         WalletBatch batch(*database);
         for (const CScript &script : script_pub_keys) {
             CTxDestination dest;
             ExtractDestination(script, dest);
             if (IsValidDestination(dest)) {
                 SetAddressBookWithDB(batch, dest, label, "receive");
             }
         }
     }
     return true;
 }
 
 /**
  * Scan active chain for relevant transactions after importing keys. This should
  * be called whenever new keys are added to the wallet, with the oldest key
  * creation time.
  *
  * @return Earliest timestamp that could be successfully scanned from. Timestamp
  * returned will be higher than startTime if relevant blocks could not be read.
  */
 int64_t CWallet::RescanFromTime(int64_t startTime,
                                 const WalletRescanReserver &reserver,
                                 bool update) {
     // Find starting block. May be null if nCreateTime is greater than the
     // highest blockchain timestamp, in which case there is nothing that needs
     // to be scanned.
     int start_height = 0;
     BlockHash start_block;
     bool start = chain().findFirstBlockWithTimeAndHeight(
         startTime - TIMESTAMP_WINDOW, 0,
         FoundBlock().hash(start_block).height(start_height));
     WalletLogPrintf("%s: Rescanning last %i blocks\n", __func__,
                     start ? WITH_LOCK(cs_wallet, return GetLastBlockHeight()) -
                                 start_height + 1
                           : 0);
 
     if (start) {
         // TODO: this should take into account failure by ScanResult::USER_ABORT
         ScanResult result = ScanForWalletTransactions(
             start_block, start_height, {} /* max_height */, reserver, update);
         if (result.status == ScanResult::FAILURE) {
             int64_t time_max;
             CHECK_NONFATAL(chain().findBlock(result.last_failed_block,
                                              FoundBlock().maxTime(time_max)));
             return time_max + TIMESTAMP_WINDOW + 1;
         }
     }
     return startTime;
 }
 
 /**
  * Scan the block chain (starting in start_block) for transactions from or to
  * us. If fUpdate is true, found transactions that already exist in the wallet
  * will be updated.
  *
  * @param[in] start_block Scan starting block. If block is not on the active
  *                        chain, the scan will return SUCCESS immediately.
  * @param[in] start_height Height of start_block
  * @param[in] max_height  Optional max scanning height. If unset there is
  *                        no maximum and scanning can continue to the tip
  *
  * @return ScanResult returning scan information and indicating success or
  *         failure. Return status will be set to SUCCESS if scan was
  *         successful. FAILURE if a complete rescan was not possible (due to
  *         pruning or corruption). USER_ABORT if the rescan was aborted before
  *         it could complete.
  *
  * @pre Caller needs to make sure start_block (and the optional stop_block) are
  * on the main chain after to the addition of any new keys you want to detect
  * transactions for.
  */
 CWallet::ScanResult CWallet::ScanForWalletTransactions(
     const BlockHash &start_block, int start_height,
     std::optional<int> max_height, const WalletRescanReserver &reserver,
     bool fUpdate) {
     int64_t nNow = GetTime();
     int64_t start_time = GetTimeMillis();
 
     assert(reserver.isReserved());
 
     BlockHash block_hash = start_block;
     ScanResult result;
 
     WalletLogPrintf("Rescan started from block %s...\n",
                     start_block.ToString());
 
     fAbortRescan = false;
     // Show rescan progress in GUI as dialog or on splashscreen, if -rescan on
     // startup.
     ShowProgress(
         strprintf("%s " + _("Rescanning...").translated, GetDisplayName()), 0);
     BlockHash tip_hash = WITH_LOCK(cs_wallet, return GetLastBlockHash());
     BlockHash end_hash = tip_hash;
     if (max_height) {
         chain().findAncestorByHeight(tip_hash, *max_height,
                                      FoundBlock().hash(end_hash));
     }
     double progress_begin = chain().guessVerificationProgress(block_hash);
     double progress_end = chain().guessVerificationProgress(end_hash);
     double progress_current = progress_begin;
     int block_height = start_height;
     while (!fAbortRescan && !chain().shutdownRequested()) {
         if (progress_end - progress_begin > 0.0) {
             m_scanning_progress = (progress_current - progress_begin) /
                                   (progress_end - progress_begin);
         } else {
             // avoid divide-by-zero for single block scan range (i.e. start and
             // stop hashes are equal)
             m_scanning_progress = 0;
         }
         if (block_height % 100 == 0 && progress_end - progress_begin > 0.0) {
             ShowProgress(
                 strprintf("%s " + _("Rescanning...").translated,
                           GetDisplayName()),
                 std::max(1, std::min(99, (int)(m_scanning_progress * 100))));
         }
         if (GetTime() >= nNow + 60) {
             nNow = GetTime();
             WalletLogPrintf("Still rescanning. At block %d. Progress=%f\n",
                             block_height, progress_current);
         }
 
         // Read block data
         CBlock block;
         chain().findBlock(block_hash, FoundBlock().data(block));
 
         // Find next block separately from reading data above, because reading
         // is slow and there might be a reorg while it is read.
         bool block_still_active = false;
         bool next_block = false;
         BlockHash next_block_hash;
         chain().findBlock(block_hash,
                           FoundBlock()
                               .inActiveChain(block_still_active)
                               .nextBlock(FoundBlock()
                                              .inActiveChain(next_block)
                                              .hash(next_block_hash)));
 
         if (!block.IsNull()) {
             LOCK(cs_wallet);
             if (!block_still_active) {
                 // Abort scan if current block is no longer active, to prevent
                 // marking transactions as coming from the wrong block.
                 result.last_failed_block = block_hash;
                 result.status = ScanResult::FAILURE;
                 break;
             }
             for (size_t posInBlock = 0; posInBlock < block.vtx.size();
                  ++posInBlock) {
                 CWalletTx::Confirmation confirm(CWalletTx::Status::CONFIRMED,
                                                 block_height, block_hash,
                                                 posInBlock);
                 SyncTransaction(block.vtx[posInBlock],
                                 {CWalletTx::Status::CONFIRMED, block_height,
                                  block_hash, int(posInBlock)},
                                 fUpdate);
             }
             // scan succeeded, record block as most recent successfully
             // scanned
             result.last_scanned_block = block_hash;
             result.last_scanned_height = block_height;
         } else {
             // could not scan block, keep scanning but record this block as
             // the most recent failure
             result.last_failed_block = block_hash;
             result.status = ScanResult::FAILURE;
         }
         if (max_height && block_height >= *max_height) {
             break;
         }
         {
             if (!next_block) {
                 // break successfully when rescan has reached the tip, or
                 // previous block is no longer on the chain due to a reorg
                 break;
             }
 
             // increment block and verification progress
             block_hash = next_block_hash;
             ++block_height;
             progress_current = chain().guessVerificationProgress(block_hash);
 
             // handle updated tip hash
             const BlockHash prev_tip_hash = tip_hash;
             tip_hash = WITH_LOCK(cs_wallet, return GetLastBlockHash());
             if (!max_height && prev_tip_hash != tip_hash) {
                 // in case the tip has changed, update progress max
                 progress_end = chain().guessVerificationProgress(tip_hash);
             }
         }
     }
 
     // Hide progress dialog in GUI.
     ShowProgress(
         strprintf("%s " + _("Rescanning...").translated, GetDisplayName()),
         100);
     if (block_height && fAbortRescan) {
         WalletLogPrintf("Rescan aborted at block %d. Progress=%f\n",
                         block_height, progress_current);
         result.status = ScanResult::USER_ABORT;
     } else if (block_height && chain().shutdownRequested()) {
         WalletLogPrintf(
             "Rescan interrupted by shutdown request at block %d. Progress=%f\n",
             block_height, progress_current);
         result.status = ScanResult::USER_ABORT;
     } else {
         WalletLogPrintf("Rescan completed in %15dms\n",
                         GetTimeMillis() - start_time);
     }
     return result;
 }
 
 void CWallet::ReacceptWalletTransactions() {
+    AssertLockHeld(cs_wallet);
+
     // If transactions aren't being broadcasted, don't let them into local
     // mempool either.
     if (!fBroadcastTransactions) {
         return;
     }
 
     std::map<int64_t, CWalletTx *> mapSorted;
 
     // Sort pending wallet transactions based on their initial wallet insertion
     // order.
     for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
         const TxId &wtxid = item.first;
         CWalletTx &wtx = item.second;
         assert(wtx.GetId() == wtxid);
 
         int nDepth = GetTxDepthInMainChain(wtx);
 
         if (!wtx.IsCoinBase() && (nDepth == 0 && !wtx.isAbandoned())) {
             mapSorted.insert(std::make_pair(wtx.nOrderPos, &wtx));
         }
     }
 
     // Try to add wallet transactions to memory pool.
     for (const std::pair<const int64_t, CWalletTx *> &item : mapSorted) {
         CWalletTx &wtx = *(item.second);
         std::string unused_err_string;
         SubmitTxMemoryPoolAndRelay(wtx, unused_err_string, false);
     }
 }
 
 bool CWallet::SubmitTxMemoryPoolAndRelay(const CWalletTx &wtx,
                                          std::string &err_string,
                                          bool relay) const {
+    AssertLockHeld(cs_wallet);
+
     // Can't relay if wallet is not broadcasting
     if (!GetBroadcastTransactions()) {
         return false;
     }
     // Don't relay abandoned transactions
     if (wtx.isAbandoned()) {
         return false;
     }
     // Don't try to submit coinbase transactions. These would fail anyway but
     // would cause log spam.
     if (wtx.IsCoinBase()) {
         return false;
     }
     // Don't try to submit conflicted or confirmed transactions.
     if (GetTxDepthInMainChain(wtx) != 0) {
         return false;
     }
 
     // Submit transaction to mempool for relay
     WalletLogPrintf("Submitting wtx %s to mempool for relay\n",
                     wtx.GetId().ToString());
     // We must set fInMempool here - while it will be re-set to true by the
     // entered-mempool callback, if we did not there would be a race where a
     // user could call sendmoney in a loop and hit spurious out of funds errors
     // because we think that this newly generated transaction's change is
     // unavailable as we're not yet aware that it is in the mempool.
     //
     // Irrespective of the failure reason, un-marking fInMempool
     // out-of-order is incorrect - it should be unmarked when
     // TransactionRemovedFromMempool fires.
     bool ret = chain().broadcastTransaction(
         GetConfig(), wtx.tx, m_default_max_tx_fee, relay, err_string);
     wtx.fInMempool |= ret;
     return ret;
 }
 
 std::set<TxId> CWallet::GetTxConflicts(const CWalletTx &wtx) const {
+    AssertLockHeld(cs_wallet);
+
     std::set<TxId> result;
     const TxId &txid = wtx.GetId();
     result = GetConflicts(txid);
     result.erase(txid);
 
     return result;
 }
 
 // Rebroadcast transactions from the wallet. We do this on a random timer
 // to slightly obfuscate which transactions come from our wallet.
 //
 // Ideally, we'd only resend transactions that we think should have been
 // mined in the most recent block. Any transaction that wasn't in the top
 // blockweight of transactions in the mempool shouldn't have been mined,
 // and so is probably just sitting in the mempool waiting to be confirmed.
 // Rebroadcasting does nothing to speed up confirmation and only damages
 // privacy.
 void CWallet::ResendWalletTransactions() {
     // During reindex, importing and IBD, old wallet transactions become
     // unconfirmed. Don't resend them as that would spam other nodes.
     if (!chain().isReadyToBroadcast()) {
         return;
     }
 
     // Do this infrequently and randomly to avoid giving away that these are our
     // transactions.
     if (GetTime() < nNextResend || !fBroadcastTransactions) {
         return;
     }
 
     bool fFirst = (nNextResend == 0);
     // resend 12-36 hours from now, ~1 day on average.
     nNextResend = GetTime() + (12 * 60 * 60) + GetRand(24 * 60 * 60);
     if (fFirst) {
         return;
     }
 
     int submitted_tx_count = 0;
 
     { // cs_wallet scope
         LOCK(cs_wallet);
 
         // Relay transactions
         for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
             CWalletTx &wtx = item.second;
             // Attempt to rebroadcast all txes more than 5 minutes older than
             // the last block. SubmitTxMemoryPoolAndRelay() will not rebroadcast
             // any confirmed or conflicting txs.
             if (wtx.nTimeReceived > m_best_block_time - 5 * 60) {
                 continue;
             }
             std::string unused_err_string;
             if (SubmitTxMemoryPoolAndRelay(wtx, unused_err_string, true)) {
                 ++submitted_tx_count;
             }
         }
     } // cs_wallet
 
     if (submitted_tx_count > 0) {
         WalletLogPrintf("%s: resubmit %u unconfirmed transactions\n", __func__,
                         submitted_tx_count);
     }
 }
 
 /** @} */ // end of mapWallet
 
 void MaybeResendWalletTxs() {
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         pwallet->ResendWalletTransactions();
     }
 }
 
 /**
  * @defgroup Actions
  *
  * @{
  */
 
 bool CWallet::SignTransaction(CMutableTransaction &tx) const {
     AssertLockHeld(cs_wallet);
 
     // Build coins map
     std::map<COutPoint, Coin> coins;
     for (auto &input : tx.vin) {
         auto mi = mapWallet.find(input.prevout.GetTxId());
         if (mi == mapWallet.end() ||
             input.prevout.GetN() >= mi->second.tx->vout.size()) {
             return false;
         }
         const CWalletTx &wtx = mi->second;
         coins[input.prevout] =
             Coin(wtx.tx->vout[input.prevout.GetN()], wtx.m_confirm.block_height,
                  wtx.IsCoinBase());
     }
     std::map<int, std::string> input_errors;
     return SignTransaction(tx, coins, SigHashType().withForkId(), input_errors);
 }
 
 bool CWallet::SignTransaction(CMutableTransaction &tx,
                               const std::map<COutPoint, Coin> &coins,
                               SigHashType sighash,
                               std::map<int, std::string> &input_errors) const {
     // Try to sign with all ScriptPubKeyMans
     for (ScriptPubKeyMan *spk_man : GetAllScriptPubKeyMans()) {
         // spk_man->SignTransaction will return true if the transaction is
         // complete, so we can exit early and return true if that happens
         if (spk_man->SignTransaction(tx, coins, sighash, input_errors)) {
             return true;
         }
     }
 
     // At this point, one input was not fully signed otherwise we would have
     // exited already
 
     // When there are no available providers for the remaining inputs, use the
     // legacy provider so we can get proper error messages.
     auto legacy_spk_man = GetLegacyScriptPubKeyMan();
     if (legacy_spk_man &&
         legacy_spk_man->SignTransaction(tx, coins, sighash, input_errors)) {
         return true;
     }
 
     return false;
 }
 
 TransactionError CWallet::FillPSBT(PartiallySignedTransaction &psbtx,
                                    bool &complete, SigHashType sighash_type,
                                    bool sign, bool bip32derivs) const {
     LOCK(cs_wallet);
     // Get all of the previous transactions
     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;
         }
 
         // If we have no utxo, grab it from the wallet.
         if (input.utxo.IsNull()) {
             const TxId &txid = txin.prevout.GetTxId();
             const auto it = mapWallet.find(txid);
             if (it != mapWallet.end()) {
                 const CWalletTx &wtx = it->second;
                 CTxOut utxo = wtx.tx->vout[txin.prevout.GetN()];
                 // Update UTXOs from the wallet.
                 input.utxo = utxo;
             }
         }
     }
 
     // Fill in information from ScriptPubKeyMans
     for (ScriptPubKeyMan *spk_man : GetAllScriptPubKeyMans()) {
         TransactionError res =
             spk_man->FillPSBT(psbtx, sighash_type, sign, bip32derivs);
         if (res != TransactionError::OK) {
             return res;
         }
     }
 
     // Complete if every input is now signed
     complete = true;
     for (const auto &input : psbtx.inputs) {
         complete &= PSBTInputSigned(input);
     }
 
     return TransactionError::OK;
 }
 
 SigningResult CWallet::SignMessage(const std::string &message,
                                    const PKHash &pkhash,
                                    std::string &str_sig) const {
     SignatureData sigdata;
     CScript script_pub_key = GetScriptForDestination(pkhash);
     for (const auto &spk_man_pair : m_spk_managers) {
         if (spk_man_pair.second->CanProvide(script_pub_key, sigdata)) {
             return spk_man_pair.second->SignMessage(message, pkhash, str_sig);
         }
     }
     return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
 }
 
 OutputType
 CWallet::TransactionChangeType(const std::optional<OutputType> &change_type,
                                const std::vector<CRecipient> &vecSend) const {
     // If -changetype is specified, always use that change type.
     if (change_type) {
         return *change_type;
     }
 
     // if m_default_address_type is legacy, use legacy address as change.
     if (m_default_address_type == OutputType::LEGACY) {
         return OutputType::LEGACY;
     }
 
     // else use m_default_address_type for change
     return m_default_address_type;
 }
 
 void CWallet::CommitTransaction(
     CTransactionRef tx, mapValue_t mapValue,
     std::vector<std::pair<std::string, std::string>> orderForm) {
     LOCK(cs_wallet);
 
     WalletLogPrintfToBeContinued("CommitTransaction:\n%s", tx->ToString());
 
     // Add tx to wallet, because if it has change it's also ours, otherwise just
     // for transaction history.
     AddToWallet(tx, {}, [&](CWalletTx &wtx, bool new_tx) {
         CHECK_NONFATAL(wtx.mapValue.empty());
         CHECK_NONFATAL(wtx.vOrderForm.empty());
         wtx.mapValue = std::move(mapValue);
         wtx.vOrderForm = std::move(orderForm);
         wtx.fTimeReceivedIsTxTime = true;
         wtx.fFromMe = true;
         return true;
     });
 
     // Notify that old coins are spent.
     for (const CTxIn &txin : tx->vin) {
         CWalletTx &coin = mapWallet.at(txin.prevout.GetTxId());
         coin.MarkDirty();
         NotifyTransactionChanged(this, coin.GetId(), CT_UPDATED);
     }
 
     // Get the inserted-CWalletTx from mapWallet so that the
     // fInMempool flag is cached properly
     CWalletTx &wtx = mapWallet.at(tx->GetId());
 
     if (!fBroadcastTransactions) {
         // Don't submit tx to the mempool
         return;
     }
 
     std::string err_string;
     if (!SubmitTxMemoryPoolAndRelay(wtx, err_string, true)) {
         WalletLogPrintf("CommitTransaction(): Transaction cannot be broadcast "
                         "immediately, %s\n",
                         err_string);
         // TODO: if we expect the failure to be long term or permanent, instead
         // delete wtx from the wallet and return failure.
     }
 }
 
 DBErrors CWallet::LoadWallet(bool &fFirstRunRet) {
     LOCK(cs_wallet);
 
     fFirstRunRet = false;
     DBErrors nLoadWalletRet = WalletBatch(*database).LoadWallet(this);
     if (nLoadWalletRet == DBErrors::NEED_REWRITE) {
         if (database->Rewrite("\x04pool")) {
             for (const auto &spk_man_pair : m_spk_managers) {
                 spk_man_pair.second->RewriteDB();
             }
         }
     }
 
     // This wallet is in its first run if there are no ScriptPubKeyMans and it
     // isn't blank or no privkeys
     fFirstRunRet = m_spk_managers.empty() &&
                    !IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
                    !IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET);
     if (fFirstRunRet) {
         assert(m_external_spk_managers.empty());
         assert(m_internal_spk_managers.empty());
     }
 
     if (nLoadWalletRet != DBErrors::LOAD_OK) {
         return nLoadWalletRet;
     }
 
     return DBErrors::LOAD_OK;
 }
 
 DBErrors CWallet::ZapSelectTx(std::vector<TxId> &txIdsIn,
                               std::vector<TxId> &txIdsOut) {
     AssertLockHeld(cs_wallet);
     DBErrors nZapSelectTxRet =
         WalletBatch(*database).ZapSelectTx(txIdsIn, txIdsOut);
     for (const TxId &txid : txIdsOut) {
         const auto &it = mapWallet.find(txid);
         wtxOrdered.erase(it->second.m_it_wtxOrdered);
         for (const auto &txin : it->second.tx->vin) {
             mapTxSpends.erase(txin.prevout);
         }
         mapWallet.erase(it);
         NotifyTransactionChanged(this, txid, CT_DELETED);
     }
 
     if (nZapSelectTxRet == DBErrors::NEED_REWRITE) {
         if (database->Rewrite("\x04pool")) {
             for (const auto &spk_man_pair : m_spk_managers) {
                 spk_man_pair.second->RewriteDB();
             }
         }
     }
 
     if (nZapSelectTxRet != DBErrors::LOAD_OK) {
         return nZapSelectTxRet;
     }
 
     MarkDirty();
 
     return DBErrors::LOAD_OK;
 }
 
 bool CWallet::SetAddressBookWithDB(WalletBatch &batch,
                                    const CTxDestination &address,
                                    const std::string &strName,
                                    const std::string &strPurpose) {
     bool fUpdated = false;
     bool is_mine;
     {
         LOCK(cs_wallet);
         std::map<CTxDestination, CAddressBookData>::iterator mi =
             m_address_book.find(address);
         fUpdated = (mi != m_address_book.end() && !mi->second.IsChange());
         m_address_book[address].SetLabel(strName);
         // Update purpose only if requested.
         if (!strPurpose.empty()) {
             m_address_book[address].purpose = strPurpose;
         }
         is_mine = IsMine(address) != ISMINE_NO;
     }
 
     NotifyAddressBookChanged(this, address, strName, is_mine, strPurpose,
                              (fUpdated ? CT_UPDATED : CT_NEW));
     if (!strPurpose.empty() && !batch.WritePurpose(address, strPurpose)) {
         return false;
     }
     return batch.WriteName(address, strName);
 }
 
 bool CWallet::SetAddressBook(const CTxDestination &address,
                              const std::string &strName,
                              const std::string &strPurpose) {
     WalletBatch batch(*database);
     return SetAddressBookWithDB(batch, address, strName, strPurpose);
 }
 
 bool CWallet::DelAddressBook(const CTxDestination &address) {
     bool is_mine;
     WalletBatch batch(*database);
     {
         LOCK(cs_wallet);
         // If we want to delete receiving addresses, we need to take care that
         // DestData "used" (and possibly newer DestData) gets preserved (and the
         // "deleted" address transformed into a change entry instead of actually
         // being deleted)
         // NOTE: This isn't a problem for sending addresses because they never
         // have any DestData yet! When adding new DestData, it should be
         // considered here whether to retain or delete it (or move it?).
         if (IsMine(address)) {
             WalletLogPrintf(
                 "%s called with IsMine address, NOT SUPPORTED. Please "
                 "report this bug! %s\n",
                 __func__, PACKAGE_BUGREPORT);
             return false;
         }
         // Delete destdata tuples associated with address
         for (const std::pair<const std::string, std::string> &item :
              m_address_book[address].destdata) {
             batch.EraseDestData(address, item.first);
         }
         m_address_book.erase(address);
         is_mine = IsMine(address) != ISMINE_NO;
     }
 
     NotifyAddressBookChanged(this, address, "", is_mine, "", CT_DELETED);
 
     batch.ErasePurpose(address);
     return batch.EraseName(address);
 }
 
 size_t CWallet::KeypoolCountExternalKeys() const {
     AssertLockHeld(cs_wallet);
 
     unsigned int count = 0;
     for (auto spk_man : GetActiveScriptPubKeyMans()) {
         count += spk_man->KeypoolCountExternalKeys();
     }
 
     return count;
 }
 
 unsigned int CWallet::GetKeyPoolSize() const {
     AssertLockHeld(cs_wallet);
 
     unsigned int count = 0;
     for (auto spk_man : GetActiveScriptPubKeyMans()) {
         count += spk_man->GetKeyPoolSize();
     }
     return count;
 }
 
 bool CWallet::TopUpKeyPool(unsigned int kpSize) {
     LOCK(cs_wallet);
     bool res = true;
     for (auto spk_man : GetActiveScriptPubKeyMans()) {
         res &= spk_man->TopUp(kpSize);
     }
     return res;
 }
 
 bool CWallet::GetNewDestination(const OutputType type, const std::string label,
                                 CTxDestination &dest, std::string &error) {
     LOCK(cs_wallet);
     error.clear();
     bool result = false;
     auto spk_man = GetScriptPubKeyMan(type, false /* internal */);
     if (spk_man) {
         spk_man->TopUp();
         result = spk_man->GetNewDestination(type, dest, error);
     } else {
         error = strprintf("Error: No %s addresses available.",
                           FormatOutputType(type));
     }
     if (result) {
         SetAddressBook(dest, label, "receive");
     }
 
     return result;
 }
 
 bool CWallet::GetNewChangeDestination(const OutputType type,
                                       CTxDestination &dest,
                                       std::string &error) {
     LOCK(cs_wallet);
     error.clear();
 
     ReserveDestination reservedest(this, type);
     if (!reservedest.GetReservedDestination(dest, true)) {
         error = _("Error: Keypool ran out, please call keypoolrefill first")
                     .translated;
         return false;
     }
 
     reservedest.KeepDestination();
     return true;
 }
 
 int64_t CWallet::GetOldestKeyPoolTime() const {
     LOCK(cs_wallet);
     int64_t oldestKey = std::numeric_limits<int64_t>::max();
     for (const auto &spk_man_pair : m_spk_managers) {
         oldestKey =
             std::min(oldestKey, spk_man_pair.second->GetOldestKeyPoolTime());
     }
     return oldestKey;
 }
 
 void CWallet::MarkDestinationsDirty(
     const std::set<CTxDestination> &destinations) {
     for (auto &entry : mapWallet) {
         CWalletTx &wtx = entry.second;
         if (wtx.m_is_cache_empty) {
             continue;
         }
 
         for (size_t i = 0; i < wtx.tx->vout.size(); i++) {
             CTxDestination dst;
 
             if (ExtractDestination(wtx.tx->vout[i].scriptPubKey, dst) &&
                 destinations.count(dst)) {
                 wtx.MarkDirty();
                 break;
             }
         }
     }
 }
 
 std::set<CTxDestination>
 CWallet::GetLabelAddresses(const std::string &label) const {
     LOCK(cs_wallet);
     std::set<CTxDestination> result;
     for (const std::pair<const CTxDestination, CAddressBookData> &item :
          m_address_book) {
         if (item.second.IsChange()) {
             continue;
         }
         const CTxDestination &address = item.first;
         const std::string &strName = item.second.GetLabel();
         if (strName == label) {
             result.insert(address);
         }
     }
 
     return result;
 }
 
 bool ReserveDestination::GetReservedDestination(CTxDestination &dest,
                                                 bool internal) {
     m_spk_man = pwallet->GetScriptPubKeyMan(type, internal);
     if (!m_spk_man) {
         return false;
     }
 
     if (nIndex == -1) {
         m_spk_man->TopUp();
 
         CKeyPool keypool;
         if (!m_spk_man->GetReservedDestination(type, internal, address, nIndex,
                                                keypool)) {
             return false;
         }
         fInternal = keypool.fInternal;
     }
     dest = address;
     return true;
 }
 
 void ReserveDestination::KeepDestination() {
     if (nIndex != -1) {
         m_spk_man->KeepDestination(nIndex, type);
     }
 
     nIndex = -1;
     address = CNoDestination();
 }
 
 void ReserveDestination::ReturnDestination() {
     if (nIndex != -1) {
         m_spk_man->ReturnDestination(nIndex, fInternal, address);
     }
     nIndex = -1;
     address = CNoDestination();
 }
 
 void CWallet::LockCoin(const COutPoint &output) {
     AssertLockHeld(cs_wallet);
     setLockedCoins.insert(output);
 }
 
 void CWallet::UnlockCoin(const COutPoint &output) {
     AssertLockHeld(cs_wallet);
     setLockedCoins.erase(output);
 }
 
 void CWallet::UnlockAllCoins() {
     AssertLockHeld(cs_wallet);
     setLockedCoins.clear();
 }
 
 bool CWallet::IsLockedCoin(const COutPoint &outpoint) const {
     AssertLockHeld(cs_wallet);
 
     return setLockedCoins.count(outpoint) > 0;
 }
 
 void CWallet::ListLockedCoins(std::vector<COutPoint> &vOutpts) const {
     AssertLockHeld(cs_wallet);
     for (COutPoint outpoint : setLockedCoins) {
         vOutpts.push_back(outpoint);
     }
 }
 
 /** @} */ // end of Actions
 
 void CWallet::GetKeyBirthTimes(std::map<CKeyID, int64_t> &mapKeyBirth) const {
     AssertLockHeld(cs_wallet);
     mapKeyBirth.clear();
 
     // map in which we'll infer heights of other keys
     std::map<CKeyID, const CWalletTx::Confirmation *> mapKeyFirstBlock;
     CWalletTx::Confirmation max_confirm;
     // the tip can be reorganized; use a 144-block safety margin
     max_confirm.block_height =
         GetLastBlockHeight() > 144 ? GetLastBlockHeight() - 144 : 0;
     CHECK_NONFATAL(chain().findAncestorByHeight(
         GetLastBlockHash(), max_confirm.block_height,
         FoundBlock().hash(max_confirm.hashBlock)));
 
     {
         LegacyScriptPubKeyMan *spk_man = GetLegacyScriptPubKeyMan();
         assert(spk_man != nullptr);
         LOCK(spk_man->cs_KeyStore);
 
         // Get birth times for keys with metadata.
         for (const auto &entry : spk_man->mapKeyMetadata) {
             if (entry.second.nCreateTime) {
                 mapKeyBirth[entry.first] = entry.second.nCreateTime;
             }
         }
 
         // Prepare to infer birth heights for keys without metadata.
         for (const CKeyID &keyid : spk_man->GetKeys()) {
             if (mapKeyBirth.count(keyid) == 0) {
                 mapKeyFirstBlock[keyid] = &max_confirm;
             }
         }
 
         // If there are no such keys, we're done.
         if (mapKeyFirstBlock.empty()) {
             return;
         }
 
         // Find first block that affects those keys, if there are any left.
         for (const auto &entry : mapWallet) {
             // iterate over all wallet transactions...
             const CWalletTx &wtx = entry.second;
             if (wtx.m_confirm.status == CWalletTx::CONFIRMED) {
                 // ... which are already in a block
                 for (const CTxOut &txout : wtx.tx->vout) {
                     // Iterate over all their outputs...
                     for (const auto &keyid :
                          GetAffectedKeys(txout.scriptPubKey, *spk_man)) {
                         // ... and all their affected keys.
                         auto rit = mapKeyFirstBlock.find(keyid);
                         if (rit != mapKeyFirstBlock.end() &&
                             wtx.m_confirm.block_height <
                                 rit->second->block_height) {
                             rit->second = &wtx.m_confirm;
                         }
                     }
                 }
             }
         }
     }
 
     // Extract block timestamps for those keys.
     for (const auto &entry : mapKeyFirstBlock) {
         int64_t block_time;
         CHECK_NONFATAL(chain().findBlock(entry.second->hashBlock,
                                          FoundBlock().time(block_time)));
         // block times can be 2h off
         mapKeyBirth[entry.first] = block_time - TIMESTAMP_WINDOW;
     }
 }
 
 /**
  * Compute smart timestamp for a transaction being added to the wallet.
  *
  * Logic:
  * - If sending a transaction, assign its timestamp to the current time.
  * - If receiving a transaction outside a block, assign its timestamp to the
  *   current time.
  * - If receiving a block with a future timestamp, assign all its (not already
  *   known) transactions' timestamps to the current time.
  * - If receiving a block with a past timestamp, before the most recent known
  *   transaction (that we care about), assign all its (not already known)
  *   transactions' timestamps to the same timestamp as that most-recent-known
  *   transaction.
  * - If receiving a block with a past timestamp, but after the most recent known
  *   transaction, assign all its (not already known) transactions' timestamps to
  *   the block time.
  *
  * For more information see CWalletTx::nTimeSmart,
  * https://bitcointalk.org/?topic=54527, or
  * https://github.com/bitcoin/bitcoin/pull/1393.
  */
 unsigned int CWallet::ComputeTimeSmart(const CWalletTx &wtx) const {
     unsigned int nTimeSmart = wtx.nTimeReceived;
     if (!wtx.isUnconfirmed() && !wtx.isAbandoned()) {
         int64_t blocktime;
         if (chain().findBlock(wtx.m_confirm.hashBlock,
                               FoundBlock().time(blocktime))) {
             int64_t latestNow = wtx.nTimeReceived;
             int64_t latestEntry = 0;
 
             // Tolerate times up to the last timestamp in the wallet not more
             // than 5 minutes into the future
             int64_t latestTolerated = latestNow + 300;
             const TxItems &txOrdered = wtxOrdered;
             for (auto it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) {
                 CWalletTx *const pwtx = it->second;
                 if (pwtx == &wtx) {
                     continue;
                 }
                 int64_t nSmartTime;
                 nSmartTime = pwtx->nTimeSmart;
                 if (!nSmartTime) {
                     nSmartTime = pwtx->nTimeReceived;
                 }
                 if (nSmartTime <= latestTolerated) {
                     latestEntry = nSmartTime;
                     if (nSmartTime > latestNow) {
                         latestNow = nSmartTime;
                     }
                     break;
                 }
             }
 
             nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
         } else {
             WalletLogPrintf("%s: found %s in block %s not in index\n", __func__,
                             wtx.GetId().ToString(),
                             wtx.m_confirm.hashBlock.ToString());
         }
     }
     return nTimeSmart;
 }
 
 bool CWallet::AddDestData(WalletBatch &batch, const CTxDestination &dest,
                           const std::string &key, const std::string &value) {
     if (boost::get<CNoDestination>(&dest)) {
         return false;
     }
 
     m_address_book[dest].destdata.insert(std::make_pair(key, value));
     return batch.WriteDestData(dest, key, value);
 }
 
 bool CWallet::EraseDestData(WalletBatch &batch, const CTxDestination &dest,
                             const std::string &key) {
     if (!m_address_book[dest].destdata.erase(key)) {
         return false;
     }
 
     return batch.EraseDestData(dest, key);
 }
 
 void CWallet::LoadDestData(const CTxDestination &dest, const std::string &key,
                            const std::string &value) {
     m_address_book[dest].destdata.insert(std::make_pair(key, value));
 }
 
 bool CWallet::GetDestData(const CTxDestination &dest, const std::string &key,
                           std::string *value) const {
     std::map<CTxDestination, CAddressBookData>::const_iterator i =
         m_address_book.find(dest);
     if (i != m_address_book.end()) {
         CAddressBookData::StringMap::const_iterator j =
             i->second.destdata.find(key);
         if (j != i->second.destdata.end()) {
             if (value) {
                 *value = j->second;
             }
 
             return true;
         }
     }
     return false;
 }
 
 std::vector<std::string>
 CWallet::GetDestValues(const std::string &prefix) const {
     std::vector<std::string> values;
     for (const auto &address : m_address_book) {
         for (const auto &data : address.second.destdata) {
             if (!data.first.compare(0, prefix.size(), prefix)) {
                 values.emplace_back(data.second);
             }
         }
     }
     return values;
 }
 
 std::unique_ptr<WalletDatabase>
 MakeWalletDatabase(const std::string &name, const DatabaseOptions &options,
                    DatabaseStatus &status, bilingual_str &error_string) {
     // Do some checking on wallet path. It should be either a:
     //
     // 1. Path where a directory can be created.
     // 2. Path to an existing directory.
     // 3. Path to a symlink to a directory.
     // 4. For backwards compatibility, the name of a data file in -walletdir.
     const fs::path wallet_path =
         fsbridge::AbsPathJoin(GetWalletDir(), fs::PathFromString(name));
     fs::file_type path_type = fs::symlink_status(wallet_path).type();
     if (!(path_type == fs::file_not_found || path_type == fs::directory_file ||
           (path_type == fs::symlink_file && fs::is_directory(wallet_path)) ||
           (path_type == fs::regular_file &&
            fs::PathFromString(name).filename() == fs::PathFromString(name)))) {
         error_string = Untranslated(
             strprintf("Invalid -wallet path '%s'. -wallet path should point to "
                       "a directory where wallet.dat and "
                       "database/log.?????????? files can be stored, a location "
                       "where such a directory could be created, "
                       "or (for backwards compatibility) the name of an "
                       "existing data file in -walletdir (%s)",
                       name, fs::quoted(fs::PathToString(GetWalletDir()))));
         status = DatabaseStatus::FAILED_BAD_PATH;
         return nullptr;
     }
     return MakeDatabase(wallet_path, options, status, error_string);
 }
 
 std::shared_ptr<CWallet>
 CWallet::Create(interfaces::Chain &chain, const std::string &name,
                 std::unique_ptr<WalletDatabase> database,
                 uint64_t wallet_creation_flags, bilingual_str &error,
                 std::vector<bilingual_str> &warnings) {
     const std::string &walletFile = database->Filename();
 
     chain.initMessage(_("Loading wallet...").translated);
 
     int64_t nStart = GetTimeMillis();
     bool fFirstRun = true;
     // TODO: Can't use std::make_shared because we need a custom deleter but
     // should be possible to use std::allocate_shared.
     std::shared_ptr<CWallet> walletInstance(
         new CWallet(&chain, name, std::move(database)), ReleaseWallet);
     DBErrors nLoadWalletRet = walletInstance->LoadWallet(fFirstRun);
     if (nLoadWalletRet != DBErrors::LOAD_OK) {
         if (nLoadWalletRet == DBErrors::CORRUPT) {
             error =
                 strprintf(_("Error loading %s: Wallet corrupted"), walletFile);
             return nullptr;
         }
 
         if (nLoadWalletRet == DBErrors::NONCRITICAL_ERROR) {
             warnings.push_back(
                 strprintf(_("Error reading %s! All keys read correctly, but "
                             "transaction data or address book entries might be "
                             "missing or incorrect."),
                           walletFile));
         } else if (nLoadWalletRet == DBErrors::TOO_NEW) {
             error = strprintf(
                 _("Error loading %s: Wallet requires newer version of %s"),
                 walletFile, PACKAGE_NAME);
             return nullptr;
         } else if (nLoadWalletRet == DBErrors::NEED_REWRITE) {
             error = strprintf(
                 _("Wallet needed to be rewritten: restart %s to complete"),
                 PACKAGE_NAME);
             return nullptr;
         } else {
             error = strprintf(_("Error loading %s"), walletFile);
             return nullptr;
         }
     }
 
     if (fFirstRun) {
         // Ensure this wallet.dat can only be opened by clients supporting
         // HD with chain split and expects no default key.
         walletInstance->SetMinVersion(FEATURE_LATEST);
 
         walletInstance->AddWalletFlags(wallet_creation_flags);
 
         // Only create LegacyScriptPubKeyMan when not descriptor wallet
         if (!walletInstance->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
             walletInstance->SetupLegacyScriptPubKeyMan();
         }
 
         if (!(wallet_creation_flags &
               (WALLET_FLAG_DISABLE_PRIVATE_KEYS | WALLET_FLAG_BLANK_WALLET))) {
             LOCK(walletInstance->cs_wallet);
             if (walletInstance->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
                 walletInstance->SetupDescriptorScriptPubKeyMans();
                 // SetupDescriptorScriptPubKeyMans already calls SetupGeneration
                 // for us so we don't need to call SetupGeneration separately
             } else {
                 // Legacy wallets need SetupGeneration here.
                 for (auto spk_man :
                      walletInstance->GetActiveScriptPubKeyMans()) {
                     if (!spk_man->SetupGeneration()) {
                         error = _("Unable to generate initial keys");
                         return nullptr;
                     }
                 }
             }
         }
 
         walletInstance->chainStateFlushed(chain.getTipLocator());
     } else if (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS) {
         // Make it impossible to disable private keys after creation
         error = strprintf(_("Error loading %s: Private keys can only be "
                             "disabled during creation"),
                           walletFile);
         return nullptr;
     } else if (walletInstance->IsWalletFlagSet(
                    WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         for (auto spk_man : walletInstance->GetActiveScriptPubKeyMans()) {
             if (spk_man->HavePrivateKeys()) {
                 warnings.push_back(
                     strprintf(_("Warning: Private keys detected in wallet {%s} "
                                 "with disabled private keys"),
                               walletFile));
             }
         }
     }
 
     if (gArgs.IsArgSet("-mintxfee")) {
         Amount n = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-mintxfee", ""), n) ||
             n == Amount::zero()) {
             error = AmountErrMsg("mintxfee", gArgs.GetArg("-mintxfee", ""));
             return nullptr;
         }
         if (n > HIGH_TX_FEE_PER_KB) {
             warnings.push_back(AmountHighWarn("-mintxfee") + Untranslated(" ") +
                                _("This is the minimum transaction fee you pay "
                                  "on every transaction."));
         }
         walletInstance->m_min_fee = CFeeRate(n);
     }
 
     if (gArgs.IsArgSet("-maxapsfee")) {
         const std::string max_aps_fee{gArgs.GetArg("-maxapsfee", "")};
         Amount n = Amount::zero();
         if (max_aps_fee == "-1") {
             n = -1 * SATOSHI;
         } else if (!ParseMoney(max_aps_fee, n)) {
             error = AmountErrMsg("maxapsfee", max_aps_fee);
             return nullptr;
         }
         if (n > HIGH_APS_FEE) {
             warnings.push_back(
                 AmountHighWarn("-maxapsfee") + Untranslated(" ") +
                 _("This is the maximum transaction fee you pay (in addition to"
                   " the normal fee) to prioritize partial spend avoidance over"
                   " regular coin selection."));
         }
         walletInstance->m_max_aps_fee = n;
     }
 
     if (gArgs.IsArgSet("-fallbackfee")) {
         Amount nFeePerK = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-fallbackfee", ""), nFeePerK)) {
             error =
                 strprintf(_("Invalid amount for -fallbackfee=<amount>: '%s'"),
                           gArgs.GetArg("-fallbackfee", ""));
             return nullptr;
         }
         if (nFeePerK > HIGH_TX_FEE_PER_KB) {
             warnings.push_back(AmountHighWarn("-fallbackfee") +
                                Untranslated(" ") +
                                _("This is the transaction fee you may pay when "
                                  "fee estimates are not available."));
         }
         walletInstance->m_fallback_fee = CFeeRate(nFeePerK);
     }
     // Disable fallback fee in case value was set to 0, enable if non-null value
     walletInstance->m_allow_fallback_fee =
         walletInstance->m_fallback_fee.GetFeePerK() != Amount::zero();
 
     if (gArgs.IsArgSet("-paytxfee")) {
         Amount nFeePerK = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-paytxfee", ""), nFeePerK)) {
             error = AmountErrMsg("paytxfee", gArgs.GetArg("-paytxfee", ""));
             return nullptr;
         }
         if (nFeePerK > HIGH_TX_FEE_PER_KB) {
             warnings.push_back(AmountHighWarn("-paytxfee") + Untranslated(" ") +
                                _("This is the transaction fee you will pay if "
                                  "you send a transaction."));
         }
         walletInstance->m_pay_tx_fee = CFeeRate(nFeePerK, 1000);
         if (walletInstance->m_pay_tx_fee < chain.relayMinFee()) {
             error = strprintf(_("Invalid amount for -paytxfee=<amount>: '%s' "
                                 "(must be at least %s)"),
                               gArgs.GetArg("-paytxfee", ""),
                               chain.relayMinFee().ToString());
             return nullptr;
         }
     }
 
     if (gArgs.IsArgSet("-maxtxfee")) {
         Amount nMaxFee = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-maxtxfee", ""), nMaxFee)) {
             error = AmountErrMsg("maxtxfee", gArgs.GetArg("-maxtxfee", ""));
             return nullptr;
         }
         if (nMaxFee > HIGH_MAX_TX_FEE) {
             warnings.push_back(_("-maxtxfee is set very high! Fees this large "
                                  "could be paid on a single transaction."));
         }
         if (CFeeRate(nMaxFee, 1000) < chain.relayMinFee()) {
             error = strprintf(
                 _("Invalid amount for -maxtxfee=<amount>: '%s' (must be at "
                   "least the minrelay fee of %s to prevent stuck "
                   "transactions)"),
                 gArgs.GetArg("-maxtxfee", ""), chain.relayMinFee().ToString());
             return nullptr;
         }
         walletInstance->m_default_max_tx_fee = nMaxFee;
     }
 
     if (chain.relayMinFee().GetFeePerK() > HIGH_TX_FEE_PER_KB) {
         warnings.push_back(
             AmountHighWarn("-minrelaytxfee") + Untranslated(" ") +
             _("The wallet will avoid paying less than the minimum relay fee."));
     }
 
     walletInstance->m_spend_zero_conf_change =
         gArgs.GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE);
 
     walletInstance->m_default_address_type = DEFAULT_ADDRESS_TYPE;
 
     walletInstance->WalletLogPrintf("Wallet completed loading in %15dms\n",
                                     GetTimeMillis() - nStart);
 
     // Try to top up keypool. No-op if the wallet is locked.
     walletInstance->TopUpKeyPool();
 
     LOCK(walletInstance->cs_wallet);
 
     // Register wallet with validationinterface. It's done before rescan to
     // avoid missing block connections between end of rescan and validation
     // subscribing. Because of wallet lock being hold, block connection
     // notifications are going to be pending on the validation-side until lock
     // release. It's likely to have block processing duplicata (if rescan block
     // range overlaps with notification one) but we guarantee at least than
     // wallet state is correct after notifications delivery. This is temporary
     // until rescan and notifications delivery are unified under same interface.
     walletInstance->m_chain_notifications_handler =
         walletInstance->chain().handleNotifications(walletInstance);
 
     int rescan_height = 0;
     if (!gArgs.GetBoolArg("-rescan", false)) {
         WalletBatch batch(*walletInstance->database);
         CBlockLocator locator;
         if (batch.ReadBestBlock(locator)) {
             if (const std::optional<int> fork_height =
                     chain.findLocatorFork(locator)) {
                 rescan_height = *fork_height;
             }
         }
     }
 
     const std::optional<int> tip_height = chain.getHeight();
     if (tip_height) {
         walletInstance->m_last_block_processed =
             chain.getBlockHash(*tip_height);
         walletInstance->m_last_block_processed_height = *tip_height;
     } else {
         walletInstance->m_last_block_processed.SetNull();
         walletInstance->m_last_block_processed_height = -1;
     }
 
     if (tip_height && *tip_height != rescan_height) {
         // We can't rescan beyond non-pruned blocks, stop and throw an error.
         // This might happen if a user uses an old wallet within a pruned node
         // or if they ran -disablewallet for a longer time, then decided to
         // re-enable
         if (chain.havePruned()) {
             // Exit early and print an error.
             // If a block is pruned after this check, we will load the wallet,
             // but fail the rescan with a generic error.
             int block_height = *tip_height;
             while (block_height > 0 &&
                    chain.haveBlockOnDisk(block_height - 1) &&
                    rescan_height != block_height) {
                 --block_height;
             }
 
             if (rescan_height != block_height) {
                 error = _("Prune: last wallet synchronisation goes beyond "
                           "pruned data. You need to -reindex (download the "
                           "whole blockchain again in case of pruned node)");
                 return nullptr;
             }
         }
 
         chain.initMessage(_("Rescanning...").translated);
         walletInstance->WalletLogPrintf(
             "Rescanning last %i blocks (from block %i)...\n",
             *tip_height - rescan_height, rescan_height);
 
         // No need to read and scan block if block was created before our wallet
         // birthday (as adjusted for block time variability)
         std::optional<int64_t> time_first_key;
         for (auto spk_man : walletInstance->GetAllScriptPubKeyMans()) {
             int64_t time = spk_man->GetTimeFirstKey();
             if (!time_first_key || time < *time_first_key) {
                 time_first_key = time;
             }
         }
         if (time_first_key) {
             chain.findFirstBlockWithTimeAndHeight(
                 *time_first_key - TIMESTAMP_WINDOW, rescan_height,
                 FoundBlock().height(rescan_height));
         }
 
         {
             WalletRescanReserver reserver(*walletInstance);
             if (!reserver.reserve() ||
                 (ScanResult::SUCCESS !=
                  walletInstance
                      ->ScanForWalletTransactions(
                          chain.getBlockHash(rescan_height), rescan_height,
                          {} /* max height */, reserver, true /* update */)
                      .status)) {
                 error = _("Failed to rescan the wallet during initialization");
                 return nullptr;
             }
         }
         walletInstance->chainStateFlushed(chain.getTipLocator());
         walletInstance->database->IncrementUpdateCounter();
     }
 
     {
         LOCK(cs_wallets);
         for (auto &load_wallet : g_load_wallet_fns) {
             load_wallet(interfaces::MakeWallet(walletInstance));
         }
     }
 
     walletInstance->SetBroadcastTransactions(
         gArgs.GetBoolArg("-walletbroadcast", DEFAULT_WALLETBROADCAST));
 
     walletInstance->WalletLogPrintf("setKeyPool.size() = %u\n",
                                     walletInstance->GetKeyPoolSize());
     walletInstance->WalletLogPrintf("mapWallet.size() = %u\n",
                                     walletInstance->mapWallet.size());
     walletInstance->WalletLogPrintf("m_address_book.size() = %u\n",
                                     walletInstance->m_address_book.size());
 
     return walletInstance;
 }
 
 const CAddressBookData *
 CWallet::FindAddressBookEntry(const CTxDestination &dest,
                               bool allow_change) const {
     const auto &address_book_it = m_address_book.find(dest);
     if (address_book_it == m_address_book.end()) {
         return nullptr;
     }
     if ((!allow_change) && address_book_it->second.IsChange()) {
         return nullptr;
     }
     return &address_book_it->second;
 }
 
 bool CWallet::UpgradeWallet(int version, bilingual_str &error) {
     int prev_version = GetVersion();
     int nMaxVersion = version;
     // The -upgradewallet without argument case
     if (nMaxVersion == 0) {
         WalletLogPrintf("Performing wallet upgrade to %i\n", FEATURE_LATEST);
         nMaxVersion = FEATURE_LATEST;
         // permanently upgrade the wallet immediately
         SetMinVersion(FEATURE_LATEST);
     } else {
         WalletLogPrintf("Allowing wallet upgrade up to %i\n", nMaxVersion);
     }
 
     if (nMaxVersion < GetVersion()) {
         error = _("Cannot downgrade wallet");
         return false;
     }
 
     SetMaxVersion(nMaxVersion);
 
     LOCK(cs_wallet);
 
     // Do not upgrade versions to any version between HD_SPLIT and
     // FEATURE_PRE_SPLIT_KEYPOOL unless already supporting HD_SPLIT
     int max_version = GetVersion();
     if (!CanSupportFeature(FEATURE_HD_SPLIT) &&
         max_version >= FEATURE_HD_SPLIT &&
         max_version < FEATURE_PRE_SPLIT_KEYPOOL) {
         error = _("Cannot upgrade a non HD split wallet without upgrading to "
                   "support pre split keypool. Please use version 200300 or no "
                   "version specified.");
         return false;
     }
 
     for (auto spk_man : GetActiveScriptPubKeyMans()) {
         if (!spk_man->Upgrade(prev_version, error)) {
             return false;
         }
     }
 
     return true;
 }
 
 void CWallet::postInitProcess() {
     LOCK(cs_wallet);
 
     // Add wallet transactions that aren't already in a block to mempool.
     // Do this here as mempool requires genesis block to be loaded.
     ReacceptWalletTransactions();
 
     // Update wallet transactions with current mempool transactions.
     chain().requestMempoolTransactions(*this);
 }
 
 bool CWallet::BackupWallet(const std::string &strDest) const {
     return database->Backup(strDest);
 }
 
 CKeyPool::CKeyPool() {
     nTime = GetTime();
     fInternal = false;
     m_pre_split = false;
 }
 
 CKeyPool::CKeyPool(const CPubKey &vchPubKeyIn, bool internalIn) {
     nTime = GetTime();
     vchPubKey = vchPubKeyIn;
     fInternal = internalIn;
     m_pre_split = false;
 }
 
 int CWallet::GetTxDepthInMainChain(const CWalletTx &wtx) const {
     AssertLockHeld(cs_wallet);
     if (wtx.isUnconfirmed() || wtx.isAbandoned()) {
         return 0;
     }
 
     return (GetLastBlockHeight() - wtx.m_confirm.block_height + 1) *
            (wtx.isConflicted() ? -1 : 1);
 }
 
 int CWallet::GetTxBlocksToMaturity(const CWalletTx &wtx) const {
+    AssertLockHeld(cs_wallet);
+
     if (!wtx.IsCoinBase()) {
         return 0;
     }
     int chain_depth = GetTxDepthInMainChain(wtx);
     // coinbase tx should not be conflicted
     assert(chain_depth >= 0);
     return std::max(0, (COINBASE_MATURITY + 1) - chain_depth);
 }
 
 bool CWallet::IsTxImmatureCoinBase(const CWalletTx &wtx) const {
+    AssertLockHeld(cs_wallet);
+
     // note GetBlocksToMaturity is 0 for non-coinbase tx
     return GetTxBlocksToMaturity(wtx) > 0;
 }
 
 bool CWallet::IsCrypted() const {
     return HasEncryptionKeys();
 }
 
 bool CWallet::IsLocked() const {
     if (!IsCrypted()) {
         return false;
     }
     LOCK(cs_wallet);
     return vMasterKey.empty();
 }
 
 bool CWallet::Lock() {
     if (!IsCrypted()) {
         return false;
     }
 
     {
         LOCK(cs_wallet);
         vMasterKey.clear();
     }
 
     NotifyStatusChanged(this);
     return true;
 }
 
 bool CWallet::Unlock(const CKeyingMaterial &vMasterKeyIn, bool accept_no_keys) {
     {
         LOCK(cs_wallet);
         for (const auto &spk_man_pair : m_spk_managers) {
             if (!spk_man_pair.second->CheckDecryptionKey(vMasterKeyIn,
                                                          accept_no_keys)) {
                 return false;
             }
         }
         vMasterKey = vMasterKeyIn;
     }
     NotifyStatusChanged(this);
     return true;
 }
 
 std::set<ScriptPubKeyMan *> CWallet::GetActiveScriptPubKeyMans() const {
     std::set<ScriptPubKeyMan *> spk_mans;
     for (bool internal : {false, true}) {
         for (OutputType t : OUTPUT_TYPES) {
             auto spk_man = GetScriptPubKeyMan(t, internal);
             if (spk_man) {
                 spk_mans.insert(spk_man);
             }
         }
     }
     return spk_mans;
 }
 
 std::set<ScriptPubKeyMan *> CWallet::GetAllScriptPubKeyMans() const {
     std::set<ScriptPubKeyMan *> spk_mans;
     for (const auto &spk_man_pair : m_spk_managers) {
         spk_mans.insert(spk_man_pair.second.get());
     }
     return spk_mans;
 }
 
 ScriptPubKeyMan *CWallet::GetScriptPubKeyMan(const OutputType &type,
                                              bool internal) const {
     const std::map<OutputType, ScriptPubKeyMan *> &spk_managers =
         internal ? m_internal_spk_managers : m_external_spk_managers;
     std::map<OutputType, ScriptPubKeyMan *>::const_iterator it =
         spk_managers.find(type);
     if (it == spk_managers.end()) {
         WalletLogPrintf(
             "%s scriptPubKey Manager for output type %d does not exist\n",
             internal ? "Internal" : "External", static_cast<int>(type));
         return nullptr;
     }
     return it->second;
 }
 
 std::set<ScriptPubKeyMan *>
 CWallet::GetScriptPubKeyMans(const CScript &script,
                              SignatureData &sigdata) const {
     std::set<ScriptPubKeyMan *> spk_mans;
     for (const auto &spk_man_pair : m_spk_managers) {
         if (spk_man_pair.second->CanProvide(script, sigdata)) {
             spk_mans.insert(spk_man_pair.second.get());
         }
     }
     return spk_mans;
 }
 
 ScriptPubKeyMan *CWallet::GetScriptPubKeyMan(const CScript &script) const {
     SignatureData sigdata;
     for (const auto &spk_man_pair : m_spk_managers) {
         if (spk_man_pair.second->CanProvide(script, sigdata)) {
             return spk_man_pair.second.get();
         }
     }
     return nullptr;
 }
 
 ScriptPubKeyMan *CWallet::GetScriptPubKeyMan(const uint256 &id) const {
     if (m_spk_managers.count(id) > 0) {
         return m_spk_managers.at(id).get();
     }
     return nullptr;
 }
 
 std::unique_ptr<SigningProvider>
 CWallet::GetSolvingProvider(const CScript &script) const {
     SignatureData sigdata;
     return GetSolvingProvider(script, sigdata);
 }
 
 std::unique_ptr<SigningProvider>
 CWallet::GetSolvingProvider(const CScript &script,
                             SignatureData &sigdata) const {
     for (const auto &spk_man_pair : m_spk_managers) {
         if (spk_man_pair.second->CanProvide(script, sigdata)) {
             return spk_man_pair.second->GetSolvingProvider(script);
         }
     }
     return nullptr;
 }
 
 LegacyScriptPubKeyMan *CWallet::GetLegacyScriptPubKeyMan() const {
     if (IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
         return nullptr;
     }
     // Legacy wallets only have one ScriptPubKeyMan which is a
     // LegacyScriptPubKeyMan. Everything in m_internal_spk_managers and
     // m_external_spk_managers point to the same legacyScriptPubKeyMan.
     auto it = m_internal_spk_managers.find(OutputType::LEGACY);
     if (it == m_internal_spk_managers.end()) {
         return nullptr;
     }
     return dynamic_cast<LegacyScriptPubKeyMan *>(it->second);
 }
 
 LegacyScriptPubKeyMan *CWallet::GetOrCreateLegacyScriptPubKeyMan() {
     SetupLegacyScriptPubKeyMan();
     return GetLegacyScriptPubKeyMan();
 }
 
 void CWallet::SetupLegacyScriptPubKeyMan() {
     if (!m_internal_spk_managers.empty() || !m_external_spk_managers.empty() ||
         !m_spk_managers.empty() || IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
         return;
     }
 
     auto spk_manager =
         std::unique_ptr<ScriptPubKeyMan>(new LegacyScriptPubKeyMan(*this));
     for (const auto &type : OUTPUT_TYPES) {
         m_internal_spk_managers[type] = spk_manager.get();
         m_external_spk_managers[type] = spk_manager.get();
     }
     m_spk_managers[spk_manager->GetID()] = std::move(spk_manager);
 }
 
 const CKeyingMaterial &CWallet::GetEncryptionKey() const {
     return vMasterKey;
 }
 
 bool CWallet::HasEncryptionKeys() const {
     return !mapMasterKeys.empty();
 }
 
 void CWallet::ConnectScriptPubKeyManNotifiers() {
     for (const auto &spk_man : GetActiveScriptPubKeyMans()) {
         spk_man->NotifyWatchonlyChanged.connect(NotifyWatchonlyChanged);
         spk_man->NotifyCanGetAddressesChanged.connect(
             NotifyCanGetAddressesChanged);
     }
 }
 
 void CWallet::LoadDescriptorScriptPubKeyMan(uint256 id,
                                             WalletDescriptor &desc) {
     auto spk_manager = std::unique_ptr<ScriptPubKeyMan>(
         new DescriptorScriptPubKeyMan(*this, desc));
     m_spk_managers[id] = std::move(spk_manager);
 }
 
 void CWallet::SetupDescriptorScriptPubKeyMans() {
     AssertLockHeld(cs_wallet);
 
     // Make a seed
     CKey seed_key;
     seed_key.MakeNewKey(true);
     CPubKey seed = seed_key.GetPubKey();
     assert(seed_key.VerifyPubKey(seed));
 
     // Get the extended key
     CExtKey master_key;
     master_key.SetSeed(seed_key.begin(), seed_key.size());
 
     for (bool internal : {false, true}) {
         for (OutputType t : OUTPUT_TYPES) {
             auto spk_manager =
                 std::make_unique<DescriptorScriptPubKeyMan>(*this, internal);
             if (IsCrypted()) {
                 if (IsLocked()) {
                     throw std::runtime_error(
                         std::string(__func__) +
                         ": Wallet is locked, cannot setup new descriptors");
                 }
                 if (!spk_manager->CheckDecryptionKey(vMasterKey) &&
                     !spk_manager->Encrypt(vMasterKey, nullptr)) {
                     throw std::runtime_error(
                         std::string(__func__) +
                         ": Could not encrypt new descriptors");
                 }
             }
             spk_manager->SetupDescriptorGeneration(master_key, t);
             uint256 id = spk_manager->GetID();
             m_spk_managers[id] = std::move(spk_manager);
             AddActiveScriptPubKeyMan(id, t, internal);
         }
     }
 }
 
 void CWallet::AddActiveScriptPubKeyMan(uint256 id, OutputType type,
                                        bool internal) {
     WalletBatch batch(*database);
     if (!batch.WriteActiveScriptPubKeyMan(static_cast<uint8_t>(type), id,
                                           internal)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing active ScriptPubKeyMan id failed");
     }
     LoadActiveScriptPubKeyMan(id, type, internal);
 }
 
 void CWallet::LoadActiveScriptPubKeyMan(uint256 id, OutputType type,
                                         bool internal) {
     WalletLogPrintf(
         "Setting spkMan to active: id = %s, type = %d, internal = %d\n",
         id.ToString(), static_cast<int>(type), static_cast<int>(internal));
     auto &spk_mans =
         internal ? m_internal_spk_managers : m_external_spk_managers;
     auto spk_man = m_spk_managers.at(id).get();
     spk_man->SetInternal(internal);
     spk_mans[type] = spk_man;
 
     NotifyCanGetAddressesChanged();
 }
 
 bool CWallet::IsLegacy() const {
     if (m_internal_spk_managers.count(OutputType::LEGACY) == 0) {
         return false;
     }
     auto spk_man = dynamic_cast<LegacyScriptPubKeyMan *>(
         m_internal_spk_managers.at(OutputType::LEGACY));
     return spk_man != nullptr;
 }
 
 DescriptorScriptPubKeyMan *
 CWallet::GetDescriptorScriptPubKeyMan(const WalletDescriptor &desc) const {
     for (auto &spk_man_pair : m_spk_managers) {
         // Try to downcast to DescriptorScriptPubKeyMan then check if the
         // descriptors match
         DescriptorScriptPubKeyMan *spk_manager =
             dynamic_cast<DescriptorScriptPubKeyMan *>(
                 spk_man_pair.second.get());
         if (spk_manager != nullptr && spk_manager->HasWalletDescriptor(desc)) {
             return spk_manager;
         }
     }
 
     return nullptr;
 }
 
 ScriptPubKeyMan *
 CWallet::AddWalletDescriptor(WalletDescriptor &desc,
                              const FlatSigningProvider &signing_provider,
                              const std::string &label, bool internal) {
     if (!IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
         WalletLogPrintf(
             "Cannot add WalletDescriptor to a non-descriptor wallet\n");
         return nullptr;
     }
 
     LOCK(cs_wallet);
     auto new_spk_man = std::make_unique<DescriptorScriptPubKeyMan>(*this, desc);
 
     // If we already have this descriptor, remove it from the maps but add the
     // existing cache to desc
     auto old_spk_man = GetDescriptorScriptPubKeyMan(desc);
     if (old_spk_man) {
         WalletLogPrintf("Update existing descriptor: %s\n",
                         desc.descriptor->ToString());
 
         {
             LOCK(old_spk_man->cs_desc_man);
             new_spk_man->SetCache(old_spk_man->GetWalletDescriptor().cache);
         }
 
         // Remove from maps of active spkMans
         auto old_spk_man_id = old_spk_man->GetID();
         for (bool internal_ : {false, true}) {
             for (OutputType t : OUTPUT_TYPES) {
                 auto active_spk_man = GetScriptPubKeyMan(t, internal_);
                 if (active_spk_man &&
                     active_spk_man->GetID() == old_spk_man_id) {
                     if (internal_) {
                         m_internal_spk_managers.erase(t);
                     } else {
                         m_external_spk_managers.erase(t);
                     }
                     break;
                 }
             }
         }
         m_spk_managers.erase(old_spk_man_id);
     }
 
     // Add the private keys to the descriptor
     for (const auto &entry : signing_provider.keys) {
         const CKey &key = entry.second;
         new_spk_man->AddDescriptorKey(key, key.GetPubKey());
     }
 
     // Top up key pool, the manager will generate new scriptPubKeys internally
     if (!new_spk_man->TopUp()) {
         WalletLogPrintf("Could not top up scriptPubKeys\n");
         return nullptr;
     }
 
     // Apply the label if necessary
     // Note: we disable labels for ranged descriptors
     if (!desc.descriptor->IsRange()) {
         auto script_pub_keys = new_spk_man->GetScriptPubKeys();
         if (script_pub_keys.empty()) {
             WalletLogPrintf(
                 "Could not generate scriptPubKeys (cache is empty)\n");
             return nullptr;
         }
 
         CTxDestination dest;
         if (!internal && ExtractDestination(script_pub_keys.at(0), dest)) {
             SetAddressBook(dest, label, "receive");
         }
     }
 
     // Save the descriptor to memory
     auto ret = new_spk_man.get();
     m_spk_managers[new_spk_man->GetID()] = std::move(new_spk_man);
 
     // Save the descriptor to DB
     ret->WriteDescriptor();
 
     return ret;
 }
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 09c61842e..aaa9f3e2e 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -1,1129 +1,1123 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2018-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_WALLET_WALLET_H
 #define BITCOIN_WALLET_WALLET_H
 
 #include <consensus/amount.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
 #include <outputtype.h>
 #include <primitives/blockhash.h>
 #include <psbt.h>
 #include <tinyformat.h>
 #include <util/message.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <util/ui_change_type.h>
 #include <validationinterface.h>
 #include <wallet/coinselection.h>
 #include <wallet/crypter.h>
 #include <wallet/rpcwallet.h>
 #include <wallet/scriptpubkeyman.h>
 #include <wallet/transaction.h>
 #include <wallet/walletdb.h>
 #include <wallet/walletutil.h>
 
 #include <algorithm>
 #include <atomic>
 #include <cstdint>
 #include <map>
 #include <memory>
 #include <optional>
 #include <set>
 #include <stdexcept>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include <boost/signals2/signal.hpp>
 
 using LoadWalletFn =
     std::function<void(std::unique_ptr<interfaces::Wallet> wallet)>;
 
 struct bilingual_str;
 
 //! Explicitly unload and delete the wallet.
 //! Blocks the current thread after signaling the unload intent so that all
 //! wallet clients release the wallet.
 //! Note that, when blocking is not required, the wallet is implicitly unloaded
 //! by the shared pointer deleter.
 void UnloadWallet(std::shared_ptr<CWallet> &&wallet);
 
 bool AddWallet(const std::shared_ptr<CWallet> &wallet);
 bool RemoveWallet(const std::shared_ptr<CWallet> &wallet,
                   std::optional<bool> load_on_start,
                   std::vector<bilingual_str> &warnings);
 bool RemoveWallet(const std::shared_ptr<CWallet> &wallet,
                   std::optional<bool> load_on_start);
 std::vector<std::shared_ptr<CWallet>> GetWallets();
 std::shared_ptr<CWallet> GetWallet(const std::string &name);
 std::shared_ptr<CWallet>
 LoadWallet(interfaces::Chain &chain, const std::string &name,
            std::optional<bool> load_on_start, const DatabaseOptions &options,
            DatabaseStatus &status, bilingual_str &error,
            std::vector<bilingual_str> &warnings);
 std::shared_ptr<CWallet>
 CreateWallet(interfaces::Chain &chain, const std::string &name,
              std::optional<bool> load_on_start, const DatabaseOptions &options,
              DatabaseStatus &status, bilingual_str &error,
              std::vector<bilingual_str> &warnings);
 std::unique_ptr<interfaces::Handler> HandleLoadWallet(LoadWalletFn load_wallet);
 std::unique_ptr<WalletDatabase>
 MakeWalletDatabase(const std::string &name, const DatabaseOptions &options,
                    DatabaseStatus &status, bilingual_str &error);
 
 //! -paytxfee default
 constexpr Amount DEFAULT_PAY_TX_FEE = Amount::zero();
 //! -fallbackfee default
 static const Amount DEFAULT_FALLBACK_FEE = Amount::zero();
 //! -mintxfee default
 static const Amount DEFAULT_TRANSACTION_MINFEE_PER_KB = 1000 * SATOSHI;
 /**
  * maximum fee increase allowed to do partial spend avoidance, even for nodes
  * with this feature disabled by default
  *
  * A value of -1 disables this feature completely.
  * A value of 0 (current default) means to attempt to do partial spend
  * avoidance, and use its results if the fees remain *unchanged* A value > 0
  * means to do partial spend avoidance if the fee difference against a regular
  * coin selection instance is in the range [0..value].
  */
 static const Amount DEFAULT_MAX_AVOIDPARTIALSPEND_FEE = Amount::zero();
 //! discourage APS fee higher than this amount
 constexpr Amount HIGH_APS_FEE{COIN / 10000};
 //! minimum recommended increment for BIP 125 replacement txs
 static const Amount WALLET_INCREMENTAL_RELAY_FEE(5000 * SATOSHI);
 //! Default for -spendzeroconfchange
 static const bool DEFAULT_SPEND_ZEROCONF_CHANGE = true;
 //! Default for -walletrejectlongchains
 static const bool DEFAULT_WALLET_REJECT_LONG_CHAINS = false;
 static const bool DEFAULT_WALLETBROADCAST = true;
 static const bool DEFAULT_DISABLE_WALLET = false;
 //! -maxtxfee default
 constexpr Amount DEFAULT_TRANSACTION_MAXFEE{COIN / 10};
 //! Discourage users to set fees higher than this amount (in satoshis) per kB
 constexpr Amount HIGH_TX_FEE_PER_KB{COIN / 100};
 //! -maxtxfee will warn if called with a higher fee than this amount (in
 //! satoshis)
 constexpr Amount HIGH_MAX_TX_FEE{100 * HIGH_TX_FEE_PER_KB};
 //! Pre-calculated constants for input size estimation
 static constexpr size_t DUMMY_P2PKH_INPUT_SIZE = 148;
 
 class CChainParams;
 class CCoinControl;
 class COutput;
 class CScript;
 class CTxMemPool;
 class CWalletTx;
 class ReserveDestination;
 
 //! Default for -addresstype
 constexpr OutputType DEFAULT_ADDRESS_TYPE{OutputType::LEGACY};
 
 static constexpr uint64_t KNOWN_WALLET_FLAGS =
     WALLET_FLAG_AVOID_REUSE | WALLET_FLAG_BLANK_WALLET |
     WALLET_FLAG_KEY_ORIGIN_METADATA | WALLET_FLAG_DISABLE_PRIVATE_KEYS |
     WALLET_FLAG_DESCRIPTORS;
 
 static constexpr uint64_t MUTABLE_WALLET_FLAGS = WALLET_FLAG_AVOID_REUSE;
 
 static const std::map<std::string, WalletFlags> WALLET_FLAG_MAP{
     {"avoid_reuse", WALLET_FLAG_AVOID_REUSE},
     {"blank", WALLET_FLAG_BLANK_WALLET},
     {"key_origin_metadata", WALLET_FLAG_KEY_ORIGIN_METADATA},
     {"disable_private_keys", WALLET_FLAG_DISABLE_PRIVATE_KEYS},
     {"descriptor_wallet", WALLET_FLAG_DESCRIPTORS},
 };
 
 extern const std::map<uint64_t, std::string> WALLET_FLAG_CAVEATS;
 
 /**
  * A wrapper to reserve an address from a wallet
  *
  * ReserveDestination is used to reserve an address.
  * It is currently only used inside of CreateTransaction.
  *
  * Instantiating a ReserveDestination does not reserve an address. To do so,
  * GetReservedDestination() needs to be called on the object. Once an address
  * has been reserved, call KeepDestination() on the ReserveDestination object to
  * make sure it is not returned. Call ReturnDestination() to return the address
  * so it can be re-used (for example, if the address was used in a new
  * transaction and that transaction was not completed and needed to be aborted).
  *
  * If an address is reserved and KeepDestination() is not called, then the
  * address will be returned when the ReserveDestination goes out of scope.
  */
 class ReserveDestination {
 protected:
     //! The wallet to reserve from
     const CWallet *const pwallet;
     //! The ScriptPubKeyMan to reserve from. Based on type when
     //! GetReservedDestination is called
     ScriptPubKeyMan *m_spk_man{nullptr};
     OutputType const type;
     //! The index of the address's key in the keypool
     int64_t nIndex{-1};
     //! The destination
     CTxDestination address;
     //! Whether this is from the internal (change output) keypool
     bool fInternal{false};
 
 public:
     //! Construct a ReserveDestination object. This does NOT reserve an address
     //! yet
     explicit ReserveDestination(CWallet *_pwallet, OutputType _type)
         : pwallet(_pwallet), type(_type) {}
 
     ReserveDestination(const ReserveDestination &) = delete;
     ReserveDestination &operator=(const ReserveDestination &) = delete;
 
     //! Destructor. If a key has been reserved and not KeepKey'ed, it will be
     //! returned to the keypool
     ~ReserveDestination() { ReturnDestination(); }
 
     //! Reserve an address
     bool GetReservedDestination(CTxDestination &pubkey, bool internal);
     //! Return reserved address
     void ReturnDestination();
     //! Keep the address. Do not return it's key to the keypool when this object
     //! goes out of scope
     void KeepDestination();
 };
 
 /** Address book data */
 class CAddressBookData {
 private:
     bool m_change{true};
     std::string m_label;
 
 public:
     std::string purpose;
 
     CAddressBookData() : purpose("unknown") {}
 
     typedef std::map<std::string, std::string> StringMap;
     StringMap destdata;
 
     bool IsChange() const { return m_change; }
     const std::string &GetLabel() const { return m_label; }
     void SetLabel(const std::string &label) {
         m_change = false;
         m_label = label;
     }
 };
 
 struct CRecipient {
     CScript scriptPubKey;
     Amount nAmount;
     bool fSubtractFeeFromAmount;
 };
 
 struct CoinSelectionParams {
     bool use_bnb = true;
     size_t change_output_size = 0;
     size_t change_spend_size = 0;
     CFeeRate effective_fee = CFeeRate(Amount::zero());
     size_t tx_noinputs_size = 0;
     //! Indicate that we are subtracting the fee from outputs
     bool m_subtract_fee_outputs = false;
 
     CoinSelectionParams(bool use_bnb_, size_t change_output_size_,
                         size_t change_spend_size_, CFeeRate effective_fee_,
                         size_t tx_noinputs_size_)
         : use_bnb(use_bnb_), change_output_size(change_output_size_),
           change_spend_size(change_spend_size_), effective_fee(effective_fee_),
           tx_noinputs_size(tx_noinputs_size_) {}
     CoinSelectionParams() {}
 };
 
 // forward declarations for ScanForWalletTransactions/RescanFromTime
 class WalletRescanReserver;
 
 /**
  * A CWallet maintains a set of transactions and balances, and provides the
  * ability to create new transactions.
  */
 class CWallet final : public WalletStorage,
                       public interfaces::Chain::Notifications {
 private:
     CKeyingMaterial vMasterKey GUARDED_BY(cs_wallet);
 
     bool Unlock(const CKeyingMaterial &vMasterKeyIn,
                 bool accept_no_keys = false);
 
     std::atomic<bool> fAbortRescan{false};
     // controlled by WalletRescanReserver
     std::atomic<bool> fScanningWallet{false};
     std::atomic<int64_t> m_scanning_start{0};
     std::atomic<double> m_scanning_progress{0};
     friend class WalletRescanReserver;
 
     //! the current wallet version: clients below this version are not able to
     //! load the wallet
     int nWalletVersion GUARDED_BY(cs_wallet) = FEATURE_BASE;
 
     //! the maximum wallet format version: memory-only variable that specifies
     //! to what version this wallet may be upgraded
     int nWalletMaxVersion GUARDED_BY(cs_wallet) = FEATURE_BASE;
 
     int64_t nNextResend = 0;
     bool fBroadcastTransactions = false;
     // Local time that the tip block was received. Used to schedule wallet
     // rebroadcasts.
     std::atomic<int64_t> m_best_block_time{0};
 
     /**
      * Used to keep track of spent outpoints, and detect and report conflicts
      * (double-spends or mutated transactions where the mutant gets mined).
      */
     typedef std::multimap<COutPoint, TxId> TxSpends;
     TxSpends mapTxSpends GUARDED_BY(cs_wallet);
     void AddToSpends(const COutPoint &outpoint, const TxId &wtxid)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     void AddToSpends(const TxId &wtxid) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     /**
      * Add a transaction to the wallet, or update it. pIndex and posInBlock
      * should be set when the transaction was known to be included in a
      * block. When *pIndex == nullptr, then wallet state is not updated in
      * AddToWallet, but notifications happen and cached balances are marked
      * dirty.
      *
      * If fUpdate is true, existing transactions will be updated.
      * TODO: One exception to this is that the abandoned state is cleared under
      * the assumption that any further notification of a transaction that was
      * considered abandoned is an indication that it is not safe to be
      * considered abandoned. Abandoned state should probably be more carefully
      * tracked via different posInBlock signals or by checking mempool presence
      * when necessary.
      */
     bool AddToWalletIfInvolvingMe(const CTransactionRef &tx,
                                   CWalletTx::Confirmation confirm, bool fUpdate)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     /**
      * Mark a transaction (and its in-wallet descendants) as conflicting with a
      * particular block.
      */
     void MarkConflicted(const BlockHash &hashBlock, int conflicting_height,
                         const TxId &txid);
 
     /**
      * Mark a transaction's inputs dirty, thus forcing the outputs to be
      * recomputed
      */
     void MarkInputsDirty(const CTransactionRef &tx)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     void SyncMetaData(std::pair<TxSpends::iterator, TxSpends::iterator>)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     /**
      * Used by
      * TransactionAddedToMemorypool/BlockConnected/Disconnected/ScanForWalletTransactions.
      * Should be called with non-zero block_hash and posInBlock if this is for a
      * transaction that is included in a block.
      */
     void SyncTransaction(const CTransactionRef &tx,
                          CWalletTx::Confirmation confirm, bool update_tx = true)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     std::atomic<uint64_t> m_wallet_flags{0};
 
     bool SetAddressBookWithDB(WalletBatch &batch, const CTxDestination &address,
                               const std::string &strName,
                               const std::string &strPurpose);
 
     //! Unsets a wallet flag and saves it to disk
     void UnsetWalletFlagWithDB(WalletBatch &batch, uint64_t flag);
 
     //! Unset the blank wallet flag and saves it to disk
     void UnsetBlankWalletFlag(WalletBatch &batch) override;
 
     /** Interface for accessing chain state. */
     interfaces::Chain *m_chain;
 
     /** Wallet name: relative directory name or "" for default wallet. */
     std::string m_name;
 
     /** Internal database handle. */
     std::unique_ptr<WalletDatabase> database;
 
     /**
      * The following is used to keep track of how far behind the wallet is
      * from the chain sync, and to allow clients to block on us being caught up.
      *
      * Processed hash is a pointer on node's tip and doesn't imply that the
      * wallet has scanned sequentially all blocks up to this one.
      */
     BlockHash m_last_block_processed GUARDED_BY(cs_wallet);
 
     /* Height of last block processed is used by wallet to know depth of
      * transactions without relying on Chain interface beyond asynchronous
      * updates. For safety, we initialize it to -1. Height is a pointer on
      * node's tip and doesn't imply that the wallet has scanned sequentially all
      * blocks up to this one.
      */
     int m_last_block_processed_height GUARDED_BY(cs_wallet) = -1;
 
     std::map<OutputType, ScriptPubKeyMan *> m_external_spk_managers;
     std::map<OutputType, ScriptPubKeyMan *> m_internal_spk_managers;
 
     // Indexed by a unique identifier produced by each ScriptPubKeyMan using
     // ScriptPubKeyMan::GetID. In many cases it will be the hash of an internal
     // structure
     std::map<uint256, std::unique_ptr<ScriptPubKeyMan>> m_spk_managers;
 
 public:
     /*
      * Main wallet lock.
      * This lock protects all the fields added by CWallet.
      */
     mutable RecursiveMutex cs_wallet;
 
     /**
      * Get database handle used by this wallet. Ideally this function would not
      * be necessary.
      */
     WalletDatabase &GetDBHandle() { return *database; }
     WalletDatabase &GetDatabase() override { return *database; }
 
     /**
      * Get a name for this wallet for logging/debugging purposes.
      */
     const std::string &GetName() const { return m_name; }
 
     typedef std::map<unsigned int, CMasterKey> MasterKeyMap;
     MasterKeyMap mapMasterKeys;
     unsigned int nMasterKeyMaxID = 0;
 
     /** Construct wallet with specified name and database implementation. */
     CWallet(interfaces::Chain *chain, const std::string &name,
             std::unique_ptr<WalletDatabase> _database)
         : m_chain(chain), m_name(name), database(std::move(_database)) {}
 
     ~CWallet() {
         // Should not have slots connected at this point.
         assert(NotifyUnload.empty());
     }
 
     /* Returns the chain params used by this wallet. */
     const CChainParams &GetChainParams() const override;
 
     bool IsCrypted() const;
     bool IsLocked() const override;
     bool Lock();
 
     /** Interface to assert chain access */
     bool HaveChain() const { return m_chain ? true : false; }
 
     std::map<TxId, CWalletTx> mapWallet GUARDED_BY(cs_wallet);
 
     typedef std::multimap<int64_t, CWalletTx *> TxItems;
     TxItems wtxOrdered;
 
     int64_t nOrderPosNext GUARDED_BY(cs_wallet) = 0;
     uint64_t nAccountingEntryNumber = 0;
 
     std::map<CTxDestination, CAddressBookData>
         m_address_book GUARDED_BY(cs_wallet);
     const CAddressBookData *
     FindAddressBookEntry(const CTxDestination &,
                          bool allow_change = false) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     std::set<COutPoint> setLockedCoins GUARDED_BY(cs_wallet);
 
     /** Registered interfaces::Chain::Notifications handler. */
     std::unique_ptr<interfaces::Handler> m_chain_notifications_handler;
 
     /** Interface for accessing chain state. */
     interfaces::Chain &chain() const {
         assert(m_chain);
         return *m_chain;
     }
 
     const CWalletTx *GetWalletTx(const TxId &txid) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
-    // TODO: Remove "NO_THREAD_SAFETY_ANALYSIS" and replace it with the correct
-    // annotation "EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)". The annotation
-    // "NO_THREAD_SAFETY_ANALYSIS" was temporarily added to avoid having to
-    // resolve the issue of member access into incomplete type CWallet. Note
-    // that we still have the runtime check "AssertLockHeld(pwallet->cs_wallet)"
-    // in place.
-    std::set<TxId>
-    GetTxConflicts(const CWalletTx &wtx) const NO_THREAD_SAFETY_ANALYSIS;
+    std::set<TxId> GetTxConflicts(const CWalletTx &wtx) const
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     /**
      * Return depth of transaction in blockchain:
      * <0  : conflicts with a transaction this deep in the blockchain
      *  0  : in memory pool, waiting to be included in a block
      * >=1 : this many blocks deep in the main chain
      */
-    // TODO: Remove "NO_THREAD_SAFETY_ANALYSIS" and replace it with the correct
-    // annotation "EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)". The annotation
-    // "NO_THREAD_SAFETY_ANALYSIS" was temporarily added to avoid having to
-    // resolve the issue of member access into incomplete type CWallet. Note
-    // that we still have the runtime check "AssertLockHeld(pwallet->cs_wallet)"
-    // in place.
-    int
-    GetTxDepthInMainChain(const CWalletTx &wtx) const NO_THREAD_SAFETY_ANALYSIS;
-    bool IsTxInMainChain(const CWalletTx &wtx) const {
+    int GetTxDepthInMainChain(const CWalletTx &wtx) const
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    bool IsTxInMainChain(const CWalletTx &wtx) const
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
+        AssertLockHeld(cs_wallet);
+
         return GetTxDepthInMainChain(wtx) > 0;
     }
 
     /**
      * @return number of blocks to maturity for this transaction:
      *  0 : is not a coinbase transaction, or is a mature coinbase transaction
      * >0 : is a coinbase transaction which matures in this many blocks
      */
-    int GetTxBlocksToMaturity(const CWalletTx &wtx) const;
-    bool IsTxImmatureCoinBase(const CWalletTx &wtx) const;
+    int GetTxBlocksToMaturity(const CWalletTx &wtx) const
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    bool IsTxImmatureCoinBase(const CWalletTx &wtx) const
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     //! check whether we are allowed to upgrade (or already support) to the
     //! named feature
     bool CanSupportFeature(enum WalletFeature wf) const override
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
         AssertLockHeld(cs_wallet);
         return nWalletMaxVersion >= wf;
     }
 
     bool IsSpent(const COutPoint &outpoint) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     // Whether this or any UTXO with the same CTxDestination has been spent.
     bool IsSpentKey(const TxId &txid, unsigned int n) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     void SetSpentKeyState(WalletBatch &batch, const TxId &txid, unsigned int n,
                           bool used, std::set<CTxDestination> &tx_destinations)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     bool IsLockedCoin(const COutPoint &outpoint) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     void LockCoin(const COutPoint &output) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     void UnlockCoin(const COutPoint &output)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     void UnlockAllCoins() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     void ListLockedCoins(std::vector<COutPoint> &vOutpts) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     /*
      * Rescan abort properties
      */
     void AbortRescan() { fAbortRescan = true; }
     bool IsAbortingRescan() const { return fAbortRescan; }
     bool IsScanning() const { return fScanningWallet; }
     int64_t ScanningDuration() const {
         return fScanningWallet ? GetTimeMillis() - m_scanning_start : 0;
     }
     double ScanningProgress() const {
         return fScanningWallet ? double(m_scanning_progress) : 0;
     }
 
     //! Upgrade stored CKeyMetadata objects to store key origin info as
     //! KeyOriginInfo
     void UpgradeKeyMetadata() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     bool LoadMinVersion(int nVersion) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
         AssertLockHeld(cs_wallet);
         nWalletVersion = nVersion;
         nWalletMaxVersion = std::max(nWalletMaxVersion, nVersion);
         return true;
     }
 
     /**
      * Adds a destination data tuple to the store, and saves it to disk
      * When adding new fields, take care to consider how DelAddressBook should
      * handle it!
      */
     bool AddDestData(WalletBatch &batch, const CTxDestination &dest,
                      const std::string &key, const std::string &value)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     //! Erases a destination data tuple in the store and on disk
     bool EraseDestData(WalletBatch &batch, const CTxDestination &dest,
                        const std::string &key)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     //! Adds a destination data tuple to the store, without saving it to disk
     void LoadDestData(const CTxDestination &dest, const std::string &key,
                       const std::string &value)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     //! Look up a destination data tuple in the store, return true if found
     //! false otherwise
     bool GetDestData(const CTxDestination &dest, const std::string &key,
                      std::string *value) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     //! Get all destination values matching a prefix.
     std::vector<std::string> GetDestValues(const std::string &prefix) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     //! Holds a timestamp at which point the wallet is scheduled (externally) to
     //! be relocked. Caller must arrange for actual relocking to occur via
     //! Lock().
     int64_t nRelockTime GUARDED_BY(cs_wallet){0};
 
     // Used to prevent concurrent calls to walletpassphrase RPC.
     Mutex m_unlock_mutex;
     bool Unlock(const SecureString &strWalletPassphrase,
                 bool accept_no_keys = false);
     bool ChangeWalletPassphrase(const SecureString &strOldWalletPassphrase,
                                 const SecureString &strNewWalletPassphrase);
     bool EncryptWallet(const SecureString &strWalletPassphrase);
 
     void GetKeyBirthTimes(std::map<CKeyID, int64_t> &mapKeyBirth) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     unsigned int ComputeTimeSmart(const CWalletTx &wtx) const;
 
     /**
      * Increment the next transaction order id
      * @return next transaction order id
      */
     int64_t IncOrderPosNext(WalletBatch *batch = nullptr)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     DBErrors ReorderTransactions();
 
     void MarkDirty();
 
     //! Callback for updating transaction metadata in mapWallet.
     //!
     //! @param wtx - reference to mapWallet transaction to update
     //! @param new_tx - true if wtx is newly inserted, false if it previously
     //! existed
     //!
     //! @return true if wtx is changed and needs to be saved to disk, otherwise
     //! false
     using UpdateWalletTxFn = std::function<bool(CWalletTx &wtx, bool new_tx)>;
 
     CWalletTx *AddToWallet(CTransactionRef tx,
                            const CWalletTx::Confirmation &confirm,
                            const UpdateWalletTxFn &update_wtx = nullptr,
                            bool fFlushOnClose = true);
     bool LoadToWallet(const TxId &txid, const UpdateWalletTxFn &fill_wtx)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     void transactionAddedToMempool(const CTransactionRef &tx,
                                    uint64_t mempool_sequence) override;
     void blockConnected(const CBlock &block, int height) override;
     void blockDisconnected(const CBlock &block, int height) override;
     void updatedBlockTip() override;
     int64_t RescanFromTime(int64_t startTime,
                            const WalletRescanReserver &reserver, bool update);
 
     struct ScanResult {
         enum { SUCCESS, FAILURE, USER_ABORT } status = SUCCESS;
 
         //! Hash and height of most recent block that was successfully scanned.
         //! Unset if no blocks were scanned due to read errors or the chain
         //! being empty.
         BlockHash last_scanned_block;
         std::optional<int> last_scanned_height;
 
         //! Hash of the most recent block that could not be scanned due to
         //! read errors or pruning. Will be set if status is FAILURE, unset if
         //! status is SUCCESS, and may or may not be set if status is
         //! USER_ABORT.
         BlockHash last_failed_block;
     };
     ScanResult ScanForWalletTransactions(const BlockHash &start_block,
                                          int start_height,
                                          std::optional<int> max_height,
                                          const WalletRescanReserver &reserver,
                                          bool fUpdate);
     void transactionRemovedFromMempool(const CTransactionRef &tx,
                                        MemPoolRemovalReason reason,
                                        uint64_t mempool_sequence) override;
     void ReacceptWalletTransactions() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     void ResendWalletTransactions();
 
     OutputType
     TransactionChangeType(const std::optional<OutputType> &change_type,
                           const std::vector<CRecipient> &vecSend) const;
 
     // Fetch the inputs and sign with SIGHASH_ALL.
     bool SignTransaction(CMutableTransaction &tx) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     // Sign the tx given the input coins and sighash.
     bool SignTransaction(CMutableTransaction &tx,
                          const std::map<COutPoint, Coin> &coins,
                          SigHashType sighash,
                          std::map<int, std::string> &input_errors) const;
     SigningResult SignMessage(const std::string &message, const PKHash &pkhash,
                               std::string &str_sig) const;
 
     /**
      * 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]  psbtx PartiallySignedTransaction to fill in
      * @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 error
      */
     TransactionError
     FillPSBT(PartiallySignedTransaction &psbtx, bool &complete,
              SigHashType sighash_type = SigHashType().withForkId(),
              bool sign = true, bool bip32derivs = true) const;
 
     /**
      * Submit the transaction to the node's mempool and then relay to peers.
      * Should be called after CreateTransaction unless you want to abort
      * broadcasting the transaction.
      *
      * @param[in] tx The transaction to be broadcast.
      * @param[in] mapValue key-values to be set on the transaction.
      * @param[in] orderForm BIP 70 / BIP 21 order form details to be set on the
      * transaction.
      */
     void CommitTransaction(
         CTransactionRef tx, mapValue_t mapValue,
         std::vector<std::pair<std::string, std::string>> orderForm);
 
     /**
      * Pass this transaction to node for mempool insertion and relay to peers
      * if flag set to true
      */
     bool SubmitTxMemoryPoolAndRelay(const CWalletTx &wtx,
-                                    std::string &err_string, bool relay) const;
+                                    std::string &err_string, bool relay) const
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     bool DummySignTx(CMutableTransaction &txNew, const std::set<CTxOut> &txouts,
                      bool use_max_sig = false) const {
         std::vector<CTxOut> v_txouts(txouts.size());
         std::copy(txouts.begin(), txouts.end(), v_txouts.begin());
         return DummySignTx(txNew, v_txouts, use_max_sig);
     }
     bool DummySignTx(CMutableTransaction &txNew,
                      const std::vector<CTxOut> &txouts,
                      bool use_max_sig = false) const;
     bool DummySignInput(CTxIn &tx_in, const CTxOut &txout,
                         bool use_max_sig = false) const;
 
     bool ImportScripts(const std::set<CScript> scripts, int64_t timestamp)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     bool ImportPrivKeys(const std::map<CKeyID, CKey> &privkey_map,
                         const int64_t timestamp)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     bool ImportPubKeys(
         const std::vector<CKeyID> &ordered_pubkeys,
         const std::map<CKeyID, CPubKey> &pubkey_map,
         const std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> &key_origins,
         const bool add_keypool, const bool internal, const int64_t timestamp)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     bool ImportScriptPubKeys(const std::string &label,
                              const std::set<CScript> &script_pub_keys,
                              const bool have_solving_data,
                              const bool apply_label, const int64_t timestamp)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     CFeeRate m_pay_tx_fee{DEFAULT_PAY_TX_FEE};
     bool m_spend_zero_conf_change{DEFAULT_SPEND_ZEROCONF_CHANGE};
     //! will be false if -fallbackfee=0
     bool m_allow_fallback_fee{true};
     // Override with -mintxfee
     CFeeRate m_min_fee{DEFAULT_TRANSACTION_MINFEE_PER_KB};
     /**
      * If fee estimation does not have enough data to provide estimates, use
      * this fee instead. Has no effect if not using fee estimation Override with
      * -fallbackfee
      */
     CFeeRate m_fallback_fee{DEFAULT_FALLBACK_FEE};
     //! note: this is absolute fee, not fee rate
     Amount m_max_aps_fee{DEFAULT_MAX_AVOIDPARTIALSPEND_FEE};
     OutputType m_default_address_type{DEFAULT_ADDRESS_TYPE};
     /**
      * Default output type for change outputs. When unset, automatically choose
      * type based on address type setting and the types other of non-change
      * outputs (see implementation in CWallet::TransactionChangeType for
      * details).
      */
     std::optional<OutputType> m_default_change_type{};
     /**
      * Absolute maximum transaction fee (in satoshis) used by default for the
      * wallet.
      */
     Amount m_default_max_tx_fee{DEFAULT_TRANSACTION_MAXFEE};
 
     size_t KeypoolCountExternalKeys() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     bool TopUpKeyPool(unsigned int kpSize = 0);
 
     int64_t GetOldestKeyPoolTime() const;
 
     std::set<CTxDestination> GetLabelAddresses(const std::string &label) const;
 
     /**
      * Marks all outputs in each one of the destinations dirty, so their cache
      * is reset and does not return outdated information.
      */
     void MarkDestinationsDirty(const std::set<CTxDestination> &destinations)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     bool GetNewDestination(const OutputType type, const std::string label,
                            CTxDestination &dest, std::string &error);
     bool GetNewChangeDestination(const OutputType type, CTxDestination &dest,
                                  std::string &error);
 
     isminetype IsMine(const CTxDestination &dest) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     isminetype IsMine(const CScript &script) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     /**
      * Returns amount of debit if the input matches the filter, otherwise
      * returns 0
      */
     Amount GetDebit(const CTxIn &txin, const isminefilter &filter) const;
     isminetype IsMine(const CTxOut &txout) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     ;
     bool IsMine(const CTransaction &tx) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     /** should probably be renamed to IsRelevantToMe */
     bool IsFromMe(const CTransaction &tx) const;
     Amount GetDebit(const CTransaction &tx, const isminefilter &filter) const;
     void chainStateFlushed(const CBlockLocator &loc) override;
 
     DBErrors LoadWallet(bool &fFirstRunRet);
     DBErrors ZapSelectTx(std::vector<TxId> &txIdsIn,
                          std::vector<TxId> &txIdsOut)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     bool SetAddressBook(const CTxDestination &address,
                         const std::string &strName, const std::string &purpose);
 
     bool DelAddressBook(const CTxDestination &address);
 
     unsigned int GetKeyPoolSize() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     //! signify that a particular wallet feature is now used. this may change
     //! nWalletVersion and nWalletMaxVersion if those are lower
     void SetMinVersion(enum WalletFeature, WalletBatch *batch_in = nullptr,
                        bool fExplicit = false) override;
 
     //! change which version we're allowed to upgrade to (note that this does
     //! not immediately imply upgrading to that format)
     bool SetMaxVersion(int nVersion);
 
     //! get the current wallet format (the oldest client version guaranteed to
     //! understand this wallet)
     int GetVersion() const {
         LOCK(cs_wallet);
         return nWalletVersion;
     }
 
     //! Get wallet transactions that conflict with given transaction (spend same
     //! outputs)
     std::set<TxId> GetConflicts(const TxId &txid) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     //! Check if a given transaction has any of its outputs spent by another
     //! transaction in the wallet
     bool HasWalletSpend(const TxId &txid) const
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     //! Flush wallet (bitdb flush)
     void Flush();
 
     //! Close wallet database
     void Close();
 
     /** Wallet is about to be unloaded */
     boost::signals2::signal<void()> NotifyUnload;
 
     /**
      * Address book entry changed.
      * @note called with lock cs_wallet held.
      */
     boost::signals2::signal<void(CWallet *wallet, const CTxDestination &address,
                                  const std::string &label, bool isMine,
                                  const std::string &purpose, ChangeType status)>
         NotifyAddressBookChanged;
 
     /**
      * Wallet transaction added, removed or updated.
      * @note called with lock cs_wallet held.
      */
     boost::signals2::signal<void(CWallet *wallet, const TxId &txid,
                                  ChangeType status)>
         NotifyTransactionChanged;
 
     /** Show progress e.g. for rescan */
     boost::signals2::signal<void(const std::string &title, int nProgress)>
         ShowProgress;
 
     /** Watch-only address added */
     boost::signals2::signal<void(bool fHaveWatchOnly)> NotifyWatchonlyChanged;
 
     /** Keypool has new keys */
     boost::signals2::signal<void()> NotifyCanGetAddressesChanged;
 
     /**
      * Wallet status (encrypted, locked) changed.
      * Note: Called without locks held.
      */
     boost::signals2::signal<void(CWallet *wallet)> NotifyStatusChanged;
 
     /** Inquire whether this wallet broadcasts transactions. */
     bool GetBroadcastTransactions() const { return fBroadcastTransactions; }
     /** Set whether this wallet broadcasts transactions. */
     void SetBroadcastTransactions(bool broadcast) {
         fBroadcastTransactions = broadcast;
     }
 
     /** Return whether transaction can be abandoned */
     bool TransactionCanBeAbandoned(const TxId &txid) const;
 
     /**
      * Mark a transaction (and it in-wallet descendants) as abandoned so its
      * inputs may be respent.
      */
     bool AbandonTransaction(const TxId &txid);
 
     /**
      * Initializes the wallet, returns a new CWallet instance or a null pointer
      * in case of an error.
      */
     static std::shared_ptr<CWallet>
     Create(interfaces::Chain &chain, const std::string &name,
            std::unique_ptr<WalletDatabase> database,
            uint64_t wallet_creation_flags, bilingual_str &error,
            std::vector<bilingual_str> &warnings);
 
     /**
      * Wallet post-init setup
      * Gives the wallet a chance to register repetitive tasks and complete
      * post-init tasks
      */
     void postInitProcess();
 
     bool BackupWallet(const std::string &strDest) const;
 
     /* Returns true if HD is enabled */
     bool IsHDEnabled() const;
 
     /**
      * Returns true if the wallet can give out new addresses. This means it has
      * keys in the keypool or can generate new keys.
      */
     bool CanGetAddresses(bool internal = false) const;
 
     /**
      * Blocks until the wallet state is up-to-date to /at least/ the current
      * chain at the time this function is entered.
      * Obviously holding cs_main/cs_wallet when going into this call may cause
      * deadlock
      */
     void BlockUntilSyncedToCurrentChain() const LOCKS_EXCLUDED(::cs_main)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_wallet);
 
     /**
      * Set a single wallet flag.
      */
     void SetWalletFlag(uint64_t flags);
 
     /**
      * Unsets a single wallet flag.
      */
     void UnsetWalletFlag(uint64_t flag);
 
     /**
      * Check if a certain wallet flag is set.
      */
     bool IsWalletFlagSet(uint64_t flag) const override;
 
     /**
      * Overwrite all flags by the given uint64_t.
      * Returns false if unknown, non-tolerable flags are present.
      */
     bool AddWalletFlags(uint64_t flags);
     /** Loads the flags into the wallet. (used by LoadWallet) */
     bool LoadWalletFlags(uint64_t flags);
 
     /** Determine if we are a legacy wallet */
     bool IsLegacy() const;
 
     /**
      * Returns a bracketed wallet name for displaying in logs, will return
      * [default wallet] if the wallet has no name.
      */
     const std::string GetDisplayName() const override {
         std::string wallet_name =
             GetName().length() == 0 ? "default wallet" : GetName();
         return strprintf("[%s]", wallet_name);
     };
 
     /**
      * Prepends the wallet name in logging output to ease debugging in
      * multi-wallet use cases.
      */
     template <typename... Params>
     void WalletLogPrintf(std::string fmt, Params... parameters) const {
         LogPrintf(("%s " + fmt).c_str(), GetDisplayName(), parameters...);
     };
 
     template <typename... Params>
     void WalletLogPrintfToBeContinued(std::string fmt,
                                       Params... parameters) const {
         LogPrintfToBeContinued(("%s " + fmt).c_str(), GetDisplayName(),
                                parameters...);
     };
 
     /** Upgrade the wallet */
     bool UpgradeWallet(int version, bilingual_str &error);
 
     //! Returns all unique ScriptPubKeyMans in m_internal_spk_managers and
     //! m_external_spk_managers
     std::set<ScriptPubKeyMan *> GetActiveScriptPubKeyMans() const;
 
     //! Returns all unique ScriptPubKeyMans
     std::set<ScriptPubKeyMan *> GetAllScriptPubKeyMans() const;
 
     //! Get the ScriptPubKeyMan for the given OutputType and internal/external
     //! chain.
     ScriptPubKeyMan *GetScriptPubKeyMan(const OutputType &type,
                                         bool internal) const;
 
     //! Get the ScriptPubKeyMan for a script
     ScriptPubKeyMan *GetScriptPubKeyMan(const CScript &script) const;
     //! Get the ScriptPubKeyMan by id
     ScriptPubKeyMan *GetScriptPubKeyMan(const uint256 &id) const;
 
     //! Get all of the ScriptPubKeyMans for a script given additional
     //! information in sigdata (populated by e.g. a psbt)
     std::set<ScriptPubKeyMan *>
     GetScriptPubKeyMans(const CScript &script, SignatureData &sigdata) const;
 
     //! Get the SigningProvider for a script
     std::unique_ptr<SigningProvider>
     GetSolvingProvider(const CScript &script) const;
     std::unique_ptr<SigningProvider>
     GetSolvingProvider(const CScript &script, SignatureData &sigdata) const;
 
     //! Get the LegacyScriptPubKeyMan which is used for all types, internal, and
     //! external.
     LegacyScriptPubKeyMan *GetLegacyScriptPubKeyMan() const;
     LegacyScriptPubKeyMan *GetOrCreateLegacyScriptPubKeyMan();
 
     //! Make a LegacyScriptPubKeyMan and set it for all types, internal, and
     //! external.
     void SetupLegacyScriptPubKeyMan();
 
     const CKeyingMaterial &GetEncryptionKey() const override;
     bool HasEncryptionKeys() const override;
 
     /** Get last block processed height */
     int GetLastBlockHeight() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
         AssertLockHeld(cs_wallet);
         assert(m_last_block_processed_height >= 0);
         return m_last_block_processed_height;
     };
     BlockHash GetLastBlockHash() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
         AssertLockHeld(cs_wallet);
         assert(m_last_block_processed_height >= 0);
         return m_last_block_processed;
     }
     /** Set last block processed height, currently only use in unit test */
     void SetLastBlockProcessed(int block_height, BlockHash block_hash)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
         AssertLockHeld(cs_wallet);
         m_last_block_processed_height = block_height;
         m_last_block_processed = block_hash;
     };
 
     //! Connect the signals from ScriptPubKeyMans to the signals in CWallet
     void ConnectScriptPubKeyManNotifiers();
 
     //! Instantiate a descriptor ScriptPubKeyMan from the WalletDescriptor and
     //! load it
     void LoadDescriptorScriptPubKeyMan(uint256 id, WalletDescriptor &desc);
 
     //! Adds the active ScriptPubKeyMan for the specified type and internal.
     //! Writes it to the wallet file
     //! @param[in] id The unique id for the ScriptPubKeyMan
     //! @param[in] type The OutputType this ScriptPubKeyMan provides addresses
     //!                 for
     //! @param[in] internal Whether this ScriptPubKeyMan provides change
     //!                     addresses
     void AddActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal);
 
     //! Loads an active ScriptPubKeyMan for the specified type and internal.
     //! (used by LoadWallet)
     //! @param[in] id The unique id for the ScriptPubKeyMan
     //! @param[in] type The OutputType this ScriptPubKeyMan provides addresses
     //!                 for
     //! @param[in] internal Whether this ScriptPubKeyMan provides change
     //!                     addresses
     void LoadActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal);
 
     //! Create new DescriptorScriptPubKeyMans and add them to the wallet
     void SetupDescriptorScriptPubKeyMans() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     //! Return the DescriptorScriptPubKeyMan for a WalletDescriptor if it is
     //! already in the wallet
     DescriptorScriptPubKeyMan *
     GetDescriptorScriptPubKeyMan(const WalletDescriptor &desc) const;
 
     //! Add a descriptor to the wallet, return a ScriptPubKeyMan & associated
     //! output type
     ScriptPubKeyMan *
     AddWalletDescriptor(WalletDescriptor &desc,
                         const FlatSigningProvider &signing_provider,
                         const std::string &label, bool internal);
 };
 
 /**
  * Called periodically by the schedule thread. Prompts individual wallets to
  * resend their transactions. Actual rebroadcast schedule is managed by the
  * wallets themselves.
  */
 void MaybeResendWalletTxs();
 
 /** RAII object to check and reserve a wallet rescan */
 class WalletRescanReserver {
 private:
     CWallet &m_wallet;
     bool m_could_reserve;
 
 public:
     explicit WalletRescanReserver(CWallet &w)
         : m_wallet(w), m_could_reserve(false) {}
 
     bool reserve() {
         assert(!m_could_reserve);
         if (m_wallet.fScanningWallet.exchange(true)) {
             return false;
         }
         m_wallet.m_scanning_start = GetTimeMillis();
         m_wallet.m_scanning_progress = 0;
         m_could_reserve = true;
         return true;
     }
 
     bool isReserved() const {
         return (m_could_reserve && m_wallet.fScanningWallet);
     }
 
     ~WalletRescanReserver() {
         if (m_could_reserve) {
             m_wallet.fScanningWallet = false;
         }
     }
 };
 
 //! Add wallet name to persistent configuration so it will be loaded on startup.
 bool AddWalletSetting(interfaces::Chain &chain, const std::string &wallet_name);
 
 //! Remove wallet name from persistent configuration so it will not be loaded on
 //! startup.
 bool RemoveWalletSetting(interfaces::Chain &chain,
                          const std::string &wallet_name);
 
 #endif // BITCOIN_WALLET_WALLET_H