diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
index de597ca89..040a6efde 100644
--- a/src/interfaces/chain.h
+++ b/src/interfaces/chain.h
@@ -1,368 +1,370 @@
 // Copyright (c) 2018-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_INTERFACES_CHAIN_H
 #define BITCOIN_INTERFACES_CHAIN_H
 
 #include <primitives/transaction.h>
 #include <primitives/txid.h>
 
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <optional>
 #include <string>
 #include <vector>
 
+class ArgsManager;
 class CBlock;
 class CChainParams;
 class Coin;
 class Config;
 class CRPCCommand;
 class CScheduler;
 class TxValidationState;
 
 struct BlockHash;
 struct bilingual_str;
 struct CBlockLocator;
 struct NodeContext;
 
 namespace Consensus {
 struct Params;
 }
 
 namespace interfaces {
 
 class Handler;
 class Wallet;
 
 //! Helper for findBlock to selectively return pieces of block data.
 class FoundBlock {
 public:
     FoundBlock &hash(BlockHash &hash) {
         m_hash = &hash;
         return *this;
     }
     FoundBlock &height(int &height) {
         m_height = &height;
         return *this;
     }
     FoundBlock &time(int64_t &time) {
         m_time = &time;
         return *this;
     }
     FoundBlock &maxTime(int64_t &max_time) {
         m_max_time = &max_time;
         return *this;
     }
     FoundBlock &mtpTime(int64_t &mtp_time) {
         m_mtp_time = &mtp_time;
         return *this;
     }
     //! Read block data from disk. If the block exists but doesn't have data
     //! (for example due to pruning), the CBlock variable will be set to null.
     FoundBlock &data(CBlock &data) {
         m_data = &data;
         return *this;
     }
 
     BlockHash *m_hash = nullptr;
     int *m_height = nullptr;
     int64_t *m_time = nullptr;
     int64_t *m_max_time = nullptr;
     int64_t *m_mtp_time = nullptr;
     CBlock *m_data = nullptr;
 };
 
 //! Interface giving clients (wallet processes, maybe other analysis tools in
 //! the future) ability to access to the chain state, receive notifications,
 //! estimate fees, and submit transactions.
 //!
 //! TODO: Current chain methods are too low level, exposing too much of the
 //! internal workings of the bitcoin node, and not being very convenient to use.
 //! Chain methods should be cleaned up and simplified over time. Examples:
 //!
 //! * The initMessages() and showProgress() methods which the wallet uses to
 //! send
 //!   notifications to the GUI should go away when GUI and wallet can directly
 //!   communicate with each other without going through the node
 //!   (https://github.com/bitcoin/bitcoin/pull/15288#discussion_r253321096).
 //!
 //! * The handleRpc, registerRpcs, rpcEnableDeprecated methods and other RPC
 //!   methods can go away if wallets listen for HTTP requests on their own
 //!   ports instead of registering to handle requests on the node HTTP port.
 //!
 //! * Move fee estimation queries to an asynchronous interface and let the
 //!   wallet cache it, fee estimation being driven by node mempool, wallet
 //!   should be the consumer.
 //!
 //! * The `guessVerificationProgress`, `getBlockHeight`, `getBlockHash`, etc
 //!   methods can go away if rescan logic is moved on the node side, and wallet
 //!   only register rescan request.
 class Chain {
 public:
     virtual ~Chain() {}
 
     //! Get current chain height, not including genesis block (returns 0 if
     //! chain only contains genesis block, std::nullopt if chain does not
     //! contain any blocks)
     virtual std::optional<int> getHeight() = 0;
 
     //! Get block height above genesis block. Returns 0 for genesis block,
     //! 1 for following block, and so on. Returns std::nullopt for a block not
     //! included in the current chain.
     virtual std::optional<int> getBlockHeight(const BlockHash &hash) = 0;
 
     //! Get block hash. Height must be valid or this function will abort.
     virtual BlockHash getBlockHash(int height) = 0;
 
     //! Check that the block is available on disk (i.e. has not been
     //! pruned), and contains transactions.
     virtual bool haveBlockOnDisk(int height) = 0;
 
     //! Return height of the first block in the chain with timestamp equal
     //! or greater than the given time and height equal or greater than the
     //! given height, or std::nullopt if there is no block with a high enough
     //! timestamp and height. Also return the block hash as an optional output
     //! parameter (to avoid the cost of a second lookup in case this information
     //! is needed.)
     virtual std::optional<int>
     findFirstBlockWithTimeAndHeight(int64_t time, int height,
                                     BlockHash *hash) = 0;
 
     //! Get locator for the current chain tip.
     virtual CBlockLocator getTipLocator() = 0;
 
     //! Return height of the highest block on chain in common with the locator,
     //! which will either be the original block used to create the locator,
     //! or one of its ancestors.
     virtual std::optional<int>
     findLocatorFork(const CBlockLocator &locator) = 0;
 
     //! Check if transaction will be final given chain height current time.
     virtual bool
     contextualCheckTransactionForCurrentBlock(const CTransaction &tx,
                                               TxValidationState &state) = 0;
 
     //! Return whether node has the block and optionally return block metadata
     //! or contents.
     virtual bool findBlock(const BlockHash &hash,
                            const FoundBlock &block = {}) = 0;
 
     //! Find first block in the chain with timestamp >= the given time
     //! and height >= than the given height, return false if there is no block
     //! with a high enough timestamp and height. Optionally return block
     //! information.
     virtual bool
     findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height,
                                     const FoundBlock &block = {}) = 0;
 
     //! Find next block if block is part of current chain. Also flag if
     //! there was a reorg and the specified block hash is no longer in the
     //! current chain, and optionally return block information.
     virtual bool findNextBlock(const BlockHash &block_hash, int block_height,
                                const FoundBlock &next = {},
                                bool *reorg = nullptr) = 0;
 
     //! Find ancestor of block at specified height and optionally return
     //! ancestor information.
     virtual bool findAncestorByHeight(const BlockHash &block_hash,
                                       int ancestor_height,
                                       const FoundBlock &ancestor_out = {}) = 0;
 
     //! Return whether block descends from a specified ancestor, and
     //! optionally return ancestor information.
     virtual bool findAncestorByHash(const BlockHash &block_hash,
                                     const BlockHash &ancestor_hash,
                                     const FoundBlock &ancestor_out = {}) = 0;
 
     //! Find most recent common ancestor between two blocks and optionally
     //! return block information.
     virtual bool findCommonAncestor(const BlockHash &block_hash1,
                                     const BlockHash &block_hash2,
                                     const FoundBlock &ancestor_out = {},
                                     const FoundBlock &block1_out = {},
                                     const FoundBlock &block2_out = {}) = 0;
 
     //! Look up unspent output information. Returns coins in the mempool and in
     //! the current chain UTXO set. Iterates through all the keys in the map and
     //! populates the values.
     virtual void findCoins(std::map<COutPoint, Coin> &coins) = 0;
 
     //! Estimate fraction of total transactions verified if blocks up to
     //! the specified block hash are verified.
     virtual double guessVerificationProgress(const BlockHash &block_hash) = 0;
 
     //! Return true if data is available for all blocks in the specified range
     //! of blocks. This checks all blocks that are ancestors of block_hash in
     //! the height range from min_height to max_height, inclusive.
     virtual bool hasBlocks(const BlockHash &block_hash, int min_height = 0,
                            std::optional<int> max_height = {}) = 0;
 
     //! Check if transaction has descendants in mempool.
     virtual bool hasDescendantsInMempool(const TxId &txid) = 0;
 
     //! Transaction is added to memory pool, if the transaction fee is below the
     //! amount specified by max_tx_fee, and broadcast to all peers if relay is
     //! set to true. Return false if the transaction could not be added due to
     //! the fee or for another reason.
     virtual bool broadcastTransaction(const Config &config,
                                       const CTransactionRef &tx,
                                       const Amount &max_tx_fee, bool relay,
                                       std::string &err_string) = 0;
 
     //! Calculate mempool ancestor and descendant counts for the given
     //! transaction.
     virtual void getTransactionAncestry(const TxId &txid, size_t &ancestors,
                                         size_t &descendants) = 0;
 
     //! Get the node's package limits.
     //! Currently only returns the ancestor and descendant count limits, but
     //! could be enhanced to return more policy settings.
     virtual void getPackageLimits(size_t &limit_ancestor_count,
                                   size_t &limit_descendant_count) = 0;
 
     //! Check if transaction will pass the mempool's chain limits.
     virtual bool checkChainLimits(const CTransactionRef &tx) = 0;
 
     //! Estimate fee
     virtual CFeeRate estimateFee() const = 0;
 
     //! Relay current minimum fee (from -minrelaytxfee settings).
     virtual CFeeRate relayMinFee() = 0;
 
     //! Relay dust fee setting (-dustrelayfee), reflecting lowest rate it's
     //! economical to spend.
     virtual CFeeRate relayDustFee() = 0;
 
     //! Check if any block has been pruned.
     virtual bool havePruned() = 0;
 
     //! Check if the node is ready to broadcast transactions.
     virtual bool isReadyToBroadcast() = 0;
 
     //! Check if in IBD.
     virtual bool isInitialBlockDownload() = 0;
 
     //! Check if shutdown requested.
     virtual bool shutdownRequested() = 0;
 
     //! Get adjusted time.
     virtual int64_t getAdjustedTime() = 0;
 
     //! Send init message.
     virtual void initMessage(const std::string &message) = 0;
 
     //! Send init warning.
     virtual void initWarning(const std::string &message) = 0;
 
     //! Send init error.
     virtual void initError(const bilingual_str &message) = 0;
 
     //! Send progress indicator.
     virtual void showProgress(const std::string &title, int progress,
                               bool resume_possible) = 0;
 
     //! Chain notifications.
     class Notifications {
     public:
         virtual ~Notifications() {}
         virtual void transactionAddedToMempool(const CTransactionRef &tx) {}
         virtual void transactionRemovedFromMempool(const CTransactionRef &ptx) {
         }
         virtual void
         blockConnected(const CBlock &block,
                        const std::vector<CTransactionRef> &tx_conflicted,
                        int height) {}
         virtual void blockDisconnected(const CBlock &block, int height) {}
         virtual void updatedBlockTip() {}
         virtual void chainStateFlushed(const CBlockLocator &locator) {}
     };
 
     //! Register handler for notifications.
     virtual std::unique_ptr<Handler>
     handleNotifications(std::shared_ptr<Notifications> notifications) = 0;
 
     //! Wait for pending notifications to be processed unless block hash points
     //! to the current chain tip.
     virtual void waitForNotificationsIfTipChanged(const BlockHash &old_tip) = 0;
 
     //! Register handler for RPC. Command is not copied, so reference
     //! needs to remain valid until Handler is disconnected.
     virtual std::unique_ptr<Handler> handleRpc(const CRPCCommand &command) = 0;
 
     //! Check if deprecated RPC is enabled.
     virtual bool rpcEnableDeprecated(const std::string &method) = 0;
 
     //! Run function after given number of seconds. Cancel any previous calls
     //! with same name.
     virtual void rpcRunLater(const std::string &name, std::function<void()> fn,
                              int64_t seconds) = 0;
 
     //! Current RPC serialization flags.
     virtual int rpcSerializationFlags() = 0;
 
     //! Synchronously send transactionAddedToMempool notifications about all
     //! current mempool transactions to the specified handler and return after
     //! the last one is sent. These notifications aren't coordinated with async
     //! notifications sent by handleNotifications, so out of date async
     //! notifications from handleNotifications can arrive during and after
     //! synchronous notifications from requestMempoolTransactions. Clients need
     //! to be prepared to handle this by ignoring notifications about unknown
     //! removed transactions and already added new transactions.
     virtual void requestMempoolTransactions(Notifications &notifications) = 0;
 
     //! This Chain's parameters
     virtual const CChainParams &params() const = 0;
 };
 
 //! Interface to let node manage chain clients (wallets, or maybe tools for
 //! monitoring and analysis in the future).
 class ChainClient {
 public:
     virtual ~ChainClient() {}
 
     //! Register rpcs.
     virtual void registerRpcs() = 0;
 
     //! Check for errors before loading.
     virtual bool verify(const CChainParams &chainParams) = 0;
 
     //! Load saved state.
     virtual bool load(const CChainParams &chainParams) = 0;
 
     //! Start client execution and provide a scheduler.
     virtual void start(CScheduler &scheduler) = 0;
 
     //! Save state to disk.
     virtual void flush() = 0;
 
     //! Shut down client.
     virtual void stop() = 0;
 
     //! Set mock time.
     virtual void setMockTime(int64_t time) = 0;
 
     //! Return interfaces for accessing wallets (if any).
     virtual std::vector<std::unique_ptr<Wallet>> getWallets() = 0;
 };
 
 //! Return implementation of Chain interface.
 std::unique_ptr<Chain> MakeChain(NodeContext &node, const CChainParams &params);
 
 //! Return implementation of ChainClient interface for a wallet client. This
 //! function will be undefined in builds where ENABLE_WALLET is false.
 //!
 //! Currently, wallets are the only chain clients. But in the future, other
 //! types of chain clients could be added, such as tools for monitoring,
 //! analysis, or fee estimation. These clients need to expose their own
 //! MakeXXXClient functions returning their implementations of the ChainClient
 //! interface.
 std::unique_ptr<ChainClient>
-MakeWalletClient(Chain &chain, std::vector<std::string> wallet_filenames);
+MakeWalletClient(Chain &chain, ArgsManager &args,
+                 std::vector<std::string> wallet_filenames);
 
 } // namespace interfaces
 
 #endif // BITCOIN_INTERFACES_CHAIN_H
diff --git a/src/interfaces/wallet.cpp b/src/interfaces/wallet.cpp
index 6f97ab55b..235aa8d14 100644
--- a/src/interfaces/wallet.cpp
+++ b/src/interfaces/wallet.cpp
@@ -1,533 +1,535 @@
 // 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 <amount.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
 #include <policy/fees.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
 #include <script/standard.h>
 #include <support/allocators/secure.h>
 #include <sync.h>
 #include <ui_interface.h>
 #include <util/check.h>
 #include <util/ref.h>
 #include <util/system.h>
 #include <wallet/context.h>
 #include <wallet/fees.h>
 #include <wallet/ismine.h>
 #include <wallet/load.h>
 #include <wallet/rpcdump.h>
 #include <wallet/wallet.h>
 
 namespace interfaces {
 namespace {
 
     //! Construct wallet tx struct.
     WalletTx MakeWalletTx(CWallet &wallet, const CWalletTx &wtx) {
         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(wallet.IsMine(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 = wtx.GetCredit(ISMINE_ALL);
         result.debit = wtx.GetDebit(ISMINE_ALL);
         result.change = wtx.GetChange();
         result.time = wtx.GetTxTime();
         result.value_map = wtx.mapValue;
         result.is_coinbase = wtx.IsCoinBase();
         return result;
     }
 
     //! Construct wallet tx status struct.
     WalletTxStatus MakeWalletTxStatus(CWallet &wallet, const CWalletTx &wtx) {
         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 = wtx.GetBlocksToMaturity();
         result.depth_in_main_chain = wtx.GetDepthInMainChain();
         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 = wtx.IsTrusted();
         result.is_abandoned = wtx.isAbandoned();
         result.is_coinbase = wtx.IsCoinBase();
         result.is_in_main_chain = wtx.IsInMainChain();
         return result;
     }
 
     //! Construct wallet TxOut struct.
     WalletTxOut MakeWalletTxOut(CWallet &wallet, const CWalletTx &wtx, int n,
                                 int depth)
         EXCLUSIVE_LOCKS_REQUIRED(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 {
             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 (!m_wallet->CreateTransaction(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 = m_wallet->GetBalance();
             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,
                             int &num_blocks) override {
             TRY_LOCK(m_wallet->cs_wallet, locked_wallet);
             if (!locked_wallet) {
                 return false;
             }
             num_blocks = m_wallet->GetLastBlockHeight();
             balances = getBalances();
             return true;
         }
         Amount getBalance() override {
             return m_wallet->GetBalance().m_mine_trusted;
         }
         Amount getAvailableBalance(const CCoinControl &coin_control) override {
             return m_wallet->GetAvailableBalance(&coin_control);
         }
         isminetype txinIsMine(const CTxIn &txin) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->IsMine(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 m_wallet->GetCredit(txout, filter);
         }
         CoinsList listCoins() override {
             LOCK(m_wallet->cs_wallet);
             CoinsList result;
             for (const auto &entry : m_wallet->ListCoins()) {
                 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 = it->second.GetDepthInMainChain();
                     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);
         }
         OutputType getDefaultChangeType() override {
             return m_wallet->m_default_change_type;
         }
         Amount getDefaultMaxTxFee() override {
             return m_wallet->m_default_max_tx_fee;
         }
         void remove() override { RemoveWallet(m_wallet); }
         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 ChainClient {
     public:
-        WalletClientImpl(Chain &chain,
+        WalletClientImpl(Chain &chain, ArgsManager &args,
                          std::vector<std::string> wallet_filenames)
             : m_wallet_filenames(std::move(wallet_filenames)) {
             m_context.chain = &chain;
+            m_context.args = &args;
         }
 
         void registerRpcs(const Span<const CRPCCommand> &commands) {
             for (const CRPCCommand &command : commands) {
                 m_rpc_commands.emplace_back(
                     command.category, command.name,
                     [this, &command](Config &config,
                                      const JSONRPCRequest &request,
                                      UniValue &result, bool last_handler) {
                         return command.actor(config, {request, m_context},
                                              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());
         }
         bool verify(const CChainParams &chainParams) override {
             return VerifyWallets(chainParams, *m_context.chain,
                                  m_wallet_filenames);
         }
         bool load(const CChainParams &chainParams) override {
             return LoadWallets(chainParams, *m_context.chain,
                                m_wallet_filenames);
         }
         void start(CScheduler &scheduler) override {
-            return StartWallets(scheduler);
+            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); }
         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;
         }
         ~WalletClientImpl() override { UnloadWallets(); }
 
         WalletContext m_context;
-        std::vector<std::string> m_wallet_filenames;
+        const std::vector<std::string> m_wallet_filenames;
         std::vector<std::unique_ptr<Handler>> m_rpc_handlers;
         std::list<CRPCCommand> m_rpc_commands;
     };
 
 } // namespace
 
 std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet> &wallet) {
     return wallet ? std::make_unique<WalletImpl>(wallet) : nullptr;
 }
 
 std::unique_ptr<ChainClient>
-MakeWalletClient(Chain &chain, std::vector<std::string> wallet_filenames) {
-    return std::make_unique<WalletClientImpl>(chain,
+MakeWalletClient(Chain &chain, ArgsManager &args,
+                 std::vector<std::string> wallet_filenames) {
+    return std::make_unique<WalletClientImpl>(chain, args,
                                               std::move(wallet_filenames));
 }
 
 } // namespace interfaces
diff --git a/src/qt/test/apptests.cpp b/src/qt/test/apptests.cpp
index 83900e750..9de57aee9 100644
--- a/src/qt/test/apptests.cpp
+++ b/src/qt/test/apptests.cpp
@@ -1,134 +1,134 @@
 // 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 <qt/test/apptests.h>
 
 #include <chainparams.h>
 #include <config.h>
 #include <httprpc.h>
 #include <key.h>
 #include <qt/bitcoin.h>
 #include <qt/bitcoingui.h>
 #include <qt/networkstyle.h>
 #include <qt/rpcconsole.h>
 #include <rpc/server.h>
 #include <shutdown.h>
 #include <util/ref.h>
 #include <validation.h>
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <test/util/setup_common.h>
 
 #include <univalue.h>
 
 #include <QAction>
 #include <QEventLoop>
 #include <QLineEdit>
 #include <QScopedPointer>
 #include <QTest>
 #include <QTextEdit>
 #include <QtGlobal>
 #include <QtTest/QtTestGui>
 #include <QtTest/QtTestWidgets>
 
 namespace {
 //! Call getblockchaininfo RPC and check first field of JSON output.
 void TestRpcCommand(RPCConsole *console) {
     QEventLoop loop;
     QTextEdit *messagesWidget =
         console->findChild<QTextEdit *>("messagesWidget");
     QObject::connect(messagesWidget, &QTextEdit::textChanged, &loop,
                      &QEventLoop::quit);
     QLineEdit *lineEdit = console->findChild<QLineEdit *>("lineEdit");
     QTest::keyClicks(lineEdit, "getblockchaininfo");
     QTest::keyClick(lineEdit, Qt::Key_Return);
     loop.exec();
     QString output = messagesWidget->toPlainText();
     UniValue value;
     value.read(
         output
             .right(output.size() -
                    output.lastIndexOf(QChar::ObjectReplacementCharacter) - 1)
             .toStdString());
     QCOMPARE(value["chain"].get_str(), std::string("regtest"));
 }
 } // namespace
 
 //! Entry point for BitcoinApplication tests.
 void AppTests::appTests() {
 #ifdef Q_OS_MAC
     if (QApplication::platformName() == "minimal") {
         // Disable for mac on "minimal" platform to avoid crashes inside the Qt
         // framework when it tries to look up unimplemented cocoa functions,
         // and fails to handle returned nulls
         // (https://bugreports.qt.io/browse/QTBUG-49686).
         QWARN("Skipping AppTests on mac build with 'minimal' platform set due "
               "to Qt bugs. To run AppTests, invoke with 'QT_QPA_PLATFORM=cocoa "
               "test_bitcoin-qt' on mac, or else use a linux or windows build.");
         return;
     }
 #endif
 
     Config &config = const_cast<Config &>(GetConfig());
 
     // Create a temp data directory to backup the gui settings to
-    BasicTestingSetup test{CBaseChainParams::REGTEST};
-    // Already started by the common test setup, so stop it to avoid
-    // interference
-    ECC_Stop();
-    LogInstance().DisconnectTestLogger();
+    fs::create_directories([] {
+        BasicTestingSetup test{CBaseChainParams::REGTEST};
+        return GetDataDir() / "blocks";
+    }());
 
     m_app.parameterSetup();
     m_app.createOptionsModel(true /* reset settings */);
     QScopedPointer<const NetworkStyle> style(
         NetworkStyle::instantiate(Params().NetworkIDString()));
     m_app.setupPlatformStyle();
     m_app.createWindow(&config, style.data());
     connect(&m_app, &BitcoinApplication::windowShown, this,
             &AppTests::guiTests);
     expectCallback("guiTests");
     m_app.baseInitialize(config);
 
     RPCServer rpcServer;
-    util::Ref context{test.m_node};
+    util::Ref context;
     HTTPRPCRequestProcessor httpRPCRequestProcessor(config, rpcServer, context);
     m_app.requestInitialize(config, rpcServer, httpRPCRequestProcessor);
     m_app.exec();
     m_app.requestShutdown(config);
     m_app.exec();
 
     // Reset global state to avoid interfering with later tests.
+    LogInstance().DisconnectTestLogger();
     AbortShutdown();
     UnloadBlockIndex();
     WITH_LOCK(::cs_main, g_chainman.Reset());
 }
 
 //! Entry point for BitcoinGUI tests.
 void AppTests::guiTests(BitcoinGUI *window) {
     HandleCallback callback{"guiTests", *this};
     connect(window, &BitcoinGUI::consoleShown, this, &AppTests::consoleTests);
     expectCallback("consoleTests");
     QAction *action = window->findChild<QAction *>("openRPCConsoleAction");
     action->activate(QAction::Trigger);
 }
 
 //! Entry point for RPCConsole tests.
 void AppTests::consoleTests(RPCConsole *console) {
     HandleCallback callback{"consoleTests", *this};
     TestRpcCommand(console);
 }
 
 //! Destructor to shut down after the last expected callback completes.
 AppTests::HandleCallback::~HandleCallback() {
     auto &callbacks = m_app_tests.m_callbacks;
     auto it = callbacks.find(m_callback);
     assert(it != callbacks.end());
     callbacks.erase(it);
     if (callbacks.empty()) {
         m_app_tests.m_app.quit();
     }
 }
diff --git a/src/qt/test/test_main.cpp b/src/qt/test/test_main.cpp
index e1c1792ee..fe1d16517 100644
--- a/src/qt/test/test_main.cpp
+++ b/src/qt/test/test_main.cpp
@@ -1,116 +1,120 @@
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <compat/setenv.h>
 #include <interfaces/node.h>
 #include <key.h>
 
 #include <qt/bitcoin.h>
 #include <qt/test/apptests.h>
 #include <qt/test/bitcoinaddressvalidatortests.h>
 #include <qt/test/compattests.h>
 #include <qt/test/guiutiltests.h>
 #include <qt/test/rpcnestedtests.h>
 #include <qt/test/uritests.h>
 #ifdef ENABLE_WALLET
 #include <qt/test/addressbooktests.h>
 #ifdef ENABLE_BIP70
 #include <qt/test/paymentservertests.h>
 #endif // ENABLE_BIP70
 #include <qt/test/wallettests.h>
 #endif // ENABLE_WALLET
 
 #include <test/util/setup_common.h>
 
 #include <QApplication>
 #include <QObject>
 #include <QTest>
 
 #if defined(QT_STATICPLUGIN)
 #include <QtPlugin>
 #if defined(QT_QPA_PLATFORM_MINIMAL)
 Q_IMPORT_PLUGIN(QMinimalIntegrationPlugin);
 #endif
 #if defined(QT_QPA_PLATFORM_XCB)
 Q_IMPORT_PLUGIN(QXcbIntegrationPlugin);
 #elif defined(QT_QPA_PLATFORM_WINDOWS)
 Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin);
 #elif defined(QT_QPA_PLATFORM_COCOA)
 Q_IMPORT_PLUGIN(QCocoaIntegrationPlugin);
 #endif
 #endif
 
 // This is all you need to run all the tests
 int main(int argc, char *argv[]) {
     // Initialize persistent globals with the testing setup state for sanity.
     // E.g. -datadir in gArgs is set to a temp directory dummy value (instead
     // of defaulting to the default datadir), or globalChainParams is set to
     // regtest params.
     //
     // All tests must use their own testing setup (if needed).
     { BasicTestingSetup dummy{CBaseChainParams::REGTEST}; }
 
     NodeContext node_context;
     std::unique_ptr<interfaces::Node> node =
         interfaces::MakeNode(&node_context);
 
     bool fInvalid = false;
 
     // Prefer the "minimal" platform for the test instead of the normal default
     // platform ("xcb", "windows", or "cocoa") so tests can't unintentionally
     // interfere with any background GUIs and don't require extra resources.
     setenv("QT_QPA_PLATFORM", "minimal", /* overwrite */ 0);
 
     // Don't remove this, it's needed to access
     // QApplication:: and QCoreApplication:: in the tests
     BitcoinApplication app(*node);
     app.setApplicationName("BitcoinABC-Qt-test");
 
+    // Make gArgs available in the NodeContext
+    node->setupServerArgs();
+    // Clear added args again
+    node->context()->args->ClearArgs();
     AppTests app_tests(app);
     if (QTest::qExec(&app_tests) != 0) {
         fInvalid = true;
     }
     URITests test1;
     if (QTest::qExec(&test1) != 0) {
         fInvalid = true;
     }
 #if defined(ENABLE_WALLET) && defined(ENABLE_BIP70)
     PaymentServerTests test2;
     if (QTest::qExec(&test2) != 0) {
         fInvalid = true;
     }
 #endif
     RPCNestedTests test3(*node);
     if (QTest::qExec(&test3) != 0) {
         fInvalid = true;
     }
     CompatTests test4;
     if (QTest::qExec(&test4) != 0) {
         fInvalid = true;
     }
     GUIUtilTests test5;
     if (QTest::qExec(&test5) != 0) {
         fInvalid = true;
     }
     BitcoinAddressValidatorTests test6;
     if (QTest::qExec(&test6) != 0) {
         fInvalid = true;
     }
 #ifdef ENABLE_WALLET
     WalletTests test7(*node);
     if (QTest::qExec(&test7) != 0) {
         fInvalid = true;
     }
     AddressBookTests test8(*node);
     if (QTest::qExec(&test8) != 0) {
         fInvalid = true;
     }
 #endif
 
     return fInvalid;
 }
diff --git a/src/wallet/bdb.cpp b/src/wallet/bdb.cpp
index 8141a723f..566c383a5 100644
--- a/src/wallet/bdb.cpp
+++ b/src/wallet/bdb.cpp
@@ -1,860 +1,859 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2020 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/bdb.h>
 #include <wallet/db.h>
 
 #include <util/strencodings.h>
 #include <util/translation.h>
 
 #include <cstdint>
 #ifndef WIN32
 #include <sys/stat.h>
 #endif
 
 namespace {
 //! Make sure database has a unique fileid within the environment. If it
 //! doesn't, throw an error. BDB caches do not work properly when more than one
 //! open database has the same fileid (values written to one database may show
 //! up in reads to other databases).
 //!
 //! BerkeleyDB generates unique fileids by default
 //! (https://docs.oracle.com/cd/E17275_01/html/programmer_reference/program_copy.html),
 //! so bitcoin should never create different databases with the same fileid, but
 //! this error can be triggered if users manually copy database files.
 void CheckUniqueFileid(const BerkeleyEnvironment &env,
                        const std::string &filename, Db &db,
                        WalletDatabaseFileId &fileid) {
     if (env.IsMock()) {
         return;
     }
 
     int ret = db.get_mpf()->get_fileid(fileid.value);
     if (ret != 0) {
         throw std::runtime_error(strprintf(
             "BerkeleyBatch: Can't open database %s (get_fileid failed with %d)",
             filename, ret));
     }
 
     for (const auto &item : env.m_fileids) {
         if (fileid == item.second && &fileid != &item.second) {
             throw std::runtime_error(strprintf(
                 "BerkeleyBatch: Can't open database %s (duplicates fileid %s "
                 "from %s)",
                 filename,
                 HexStr(std::begin(item.second.value),
                        std::end(item.second.value)),
                 item.first));
         }
     }
 }
 
 RecursiveMutex cs_db;
 
 //! Map from directory name to db environment.
 std::map<std::string, std::weak_ptr<BerkeleyEnvironment>>
     g_dbenvs GUARDED_BY(cs_db);
 } // namespace
 
 bool WalletDatabaseFileId::operator==(const WalletDatabaseFileId &rhs) const {
     return memcmp(value, &rhs.value, sizeof(value)) == 0;
 }
 
 bool IsBDBWalletLoaded(const fs::path &wallet_path) {
     fs::path env_directory;
     std::string database_filename;
     SplitWalletPath(wallet_path, env_directory, database_filename);
 
     LOCK(cs_db);
     auto env = g_dbenvs.find(env_directory.string());
     if (env == g_dbenvs.end()) {
         return false;
     }
 
     auto database = env->second.lock();
     return database && database->IsDatabaseLoaded(database_filename);
 }
 
 /**
  * @param[in] wallet_path Path to wallet directory. Or (for backwards
  * compatibility only) a path to a berkeley btree data file inside a wallet
  * directory.
  * @param[out] database_filename Filename of berkeley btree data file inside the
  * wallet directory.
  * @return A shared pointer to the BerkeleyEnvironment object for the wallet
  * directory, never empty because ~BerkeleyEnvironment erases the weak pointer
  * from the g_dbenvs map.
  * @post A new BerkeleyEnvironment weak pointer is inserted into g_dbenvs if the
  * directory path key was not already in the map.
  */
 std::shared_ptr<BerkeleyEnvironment>
 GetWalletEnv(const fs::path &wallet_path, std::string &database_filename) {
     fs::path env_directory;
     SplitWalletPath(wallet_path, env_directory, database_filename);
     LOCK(cs_db);
     auto inserted = g_dbenvs.emplace(env_directory.string(),
                                      std::weak_ptr<BerkeleyEnvironment>());
     if (inserted.second) {
         auto env =
             std::make_shared<BerkeleyEnvironment>(env_directory.string());
         inserted.first->second = env;
         return env;
     }
     return inserted.first->second.lock();
 }
 
 //
 // BerkeleyBatch
 //
 
 void BerkeleyEnvironment::Close() {
     if (!fDbEnvInit) {
         return;
     }
 
     fDbEnvInit = false;
 
     for (auto &db : m_databases) {
         auto count = mapFileUseCount.find(db.first);
         assert(count == mapFileUseCount.end() || count->second == 0);
         BerkeleyDatabase &database = db.second.get();
         if (database.m_db) {
             database.m_db->close(0);
             database.m_db.reset();
         }
     }
 
     FILE *error_file = nullptr;
     dbenv->get_errfile(&error_file);
 
     int ret = dbenv->close(0);
     if (ret != 0) {
         LogPrintf("BerkeleyEnvironment::Close: Error %d closing database "
                   "environment: %s\n",
                   ret, DbEnv::strerror(ret));
     }
     if (!fMockDb) {
         DbEnv(u_int32_t(0)).remove(strPath.c_str(), 0);
     }
 
     if (error_file) {
         fclose(error_file);
     }
 
     UnlockDirectory(strPath, ".walletlock");
 }
 
 void BerkeleyEnvironment::Reset() {
     dbenv.reset(new DbEnv(DB_CXX_NO_EXCEPTIONS));
     fDbEnvInit = false;
     fMockDb = false;
 }
 
 BerkeleyEnvironment::BerkeleyEnvironment(const fs::path &dir_path)
     : strPath(dir_path.string()) {
     Reset();
 }
 
 BerkeleyEnvironment::~BerkeleyEnvironment() {
     LOCK(cs_db);
     g_dbenvs.erase(strPath);
     Close();
 }
 
 bool BerkeleyEnvironment::Open(bool retry) {
     if (fDbEnvInit) {
         return true;
     }
 
     fs::path pathIn = strPath;
     TryCreateDirectories(pathIn);
     if (!LockDirectory(pathIn, ".walletlock")) {
         LogPrintf("Cannot obtain a lock on wallet directory %s. Another "
                   "instance of bitcoin may be using it.\n",
                   strPath);
         return false;
     }
 
     fs::path pathLogDir = pathIn / "database";
     TryCreateDirectories(pathLogDir);
     fs::path pathErrorFile = pathIn / "db.log";
     LogPrintf("BerkeleyEnvironment::Open: LogDir=%s ErrorFile=%s\n",
               pathLogDir.string(), pathErrorFile.string());
 
     unsigned int nEnvFlags = 0;
     if (gArgs.GetBoolArg("-privdb", DEFAULT_WALLET_PRIVDB)) {
         nEnvFlags |= DB_PRIVATE;
     }
 
     dbenv->set_lg_dir(pathLogDir.string().c_str());
     // 1 MiB should be enough for just the wallet
     dbenv->set_cachesize(0, 0x100000, 1);
     dbenv->set_lg_bsize(0x10000);
     dbenv->set_lg_max(1048576);
     dbenv->set_lk_max_locks(40000);
     dbenv->set_lk_max_objects(40000);
     /// debug
     dbenv->set_errfile(fsbridge::fopen(pathErrorFile, "a"));
     dbenv->set_flags(DB_AUTO_COMMIT, 1);
     dbenv->set_flags(DB_TXN_WRITE_NOSYNC, 1);
     dbenv->log_set_config(DB_LOG_AUTO_REMOVE, 1);
     int ret =
         dbenv->open(strPath.c_str(),
                     DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL |
                         DB_INIT_TXN | DB_THREAD | DB_RECOVER | nEnvFlags,
                     S_IRUSR | S_IWUSR);
     if (ret != 0) {
         LogPrintf("BerkeleyEnvironment::Open: Error %d opening database "
                   "environment: %s\n",
                   ret, DbEnv::strerror(ret));
         int ret2 = dbenv->close(0);
         if (ret2 != 0) {
             LogPrintf("BerkeleyEnvironment::Open: Error %d closing failed "
                       "database environment: %s\n",
                       ret2, DbEnv::strerror(ret2));
         }
         Reset();
         if (retry) {
             // try moving the database env out of the way
             fs::path pathDatabaseBak =
                 pathIn / strprintf("database.%d.bak", GetTime());
             try {
                 fs::rename(pathLogDir, pathDatabaseBak);
                 LogPrintf("Moved old %s to %s. Retrying.\n",
                           pathLogDir.string(), pathDatabaseBak.string());
             } catch (const fs::filesystem_error &) {
                 // failure is ok (well, not really, but it's not worse than what
                 // we started with)
             }
             // try opening it again one more time
             if (!Open(false /* retry */)) {
                 // if it still fails, it probably means we can't even create the
                 // database env
                 return false;
             }
         } else {
             return false;
         }
     }
 
     fDbEnvInit = true;
     fMockDb = false;
     return true;
 }
 
 //! Construct an in-memory mock Berkeley environment for testing
 BerkeleyEnvironment::BerkeleyEnvironment() {
     Reset();
 
     LogPrint(BCLog::WALLETDB, "BerkeleyEnvironment::MakeMock\n");
 
     dbenv->set_cachesize(1, 0, 1);
     dbenv->set_lg_bsize(10485760 * 4);
     dbenv->set_lg_max(10485760);
     dbenv->set_lk_max_locks(10000);
     dbenv->set_lk_max_objects(10000);
     dbenv->set_flags(DB_AUTO_COMMIT, 1);
     dbenv->log_set_config(DB_LOG_IN_MEMORY, 1);
     int ret =
         dbenv->open(nullptr,
                     DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL |
                         DB_INIT_TXN | DB_THREAD | DB_PRIVATE,
                     S_IRUSR | S_IWUSR);
     if (ret > 0) {
         throw std::runtime_error(
             strprintf("BerkeleyEnvironment::MakeMock: Error %d opening "
                       "database environment.",
                       ret));
     }
 
     fDbEnvInit = true;
     fMockDb = true;
 }
 
 bool BerkeleyEnvironment::Verify(const std::string &strFile) {
     LOCK(cs_db);
     assert(mapFileUseCount.count(strFile) == 0);
 
     Db db(dbenv.get(), 0);
     int result = db.verify(strFile.c_str(), nullptr, nullptr, 0);
     return result == 0;
 }
 
 BerkeleyBatch::SafeDbt::SafeDbt() {
     m_dbt.set_flags(DB_DBT_MALLOC);
 }
 
 BerkeleyBatch::SafeDbt::SafeDbt(void *data, size_t size) : m_dbt(data, size) {}
 
 BerkeleyBatch::SafeDbt::~SafeDbt() {
     if (m_dbt.get_data() != nullptr) {
         // Clear memory, e.g. in case it was a private key
         memory_cleanse(m_dbt.get_data(), m_dbt.get_size());
         // under DB_DBT_MALLOC, data is malloced by the Dbt, but must be
         // freed by the caller.
         // https://docs.oracle.com/cd/E17275_01/html/api_reference/C/dbt.html
         if (m_dbt.get_flags() & DB_DBT_MALLOC) {
             free(m_dbt.get_data());
         }
     }
 }
 
 const void *BerkeleyBatch::SafeDbt::get_data() const {
     return m_dbt.get_data();
 }
 
 u_int32_t BerkeleyBatch::SafeDbt::get_size() const {
     return m_dbt.get_size();
 }
 
 BerkeleyBatch::SafeDbt::operator Dbt *() {
     return &m_dbt;
 }
 
 bool BerkeleyDatabase::Verify(bilingual_str &errorStr) {
     fs::path walletDir = env->Directory();
     fs::path file_path = walletDir / strFile;
 
     LogPrintf("Using BerkeleyDB version %s\n",
               DbEnv::version(nullptr, nullptr, nullptr));
     LogPrintf("Using wallet %s\n", file_path.string());
 
     if (!env->Open(true /* retry */)) {
         errorStr = strprintf(
             _("Error initializing wallet database environment %s!"), walletDir);
         return false;
     }
 
     if (fs::exists(file_path)) {
         if (!env->Verify(strFile)) {
             errorStr =
                 strprintf(_("%s corrupt. Try using the wallet tool "
                             "bitcoin-wallet to salvage or restoring a backup."),
                           file_path);
             return false;
         }
     }
     // also return true if files does not exists
     return true;
 }
 
 void BerkeleyEnvironment::CheckpointLSN(const std::string &strFile) {
     dbenv->txn_checkpoint(0, 0, 0);
     if (fMockDb) {
         return;
     }
     dbenv->lsn_reset(strFile.c_str(), 0);
 }
 
 BerkeleyBatch::BerkeleyBatch(BerkeleyDatabase &database, const char *pszMode,
                              bool fFlushOnCloseIn)
     : pdb(nullptr), activeTxn(nullptr) {
     fReadOnly = (!strchr(pszMode, '+') && !strchr(pszMode, 'w'));
     fFlushOnClose = fFlushOnCloseIn;
     env = database.env.get();
     if (database.IsDummy()) {
         return;
     }
 
     const std::string &strFilename = database.strFile;
 
     bool fCreate = strchr(pszMode, 'c') != nullptr;
     unsigned int nFlags = DB_THREAD;
     if (fCreate) {
         nFlags |= DB_CREATE;
     }
 
     {
         LOCK(cs_db);
         if (!env->Open(false /* retry */)) {
             throw std::runtime_error(
                 "BerkeleyBatch: Failed to open database environment.");
         }
 
         pdb = database.m_db.get();
         if (pdb == nullptr) {
             int ret;
             std::unique_ptr<Db> pdb_temp =
                 std::make_unique<Db>(env->dbenv.get(), 0);
 
             bool fMockDb = env->IsMock();
             if (fMockDb) {
                 DbMpoolFile *mpf = pdb_temp->get_mpf();
                 ret = mpf->set_flags(DB_MPOOL_NOFILE, 1);
                 if (ret != 0) {
                     throw std::runtime_error(
                         strprintf("BerkeleyBatch: Failed to configure for no "
                                   "temp file backing for database %s",
                                   strFilename));
                 }
             }
 
             ret = pdb_temp->open(
                 nullptr,                                 // Txn pointer
                 fMockDb ? nullptr : strFilename.c_str(), // Filename
                 fMockDb ? strFilename.c_str() : "main",  // Logical db name
                 DB_BTREE,                                // Database type
                 nFlags,                                  // Flags
                 0);
 
             if (ret != 0) {
                 throw std::runtime_error(
                     strprintf("BerkeleyBatch: Error %d, can't open database %s",
                               ret, strFilename));
             }
 
             // Call CheckUniqueFileid on the containing BDB environment to
             // avoid BDB data consistency bugs that happen when different data
             // files in the same environment have the same fileid.
             //
             // Also call CheckUniqueFileid on all the other g_dbenvs to prevent
             // bitcoin from opening the same data file through another
             // environment when the file is referenced through equivalent but
             // not obviously identical symlinked or hard linked or bind mounted
             // paths. In the future a more relaxed check for equal inode and
             // device ids could be done instead, which would allow opening
             // different backup copies of a wallet at the same time. Maybe even
             // more ideally, an exclusive lock for accessing the database could
             // be implemented, so no equality checks are needed at all. (Newer
             // versions of BDB have an set_lk_exclusive method for this
             // purpose, but the older version we use does not.)
             for (const auto &dbenv : g_dbenvs) {
                 CheckUniqueFileid(*dbenv.second.lock().get(), strFilename,
                                   *pdb_temp, this->env->m_fileids[strFilename]);
             }
 
             pdb = pdb_temp.release();
             database.m_db.reset(pdb);
 
             if (fCreate && !Exists(std::string("version"))) {
                 bool fTmp = fReadOnly;
                 fReadOnly = false;
                 Write(std::string("version"), CLIENT_VERSION);
                 fReadOnly = fTmp;
             }
         }
         ++env->mapFileUseCount[strFilename];
         strFile = strFilename;
     }
 }
 
 void BerkeleyBatch::Flush() {
     if (activeTxn) {
         return;
     }
 
     // Flush database activity from memory pool to disk log
     unsigned int nMinutes = 0;
     if (fReadOnly) {
         nMinutes = 1;
     }
 
     // env is nullptr for dummy databases (i.e. in tests). Don't actually flush
     // if env is nullptr so we don't segfault
     if (env) {
         env->dbenv->txn_checkpoint(
             nMinutes
                 ? gArgs.GetArg("-dblogsize", DEFAULT_WALLET_DBLOGSIZE) * 1024
                 : 0,
             nMinutes, 0);
     }
 }
 
 void BerkeleyDatabase::IncrementUpdateCounter() {
     ++nUpdateCounter;
 }
 
 void BerkeleyBatch::Close() {
     if (!pdb) {
         return;
     }
     if (activeTxn) {
         activeTxn->abort();
     }
     activeTxn = nullptr;
     pdb = nullptr;
 
     if (fFlushOnClose) {
         Flush();
     }
 
     {
         LOCK(cs_db);
         --env->mapFileUseCount[strFile];
     }
     env->m_db_in_use.notify_all();
 }
 
 void BerkeleyEnvironment::CloseDb(const std::string &strFile) {
     LOCK(cs_db);
     auto it = m_databases.find(strFile);
     assert(it != m_databases.end());
     BerkeleyDatabase &database = it->second.get();
     if (database.m_db) {
         // Close the database handle
         database.m_db->close(0);
         database.m_db.reset();
     }
 }
 
 void BerkeleyEnvironment::ReloadDbEnv() {
     // Make sure that no Db's are in use
     AssertLockNotHeld(cs_db);
     std::unique_lock<RecursiveMutex> lock(cs_db);
     m_db_in_use.wait(lock, [this]() {
         for (auto &count : mapFileUseCount) {
             if (count.second > 0) {
                 return false;
             }
         }
         return true;
     });
 
     std::vector<std::string> filenames;
     for (auto it : m_databases) {
         filenames.push_back(it.first);
     }
     // Close the individual Db's
     for (const std::string &filename : filenames) {
         CloseDb(filename);
     }
     // Reset the environment
     // This will flush and close the environment
     Flush(true);
     Reset();
     Open(true);
 }
 
 bool BerkeleyDatabase::Rewrite(const char *pszSkip) {
     if (IsDummy()) {
         return true;
     }
     while (true) {
         {
             LOCK(cs_db);
             if (!env->mapFileUseCount.count(strFile) ||
                 env->mapFileUseCount[strFile] == 0) {
                 // Flush log data to the dat file
                 env->CloseDb(strFile);
                 env->CheckpointLSN(strFile);
                 env->mapFileUseCount.erase(strFile);
 
                 bool fSuccess = true;
                 LogPrintf("BerkeleyBatch::Rewrite: Rewriting %s...\n", strFile);
                 std::string strFileRes = strFile + ".rewrite";
                 { // surround usage of db with extra {}
                     BerkeleyBatch db(*this, "r");
                     std::unique_ptr<Db> pdbCopy =
                         std::make_unique<Db>(env->dbenv.get(), 0);
 
                     int ret = pdbCopy->open(nullptr,            // Txn pointer
                                             strFileRes.c_str(), // Filename
                                             "main",    // Logical db name
                                             DB_BTREE,  // Database type
                                             DB_CREATE, // Flags
                                             0);
                     if (ret > 0) {
                         LogPrintf("BerkeleyBatch::Rewrite: Can't create "
                                   "database file %s\n",
                                   strFileRes);
                         fSuccess = false;
                     }
 
                     Dbc *pcursor = db.GetCursor();
                     if (pcursor) {
                         while (fSuccess) {
                             CDataStream ssKey(SER_DISK, CLIENT_VERSION);
                             CDataStream ssValue(SER_DISK, CLIENT_VERSION);
                             int ret1 = db.ReadAtCursor(pcursor, ssKey, ssValue);
                             if (ret1 == DB_NOTFOUND) {
                                 pcursor->close();
                                 break;
                             }
                             if (ret1 != 0) {
                                 pcursor->close();
                                 fSuccess = false;
                                 break;
                             }
                             if (pszSkip &&
                                 strncmp(ssKey.data(), pszSkip,
                                         std::min(ssKey.size(),
                                                  strlen(pszSkip))) == 0) {
                                 continue;
                             }
                             if (strncmp(ssKey.data(), "\x07version", 8) == 0) {
                                 // Update version:
                                 ssValue.clear();
                                 ssValue << CLIENT_VERSION;
                             }
                             Dbt datKey(ssKey.data(), ssKey.size());
                             Dbt datValue(ssValue.data(), ssValue.size());
                             int ret2 = pdbCopy->put(nullptr, &datKey, &datValue,
                                                     DB_NOOVERWRITE);
                             if (ret2 > 0) {
                                 fSuccess = false;
                             }
                         }
                     }
                     if (fSuccess) {
                         db.Close();
                         env->CloseDb(strFile);
                         if (pdbCopy->close(0)) {
                             fSuccess = false;
                         }
                     } else {
                         pdbCopy->close(0);
                     }
                 }
                 if (fSuccess) {
                     Db dbA(env->dbenv.get(), 0);
                     if (dbA.remove(strFile.c_str(), nullptr, 0)) {
                         fSuccess = false;
                     }
                     Db dbB(env->dbenv.get(), 0);
                     if (dbB.rename(strFileRes.c_str(), nullptr, strFile.c_str(),
                                    0)) {
                         fSuccess = false;
                     }
                 }
                 if (!fSuccess) {
                     LogPrintf("BerkeleyBatch::Rewrite: Failed to rewrite "
                               "database file %s\n",
                               strFileRes);
                 }
                 return fSuccess;
             }
         }
         UninterruptibleSleep(std::chrono::milliseconds{100});
     }
 }
 
 void BerkeleyEnvironment::Flush(bool fShutdown) {
     int64_t nStart = GetTimeMillis();
     // Flush log data to the actual data file on all files that are not in use
     LogPrint(BCLog::WALLETDB, "BerkeleyEnvironment::Flush: [%s] Flush(%s)%s\n",
              strPath, fShutdown ? "true" : "false",
              fDbEnvInit ? "" : " database not started");
     if (!fDbEnvInit) {
         return;
     }
     {
         LOCK(cs_db);
         std::map<std::string, int>::iterator mi = mapFileUseCount.begin();
         while (mi != mapFileUseCount.end()) {
             std::string strFile = (*mi).first;
             int nRefCount = (*mi).second;
             LogPrint(
                 BCLog::WALLETDB,
                 "BerkeleyEnvironment::Flush: Flushing %s (refcount = %d)...\n",
                 strFile, nRefCount);
             if (nRefCount == 0) {
                 // Move log data to the dat file
                 CloseDb(strFile);
                 LogPrint(BCLog::WALLETDB,
                          "BerkeleyEnvironment::Flush: %s checkpoint\n",
                          strFile);
                 dbenv->txn_checkpoint(0, 0, 0);
                 LogPrint(BCLog::WALLETDB,
                          "BerkeleyEnvironment::Flush: %s detach\n", strFile);
                 if (!fMockDb) {
                     dbenv->lsn_reset(strFile.c_str(), 0);
                 }
                 LogPrint(BCLog::WALLETDB,
                          "BerkeleyEnvironment::Flush: %s closed\n", strFile);
                 mapFileUseCount.erase(mi++);
             } else {
                 mi++;
             }
         }
         LogPrint(BCLog::WALLETDB,
                  "BerkeleyEnvironment::Flush: Flush(%s)%s took %15dms\n",
                  fShutdown ? "true" : "false",
                  fDbEnvInit ? "" : " database not started",
                  GetTimeMillis() - nStart);
         if (fShutdown) {
             char **listp;
             if (mapFileUseCount.empty()) {
                 dbenv->log_archive(&listp, DB_ARCH_REMOVE);
                 Close();
                 if (!fMockDb) {
                     fs::remove_all(fs::path(strPath) / "database");
                 }
             }
         }
     }
 }
 
 bool BerkeleyDatabase::PeriodicFlush() {
     // There's nothing to do for dummy databases. Return true.
     if (IsDummy()) {
         return true;
     }
 
     // Don't flush if we can't acquire the lock.
     TRY_LOCK(cs_db, lockDb);
     if (!lockDb) {
         return false;
     }
 
     // Don't flush if any databases are in use
-    for (auto it = env->mapFileUseCount.begin();
-         it != env->mapFileUseCount.end(); it++) {
-        if ((*it).second > 0) {
+    for (const auto &use_count : env->mapFileUseCount) {
+        if (use_count.second > 0) {
             return false;
         }
     }
 
     // Don't flush if there haven't been any batch writes for this database.
     auto it = env->mapFileUseCount.find(strFile);
     if (it == env->mapFileUseCount.end()) {
         return false;
     }
 
     LogPrint(BCLog::WALLETDB, "Flushing %s\n", strFile);
     int64_t nStart = GetTimeMillis();
 
     // Flush wallet file so it's self contained
     env->CloseDb(strFile);
     env->CheckpointLSN(strFile);
     env->mapFileUseCount.erase(it);
 
     LogPrint(BCLog::WALLETDB, "Flushed %s %dms\n", strFile,
              GetTimeMillis() - nStart);
 
     return true;
 }
 
 bool BerkeleyDatabase::Backup(const std::string &strDest) const {
     if (IsDummy()) {
         return false;
     }
     while (true) {
         {
             LOCK(cs_db);
             if (!env->mapFileUseCount.count(strFile) ||
                 env->mapFileUseCount[strFile] == 0) {
                 // Flush log data to the dat file
                 env->CloseDb(strFile);
                 env->CheckpointLSN(strFile);
                 env->mapFileUseCount.erase(strFile);
 
                 // Copy wallet file.
                 fs::path pathSrc = env->Directory() / strFile;
                 fs::path pathDest(strDest);
                 if (fs::is_directory(pathDest)) {
                     pathDest /= strFile;
                 }
 
                 try {
                     if (fs::equivalent(pathSrc, pathDest)) {
                         LogPrintf("cannot backup to wallet source file %s\n",
                                   pathDest.string());
                         return false;
                     }
 
                     fs::copy_file(pathSrc, pathDest,
                                   fs::copy_option::overwrite_if_exists);
                     LogPrintf("copied %s to %s\n", strFile, pathDest.string());
                     return true;
                 } catch (const fs::filesystem_error &e) {
                     LogPrintf("error copying %s to %s - %s\n", strFile,
                               pathDest.string(),
                               fsbridge::get_filesystem_error_message(e));
                     return false;
                 }
             }
         }
         UninterruptibleSleep(std::chrono::milliseconds{100});
     }
 }
 
 void BerkeleyDatabase::Flush(bool shutdown) {
     if (!IsDummy()) {
         env->Flush(shutdown);
         if (shutdown) {
             LOCK(cs_db);
             g_dbenvs.erase(env->Directory().string());
             env = nullptr;
         } else {
             // TODO: To avoid g_dbenvs.erase erasing the environment prematurely
             // after the first database shutdown when multiple databases are
             // open in the same environment, should replace raw database `env`
             // pointers with shared or weak pointers, or else separate the
             // database and environment shutdowns so environments can be shut
             // down after databases.
             env->m_fileids.erase(strFile);
         }
     }
 }
 
 void BerkeleyDatabase::ReloadDbEnv() {
     if (!IsDummy()) {
         env->ReloadDbEnv();
     }
 }
 
 Dbc *BerkeleyBatch::GetCursor() {
     if (!pdb) {
         return nullptr;
     }
     Dbc *pcursor = nullptr;
     int ret = pdb->cursor(nullptr, &pcursor, 0);
     if (ret != 0) {
         return nullptr;
     }
     return pcursor;
 }
 
 int BerkeleyBatch::ReadAtCursor(Dbc *pcursor, CDataStream &ssKey,
                                 CDataStream &ssValue) {
     // Read at cursor
     SafeDbt datKey;
     SafeDbt datValue;
     int ret = pcursor->get(datKey, datValue, DB_NEXT);
     if (ret != 0) {
         return ret;
     } else if (datKey.get_data() == nullptr || datValue.get_data() == nullptr) {
         return 99999;
     }
 
     // Convert to streams
     ssKey.SetType(SER_DISK);
     ssKey.clear();
     ssKey.write((char *)datKey.get_data(), datKey.get_size());
     ssValue.SetType(SER_DISK);
     ssValue.clear();
     ssValue.write((char *)datValue.get_data(), datValue.get_size());
     return 0;
 }
 
 bool BerkeleyBatch::TxnBegin() {
     if (!pdb || activeTxn) {
         return false;
     }
     DbTxn *ptxn = env->TxnBegin();
     if (!ptxn) {
         return false;
     }
     activeTxn = ptxn;
     return true;
 }
 
 bool BerkeleyBatch::TxnCommit() {
     if (!pdb || !activeTxn) {
         return false;
     }
     int ret = activeTxn->commit(0);
     activeTxn = nullptr;
     return (ret == 0);
 }
 
 bool BerkeleyBatch::TxnAbort() {
     if (!pdb || !activeTxn) {
         return false;
     }
     int ret = activeTxn->abort();
     activeTxn = nullptr;
     return (ret == 0);
 }
diff --git a/src/wallet/context.h b/src/wallet/context.h
index 26543b31e..3a9b4ddd5 100644
--- a/src/wallet/context.h
+++ b/src/wallet/context.h
@@ -1,32 +1,34 @@
 // Copyright (c) 2020 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_CONTEXT_H
 #define BITCOIN_WALLET_CONTEXT_H
 
+class ArgsManager;
 namespace interfaces {
 class Chain;
 } // namespace interfaces
 
 //! WalletContext struct containing references to state shared between CWallet
 //! instances, like the reference to the chain interface, and the list of opened
 //! wallets.
 //!
 //! Future shared state can be added here as an alternative to adding global
 //! variables.
 //!
 //! The struct isn't intended to have any member functions. It should just be a
 //! collection of state pointers that doesn't pull in dependencies or implement
 //! behavior.
 struct WalletContext {
     interfaces::Chain *chain{nullptr};
+    ArgsManager *args{nullptr};
 
     //! Declare default constructor and destructor that are not inline, so code
     //! instantiating the WalletContext struct doesn't need to #include class
     //! definitions for smart pointer and container members.
     WalletContext();
     ~WalletContext();
 };
 
 #endif // BITCOIN_WALLET_CONTEXT_H
diff --git a/src/wallet/init.cpp b/src/wallet/init.cpp
index befd0abde..a5607133c 100644
--- a/src/wallet/init.cpp
+++ b/src/wallet/init.cpp
@@ -1,226 +1,228 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2017 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.
 
 #include <config.h>
 #include <init.h>
 #include <interfaces/chain.h>
 #include <net.h>
 #include <network.h>
 #include <node/context.h>
 #include <ui_interface.h>
+#include <util/check.h>
 #include <util/moneystr.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/rpcdump.h>
 #include <wallet/wallet.h>
 #include <walletinitinterface.h>
 
 class WalletInit : public WalletInitInterface {
 public:
     //! Was the wallet component compiled in.
     bool HasWalletSupport() const override { return true; }
 
     //! Return the wallets help message.
     void AddWalletOptions() const override;
 
     //! Wallets parameter interaction
     bool ParameterInteraction() const override;
 
     //! Add wallets that should be opened to list of chain clients.
     void Construct(NodeContext &node) const override;
 };
 
 const WalletInitInterface &g_wallet_init_interface = WalletInit();
 
 void WalletInit::AddWalletOptions() const {
     gArgs.AddArg(
         "-avoidpartialspends",
         strprintf("Group outputs by address, selecting all or none, instead of "
                   "selecting on a per-output basis. Privacy is improved as an "
                   "address is only used once (unless someone sends to it after "
                   "spending from it), but may result in slightly higher fees "
                   "as suboptimal coin selection may result due to the added "
                   "limitation (default: %u (always enabled for wallets with "
                   "\"avoid_reuse\" enabled))",
                   DEFAULT_AVOIDPARTIALSPENDS),
         ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
 
     gArgs.AddArg("-disablewallet",
                  "Do not load the wallet and disable wallet RPC calls",
                  ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     gArgs.AddArg("-fallbackfee=<amt>",
                  strprintf("A fee rate (in %s/kB) that will be used when fee "
                            "estimation has insufficient data. 0 to entirely "
                            "disable the fallbackfee feature. (default: %s)",
                            CURRENCY_UNIT, FormatMoney(DEFAULT_FALLBACK_FEE)),
                  ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     gArgs.AddArg(
         "-keypool=<n>",
         strprintf("Set key pool size to <n> (default: %u). Warning: Smaller "
                   "sizes may increase the risk of losing funds when restoring "
                   "from an old backup, if none of the addresses in the "
                   "original keypool have been used.",
                   DEFAULT_KEYPOOL_SIZE),
         ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     gArgs.AddArg(
         "-maxapsfee=<n>",
         strprintf(
             "Spend up to this amount in additional (absolute) fees (in %s) if "
             "it allows the use of partial spend avoidance (default: %s)",
             CURRENCY_UNIT, FormatMoney(DEFAULT_MAX_AVOIDPARTIALSPEND_FEE)),
         ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     gArgs.AddArg(
         "-maxtxfee=<amt>",
         strprintf("Maximum total fees (in %s) to use in a single wallet "
                   "transaction or raw transaction; setting this too low may "
                   "abort large transactions (default: %s)",
                   CURRENCY_UNIT, FormatMoney(DEFAULT_TRANSACTION_MAXFEE)),
         ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-mintxfee=<amt>",
                  strprintf("Fees (in %s/kB) smaller than this are considered "
                            "zero fee for transaction creation (default: %s)",
                            CURRENCY_UNIT,
                            FormatMoney(DEFAULT_TRANSACTION_MINFEE_PER_KB)),
                  ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     gArgs.AddArg(
         "-paytxfee=<amt>",
         strprintf(
             "Fee (in %s/kB) to add to transactions you send (default: %s)",
             CURRENCY_UNIT,
             FormatMoney(CFeeRate{DEFAULT_PAY_TX_FEE}.GetFeePerK())),
         ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     gArgs.AddArg(
         "-rescan",
         "Rescan the block chain for missing wallet transactions on startup",
         ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     gArgs.AddArg(
         "-spendzeroconfchange",
         strprintf(
             "Spend unconfirmed change when sending transactions (default: %d)",
             DEFAULT_SPEND_ZEROCONF_CHANGE),
         ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     gArgs.AddArg("-wallet=<path>",
                  "Specify wallet database path. Can be specified multiple "
                  "times to load multiple wallets. Path is interpreted relative "
                  "to <walletdir> if it is not absolute, and will be created if "
                  "it does not exist (as a directory containing a wallet.dat "
                  "file and log files). For backwards compatibility this will "
                  "also accept names of existing data files in <walletdir>.)",
                  ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
                  OptionsCategory::WALLET);
     gArgs.AddArg(
         "-walletbroadcast",
         strprintf("Make the wallet broadcast transactions (default: %d)",
                   DEFAULT_WALLETBROADCAST),
         ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     gArgs.AddArg("-walletdir=<dir>",
                  "Specify directory to hold wallets (default: "
                  "<datadir>/wallets if it exists, otherwise <datadir>)",
                  ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
                  OptionsCategory::WALLET);
 #if defined(HAVE_SYSTEM)
     gArgs.AddArg("-walletnotify=<cmd>",
                  "Execute command when a wallet transaction changes. %s in cmd "
                  "is replaced by TxID and %w is replaced by wallet name. %w is "
                  "not currently implemented on windows. On systems where %w is "
                  "supported, it should NOT be quoted because this would break "
                  "shell escaping used to invoke the command.",
                  ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
 #endif
     gArgs.AddArg(
         "-zapwallettxes=<mode>",
         "Delete all wallet transactions and only recover those parts of the "
         "blockchain through -rescan on startup (1 = keep tx meta data e.g. "
         "payment request information, 2 = drop tx meta data)",
         ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
 
     gArgs.AddArg("-dblogsize=<n>",
                  strprintf("Flush wallet database activity from memory to disk "
                            "log every <n> megabytes (default: %u)",
                            DEFAULT_WALLET_DBLOGSIZE),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::WALLET_DEBUG_TEST);
     gArgs.AddArg(
         "-flushwallet",
         strprintf("Run a thread to flush wallet periodically (default: %d)",
                   DEFAULT_FLUSHWALLET),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::WALLET_DEBUG_TEST);
     gArgs.AddArg("-privdb",
                  strprintf("Sets the DB_PRIVATE flag in the wallet db "
                            "environment (default: %d)",
                            DEFAULT_WALLET_PRIVDB),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::WALLET_DEBUG_TEST);
     gArgs.AddArg("-walletrejectlongchains",
                  strprintf("Wallet will not create transactions that violate "
                            "mempool chain limits (default: %d)",
                            DEFAULT_WALLET_REJECT_LONG_CHAINS),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::WALLET_DEBUG_TEST);
 }
 
 bool WalletInit::ParameterInteraction() const {
     if (gArgs.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET)) {
         for (const std::string &wallet : gArgs.GetArgs("-wallet")) {
             LogPrintf("%s: parameter interaction: -disablewallet -> ignoring "
                       "-wallet=%s\n",
                       __func__, wallet);
         }
 
         return true;
     }
 
     const bool is_multiwallet = gArgs.GetArgs("-wallet").size() > 1;
 
     if (gArgs.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY) &&
         gArgs.SoftSetBoolArg("-walletbroadcast", false)) {
         LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting "
                   "-walletbroadcast=0\n",
                   __func__);
     }
 
     bool zapwallettxes = gArgs.GetBoolArg("-zapwallettxes", false);
     // -zapwallettxes implies dropping the mempool on startup
     if (zapwallettxes && gArgs.SoftSetBoolArg("-persistmempool", false)) {
         LogPrintf("%s: parameter interaction: -zapwallettxes enabled -> "
                   "setting -persistmempool=0\n",
                   __func__);
     }
 
     // -zapwallettxes implies a rescan
     if (zapwallettxes) {
         if (is_multiwallet) {
             return InitError(strprintf(
                 Untranslated("%s is only allowed with a single wallet file"),
                 "-zapwallettxes"));
         }
         if (gArgs.SoftSetBoolArg("-rescan", true)) {
             LogPrintf("%s: parameter interaction: -zapwallettxes enabled -> "
                       "setting -rescan=1\n",
                       __func__);
         }
     }
 
     if (gArgs.GetBoolArg("-sysperms", false)) {
         return InitError(
             Untranslated("-sysperms is not allowed in combination with enabled "
                          "wallet functionality"));
     }
 
     return true;
 }
 
 void WalletInit::Construct(NodeContext &node) const {
-    if (gArgs.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET)) {
+    ArgsManager &args = *Assert(node.args);
+    if (args.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET)) {
         LogPrintf("Wallet disabled!\n");
         return;
     }
-    gArgs.SoftSetArg("-wallet", "");
-    node.chain_clients.emplace_back(
-        interfaces::MakeWalletClient(*node.chain, gArgs.GetArgs("-wallet")));
+    args.SoftSetArg("-wallet", "");
+    node.chain_clients.emplace_back(interfaces::MakeWalletClient(
+        *node.chain, args, args.GetArgs("-wallet")));
 }
diff --git a/src/wallet/load.cpp b/src/wallet/load.cpp
index cc83424a8..2802e670d 100644
--- a/src/wallet/load.cpp
+++ b/src/wallet/load.cpp
@@ -1,137 +1,140 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <wallet/load.h>
 
 #include <interfaces/chain.h>
 #include <scheduler.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <wallet/wallet.h>
+#include <wallet/walletdb.h>
 
 bool VerifyWallets(const CChainParams &chainParams, interfaces::Chain &chain,
                    const std::vector<std::string> &wallet_files) {
     if (gArgs.IsArgSet("-walletdir")) {
         fs::path wallet_dir = gArgs.GetArg("-walletdir", "");
         boost::system::error_code error;
         // The canonical path cleans the path, preventing >1 Berkeley
         // environment instances for the same directory
         fs::path canonical_wallet_dir = fs::canonical(wallet_dir, error);
         if (error || !fs::exists(wallet_dir)) {
             chain.initError(
                 strprintf(_("Specified -walletdir \"%s\" does not exist"),
                           wallet_dir.string()));
             return false;
         } else if (!fs::is_directory(wallet_dir)) {
             chain.initError(
                 strprintf(_("Specified -walletdir \"%s\" is not a directory"),
                           wallet_dir.string()));
             return false;
             // The canonical path transforms relative paths into absolute ones,
             // so we check the non-canonical version
         } else if (!wallet_dir.is_absolute()) {
             chain.initError(
                 strprintf(_("Specified -walletdir \"%s\" is a relative path"),
                           wallet_dir.string()));
             return false;
         }
         gArgs.ForceSetArg("-walletdir", canonical_wallet_dir.string());
     }
 
     LogPrintf("Using wallet directory %s\n", GetWalletDir().string());
 
     chain.initMessage(_("Verifying wallet(s)...").translated);
 
     // Keep track of each wallet absolute path to detect duplicates.
     std::set<fs::path> wallet_paths;
 
     for (const auto &wallet_file : wallet_files) {
         WalletLocation location(wallet_file);
 
         if (!wallet_paths.insert(location.GetPath()).second) {
             chain.initError(strprintf(_("Error loading wallet %s. Duplicate "
                                         "-wallet filename specified."),
                                       wallet_file));
             return false;
         }
 
         bilingual_str error_string;
         std::vector<bilingual_str> warnings;
         bool verify_success = CWallet::Verify(chainParams, chain, location,
                                               error_string, warnings);
         if (!warnings.empty()) {
             chain.initWarning(Join(warnings, "\n", OpTranslated));
         }
         if (!verify_success) {
             chain.initError(error_string);
             return false;
         }
     }
 
     return true;
 }
 
 bool LoadWallets(const CChainParams &chainParams, interfaces::Chain &chain,
                  const std::vector<std::string> &wallet_files) {
     for (const std::string &walletFile : wallet_files) {
         bilingual_str error;
         std::vector<bilingual_str> warnings;
         std::shared_ptr<CWallet> pwallet = CWallet::CreateWalletFromFile(
             chainParams, chain, WalletLocation(walletFile), error, warnings);
         if (!warnings.empty()) {
             chain.initWarning(Join(warnings, "\n", OpTranslated));
         }
         if (!pwallet) {
             chain.initError(error);
             return false;
         }
         AddWallet(pwallet);
     }
 
     return true;
 }
 
-void StartWallets(CScheduler &scheduler) {
+void StartWallets(CScheduler &scheduler, const ArgsManager &args) {
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         pwallet->postInitProcess();
     }
 
     // Schedule periodic wallet flushes and tx rebroadcasts
-    scheduler.scheduleEvery(
-        [] {
-            MaybeCompactWalletDB();
-            return true;
-        },
-        std::chrono::milliseconds{500});
+    if (args.GetBoolArg("-flushwallet", DEFAULT_FLUSHWALLET)) {
+        scheduler.scheduleEvery(
+            [] {
+                MaybeCompactWalletDB();
+                return true;
+            },
+            std::chrono::milliseconds{500});
+    }
     scheduler.scheduleEvery(
         [] {
             MaybeResendWalletTxs();
             return true;
         },
         std::chrono::milliseconds{1000});
 }
 
 void FlushWallets() {
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         pwallet->Flush(false);
     }
 }
 
 void StopWallets() {
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         pwallet->Flush(true);
     }
 }
 
 void UnloadWallets() {
     auto wallets = GetWallets();
     while (!wallets.empty()) {
         auto wallet = wallets.back();
         wallets.pop_back();
         RemoveWallet(wallet);
         UnloadWallet(std::move(wallet));
     }
 }
diff --git a/src/wallet/load.h b/src/wallet/load.h
index 5630f9340..8660be7e1 100644
--- a/src/wallet/load.h
+++ b/src/wallet/load.h
@@ -1,40 +1,41 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_WALLET_LOAD_H
 #define BITCOIN_WALLET_LOAD_H
 
 #include <string>
 #include <vector>
 
+class ArgsManager;
 class CChainParams;
 class CScheduler;
 
 namespace interfaces {
 class Chain;
 } // namespace interfaces
 
 //! Responsible for reading and validating the -wallet arguments and verifying
 //! the wallet database.
 bool VerifyWallets(const CChainParams &chainParams, interfaces::Chain &chain,
                    const std::vector<std::string> &wallet_files);
 
 //! Load wallet databases.
 bool LoadWallets(const CChainParams &chainParams, interfaces::Chain &chain,
                  const std::vector<std::string> &wallet_files);
 
 //! Complete startup of wallets.
-void StartWallets(CScheduler &scheduler);
+void StartWallets(CScheduler &scheduler, const ArgsManager &args);
 
 //! Flush all wallets in preparation for shutdown.
 void FlushWallets();
 
 //! Stop all wallets. Wallets will be flushed first.
 void StopWallets();
 
 //! Close all wallets.
 void UnloadWallets();
 
 #endif // BITCOIN_WALLET_LOAD_H
diff --git a/src/wallet/test/init_test_fixture.cpp b/src/wallet/test/init_test_fixture.cpp
index 90eb49bc9..02635c01d 100644
--- a/src/wallet/test/init_test_fixture.cpp
+++ b/src/wallet/test/init_test_fixture.cpp
@@ -1,46 +1,47 @@
 // 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 <wallet/test/init_test_fixture.h>
 
 #include <chainparams.h>
 #include <fs.h>
+#include <util/check.h>
 #include <util/system.h>
 
 InitWalletDirTestingSetup::InitWalletDirTestingSetup(
     const std::string &chainName)
     : BasicTestingSetup(chainName) {
     m_chain = interfaces::MakeChain(m_node, Params());
-    m_chain_client = MakeWalletClient(*m_chain, {});
+    m_chain_client = MakeWalletClient(*m_chain, *Assert(m_node.args), {});
 
     std::string sep;
     sep += fs::path::preferred_separator;
 
     m_datadir = GetDataDir();
     m_cwd = fs::current_path();
 
     m_walletdir_path_cases["default"] = m_datadir / "wallets";
     m_walletdir_path_cases["custom"] = m_datadir / "my_wallets";
     m_walletdir_path_cases["nonexistent"] = m_datadir / "path_does_not_exist";
     m_walletdir_path_cases["file"] = m_datadir / "not_a_directory.dat";
     m_walletdir_path_cases["trailing"] = m_datadir / "wallets" / sep;
     m_walletdir_path_cases["trailing2"] = m_datadir / "wallets" / sep / sep;
 
     fs::current_path(m_datadir);
     m_walletdir_path_cases["relative"] = "wallets";
 
     fs::create_directories(m_walletdir_path_cases["default"]);
     fs::create_directories(m_walletdir_path_cases["custom"]);
     fs::create_directories(m_walletdir_path_cases["relative"]);
     std::ofstream f(m_walletdir_path_cases["file"].BOOST_FILESYSTEM_C_STR);
     f.close();
 }
 
 InitWalletDirTestingSetup::~InitWalletDirTestingSetup() {
     fs::current_path(m_cwd);
 }
 
 void InitWalletDirTestingSetup::SetWalletDir(const fs::path &walletdir_path) {
     gArgs.ForceSetArg("-walletdir", walletdir_path.string());
 }
diff --git a/src/wallet/test/wallet_test_fixture.h b/src/wallet/test/wallet_test_fixture.h
index ac342d7af..cab25ea8a 100644
--- a/src/wallet/test/wallet_test_fixture.h
+++ b/src/wallet/test/wallet_test_fixture.h
@@ -1,31 +1,32 @@
 // Copyright (c) 2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_WALLET_TEST_WALLET_TEST_FIXTURE_H
 #define BITCOIN_WALLET_TEST_WALLET_TEST_FIXTURE_H
 
 #include <interfaces/chain.h>
 #include <interfaces/wallet.h>
 #include <node/context.h>
+#include <util/check.h>
 #include <wallet/wallet.h>
 
 #include <test/util/setup_common.h>
 
 #include <memory>
 
 /**
  * Testing setup and teardown for wallet.
  */
 struct WalletTestingSetup : public TestingSetup {
     explicit WalletTestingSetup(
         const std::string &chainName = CBaseChainParams::MAIN);
 
     std::unique_ptr<interfaces::Chain> m_chain;
     std::unique_ptr<interfaces::ChainClient> m_chain_client =
-        interfaces::MakeWalletClient(*m_chain, {});
+        interfaces::MakeWalletClient(*m_chain, *Assert(m_node.args), {});
     CWallet m_wallet;
     std::unique_ptr<interfaces::Handler> m_chain_notifications_handler;
 };
 
 #endif // BITCOIN_WALLET_TEST_WALLET_TEST_FIXTURE_H
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index a39c8c999..c1340aec1 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -1,1009 +1,1006 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <wallet/walletdb.h>
 
 #include <chainparams.h>
 #include <fs.h>
 #include <key_io.h>
 #include <protocol.h>
 #include <serialize.h>
 #include <sync.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <wallet/wallet.h>
 
 #include <atomic>
 
 namespace DBKeys {
 const std::string ACENTRY{"acentry"};
 const std::string ACTIVEEXTERNALSPK{"activeexternalspk"};
 const std::string ACTIVEINTERNALSPK{"activeinternalspk"};
 const std::string BESTBLOCK_NOMERKLE{"bestblock_nomerkle"};
 const std::string BESTBLOCK{"bestblock"};
 const std::string CRYPTED_KEY{"ckey"};
 const std::string CSCRIPT{"cscript"};
 const std::string DEFAULTKEY{"defaultkey"};
 const std::string DESTDATA{"destdata"};
 const std::string FLAGS{"flags"};
 const std::string HDCHAIN{"hdchain"};
 const std::string KEYMETA{"keymeta"};
 const std::string KEY{"key"};
 const std::string MASTER_KEY{"mkey"};
 const std::string MINVERSION{"minversion"};
 const std::string NAME{"name"};
 const std::string OLD_KEY{"wkey"};
 const std::string ORDERPOSNEXT{"orderposnext"};
 const std::string POOL{"pool"};
 const std::string PURPOSE{"purpose"};
 const std::string SETTINGS{"settings"};
 const std::string TX{"tx"};
 const std::string VERSION{"version"};
 const std::string WALLETDESCRIPTOR{"walletdescriptor"};
 const std::string WALLETDESCRIPTORCACHE{"walletdescriptorcache"};
 const std::string WALLETDESCRIPTORCKEY{"walletdescriptorckey"};
 const std::string WALLETDESCRIPTORKEY{"walletdescriptorkey"};
 const std::string WATCHMETA{"watchmeta"};
 const std::string WATCHS{"watchs"};
 } // namespace DBKeys
 
 //
 // WalletBatch
 //
 
 bool WalletBatch::WriteName(const CTxDestination &address,
                             const std::string &strName) {
     if (!IsValidDestination(address)) {
         return false;
     }
     return WriteIC(
         std::make_pair(DBKeys::NAME, EncodeLegacyAddr(address, Params())),
         strName);
 }
 
 bool WalletBatch::EraseName(const CTxDestination &address) {
     // This should only be used for sending addresses, never for receiving
     // addresses, receiving addresses must always have an address book entry if
     // they're not change return.
     if (!IsValidDestination(address)) {
         return false;
     }
     return EraseIC(
         std::make_pair(DBKeys::NAME, EncodeLegacyAddr(address, Params())));
 }
 
 bool WalletBatch::WritePurpose(const CTxDestination &address,
                                const std::string &strPurpose) {
     if (!IsValidDestination(address)) {
         return false;
     }
     return WriteIC(
         std::make_pair(DBKeys::PURPOSE, EncodeLegacyAddr(address, Params())),
         strPurpose);
 }
 
 bool WalletBatch::ErasePurpose(const CTxDestination &address) {
     if (!IsValidDestination(address)) {
         return false;
     }
     return EraseIC(
         std::make_pair(DBKeys::PURPOSE, EncodeLegacyAddr(address, Params())));
 }
 
 bool WalletBatch::WriteTx(const CWalletTx &wtx) {
     return WriteIC(std::make_pair(DBKeys::TX, wtx.GetId()), wtx);
 }
 
 bool WalletBatch::EraseTx(uint256 hash) {
     return EraseIC(std::make_pair(DBKeys::TX, hash));
 }
 
 bool WalletBatch::WriteKeyMetadata(const CKeyMetadata &meta,
                                    const CPubKey &pubkey,
                                    const bool overwrite) {
     return WriteIC(std::make_pair(DBKeys::KEYMETA, pubkey), meta, overwrite);
 }
 
 bool WalletBatch::WriteKey(const CPubKey &vchPubKey, const CPrivKey &vchPrivKey,
                            const CKeyMetadata &keyMeta) {
     if (!WriteKeyMetadata(keyMeta, vchPubKey, false)) {
         return false;
     }
 
     // hash pubkey/privkey to accelerate wallet load
     std::vector<uint8_t> vchKey;
     vchKey.reserve(vchPubKey.size() + vchPrivKey.size());
     vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
     vchKey.insert(vchKey.end(), vchPrivKey.begin(), vchPrivKey.end());
 
     return WriteIC(
         std::make_pair(DBKeys::KEY, vchPubKey),
         std::make_pair(vchPrivKey, Hash(vchKey.begin(), vchKey.end())), false);
 }
 
 bool WalletBatch::WriteCryptedKey(const CPubKey &vchPubKey,
                                   const std::vector<uint8_t> &vchCryptedSecret,
                                   const CKeyMetadata &keyMeta) {
     if (!WriteKeyMetadata(keyMeta, vchPubKey, true)) {
         return false;
     }
 
     if (!WriteIC(std::make_pair(DBKeys::CRYPTED_KEY, vchPubKey),
                  vchCryptedSecret, false)) {
         return false;
     }
     EraseIC(std::make_pair(DBKeys::KEY, vchPubKey));
     return true;
 }
 
 bool WalletBatch::WriteMasterKey(unsigned int nID,
                                  const CMasterKey &kMasterKey) {
     return WriteIC(std::make_pair(DBKeys::MASTER_KEY, nID), kMasterKey, true);
 }
 
 bool WalletBatch::WriteCScript(const uint160 &hash,
                                const CScript &redeemScript) {
     return WriteIC(std::make_pair(DBKeys::CSCRIPT, hash), redeemScript, false);
 }
 
 bool WalletBatch::WriteWatchOnly(const CScript &dest,
                                  const CKeyMetadata &keyMeta) {
     if (!WriteIC(std::make_pair(DBKeys::WATCHMETA, dest), keyMeta)) {
         return false;
     }
     return WriteIC(std::make_pair(DBKeys::WATCHS, dest), '1');
 }
 
 bool WalletBatch::EraseWatchOnly(const CScript &dest) {
     if (!EraseIC(std::make_pair(DBKeys::WATCHMETA, dest))) {
         return false;
     }
     return EraseIC(std::make_pair(DBKeys::WATCHS, dest));
 }
 
 bool WalletBatch::WriteBestBlock(const CBlockLocator &locator) {
     // Write empty block locator so versions that require a merkle branch
     // automatically rescan
     WriteIC(DBKeys::BESTBLOCK, CBlockLocator());
     return WriteIC(DBKeys::BESTBLOCK_NOMERKLE, locator);
 }
 
 bool WalletBatch::ReadBestBlock(CBlockLocator &locator) {
     if (m_batch.Read(DBKeys::BESTBLOCK, locator) && !locator.vHave.empty()) {
         return true;
     }
     return m_batch.Read(DBKeys::BESTBLOCK_NOMERKLE, locator);
 }
 
 bool WalletBatch::WriteOrderPosNext(int64_t nOrderPosNext) {
     return WriteIC(DBKeys::ORDERPOSNEXT, nOrderPosNext);
 }
 
 bool WalletBatch::ReadPool(int64_t nPool, CKeyPool &keypool) {
     return m_batch.Read(std::make_pair(DBKeys::POOL, nPool), keypool);
 }
 
 bool WalletBatch::WritePool(int64_t nPool, const CKeyPool &keypool) {
     return WriteIC(std::make_pair(DBKeys::POOL, nPool), keypool);
 }
 
 bool WalletBatch::ErasePool(int64_t nPool) {
     return EraseIC(std::make_pair(DBKeys::POOL, nPool));
 }
 
 bool WalletBatch::WriteMinVersion(int nVersion) {
     return WriteIC(DBKeys::MINVERSION, nVersion);
 }
 
 bool WalletBatch::WriteActiveScriptPubKeyMan(uint8_t type, const uint256 &id,
                                              bool internal) {
     std::string key =
         internal ? DBKeys::ACTIVEINTERNALSPK : DBKeys::ACTIVEEXTERNALSPK;
     return WriteIC(make_pair(key, type), id);
 }
 
 bool WalletBatch::WriteDescriptorKey(const uint256 &desc_id,
                                      const CPubKey &pubkey,
                                      const CPrivKey &privkey) {
     // hash pubkey/privkey to accelerate wallet load
     std::vector<uint8_t> key;
     key.reserve(pubkey.size() + privkey.size());
     key.insert(key.end(), pubkey.begin(), pubkey.end());
     key.insert(key.end(), privkey.begin(), privkey.end());
 
     return WriteIC(std::make_pair(DBKeys::WALLETDESCRIPTORKEY,
                                   std::make_pair(desc_id, pubkey)),
                    std::make_pair(privkey, Hash(key.begin(), key.end())),
                    false);
 }
 
 bool WalletBatch::WriteCryptedDescriptorKey(
     const uint256 &desc_id, const CPubKey &pubkey,
     const std::vector<uint8_t> &secret) {
     if (!WriteIC(std::make_pair(DBKeys::WALLETDESCRIPTORCKEY,
                                 std::make_pair(desc_id, pubkey)),
                  secret, false)) {
         return false;
     }
     EraseIC(std::make_pair(DBKeys::WALLETDESCRIPTORKEY,
                            std::make_pair(desc_id, pubkey)));
     return true;
 }
 
 bool WalletBatch::WriteDescriptor(const uint256 &desc_id,
                                   const WalletDescriptor &descriptor) {
     return WriteIC(make_pair(DBKeys::WALLETDESCRIPTOR, desc_id), descriptor);
 }
 
 bool WalletBatch::WriteDescriptorDerivedCache(const CExtPubKey &xpub,
                                               const uint256 &desc_id,
                                               uint32_t key_exp_index,
                                               uint32_t der_index) {
     std::vector<uint8_t> ser_xpub(BIP32_EXTKEY_SIZE);
     xpub.Encode(ser_xpub.data());
     return WriteIC(
         std::make_pair(std::make_pair(DBKeys::WALLETDESCRIPTORCACHE, desc_id),
                        std::make_pair(key_exp_index, der_index)),
         ser_xpub);
 }
 
 bool WalletBatch::WriteDescriptorParentCache(const CExtPubKey &xpub,
                                              const uint256 &desc_id,
                                              uint32_t key_exp_index) {
     std::vector<uint8_t> ser_xpub(BIP32_EXTKEY_SIZE);
     xpub.Encode(ser_xpub.data());
     return WriteIC(
         std::make_pair(std::make_pair(DBKeys::WALLETDESCRIPTORCACHE, desc_id),
                        key_exp_index),
         ser_xpub);
 }
 
 class CWalletScanState {
 public:
     unsigned int nKeys{0};
     unsigned int nCKeys{0};
     unsigned int nWatchKeys{0};
     unsigned int nKeyMeta{0};
     unsigned int m_unknown_records{0};
     bool fIsEncrypted{false};
     bool fAnyUnordered{false};
     std::vector<TxId> vWalletUpgrade;
     std::map<OutputType, uint256> m_active_external_spks;
     std::map<OutputType, uint256> m_active_internal_spks;
     std::map<uint256, DescriptorCache> m_descriptor_caches;
     std::map<std::pair<uint256, CKeyID>, CKey> m_descriptor_keys;
     std::map<std::pair<uint256, CKeyID>,
              std::pair<CPubKey, std::vector<uint8_t>>>
         m_descriptor_crypt_keys;
 
     CWalletScanState() {}
 };
 
 static bool ReadKeyValue(CWallet *pwallet, CDataStream &ssKey,
                          CDataStream &ssValue, CWalletScanState &wss,
                          std::string &strType, std::string &strErr)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     try {
         // Unserialize
         // Taking advantage of the fact that pair serialization is just the two
         // items serialized one after the other.
         ssKey >> strType;
         if (strType == DBKeys::NAME) {
             std::string strAddress;
             ssKey >> strAddress;
             std::string label;
             ssValue >> label;
             pwallet
                 ->m_address_book[DecodeDestination(strAddress,
                                                    pwallet->GetChainParams())]
                 .SetLabel(label);
         } else if (strType == DBKeys::PURPOSE) {
             std::string strAddress;
             ssKey >> strAddress;
             ssValue >> pwallet
                            ->m_address_book[DecodeDestination(
                                strAddress, pwallet->GetChainParams())]
                            .purpose;
         } else if (strType == DBKeys::TX) {
             TxId txid;
             ssKey >> txid;
             CWalletTx wtx(nullptr /* pwallet */, MakeTransactionRef());
             ssValue >> wtx;
             if (wtx.GetId() != txid) {
                 return false;
             }
 
             // Undo serialize changes in 31600
             if (31404 <= wtx.fTimeReceivedIsTxTime &&
                 wtx.fTimeReceivedIsTxTime <= 31703) {
                 if (!ssValue.empty()) {
                     char fTmp;
                     char fUnused;
                     std::string unused_string;
                     ssValue >> fTmp >> fUnused >> unused_string;
                     strErr = strprintf("LoadWallet() upgrading tx ver=%d %d %s",
                                        wtx.fTimeReceivedIsTxTime, fTmp,
                                        txid.ToString());
                     wtx.fTimeReceivedIsTxTime = fTmp;
                 } else {
                     strErr =
                         strprintf("LoadWallet() repairing tx ver=%d %s",
                                   wtx.fTimeReceivedIsTxTime, txid.ToString());
                     wtx.fTimeReceivedIsTxTime = 0;
                 }
                 wss.vWalletUpgrade.push_back(txid);
             }
 
             if (wtx.nOrderPos == -1) {
                 wss.fAnyUnordered = true;
             }
 
             pwallet->LoadToWallet(wtx);
         } else if (strType == DBKeys::WATCHS) {
             wss.nWatchKeys++;
             CScript script;
             ssKey >> script;
             char fYes;
             ssValue >> fYes;
             if (fYes == '1') {
                 pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadWatchOnly(
                     script);
             }
         } else if (strType == DBKeys::KEY) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             if (!vchPubKey.IsValid()) {
                 strErr = "Error reading wallet database: CPubKey corrupt";
                 return false;
             }
             CKey key;
             CPrivKey pkey;
             uint256 hash;
 
             wss.nKeys++;
             ssValue >> pkey;
 
             // Old wallets store keys as DBKeys::KEY [pubkey] => [privkey] ...
             // which was slow for wallets with lots of keys, because the public
             // key is re-derived from the private key using EC operations as a
             // checksum. Newer wallets store keys as DBKeys::KEY [pubkey] =>
             // [privkey][hash(pubkey,privkey)], which is much faster while
             // remaining backwards-compatible.
             try {
                 ssValue >> hash;
             } catch (...) {
             }
 
             bool fSkipCheck = false;
 
             if (!hash.IsNull()) {
                 // hash pubkey/privkey to accelerate wallet load
                 std::vector<uint8_t> vchKey;
                 vchKey.reserve(vchPubKey.size() + pkey.size());
                 vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
                 vchKey.insert(vchKey.end(), pkey.begin(), pkey.end());
 
                 if (Hash(vchKey.begin(), vchKey.end()) != hash) {
                     strErr = "Error reading wallet database: CPubKey/CPrivKey "
                              "corrupt";
                     return false;
                 }
 
                 fSkipCheck = true;
             }
 
             if (!key.Load(pkey, vchPubKey, fSkipCheck)) {
                 strErr = "Error reading wallet database: CPrivKey corrupt";
                 return false;
             }
             if (!pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadKey(
                     key, vchPubKey)) {
                 strErr = "Error reading wallet database: "
                          "LegacyScriptPubKeyMan::LoadKey failed";
                 return false;
             }
         } else if (strType == DBKeys::MASTER_KEY) {
             // Master encryption key is loaded into only the wallet and not any
             // of the ScriptPubKeyMans.
             unsigned int nID;
             ssKey >> nID;
             CMasterKey kMasterKey;
             ssValue >> kMasterKey;
             if (pwallet->mapMasterKeys.count(nID) != 0) {
                 strErr = strprintf(
                     "Error reading wallet database: duplicate CMasterKey id %u",
                     nID);
                 return false;
             }
             pwallet->mapMasterKeys[nID] = kMasterKey;
             if (pwallet->nMasterKeyMaxID < nID) {
                 pwallet->nMasterKeyMaxID = nID;
             }
         } else if (strType == DBKeys::CRYPTED_KEY) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             if (!vchPubKey.IsValid()) {
                 strErr = "Error reading wallet database: CPubKey corrupt";
                 return false;
             }
             std::vector<uint8_t> vchPrivKey;
             ssValue >> vchPrivKey;
             wss.nCKeys++;
 
             if (!pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadCryptedKey(
                     vchPubKey, vchPrivKey)) {
                 strErr = "Error reading wallet database: "
                          "LegacyScriptPubKeyMan::LoadCryptedKey failed";
                 return false;
             }
             wss.fIsEncrypted = true;
         } else if (strType == DBKeys::KEYMETA) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             CKeyMetadata keyMeta;
             ssValue >> keyMeta;
             wss.nKeyMeta++;
             pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadKeyMetadata(
                 vchPubKey.GetID(), keyMeta);
         } else if (strType == DBKeys::WATCHMETA) {
             CScript script;
             ssKey >> script;
             CKeyMetadata keyMeta;
             ssValue >> keyMeta;
             wss.nKeyMeta++;
             pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadScriptMetadata(
                 CScriptID(script), keyMeta);
         } else if (strType == DBKeys::DEFAULTKEY) {
             // We don't want or need the default key, but if there is one set,
             // we want to make sure that it is valid so that we can detect
             // corruption
             CPubKey vchPubKey;
             ssValue >> vchPubKey;
             if (!vchPubKey.IsValid()) {
                 strErr = "Error reading wallet database: Default Key corrupt";
                 return false;
             }
         } else if (strType == DBKeys::POOL) {
             int64_t nIndex;
             ssKey >> nIndex;
             CKeyPool keypool;
             ssValue >> keypool;
 
             pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadKeyPool(nIndex,
                                                                      keypool);
         } else if (strType == DBKeys::CSCRIPT) {
             uint160 hash;
             ssKey >> hash;
             CScript script;
             ssValue >> script;
             if (!pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadCScript(
                     script)) {
                 strErr = "Error reading wallet database: "
                          "LegacyScriptPubKeyMan::LoadCScript failed";
                 return false;
             }
         } else if (strType == DBKeys::ORDERPOSNEXT) {
             ssValue >> pwallet->nOrderPosNext;
         } else if (strType == DBKeys::DESTDATA) {
             std::string strAddress, strKey, strValue;
             ssKey >> strAddress;
             ssKey >> strKey;
             ssValue >> strValue;
             pwallet->LoadDestData(
                 DecodeDestination(strAddress, pwallet->GetChainParams()),
                 strKey, strValue);
         } else if (strType == DBKeys::HDCHAIN) {
             CHDChain chain;
             ssValue >> chain;
             pwallet->GetOrCreateLegacyScriptPubKeyMan()->SetHDChain(chain,
                                                                     true);
         } else if (strType == DBKeys::FLAGS) {
             uint64_t flags;
             ssValue >> flags;
             if (!pwallet->SetWalletFlags(flags, true)) {
                 strErr = "Error reading wallet database: Unknown non-tolerable "
                          "wallet flags found";
                 return false;
             }
         } else if (strType == DBKeys::OLD_KEY) {
             strErr = "Found unsupported 'wkey' record, try loading with "
                      "version 0.20";
             return false;
         } else if (strType == DBKeys::ACTIVEEXTERNALSPK ||
                    strType == DBKeys::ACTIVEINTERNALSPK) {
             uint8_t type;
             ssKey >> type;
             uint256 id;
             ssValue >> id;
 
             bool internal = strType == DBKeys::ACTIVEINTERNALSPK;
             auto &spk_mans = internal ? wss.m_active_internal_spks
                                       : wss.m_active_external_spks;
             if (spk_mans.count(static_cast<OutputType>(type)) > 0) {
                 strErr =
                     "Multiple ScriptPubKeyMans specified for a single type";
                 return false;
             }
             spk_mans[static_cast<OutputType>(type)] = id;
         } else if (strType == DBKeys::WALLETDESCRIPTOR) {
             uint256 id;
             ssKey >> id;
             WalletDescriptor desc;
             ssValue >> desc;
             if (wss.m_descriptor_caches.count(id) == 0) {
                 wss.m_descriptor_caches[id] = DescriptorCache();
             }
             pwallet->LoadDescriptorScriptPubKeyMan(id, desc);
         } else if (strType == DBKeys::WALLETDESCRIPTORCACHE) {
             bool parent = true;
             uint256 desc_id;
             uint32_t key_exp_index;
             uint32_t der_index;
             ssKey >> desc_id;
             ssKey >> key_exp_index;
 
             // if the der_index exists, it's a derived xpub
             try {
                 ssKey >> der_index;
                 parent = false;
             } catch (...) {
             }
 
             std::vector<uint8_t> ser_xpub(BIP32_EXTKEY_SIZE);
             ssValue >> ser_xpub;
             CExtPubKey xpub;
             xpub.Decode(ser_xpub.data());
             if (wss.m_descriptor_caches.count(desc_id)) {
                 wss.m_descriptor_caches[desc_id] = DescriptorCache();
             }
             if (parent) {
                 wss.m_descriptor_caches[desc_id].CacheParentExtPubKey(
                     key_exp_index, xpub);
             } else {
                 wss.m_descriptor_caches[desc_id].CacheDerivedExtPubKey(
                     key_exp_index, der_index, xpub);
             }
         } else if (strType == DBKeys::WALLETDESCRIPTORKEY) {
             uint256 desc_id;
             CPubKey pubkey;
             ssKey >> desc_id;
             ssKey >> pubkey;
             if (!pubkey.IsValid()) {
                 strErr = "Error reading wallet database: CPubKey corrupt";
                 return false;
             }
             CKey key;
             CPrivKey pkey;
             uint256 hash;
 
             wss.nKeys++;
             ssValue >> pkey;
             ssValue >> hash;
 
             // hash pubkey/privkey to accelerate wallet load
             std::vector<uint8_t> to_hash;
             to_hash.reserve(pubkey.size() + pkey.size());
             to_hash.insert(to_hash.end(), pubkey.begin(), pubkey.end());
             to_hash.insert(to_hash.end(), pkey.begin(), pkey.end());
 
             if (Hash(to_hash.begin(), to_hash.end()) != hash) {
                 strErr =
                     "Error reading wallet database: CPubKey/CPrivKey corrupt";
                 return false;
             }
 
             if (!key.Load(pkey, pubkey, true)) {
                 strErr = "Error reading wallet database: CPrivKey corrupt";
                 return false;
             }
             wss.m_descriptor_keys.insert(
                 std::make_pair(std::make_pair(desc_id, pubkey.GetID()), key));
         } else if (strType == DBKeys::WALLETDESCRIPTORCKEY) {
             uint256 desc_id;
             CPubKey pubkey;
             ssKey >> desc_id;
             ssKey >> pubkey;
             if (!pubkey.IsValid()) {
                 strErr = "Error reading wallet database: CPubKey corrupt";
                 return false;
             }
             std::vector<uint8_t> privkey;
             ssValue >> privkey;
             wss.nCKeys++;
 
             wss.m_descriptor_crypt_keys.insert(
                 std::make_pair(std::make_pair(desc_id, pubkey.GetID()),
                                std::make_pair(pubkey, privkey)));
             wss.fIsEncrypted = true;
         } else if (strType != DBKeys::BESTBLOCK &&
                    strType != DBKeys::BESTBLOCK_NOMERKLE &&
                    strType != DBKeys::MINVERSION &&
                    strType != DBKeys::ACENTRY && strType != DBKeys::VERSION &&
                    strType != DBKeys::SETTINGS) {
             wss.m_unknown_records++;
         }
     } catch (const std::exception &e) {
         if (strErr.empty()) {
             strErr = e.what();
         }
         return false;
     } catch (...) {
         if (strErr.empty()) {
             strErr = "Caught unknown exception in ReadKeyValue";
         }
         return false;
     }
     return true;
 }
 
 bool ReadKeyValue(CWallet *pwallet, CDataStream &ssKey, CDataStream &ssValue,
                   std::string &strType, std::string &strErr) {
     CWalletScanState dummy_wss;
     LOCK(pwallet->cs_wallet);
     return ReadKeyValue(pwallet, ssKey, ssValue, dummy_wss, strType, strErr);
 }
 
 bool WalletBatch::IsKeyType(const std::string &strType) {
     return (strType == DBKeys::KEY || strType == DBKeys::MASTER_KEY ||
             strType == DBKeys::CRYPTED_KEY);
 }
 
 DBErrors WalletBatch::LoadWallet(CWallet *pwallet) {
     CWalletScanState wss;
     bool fNoncriticalErrors = false;
     DBErrors result = DBErrors::LOAD_OK;
 
     LOCK(pwallet->cs_wallet);
     try {
         int nMinVersion = 0;
         if (m_batch.Read(DBKeys::MINVERSION, nMinVersion)) {
             if (nMinVersion > FEATURE_LATEST) {
                 return DBErrors::TOO_NEW;
             }
             pwallet->LoadMinVersion(nMinVersion);
         }
 
         // Get cursor
         Dbc *pcursor = m_batch.GetCursor();
         if (!pcursor) {
             pwallet->WalletLogPrintf("Error getting wallet database cursor\n");
             return DBErrors::CORRUPT;
         }
 
         while (true) {
             // Read next record
             CDataStream ssKey(SER_DISK, CLIENT_VERSION);
             CDataStream ssValue(SER_DISK, CLIENT_VERSION);
             int ret = m_batch.ReadAtCursor(pcursor, ssKey, ssValue);
             if (ret == DB_NOTFOUND) {
                 break;
             }
 
             if (ret != 0) {
                 pwallet->WalletLogPrintf(
                     "Error reading next record from wallet database\n");
                 return DBErrors::CORRUPT;
             }
 
             // Try to be tolerant of single corrupt records:
             std::string strType, strErr;
             if (!ReadKeyValue(pwallet, ssKey, ssValue, wss, strType, strErr)) {
                 // losing keys is considered a catastrophic error, anything else
                 // we assume the user can live with:
                 if (IsKeyType(strType) || strType == DBKeys::DEFAULTKEY) {
                     result = DBErrors::CORRUPT;
                 } else if (strType == DBKeys::FLAGS) {
                     // Reading the wallet flags can only fail if unknown flags
                     // are present.
                     result = DBErrors::TOO_NEW;
                 } else {
                     // Leave other errors alone, if we try to fix them we might
                     // make things worse. But do warn the user there is
                     // something wrong.
                     fNoncriticalErrors = true;
                     if (strType == DBKeys::TX) {
                         // Rescan if there is a bad transaction record:
                         gArgs.SoftSetBoolArg("-rescan", true);
                     }
                 }
             }
             if (!strErr.empty()) {
                 pwallet->WalletLogPrintf("%s\n", strErr);
             }
         }
         pcursor->close();
     } catch (...) {
         result = DBErrors::CORRUPT;
     }
 
     // Set the active ScriptPubKeyMans
     for (auto spk_man_pair : wss.m_active_external_spks) {
         pwallet->SetActiveScriptPubKeyMan(
             spk_man_pair.second, spk_man_pair.first, /* internal */ false,
             /* memonly */ true);
     }
     for (auto spk_man_pair : wss.m_active_internal_spks) {
         pwallet->SetActiveScriptPubKeyMan(
             spk_man_pair.second, spk_man_pair.first, /* internal */ true,
             /* memonly */ true);
     }
 
     // Set the descriptor caches
     for (auto desc_cache_pair : wss.m_descriptor_caches) {
         auto spk_man = pwallet->GetScriptPubKeyMan(desc_cache_pair.first);
         assert(spk_man);
         ((DescriptorScriptPubKeyMan *)spk_man)
             ->SetCache(desc_cache_pair.second);
     }
 
     // Set the descriptor keys
     for (auto desc_key_pair : wss.m_descriptor_keys) {
         auto spk_man = pwallet->GetScriptPubKeyMan(desc_key_pair.first.first);
         ((DescriptorScriptPubKeyMan *)spk_man)
             ->AddKey(desc_key_pair.first.second, desc_key_pair.second);
     }
     for (auto desc_key_pair : wss.m_descriptor_crypt_keys) {
         auto spk_man = pwallet->GetScriptPubKeyMan(desc_key_pair.first.first);
         ((DescriptorScriptPubKeyMan *)spk_man)
             ->AddCryptedKey(desc_key_pair.first.second,
                             desc_key_pair.second.first,
                             desc_key_pair.second.second);
     }
 
     if (fNoncriticalErrors && result == DBErrors::LOAD_OK) {
         result = DBErrors::NONCRITICAL_ERROR;
     }
 
     // Any wallet corruption at all: skip any rewriting or upgrading, we don't
     // want to make it worse.
     if (result != DBErrors::LOAD_OK) {
         return result;
     }
 
     // Last client version to open this wallet, was previously the file version
     // number
     int last_client = CLIENT_VERSION;
     m_batch.Read(DBKeys::VERSION, last_client);
 
     int wallet_version = pwallet->GetVersion();
     pwallet->WalletLogPrintf("Wallet File Version = %d\n",
                              wallet_version > 0 ? wallet_version : last_client);
 
     pwallet->WalletLogPrintf("Keys: %u plaintext, %u encrypted, %u w/ "
                              "metadata, %u total. Unknown wallet records: %u\n",
                              wss.nKeys, wss.nCKeys, wss.nKeyMeta,
                              wss.nKeys + wss.nCKeys, wss.m_unknown_records);
 
     // nTimeFirstKey is only reliable if all keys have metadata
     if (pwallet->IsLegacy() &&
         (wss.nKeys + wss.nCKeys + wss.nWatchKeys) != wss.nKeyMeta) {
         auto spk_man = pwallet->GetOrCreateLegacyScriptPubKeyMan();
         if (spk_man) {
             LOCK(spk_man->cs_KeyStore);
             spk_man->UpdateTimeFirstKey(1);
         }
     }
 
     for (const TxId &txid : wss.vWalletUpgrade) {
         WriteTx(pwallet->mapWallet.at(txid));
     }
 
     // Rewrite encrypted wallets of versions 0.4.0 and 0.5.0rc:
     if (wss.fIsEncrypted && (last_client == 40000 || last_client == 50000)) {
         return DBErrors::NEED_REWRITE;
     }
 
     if (last_client < CLIENT_VERSION) {
         // Update
         m_batch.Write(DBKeys::VERSION, CLIENT_VERSION);
     }
 
     if (wss.fAnyUnordered) {
         result = pwallet->ReorderTransactions();
     }
 
     // Upgrade all of the wallet keymetadata to have the hd master key id
     // This operation is not atomic, but if it fails, updated entries are still
     // backwards compatible with older software
     try {
         pwallet->UpgradeKeyMetadata();
     } catch (...) {
         result = DBErrors::CORRUPT;
     }
 
     return result;
 }
 
 DBErrors WalletBatch::FindWalletTx(std::vector<TxId> &txIds,
                                    std::vector<CWalletTx> &vWtx) {
     DBErrors result = DBErrors::LOAD_OK;
 
     try {
         int nMinVersion = 0;
         if (m_batch.Read(DBKeys::MINVERSION, nMinVersion)) {
             if (nMinVersion > FEATURE_LATEST) {
                 return DBErrors::TOO_NEW;
             }
         }
 
         // Get cursor
         Dbc *pcursor = m_batch.GetCursor();
         if (!pcursor) {
             LogPrintf("Error getting wallet database cursor\n");
             return DBErrors::CORRUPT;
         }
 
         while (true) {
             // Read next record
             CDataStream ssKey(SER_DISK, CLIENT_VERSION);
             CDataStream ssValue(SER_DISK, CLIENT_VERSION);
             int ret = m_batch.ReadAtCursor(pcursor, ssKey, ssValue);
             if (ret == DB_NOTFOUND) {
                 break;
             }
 
             if (ret != 0) {
                 LogPrintf("Error reading next record from wallet database\n");
                 return DBErrors::CORRUPT;
             }
 
             std::string strType;
             ssKey >> strType;
             if (strType == DBKeys::TX) {
                 TxId txid;
                 ssKey >> txid;
 
                 CWalletTx wtx(nullptr /* pwallet */, MakeTransactionRef());
                 ssValue >> wtx;
 
                 txIds.push_back(txid);
                 vWtx.push_back(wtx);
             }
         }
         pcursor->close();
     } catch (...) {
         result = DBErrors::CORRUPT;
     }
 
     return result;
 }
 
 DBErrors WalletBatch::ZapSelectTx(std::vector<TxId> &txIdsIn,
                                   std::vector<TxId> &txIdsOut) {
     // Build list of wallet TXs and hashes.
     std::vector<TxId> txIds;
     std::vector<CWalletTx> vWtx;
     DBErrors err = FindWalletTx(txIds, vWtx);
     if (err != DBErrors::LOAD_OK) {
         return err;
     }
 
     std::sort(txIds.begin(), txIds.end());
     std::sort(txIdsIn.begin(), txIdsIn.end());
 
     // Erase each matching wallet TX.
     bool delerror = false;
     std::vector<TxId>::iterator it = txIdsIn.begin();
     for (const TxId &txid : txIds) {
         while (it < txIdsIn.end() && (*it) < txid) {
             it++;
         }
         if (it == txIdsIn.end()) {
             break;
         }
 
         if ((*it) == txid) {
             if (!EraseTx(txid)) {
                 LogPrint(BCLog::WALLETDB,
                          "Transaction was found for deletion but returned "
                          "database error: %s\n",
                          txid.GetHex());
                 delerror = true;
             }
             txIdsOut.push_back(txid);
         }
     }
 
     if (delerror) {
         return DBErrors::CORRUPT;
     }
     return DBErrors::LOAD_OK;
 }
 
 DBErrors WalletBatch::ZapWalletTx(std::vector<CWalletTx> &vWtx) {
     // Build list of wallet TXs.
     std::vector<TxId> txIds;
     DBErrors err = FindWalletTx(txIds, vWtx);
     if (err != DBErrors::LOAD_OK) {
         return err;
     }
 
     // Erase each wallet TX.
     for (const TxId &txid : txIds) {
         if (!EraseTx(txid)) {
             return DBErrors::CORRUPT;
         }
     }
 
     return DBErrors::LOAD_OK;
 }
 
 void MaybeCompactWalletDB() {
     static std::atomic<bool> fOneThread;
     if (fOneThread.exchange(true)) {
         return;
     }
-    if (!gArgs.GetBoolArg("-flushwallet", DEFAULT_FLUSHWALLET)) {
-        return;
-    }
 
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         WalletDatabase &dbh = pwallet->GetDBHandle();
 
         unsigned int nUpdateCounter = dbh.nUpdateCounter;
 
         if (dbh.nLastSeen != nUpdateCounter) {
             dbh.nLastSeen = nUpdateCounter;
             dbh.nLastWalletUpdate = GetTime();
         }
 
         if (dbh.nLastFlushed != nUpdateCounter &&
             GetTime() - dbh.nLastWalletUpdate >= 2) {
             if (dbh.PeriodicFlush()) {
                 dbh.nLastFlushed = nUpdateCounter;
             }
         }
     }
 
     fOneThread = false;
 }
 
 bool WalletBatch::WriteDestData(const CTxDestination &address,
                                 const std::string &key,
                                 const std::string &value) {
     if (!IsValidDestination(address)) {
         return false;
     }
     return WriteIC(
         std::make_pair(
             DBKeys::DESTDATA,
             std::make_pair(EncodeLegacyAddr(address, Params()), key)),
         value);
 }
 
 bool WalletBatch::EraseDestData(const CTxDestination &address,
                                 const std::string &key) {
     if (!IsValidDestination(address)) {
         return false;
     }
     return EraseIC(std::make_pair(
         DBKeys::DESTDATA,
         std::make_pair(EncodeLegacyAddr(address, Params()), key)));
 }
 
 bool WalletBatch::WriteHDChain(const CHDChain &chain) {
     return WriteIC(DBKeys::HDCHAIN, chain);
 }
 
 bool WalletBatch::WriteWalletFlags(const uint64_t flags) {
     return WriteIC(DBKeys::FLAGS, flags);
 }
 
 bool WalletBatch::TxnBegin() {
     return m_batch.TxnBegin();
 }
 
 bool WalletBatch::TxnCommit() {
     return m_batch.TxnCommit();
 }
 
 bool WalletBatch::TxnAbort() {
     return m_batch.TxnAbort();
 }
 
 bool IsWalletLoaded(const fs::path &wallet_path) {
     return IsBDBWalletLoaded(wallet_path);
 }
diff --git a/test/functional/wallet_dump.py b/test/functional/wallet_dump.py
index 94c6834d0..852db49ca 100755
--- a/test/functional/wallet_dump.py
+++ b/test/functional/wallet_dump.py
@@ -1,169 +1,173 @@
 #!/usr/bin/env python3
 # Copyright (c) 2016-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.
 """Test the dumpwallet RPC."""
 
 import os
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_raises_rpc_error,
 )
 
 
 def read_dump(file_name, addrs, script_addrs, hd_master_addr_old):
     """
     Read the given dump, count the addrs that match, count change and reserve.
     Also check that the old hd_master is inactive
     """
     with open(file_name, encoding='utf8') as inputfile:
         found_addr = 0
         found_script_addr = 0
         found_addr_chg = 0
         found_addr_rsv = 0
         hd_master_addr_ret = None
         for line in inputfile:
             # only read non comment lines
             if line[0] != "#" and len(line) > 10:
                 # split out some data
                 key_date_label, comment = line.split("#")
                 key_date_label = key_date_label.split(" ")
                 # key = key_date_label[0]
                 date = key_date_label[1]
                 keytype = key_date_label[2]
 
                 imported_key = date == '1970-01-01T00:00:01Z'
                 if imported_key:
                     # Imported keys have multiple addresses, no label (keypath) and timestamp
                     # Skip them
                     continue
 
                 addr_keypath = comment.split(" addr=")[1]
                 addr = addr_keypath.split(" ")[0]
                 keypath = None
                 if keytype == "inactivehdseed=1":
                     # ensure the old master is still available
                     assert hd_master_addr_old == addr
                 elif keytype == "hdseed=1":
                     # ensure we have generated a new hd master key
                     assert hd_master_addr_old != addr
                     hd_master_addr_ret = addr
                 elif keytype == "script=1":
                     # scripts don't have keypaths
                     keypath = None
                 else:
                     keypath = addr_keypath.rstrip().split("hdkeypath=")[1]
 
                 # count key types
                 for addrObj in addrs:
                     if addrObj['address'] == addr and addrObj['hdkeypath'] == keypath and keytype == "label=":
                         found_addr += 1
                         break
                     elif keytype == "change=1":
                         found_addr_chg += 1
                         break
                     elif keytype == "reserve=1":
                         found_addr_rsv += 1
                         break
 
                 # count scripts
                 for script_addr in script_addrs:
                     if script_addr == addr.rstrip() and keytype == "script=1":
                         found_script_addr += 1
                         break
 
         return found_addr, found_script_addr, found_addr_chg, found_addr_rsv, hd_master_addr_ret
 
 
 class WalletDumpTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [["-keypool=90"]]
         self.rpc_timeout = 120
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def setup_network(self):
         self.add_nodes(self.num_nodes, extra_args=self.extra_args)
         self.start_nodes()
 
     def run_test(self):
         wallet_unenc_dump = os.path.join(
             self.nodes[0].datadir, "wallet.unencrypted.dump")
         wallet_enc_dump = os.path.join(
             self.nodes[0].datadir, "wallet.encrypted.dump")
 
         # generate 20 addresses to compare against the dump
         test_addr_count = 20
         addrs = []
         for i in range(0, test_addr_count):
             addr = self.nodes[0].getnewaddress()
             vaddr = self.nodes[0].getaddressinfo(
                 addr)  # required to get hd keypath
             addrs.append(vaddr)
         # Should be a no-op:
         self.nodes[0].keypoolrefill()
 
         # Test scripts dump by adding a 1-of-1 multisig address
         multisig_addr = self.nodes[0].addmultisigaddress(
             1, [addrs[0]["address"]])["address"]
 
         # dump unencrypted wallet
         result = self.nodes[0].dumpwallet(wallet_unenc_dump)
         assert_equal(result['filename'], wallet_unenc_dump)
 
         found_addr, found_script_addr, found_addr_chg, found_addr_rsv, hd_master_addr_unenc = \
             read_dump(wallet_unenc_dump, addrs, [multisig_addr], None)
         # all keys must be in the dump
         assert_equal(found_addr, test_addr_count)
         # all scripts must be in the dump
         assert_equal(found_script_addr, 1)
         # 0 blocks where mined
         assert_equal(found_addr_chg, 0)
         # 90 keys plus 100% internal keys
         assert_equal(found_addr_rsv, 90 * 2)
 
         # encrypt wallet, restart, unlock and dump
         self.nodes[0].encryptwallet('test')
         self.nodes[0].walletpassphrase('test', 10)
         # Should be a no-op:
         self.nodes[0].keypoolrefill()
         self.nodes[0].dumpwallet(wallet_enc_dump)
 
         found_addr, found_script_addr, found_addr_chg, found_addr_rsv, _ = \
             read_dump(
                 wallet_enc_dump,
                 addrs,
                 [multisig_addr],
                 hd_master_addr_unenc)
         assert_equal(found_addr, test_addr_count)
         assert_equal(found_script_addr, 1)
         # old reserve keys are marked as change now
         assert_equal(found_addr_chg, 90 * 2)
         assert_equal(found_addr_rsv, 90 * 2)
 
         # Overwriting should fail
         assert_raises_rpc_error(-8,
                                 "already exists",
                                 lambda: self.nodes[0].dumpwallet(wallet_enc_dump))
 
         # Restart node with new wallet, and test importwallet
         self.stop_node(0)
         self.start_node(0, ['-wallet=w2'])
 
         # Make sure the address is not IsMine before import
         result = self.nodes[0].getaddressinfo(multisig_addr)
         assert result['ismine'] is False
 
         self.nodes[0].importwallet(wallet_unenc_dump)
 
         # Now check IsMine is true
         result = self.nodes[0].getaddressinfo(multisig_addr)
         assert result['ismine'] is True
 
+        self.log.info('Check that wallet is flushed')
+        with self.nodes[0].assert_debug_log(['Flushing wallet.dat'], timeout=20):
+            self.nodes[0].getnewaddress()
+
 
 if __name__ == '__main__':
     WalletDumpTest().main()