diff --git a/doc/release-notes/release-notes.md b/doc/release-notes/release-notes.md
index 50560857c..e4e33b110 100644
--- a/doc/release-notes/release-notes.md
+++ b/doc/release-notes/release-notes.md
@@ -1,7 +1,14 @@
 # Bitcoin ABC 0.24.4 Release Notes
 
 Bitcoin ABC version 0.24.4 is now available from:
 
   <https://download.bitcoinabc.org/0.24.4/>
 
 This release includes the following features and fixes:
+
+- Bitcoin ABC will no longer create an unnamed `""` wallet by default when no wallet is
+  specified on the command line or in the configuration files. For backwards compatibility,
+  if an unnamed `""` wallet already exists and would have been loaded previously, then it
+  will still be loaded. Users without an unnamed `""` wallet and without any other wallets
+  to be loaded on startup  will be prompted to either choose a wallet to load, or to
+  create a new wallet.
diff --git a/src/interfaces/wallet.cpp b/src/interfaces/wallet.cpp
index c23502f7c..0ad2aa052 100644
--- a/src/interfaces/wallet.cpp
+++ b/src/interfaces/wallet.cpp
@@ -1,575 +1,567 @@
 // 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 <util/check.h>
 #include <util/ref.h>
 #include <util/system.h>
 #include <util/ui_change_type.h>
 #include <wallet/context.h>
 #include <wallet/fees.h>
 #include <wallet/ismine.h>
 #include <wallet/load.h>
 #include <wallet/rpcdump.h>
 #include <wallet/wallet.h>
 
 namespace interfaces {
 namespace {
 
     //! Construct wallet tx struct.
     WalletTx MakeWalletTx(CWallet &wallet, const CWalletTx &wtx) {
         LOCK(wallet.cs_wallet);
         WalletTx result;
         result.tx = wtx.tx;
         result.txin_is_mine.reserve(wtx.tx->vin.size());
         for (const auto &txin : wtx.tx->vin) {
             result.txin_is_mine.emplace_back(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 {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->IsMine(dest) & ISMINE_SPENDABLE;
         }
         bool haveWatchOnly() override {
             auto spk_man = m_wallet->GetLegacyScriptPubKeyMan();
             if (spk_man) {
                 return spk_man->HaveWatchOnly();
             }
             return false;
         };
         bool setAddressBook(const CTxDestination &dest, const std::string &name,
                             const std::string &purpose) override {
             return m_wallet->SetAddressBook(dest, name, purpose);
         }
         bool delAddressBook(const CTxDestination &dest) override {
             return m_wallet->DelAddressBook(dest);
         }
         bool getAddress(const CTxDestination &dest, std::string *name,
                         isminetype *is_mine, std::string *purpose) override {
             LOCK(m_wallet->cs_wallet);
             auto it = m_wallet->m_address_book.find(dest);
             if (it == m_wallet->m_address_book.end() || it->second.IsChange()) {
                 return false;
             }
             if (name) {
                 *name = it->second.GetLabel();
             }
             if (is_mine) {
                 *is_mine = m_wallet->IsMine(dest);
             }
             if (purpose) {
                 *purpose = it->second.purpose;
             }
             return true;
         }
         std::vector<WalletAddress> getAddresses() override {
             LOCK(m_wallet->cs_wallet);
             std::vector<WalletAddress> result;
             for (const auto &item : m_wallet->m_address_book) {
                 if (item.second.IsChange()) {
                     continue;
                 }
                 result.emplace_back(item.first, m_wallet->IsMine(item.first),
                                     item.second.GetLabel(),
                                     item.second.purpose);
             }
             return result;
         }
         bool addDestData(const CTxDestination &dest, const std::string &key,
                          const std::string &value) override {
             LOCK(m_wallet->cs_wallet);
             WalletBatch batch{m_wallet->GetDatabase()};
             return m_wallet->AddDestData(batch, dest, key, value);
         }
         bool eraseDestData(const CTxDestination &dest,
                            const std::string &key) override {
             LOCK(m_wallet->cs_wallet);
             WalletBatch batch{m_wallet->GetDatabase()};
             return m_wallet->EraseDestData(batch, dest, key);
         }
         std::vector<std::string>
         getDestValues(const std::string &prefix) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->GetDestValues(prefix);
         }
         void lockCoin(const COutPoint &output) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->LockCoin(output);
         }
         void unlockCoin(const COutPoint &output) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->UnlockCoin(output);
         }
         bool isLockedCoin(const COutPoint &output) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->IsLockedCoin(output);
         }
         void listLockedCoins(std::vector<COutPoint> &outputs) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->ListLockedCoins(outputs);
         }
         CTransactionRef
         createTransaction(const std::vector<CRecipient> &recipients,
                           const CCoinControl &coin_control, bool sign,
                           int &change_pos, Amount &fee,
                           bilingual_str &fail_reason) override {
             LOCK(m_wallet->cs_wallet);
             CTransactionRef tx;
             if (!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,
                             BlockHash &block_hash) override {
             TRY_LOCK(m_wallet->cs_wallet, locked_wallet);
             if (!locked_wallet) {
                 return false;
             }
             block_hash = m_wallet->GetLastBlockHash();
             balances = getBalances();
             return true;
         }
         Amount getBalance() override {
             return 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);
         }
         Amount getDefaultMaxTxFee() override {
             return m_wallet->m_default_max_tx_fee;
         }
         void remove() override {
             RemoveWallet(m_wallet, false /* load_on_start */);
         }
         bool isLegacy() override { return m_wallet->IsLegacy(); }
         std::unique_ptr<Handler> handleUnload(UnloadFn fn) override {
             return MakeHandler(m_wallet->NotifyUnload.connect(fn));
         }
         std::unique_ptr<Handler>
         handleShowProgress(ShowProgressFn fn) override {
             return MakeHandler(m_wallet->ShowProgress.connect(fn));
         }
         std::unique_ptr<Handler>
         handleStatusChanged(StatusChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyStatusChanged.connect(
                 [fn](CWallet *) { fn(); }));
         }
         std::unique_ptr<Handler>
         handleAddressBookChanged(AddressBookChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyAddressBookChanged.connect(
                 [fn](CWallet *, const CTxDestination &address,
                      const std::string &label, bool is_mine,
                      const std::string &purpose, ChangeType status) {
                     fn(address, label, is_mine, purpose, status);
                 }));
         }
         std::unique_ptr<Handler>
         handleTransactionChanged(TransactionChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyTransactionChanged.connect(
                 [fn](CWallet *, const TxId &txid, ChangeType status) {
                     fn(txid, status);
                 }));
         }
         std::unique_ptr<Handler>
         handleWatchOnlyChanged(WatchOnlyChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyWatchonlyChanged.connect(fn));
         }
         std::unique_ptr<Handler>
         handleCanGetAddressesChanged(CanGetAddressesChangedFn fn) override {
             return MakeHandler(
                 m_wallet->NotifyCanGetAddressesChanged.connect(fn));
         }
         Amount getRequiredFee(unsigned int tx_bytes) override {
             return GetRequiredFee(*m_wallet, tx_bytes);
         }
         Amount getMinimumFee(unsigned int tx_bytes,
                              const CCoinControl &coin_control) override {
             return GetMinimumFee(*m_wallet, tx_bytes, coin_control);
         }
         CWallet *wallet() override { return m_wallet.get(); }
 
         std::shared_ptr<CWallet> m_wallet;
     };
 
     class WalletClientImpl : public WalletClient {
     public:
-        WalletClientImpl(Chain &chain, ArgsManager &args,
-                         std::vector<std::string> wallet_filenames)
-            : m_wallet_filenames(std::move(wallet_filenames)) {
+        WalletClientImpl(Chain &chain, ArgsManager &args) {
             m_context.chain = &chain;
             m_context.args = &args;
         }
         ~WalletClientImpl() override { UnloadWallets(); }
 
         //! ChainClient methods
         void registerRpcs(const Span<const CRPCCommand> &commands) {
             for (const CRPCCommand &command : commands) {
                 m_rpc_commands.emplace_back(
                     command.category, command.name,
                     [this, &command](const Config &config,
                                      const JSONRPCRequest &request,
                                      UniValue &result, bool last_handler) {
                         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() override {
-            return VerifyWallets(*m_context.chain, m_wallet_filenames);
-        }
-        bool load() override {
-            return LoadWallets(*m_context.chain, m_wallet_filenames);
-        }
+        bool verify() override { return VerifyWallets(*m_context.chain); }
+        bool load() override { return LoadWallets(*m_context.chain); }
         void start(CScheduler &scheduler) override {
             return StartWallets(scheduler, *Assert(m_context.args));
         }
         void flush() override { return FlushWallets(); }
         void stop() override { return StopWallets(); }
         void setMockTime(int64_t time) override { return SetMockTime(time); }
 
         //! WalletClient methods
         std::unique_ptr<Wallet>
         createWallet(const std::string &name, const SecureString &passphrase,
                      uint64_t wallet_creation_flags, bilingual_str &error,
                      std::vector<bilingual_str> &warnings) override {
             std::shared_ptr<CWallet> wallet;
             DatabaseOptions options;
             DatabaseStatus status;
             options.require_create = true;
             options.create_flags = wallet_creation_flags;
             options.create_passphrase = passphrase;
 
             return MakeWallet(CreateWallet(*m_context.chain, name,
                                            true /* load_on_start */, options,
                                            status, error, warnings));
         }
         std::unique_ptr<Wallet>
         loadWallet(const std::string &name, bilingual_str &error,
                    std::vector<bilingual_str> &warnings) override {
             DatabaseOptions options;
             DatabaseStatus status;
             options.require_existing = true;
             return MakeWallet(LoadWallet(*m_context.chain, name,
                                          true /* load_on_start */, options,
                                          status, error, warnings));
         }
         std::string getWalletDir() override { return GetWalletDir().string(); }
         std::vector<std::string> listWalletDir() override {
             std::vector<std::string> paths;
             for (auto &path : ListWalletDir()) {
                 paths.push_back(path.string());
             }
             return paths;
         }
 
         std::vector<std::unique_ptr<Wallet>> getWallets() override {
             std::vector<std::unique_ptr<Wallet>> wallets;
             for (const auto &wallet : GetWallets()) {
                 wallets.emplace_back(MakeWallet(wallet));
             }
             return wallets;
         }
 
         std::unique_ptr<Handler> handleLoadWallet(LoadWalletFn fn) override {
             return HandleLoadWallet(std::move(fn));
         }
 
         WalletContext m_context;
         const std::vector<std::string> m_wallet_filenames;
         std::vector<std::unique_ptr<Handler>> m_rpc_handlers;
         std::list<CRPCCommand> m_rpc_commands;
     };
 
 } // namespace
 
 std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet> &wallet) {
     return wallet ? std::make_unique<WalletImpl>(wallet) : nullptr;
 }
 
-std::unique_ptr<WalletClient>
-MakeWalletClient(Chain &chain, ArgsManager &args,
-                 std::vector<std::string> wallet_filenames) {
-    return std::make_unique<WalletClientImpl>(chain, args,
-                                              std::move(wallet_filenames));
+std::unique_ptr<WalletClient> MakeWalletClient(Chain &chain,
+                                               ArgsManager &args) {
+    return std::make_unique<WalletClientImpl>(chain, args);
 }
 
 } // namespace interfaces
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index 030ef7d88..12da2698b 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -1,420 +1,418 @@
 // 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.
 
 #ifndef BITCOIN_INTERFACES_WALLET_H
 #define BITCOIN_INTERFACES_WALLET_H
 
 #include <amount.h>           // For Amount
 #include <interfaces/chain.h> // For ChainClient
 #include <primitives/blockhash.h>
 #include <primitives/transaction.h> // For CTxOut
 #include <pubkey.h> // For CKeyID and CScriptID (definitions needed in CTxDestination instantiation)
 #include <script/sighashtype.h>
 #include <script/standard.h>           // For CTxDestination
 #include <support/allocators/secure.h> // For SecureString
 #include <util/message.h>
 #include <util/ui_change_type.h>
 
 #include <cstdint>
 #include <functional>
 #include <map>
 #include <memory>
 #include <string>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 class CChainParams;
 class CCoinControl;
 class CKey;
 class CMutableTransaction;
 class COutPoint;
 class CTransaction;
 class CWallet;
 enum class FeeReason;
 enum class OutputType;
 enum class TransactionError;
 enum isminetype : unsigned int;
 struct CRecipient;
 struct PartiallySignedTransaction;
 struct WalletContext;
 typedef uint8_t isminefilter;
 struct TxId;
 struct bilingual_str;
 
 namespace interfaces {
 
 class Handler;
 struct WalletAddress;
 struct WalletBalances;
 struct WalletTx;
 struct WalletTxOut;
 struct WalletTxStatus;
 
 using WalletOrderForm = std::vector<std::pair<std::string, std::string>>;
 using WalletValueMap = std::map<std::string, std::string>;
 
 //! Interface for accessing a wallet.
 class Wallet {
 public:
     virtual ~Wallet() {}
 
     //! Encrypt wallet.
     virtual bool encryptWallet(const SecureString &wallet_passphrase) = 0;
 
     //! Return whether wallet is encrypted.
     virtual bool isCrypted() = 0;
 
     //! Lock wallet.
     virtual bool lock() = 0;
 
     //! Unlock wallet.
     virtual bool unlock(const SecureString &wallet_passphrase) = 0;
 
     //! Return whether wallet is locked.
     virtual bool isLocked() = 0;
 
     //! Change wallet passphrase.
     virtual bool
     changeWalletPassphrase(const SecureString &old_wallet_passphrase,
                            const SecureString &new_wallet_passphrase) = 0;
 
     //! Abort a rescan.
     virtual void abortRescan() = 0;
 
     //! Back up wallet.
     virtual bool backupWallet(const std::string &filename) = 0;
 
     //! Get wallet name.
     virtual std::string getWalletName() = 0;
 
     //! Get chainparams.
     virtual const CChainParams &getChainParams() = 0;
 
     //! Get set of addresses corresponding to a given label.
     virtual std::set<CTxDestination>
     getLabelAddresses(const std::string &label) = 0;
 
     // Get a new address.
     virtual bool getNewDestination(const OutputType type,
                                    const std::string label,
                                    CTxDestination &dest) = 0;
 
     //! Get public key.
     virtual bool getPubKey(const CScript &script, const CKeyID &address,
                            CPubKey &pub_key) = 0;
 
     //! Sign message
     virtual SigningResult signMessage(const std::string &message,
                                       const PKHash &pkhash,
                                       std::string &str_sig) = 0;
 
     //! Return whether wallet has private key.
     virtual bool isSpendable(const CTxDestination &dest) = 0;
 
     //! Return whether wallet has watch only keys.
     virtual bool haveWatchOnly() = 0;
 
     //! Add or update address.
     virtual bool setAddressBook(const CTxDestination &dest,
                                 const std::string &name,
                                 const std::string &purpose) = 0;
 
     // Remove address.
     virtual bool delAddressBook(const CTxDestination &dest) = 0;
 
     //! Look up address in wallet, return whether exists.
     virtual bool getAddress(const CTxDestination &dest, std::string *name,
                             isminetype *is_mine, std::string *purpose) = 0;
 
     //! Get wallet address list.
     virtual std::vector<WalletAddress> getAddresses() = 0;
 
     //! Add dest data.
     virtual bool addDestData(const CTxDestination &dest, const std::string &key,
                              const std::string &value) = 0;
 
     //! Erase dest data.
     virtual bool eraseDestData(const CTxDestination &dest,
                                const std::string &key) = 0;
 
     //! Get dest values with prefix.
     virtual std::vector<std::string>
     getDestValues(const std::string &prefix) = 0;
 
     //! Lock coin.
     virtual void lockCoin(const COutPoint &output) = 0;
 
     //! Unlock coin.
     virtual void unlockCoin(const COutPoint &output) = 0;
 
     //! Return whether coin is locked.
     virtual bool isLockedCoin(const COutPoint &output) = 0;
 
     //! List locked coins.
     virtual void listLockedCoins(std::vector<COutPoint> &outputs) = 0;
 
     //! Create transaction.
     virtual CTransactionRef
     createTransaction(const std::vector<CRecipient> &recipients,
                       const CCoinControl &coin_control, bool sign,
                       int &change_pos, Amount &fee,
                       bilingual_str &fail_reason) = 0;
 
     //! Commit transaction.
     virtual void commitTransaction(CTransactionRef tx, WalletValueMap value_map,
                                    WalletOrderForm order_form) = 0;
 
     //! Return whether transaction can be abandoned.
     virtual bool transactionCanBeAbandoned(const TxId &txid) = 0;
 
     //! Abandon transaction.
     virtual bool abandonTransaction(const TxId &txid) = 0;
 
     //! Get a transaction.
     virtual CTransactionRef getTx(const TxId &txid) = 0;
 
     //! Get transaction information.
     virtual WalletTx getWalletTx(const TxId &txid) = 0;
 
     //! Get list of all wallet transactions.
     virtual std::vector<WalletTx> getWalletTxs() = 0;
 
     //! Try to get updated status for a particular transaction, if possible
     //! without blocking.
     virtual bool tryGetTxStatus(const TxId &txid, WalletTxStatus &tx_status,
                                 int &num_blocks, int64_t &block_time) = 0;
 
     //! Get transaction details.
     virtual WalletTx getWalletTxDetails(const TxId &txid,
                                         WalletTxStatus &tx_status,
                                         WalletOrderForm &order_form,
                                         bool &in_mempool, int &num_blocks) = 0;
 
     //! Fill PSBT.
     virtual TransactionError fillPSBT(SigHashType sighash_type, bool sign,
                                       bool bip32derivs,
                                       PartiallySignedTransaction &psbtx,
                                       bool &complete) const = 0;
 
     //! Get balances.
     virtual WalletBalances getBalances() = 0;
 
     //! Get balances if possible without blocking.
     virtual bool tryGetBalances(WalletBalances &balances,
                                 BlockHash &block_hash) = 0;
 
     //! Get balance.
     virtual Amount getBalance() = 0;
 
     //! Get available balance.
     virtual Amount getAvailableBalance(const CCoinControl &coin_control) = 0;
 
     //! Return whether transaction input belongs to wallet.
     virtual isminetype txinIsMine(const CTxIn &txin) = 0;
 
     //! Return whether transaction output belongs to wallet.
     virtual isminetype txoutIsMine(const CTxOut &txout) = 0;
 
     //! Return debit amount if transaction input belongs to wallet.
     virtual Amount getDebit(const CTxIn &txin, isminefilter filter) = 0;
 
     //! Return credit amount if transaction input belongs to wallet.
     virtual Amount getCredit(const CTxOut &txout, isminefilter filter) = 0;
 
     //! Return AvailableCoins + LockedCoins grouped by wallet address.
     //! (put change in one group with wallet address)
     using CoinsList = std::map<CTxDestination,
                                std::vector<std::tuple<COutPoint, WalletTxOut>>>;
     virtual CoinsList listCoins() = 0;
 
     //! Return wallet transaction output information.
     virtual std::vector<WalletTxOut>
     getCoins(const std::vector<COutPoint> &outputs) = 0;
 
     //! Get required fee.
     virtual Amount getRequiredFee(unsigned int tx_bytes) = 0;
 
     //! Get minimum fee.
     virtual Amount getMinimumFee(unsigned int tx_bytes,
                                  const CCoinControl &coin_control) = 0;
 
     // Return whether HD enabled.
     virtual bool hdEnabled() = 0;
 
     // Return whether the wallet is blank.
     virtual bool canGetAddresses() const = 0;
 
     // Return whether private keys enabled.
     virtual bool privateKeysDisabled() = 0;
 
     // Get default address type.
     virtual OutputType getDefaultAddressType() = 0;
 
     //! Get max tx fee.
     virtual Amount getDefaultMaxTxFee() = 0;
 
     // Remove wallet.
     virtual void remove() = 0;
 
     //! Return whether is a legacy wallet
     virtual bool isLegacy() = 0;
 
     //! Register handler for unload message.
     using UnloadFn = std::function<void()>;
     virtual std::unique_ptr<Handler> handleUnload(UnloadFn fn) = 0;
 
     //! Register handler for show progress messages.
     using ShowProgressFn =
         std::function<void(const std::string &title, int progress)>;
     virtual std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) = 0;
 
     //! Register handler for status changed messages.
     using StatusChangedFn = std::function<void()>;
     virtual std::unique_ptr<Handler>
     handleStatusChanged(StatusChangedFn fn) = 0;
 
     //! Register handler for address book changed messages.
     using AddressBookChangedFn = std::function<void(
         const CTxDestination &address, const std::string &label, bool is_mine,
         const std::string &purpose, ChangeType status)>;
     virtual std::unique_ptr<Handler>
     handleAddressBookChanged(AddressBookChangedFn fn) = 0;
 
     //! Register handler for transaction changed messages.
     using TransactionChangedFn =
         std::function<void(const TxId &txid, ChangeType status)>;
     virtual std::unique_ptr<Handler>
     handleTransactionChanged(TransactionChangedFn fn) = 0;
 
     //! Register handler for watchonly changed messages.
     using WatchOnlyChangedFn = std::function<void(bool have_watch_only)>;
     virtual std::unique_ptr<Handler>
     handleWatchOnlyChanged(WatchOnlyChangedFn fn) = 0;
 
     //! Register handler for keypool changed messages.
     using CanGetAddressesChangedFn = std::function<void()>;
     virtual std::unique_ptr<Handler>
     handleCanGetAddressesChanged(CanGetAddressesChangedFn fn) = 0;
 
     //! Return pointer to internal wallet class, useful for testing.
     virtual CWallet *wallet() { return nullptr; }
 };
 
 //! Wallet chain client that in addition to having chain client methods for
 //! starting up, shutting down, and registering RPCs, also has additional
 //! methods (called by the GUI) to load and create wallets.
 class WalletClient : public ChainClient {
 public:
     //! Create new wallet.
     virtual std::unique_ptr<Wallet>
     createWallet(const std::string &name, const SecureString &passphrase,
                  uint64_t wallet_creation_flags, bilingual_str &error,
                  std::vector<bilingual_str> &warnings) = 0;
 
     //! Load existing wallet.
     virtual std::unique_ptr<Wallet>
     loadWallet(const std::string &name, bilingual_str &error,
                std::vector<bilingual_str> &warnings) = 0;
 
     //! Return default wallet directory.
     virtual std::string getWalletDir() = 0;
 
     //! Return available wallets in wallet directory.
     virtual std::vector<std::string> listWalletDir() = 0;
 
     //! Return interfaces for accessing wallets (if any).
     virtual std::vector<std::unique_ptr<Wallet>> getWallets() = 0;
 
     //! Register handler for load wallet messages. This callback is triggered by
     //! createWallet and loadWallet above, and also triggered when wallets are
     //! loaded at startup or by RPC.
     using LoadWalletFn = std::function<void(std::unique_ptr<Wallet> wallet)>;
     virtual std::unique_ptr<Handler> handleLoadWallet(LoadWalletFn fn) = 0;
 };
 
 //! Information about one wallet address.
 struct WalletAddress {
     CTxDestination dest;
     isminetype is_mine;
     std::string name;
     std::string purpose;
 
     WalletAddress(CTxDestination destIn, isminetype isMineIn,
                   std::string nameIn, std::string purposeIn)
         : dest(std::move(destIn)), is_mine(isMineIn), name(std::move(nameIn)),
           purpose(std::move(purposeIn)) {}
 };
 
 //! Collection of wallet balances.
 struct WalletBalances {
     Amount balance = Amount::zero();
     Amount unconfirmed_balance = Amount::zero();
     Amount immature_balance = Amount::zero();
     bool have_watch_only = false;
     Amount watch_only_balance = Amount::zero();
     Amount unconfirmed_watch_only_balance = Amount::zero();
     Amount immature_watch_only_balance = Amount::zero();
 
     bool balanceChanged(const WalletBalances &prev) const {
         return balance != prev.balance ||
                unconfirmed_balance != prev.unconfirmed_balance ||
                immature_balance != prev.immature_balance ||
                watch_only_balance != prev.watch_only_balance ||
                unconfirmed_watch_only_balance !=
                    prev.unconfirmed_watch_only_balance ||
                immature_watch_only_balance != prev.immature_watch_only_balance;
     }
 };
 
 // Wallet transaction information.
 struct WalletTx {
     CTransactionRef tx;
     std::vector<isminetype> txin_is_mine;
     std::vector<isminetype> txout_is_mine;
     std::vector<CTxDestination> txout_address;
     std::vector<isminetype> txout_address_is_mine;
     Amount credit;
     Amount debit;
     Amount change;
     int64_t time;
     std::map<std::string, std::string> value_map;
     bool is_coinbase;
 };
 
 //! Updated transaction status.
 struct WalletTxStatus {
     int block_height;
     int blocks_to_maturity;
     int depth_in_main_chain;
     unsigned int time_received;
     uint32_t lock_time;
     bool is_final;
     bool is_trusted;
     bool is_abandoned;
     bool is_coinbase;
     bool is_in_main_chain;
 };
 
 //! Wallet transaction output.
 struct WalletTxOut {
     CTxOut txout;
     int64_t time;
     int depth_in_main_chain = -1;
     bool is_spent = false;
 };
 
 //! Return implementation of Wallet interface. This function is defined in
 //! dummywallet.cpp and throws if the wallet component is not compiled.
 std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet> &wallet);
 
 //! Return implementation of ChainClient interface for a wallet client. This
 //! function will be undefined in builds where ENABLE_WALLET is false.
-std::unique_ptr<WalletClient>
-MakeWalletClient(Chain &chain, ArgsManager &args,
-                 std::vector<std::string> wallet_filenames);
+std::unique_ptr<WalletClient> MakeWalletClient(Chain &chain, ArgsManager &args);
 
 } // namespace interfaces
 
 #endif // BITCOIN_INTERFACES_WALLET_H
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index 180d4778e..e8bb7fcd1 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -1,1654 +1,1658 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/bitcoingui.h>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <node/ui_interface.h>
 #include <qt/bitcoinunits.h>
 #include <qt/clientmodel.h>
 #include <qt/createwalletdialog.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #ifdef Q_OS_MAC
 #include <qt/macdockiconhandler.h>
 #endif
 #include <qt/modaloverlay.h>
 #include <qt/networkstyle.h>
 #include <qt/notificator.h>
 #include <qt/openuridialog.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/rpcconsole.h>
 #include <qt/utilitydialog.h>
 #ifdef ENABLE_WALLET
 #include <qt/walletcontroller.h>
 #include <qt/walletframe.h>
 #include <qt/walletmodel.h>
 #include <qt/walletview.h>
 #endif // ENABLE_WALLET
 #include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 
 #include <memory>
 
 #include <QAction>
 #include <QApplication>
 #include <QComboBox>
 #include <QDateTime>
 #include <QDragEnterEvent>
 #include <QListWidget>
 #include <QMenu>
 #include <QMenuBar>
 #include <QMessageBox>
 #include <QMimeData>
 #include <QProgressDialog>
 #include <QScreen>
 #include <QSettings>
 #include <QShortcut>
 #include <QStackedWidget>
 #include <QStatusBar>
 #include <QStyle>
 #include <QSystemTrayIcon>
 #include <QTimer>
 #include <QToolBar>
 #include <QUrlQuery>
 #include <QVBoxLayout>
 #include <QWindow>
 
 const std::string BitcoinGUI::DEFAULT_UIPLATFORM =
 #if defined(Q_OS_MAC)
     "macosx"
 #elif defined(Q_OS_WIN)
     "windows"
 #else
     "other"
 #endif
     ;
 
 BitcoinGUI::BitcoinGUI(interfaces::Node &node, const Config *configIn,
                        const PlatformStyle *_platformStyle,
                        const NetworkStyle *networkStyle, QWidget *parent)
     : QMainWindow(parent), m_node(node), trayIconMenu{new QMenu()},
       config(configIn), platformStyle(_platformStyle),
       m_network_style(networkStyle) {
     QSettings settings;
     if (!restoreGeometry(settings.value("MainWindowGeometry").toByteArray())) {
         // Restore failed (perhaps missing setting), center the window
         move(QGuiApplication::primaryScreen()->availableGeometry().center() -
              frameGeometry().center());
     }
 
 #ifdef ENABLE_WALLET
     enableWallet = WalletModel::isWalletEnabled();
 #endif // ENABLE_WALLET
     QApplication::setWindowIcon(m_network_style->getTrayAndWindowIcon());
     setWindowIcon(m_network_style->getTrayAndWindowIcon());
     updateWindowTitle();
 
     rpcConsole = new RPCConsole(node, _platformStyle, nullptr);
     helpMessageDialog = new HelpMessageDialog(this, false);
 #ifdef ENABLE_WALLET
     if (enableWallet) {
         /** Create wallet frame and make it the central widget */
         walletFrame = new WalletFrame(_platformStyle, this);
         setCentralWidget(walletFrame);
     } else
 #endif // ENABLE_WALLET
     {
         /**
          * When compiled without wallet or -disablewallet is provided,  the
          * central widget is the rpc console.
          */
         setCentralWidget(rpcConsole);
         Q_EMIT consoleShown(rpcConsole);
     }
 
     modalOverlay = new ModalOverlay(enableWallet, this->centralWidget());
 
     // Accept D&D of URIs
     setAcceptDrops(true);
 
     // Create actions for the toolbar, menu bar and tray/dock icon
     // Needs walletFrame to be initialized
     createActions();
 
     // Create application menu bar
     createMenuBar();
 
     // Create the toolbars
     createToolBars();
 
     // Create system tray icon and notification
     if (QSystemTrayIcon::isSystemTrayAvailable()) {
         createTrayIcon();
     }
     notificator =
         new Notificator(QApplication::applicationName(), trayIcon, this);
 
     // Create status bar
     statusBar();
 
     // Disable size grip because it looks ugly and nobody needs it
     statusBar()->setSizeGripEnabled(false);
 
     // Status bar notification icons
     QFrame *frameBlocks = new QFrame();
     frameBlocks->setContentsMargins(0, 0, 0, 0);
     frameBlocks->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
     QHBoxLayout *frameBlocksLayout = new QHBoxLayout(frameBlocks);
     frameBlocksLayout->setContentsMargins(3, 0, 3, 0);
     frameBlocksLayout->setSpacing(3);
     unitDisplayControl = new UnitDisplayStatusBarControl(platformStyle);
     labelWalletEncryptionIcon = new QLabel();
     labelWalletHDStatusIcon = new QLabel();
     labelProxyIcon = new GUIUtil::ClickableLabel();
     connectionsControl = new GUIUtil::ClickableLabel();
     labelBlocksIcon = new GUIUtil::ClickableLabel();
     if (enableWallet) {
         frameBlocksLayout->addStretch();
         frameBlocksLayout->addWidget(unitDisplayControl);
         frameBlocksLayout->addStretch();
         frameBlocksLayout->addWidget(labelWalletEncryptionIcon);
         frameBlocksLayout->addWidget(labelWalletHDStatusIcon);
     }
     frameBlocksLayout->addWidget(labelProxyIcon);
     frameBlocksLayout->addStretch();
     frameBlocksLayout->addWidget(connectionsControl);
     frameBlocksLayout->addStretch();
     frameBlocksLayout->addWidget(labelBlocksIcon);
     frameBlocksLayout->addStretch();
 
     // Progress bar and label for blocks download
     progressBarLabel = new QLabel();
     progressBarLabel->setVisible(false);
     progressBar = new GUIUtil::ProgressBar();
     progressBar->setAlignment(Qt::AlignCenter);
     progressBar->setVisible(false);
 
     // Override style sheet for progress bar for styles that have a segmented
     // progress bar, as they make the text unreadable (workaround for issue
     // #1071)
     // See https://doc.qt.io/qt-5/gallery.html
     QString curStyle = QApplication::style()->metaObject()->className();
     if (curStyle == "QWindowsStyle" || curStyle == "QWindowsXPStyle") {
         progressBar->setStyleSheet(
             "QProgressBar { background-color: #e8e8e8; border: 1px solid grey; "
             "border-radius: 7px; padding: 1px; text-align: center; } "
             "QProgressBar::chunk { background: QLinearGradient(x1: 0, y1: 0, "
             "x2: 1, y2: 0, stop: 0 #FF8000, stop: 1 orange); border-radius: "
             "7px; margin: 0px; }");
     }
 
     statusBar()->addWidget(progressBarLabel);
     statusBar()->addWidget(progressBar);
     statusBar()->addPermanentWidget(frameBlocks);
 
     // Install event filter to be able to catch status tip events
     // (QEvent::StatusTip)
     this->installEventFilter(this);
 
     // Initially wallet actions should be disabled
     setWalletActionsEnabled(false);
 
     // Subscribe to notifications from core
     subscribeToCoreSignals();
 
     connect(connectionsControl, &GUIUtil::ClickableLabel::clicked,
             [this] { m_node.setNetworkActive(!m_node.getNetworkActive()); });
     connect(labelProxyIcon, &GUIUtil::ClickableLabel::clicked,
             [this] { openOptionsDialogWithTab(OptionsDialog::TAB_NETWORK); });
 
     connect(labelBlocksIcon, &GUIUtil::ClickableLabel::clicked, this,
             &BitcoinGUI::showModalOverlay);
     connect(progressBar, &GUIUtil::ClickableProgressBar::clicked, this,
             &BitcoinGUI::showModalOverlay);
 #ifdef ENABLE_WALLET
     if (enableWallet) {
         connect(walletFrame, &WalletFrame::requestedSyncWarningInfo, this,
                 &BitcoinGUI::showModalOverlay);
     }
 #endif
 
 #ifdef Q_OS_MAC
     m_app_nap_inhibitor = new CAppNapInhibitor;
 #endif
 
     GUIUtil::handleCloseWindowShortcut(this);
 }
 
 BitcoinGUI::~BitcoinGUI() {
     // Unsubscribe from notifications from core
     unsubscribeFromCoreSignals();
 
     QSettings settings;
     settings.setValue("MainWindowGeometry", saveGeometry());
     // Hide tray icon, as deleting will let it linger until quit (on Ubuntu)
     if (trayIcon) {
         trayIcon->hide();
     }
 #ifdef Q_OS_MAC
     delete m_app_nap_inhibitor;
     delete appMenuBar;
     MacDockIconHandler::cleanup();
 #endif
 
     delete rpcConsole;
 }
 
 void BitcoinGUI::createActions() {
     QActionGroup *tabGroup = new QActionGroup(this);
     connect(modalOverlay, &ModalOverlay::triggered, tabGroup,
             &QActionGroup::setEnabled);
 
     overviewAction =
         new QAction(platformStyle->SingleColorIcon(":/icons/overview"),
                     tr("&Overview"), this);
     overviewAction->setStatusTip(tr("Show general overview of wallet"));
     overviewAction->setToolTip(overviewAction->statusTip());
     overviewAction->setCheckable(true);
     overviewAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_1));
     tabGroup->addAction(overviewAction);
 
     sendCoinsAction = new QAction(
         platformStyle->SingleColorIcon(":/icons/send"), tr("&Send"), this);
     sendCoinsAction->setStatusTip(tr("Send coins to a Bitcoin address"));
     sendCoinsAction->setToolTip(sendCoinsAction->statusTip());
     sendCoinsAction->setCheckable(true);
     sendCoinsAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_2));
     tabGroup->addAction(sendCoinsAction);
 
     sendCoinsMenuAction = new QAction(sendCoinsAction->text(), this);
     sendCoinsMenuAction->setStatusTip(sendCoinsAction->statusTip());
     sendCoinsMenuAction->setToolTip(sendCoinsMenuAction->statusTip());
 
     receiveCoinsAction = new QAction(
         platformStyle->SingleColorIcon(":/icons/receiving_addresses"),
         tr("&Receive"), this);
     receiveCoinsAction->setStatusTip(
         tr("Request payments (generates QR codes and %1: URIs)")
             .arg(QString::fromStdString(
                 config->GetChainParams().CashAddrPrefix())));
     receiveCoinsAction->setToolTip(receiveCoinsAction->statusTip());
     receiveCoinsAction->setCheckable(true);
     receiveCoinsAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_3));
     tabGroup->addAction(receiveCoinsAction);
 
     receiveCoinsMenuAction = new QAction(receiveCoinsAction->text(), this);
     receiveCoinsMenuAction->setStatusTip(receiveCoinsAction->statusTip());
     receiveCoinsMenuAction->setToolTip(receiveCoinsMenuAction->statusTip());
 
     historyAction =
         new QAction(platformStyle->SingleColorIcon(":/icons/history"),
                     tr("&Transactions"), this);
     historyAction->setStatusTip(tr("Browse transaction history"));
     historyAction->setToolTip(historyAction->statusTip());
     historyAction->setCheckable(true);
     historyAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_4));
     tabGroup->addAction(historyAction);
 
 #ifdef ENABLE_WALLET
     // These showNormalIfMinimized are needed because Send Coins and Receive
     // Coins can be triggered from the tray menu, and need to show the GUI to be
     // useful.
     connect(overviewAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(overviewAction, &QAction::triggered, this,
             &BitcoinGUI::gotoOverviewPage);
     connect(sendCoinsAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(sendCoinsAction, &QAction::triggered,
             [this] { gotoSendCoinsPage(); });
     connect(sendCoinsMenuAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(sendCoinsMenuAction, &QAction::triggered,
             [this] { gotoSendCoinsPage(); });
     connect(receiveCoinsAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(receiveCoinsAction, &QAction::triggered, this,
             &BitcoinGUI::gotoReceiveCoinsPage);
     connect(receiveCoinsMenuAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(receiveCoinsMenuAction, &QAction::triggered, this,
             &BitcoinGUI::gotoReceiveCoinsPage);
     connect(historyAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(historyAction, &QAction::triggered, this,
             &BitcoinGUI::gotoHistoryPage);
 #endif // ENABLE_WALLET
 
     quitAction = new QAction(tr("E&xit"), this);
     quitAction->setStatusTip(tr("Quit application"));
     quitAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q));
     quitAction->setMenuRole(QAction::QuitRole);
     aboutAction = new QAction(tr("&About %1").arg(PACKAGE_NAME), this);
     aboutAction->setStatusTip(
         tr("Show information about %1").arg(PACKAGE_NAME));
     aboutAction->setMenuRole(QAction::AboutRole);
     aboutAction->setEnabled(false);
     aboutQtAction = new QAction(tr("About &Qt"), this);
     aboutQtAction->setStatusTip(tr("Show information about Qt"));
     aboutQtAction->setMenuRole(QAction::AboutQtRole);
     optionsAction = new QAction(tr("&Options..."), this);
     optionsAction->setStatusTip(
         tr("Modify configuration options for %1").arg(PACKAGE_NAME));
     optionsAction->setMenuRole(QAction::PreferencesRole);
     optionsAction->setEnabled(false);
     toggleHideAction = new QAction(tr("&Show / Hide"), this);
     toggleHideAction->setStatusTip(tr("Show or hide the main Window"));
 
     encryptWalletAction = new QAction(tr("&Encrypt Wallet..."), this);
     encryptWalletAction->setStatusTip(
         tr("Encrypt the private keys that belong to your wallet"));
     encryptWalletAction->setCheckable(true);
     backupWalletAction = new QAction(tr("&Backup Wallet..."), this);
     backupWalletAction->setStatusTip(tr("Backup wallet to another location"));
     changePassphraseAction = new QAction(tr("&Change Passphrase..."), this);
     changePassphraseAction->setStatusTip(
         tr("Change the passphrase used for wallet encryption"));
     signMessageAction = new QAction(tr("Sign &message..."), this);
     signMessageAction->setStatusTip(
         tr("Sign messages with your Bitcoin addresses to prove you own them"));
     verifyMessageAction = new QAction(tr("&Verify message..."), this);
     verifyMessageAction->setStatusTip(
         tr("Verify messages to ensure they were signed with specified Bitcoin "
            "addresses"));
     m_load_psbt_action = new QAction(tr("Load PSBT..."), this);
     m_load_psbt_action->setStatusTip(
         tr("Load Partially Signed Bitcoin Transaction"));
 
     openRPCConsoleAction = new QAction(tr("&Debug window"), this);
     openRPCConsoleAction->setStatusTip(
         tr("Open node debugging and diagnostic console"));
     // initially disable the debug window menu item
     openRPCConsoleAction->setEnabled(false);
     openRPCConsoleAction->setObjectName("openRPCConsoleAction");
 
     usedSendingAddressesAction = new QAction(tr("&Sending addresses"), this);
     usedSendingAddressesAction->setStatusTip(
         tr("Show the list of used sending addresses and labels"));
     usedReceivingAddressesAction =
         new QAction(tr("&Receiving addresses"), this);
     usedReceivingAddressesAction->setStatusTip(
         tr("Show the list of used receiving addresses and labels"));
 
     openAction = new QAction(tr("Open &URI..."), this);
     openAction->setStatusTip(
         tr("Open a %1: URI or payment request")
             .arg(QString::fromStdString(
                 config->GetChainParams().CashAddrPrefix())));
 
     m_open_wallet_action = new QAction(tr("Open Wallet"), this);
     m_open_wallet_action->setEnabled(false);
     m_open_wallet_action->setStatusTip(tr("Open a wallet"));
     m_open_wallet_menu = new QMenu(this);
 
     m_close_wallet_action = new QAction(tr("Close Wallet..."), this);
     m_close_wallet_action->setStatusTip(tr("Close wallet"));
 
     m_create_wallet_action = new QAction(tr("Create Wallet..."), this);
     m_create_wallet_action->setEnabled(false);
     m_create_wallet_action->setStatusTip(tr("Create a new wallet"));
 
     m_close_all_wallets_action = new QAction(tr("Close All Wallets..."), this);
     m_close_all_wallets_action->setStatusTip(tr("Close all wallets"));
 
     showHelpMessageAction = new QAction(tr("&Command-line options"), this);
     showHelpMessageAction->setMenuRole(QAction::NoRole);
     showHelpMessageAction->setStatusTip(
         tr("Show the %1 help message to get a list with possible Bitcoin "
            "command-line options")
             .arg(PACKAGE_NAME));
 
     m_mask_values_action = new QAction(tr("&Mask values"), this);
     m_mask_values_action->setShortcut(
         QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_M));
     m_mask_values_action->setStatusTip(
         tr("Mask the values in the Overview tab"));
     m_mask_values_action->setCheckable(true);
 
     connect(quitAction, &QAction::triggered, qApp, QApplication::quit);
     connect(aboutAction, &QAction::triggered, this, &BitcoinGUI::aboutClicked);
     connect(aboutQtAction, &QAction::triggered, qApp, QApplication::aboutQt);
     connect(optionsAction, &QAction::triggered, this,
             &BitcoinGUI::optionsClicked);
     connect(toggleHideAction, &QAction::triggered, this,
             &BitcoinGUI::toggleHidden);
     connect(showHelpMessageAction, &QAction::triggered, this,
             &BitcoinGUI::showHelpMessageClicked);
     connect(openRPCConsoleAction, &QAction::triggered, this,
             &BitcoinGUI::showDebugWindow);
     // prevents an open debug window from becoming stuck/unusable on client
     // shutdown
     connect(quitAction, &QAction::triggered, rpcConsole, &QWidget::hide);
 
 #ifdef ENABLE_WALLET
     if (walletFrame) {
         connect(encryptWalletAction, &QAction::triggered, walletFrame,
                 &WalletFrame::encryptWallet);
         connect(backupWalletAction, &QAction::triggered, walletFrame,
                 &WalletFrame::backupWallet);
         connect(changePassphraseAction, &QAction::triggered, walletFrame,
                 &WalletFrame::changePassphrase);
         connect(signMessageAction, &QAction::triggered,
                 [this] { showNormalIfMinimized(); });
         connect(signMessageAction, &QAction::triggered,
                 [this] { gotoSignMessageTab(); });
         connect(verifyMessageAction, &QAction::triggered,
                 [this] { showNormalIfMinimized(); });
         connect(verifyMessageAction, &QAction::triggered,
                 [this] { gotoVerifyMessageTab(); });
         connect(m_load_psbt_action, &QAction::triggered,
                 [this] { gotoLoadPSBT(); });
         connect(usedSendingAddressesAction, &QAction::triggered, walletFrame,
                 &WalletFrame::usedSendingAddresses);
         connect(usedReceivingAddressesAction, &QAction::triggered, walletFrame,
                 &WalletFrame::usedReceivingAddresses);
         connect(openAction, &QAction::triggered, this,
                 &BitcoinGUI::openClicked);
         connect(m_open_wallet_menu, &QMenu::aboutToShow, [this] {
             m_open_wallet_menu->clear();
             for (const std::pair<const std::string, bool> &i :
                  m_wallet_controller->listWalletDir()) {
                 const std::string &path = i.first;
                 QString name = path.empty()
                                    ? QString("[" + tr("default wallet") + "]")
                                    : QString::fromStdString(path);
                 // Menu items remove single &. Single & are shown when && is in
                 // the string, but only the first occurrence. So replace only
                 // the first & with &&
                 name.replace(name.indexOf(QChar('&')), 1, QString("&&"));
                 QAction *action = m_open_wallet_menu->addAction(name);
 
                 if (i.second) {
                     // This wallet is already loaded
                     action->setEnabled(false);
                     continue;
                 }
 
                 connect(action, &QAction::triggered, [this, path] {
                     auto activity =
                         new OpenWalletActivity(m_wallet_controller, this);
                     connect(activity, &OpenWalletActivity::opened, this,
                             &BitcoinGUI::setCurrentWallet);
                     connect(activity, &OpenWalletActivity::finished, activity,
                             &QObject::deleteLater);
                     activity->open(path);
                 });
             }
             if (m_open_wallet_menu->isEmpty()) {
                 QAction *action =
                     m_open_wallet_menu->addAction(tr("No wallets available"));
                 action->setEnabled(false);
             }
         });
         connect(m_close_wallet_action, &QAction::triggered, [this] {
             m_wallet_controller->closeWallet(walletFrame->currentWalletModel(),
                                              this);
         });
         connect(m_create_wallet_action, &QAction::triggered, [this] {
             auto activity = new CreateWalletActivity(m_wallet_controller, this);
             connect(activity, &CreateWalletActivity::created, this,
                     &BitcoinGUI::setCurrentWallet);
             connect(activity, &CreateWalletActivity::finished, activity,
                     &QObject::deleteLater);
             activity->create();
         });
         connect(m_close_all_wallets_action, &QAction::triggered,
                 [this] { m_wallet_controller->closeAllWallets(this); });
         connect(m_mask_values_action, &QAction::toggled, this,
                 &BitcoinGUI::setPrivacy);
     }
 #endif // ENABLE_WALLET
 
     connect(new QShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_C), this),
             &QShortcut::activated, this,
             &BitcoinGUI::showDebugWindowActivateConsole);
     connect(new QShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_D), this),
             &QShortcut::activated, this, &BitcoinGUI::showDebugWindow);
 }
 
 void BitcoinGUI::createMenuBar() {
 #ifdef Q_OS_MAC
     // Create a decoupled menu bar on Mac which stays even if the window is
     // closed
     appMenuBar = new QMenuBar();
 #else
     // Get the main window's menu bar on other platforms
     appMenuBar = menuBar();
 #endif
 
     // Configure the menus
     QMenu *file = appMenuBar->addMenu(tr("&File"));
     if (walletFrame) {
         file->addAction(m_create_wallet_action);
         file->addAction(m_open_wallet_action);
         file->addAction(m_close_wallet_action);
         file->addAction(m_close_all_wallets_action);
         file->addSeparator();
         file->addAction(openAction);
         file->addAction(backupWalletAction);
         file->addAction(signMessageAction);
         file->addAction(verifyMessageAction);
         file->addAction(m_load_psbt_action);
         file->addSeparator();
     }
     file->addAction(quitAction);
 
     QMenu *settings = appMenuBar->addMenu(tr("&Settings"));
     if (walletFrame) {
         settings->addAction(encryptWalletAction);
         settings->addAction(changePassphraseAction);
         settings->addSeparator();
         settings->addAction(m_mask_values_action);
         settings->addSeparator();
     }
     settings->addAction(optionsAction);
 
     QMenu *window_menu = appMenuBar->addMenu(tr("&Window"));
 
     QAction *minimize_action = window_menu->addAction(tr("Minimize"));
     minimize_action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M));
     connect(minimize_action, &QAction::triggered,
             [] { QApplication::activeWindow()->showMinimized(); });
     connect(qApp, &QApplication::focusWindowChanged,
             [minimize_action](QWindow *window) {
                 minimize_action->setEnabled(
                     window != nullptr &&
                     (window->flags() & Qt::Dialog) != Qt::Dialog &&
                     window->windowState() != Qt::WindowMinimized);
             });
 
 #ifdef Q_OS_MAC
     QAction *zoom_action = window_menu->addAction(tr("Zoom"));
     connect(zoom_action, &QAction::triggered, [] {
         QWindow *window = qApp->focusWindow();
         if (window->windowState() != Qt::WindowMaximized) {
             window->showMaximized();
         } else {
             window->showNormal();
         }
     });
 
     connect(qApp, &QApplication::focusWindowChanged,
             [zoom_action](QWindow *window) {
                 zoom_action->setEnabled(window != nullptr);
             });
 #endif
 
     if (walletFrame) {
 #ifdef Q_OS_MAC
         window_menu->addSeparator();
         QAction *main_window_action = window_menu->addAction(tr("Main Window"));
         connect(main_window_action, &QAction::triggered,
                 [this] { GUIUtil::bringToFront(this); });
 #endif
         window_menu->addSeparator();
         window_menu->addAction(usedSendingAddressesAction);
         window_menu->addAction(usedReceivingAddressesAction);
     }
 
     window_menu->addSeparator();
     for (RPCConsole::TabTypes tab_type : rpcConsole->tabs()) {
         QAction *tab_action =
             window_menu->addAction(rpcConsole->tabTitle(tab_type));
         tab_action->setShortcut(rpcConsole->tabShortcut(tab_type));
         connect(tab_action, &QAction::triggered, [this, tab_type] {
             rpcConsole->setTabFocus(tab_type);
             showDebugWindow();
         });
     }
 
     QMenu *help = appMenuBar->addMenu(tr("&Help"));
     help->addAction(showHelpMessageAction);
     help->addSeparator();
     help->addAction(aboutAction);
     help->addAction(aboutQtAction);
 }
 
 void BitcoinGUI::createToolBars() {
     if (walletFrame) {
         QToolBar *toolbar = addToolBar(tr("Tabs toolbar"));
         appToolBar = toolbar;
         toolbar->setContextMenuPolicy(Qt::PreventContextMenu);
         toolbar->setMovable(false);
         toolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
         toolbar->addAction(overviewAction);
         toolbar->addAction(sendCoinsAction);
         toolbar->addAction(receiveCoinsAction);
         toolbar->addAction(historyAction);
         overviewAction->setChecked(true);
 
 #ifdef ENABLE_WALLET
         QWidget *spacer = new QWidget();
         spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
         toolbar->addWidget(spacer);
 
         m_wallet_selector = new QComboBox();
         m_wallet_selector->setSizeAdjustPolicy(QComboBox::AdjustToContents);
         connect(m_wallet_selector,
                 static_cast<void (QComboBox::*)(int)>(
                     &QComboBox::currentIndexChanged),
                 this, &BitcoinGUI::setCurrentWalletBySelectorIndex);
 
         m_wallet_selector_label = new QLabel();
         m_wallet_selector_label->setText(tr("Wallet:") + " ");
         m_wallet_selector_label->setBuddy(m_wallet_selector);
 
         m_wallet_selector_label_action =
             appToolBar->addWidget(m_wallet_selector_label);
         m_wallet_selector_action = appToolBar->addWidget(m_wallet_selector);
 
         m_wallet_selector_label_action->setVisible(false);
         m_wallet_selector_action->setVisible(false);
 #endif
     }
 }
 
 void BitcoinGUI::setClientModel(ClientModel *_clientModel,
                                 interfaces::BlockAndHeaderTipInfo *tip_info) {
     this->clientModel = _clientModel;
     if (_clientModel) {
         // Create system tray menu (or setup the dock menu) that late to prevent
         // users from calling actions, while the client has not yet fully loaded
         createTrayIconMenu();
 
         // Keep up to date with client
         updateNetworkState();
         connect(_clientModel, &ClientModel::numConnectionsChanged, this,
                 &BitcoinGUI::setNumConnections);
         connect(_clientModel, &ClientModel::networkActiveChanged, this,
                 &BitcoinGUI::setNetworkActive);
 
         modalOverlay->setKnownBestHeight(
             tip_info->header_height,
             QDateTime::fromTime_t(tip_info->header_time));
         setNumBlocks(tip_info->block_height,
                      QDateTime::fromTime_t(tip_info->block_time),
                      tip_info->verification_progress, false,
                      SynchronizationState::INIT_DOWNLOAD);
         connect(_clientModel, &ClientModel::numBlocksChanged, this,
                 &BitcoinGUI::setNumBlocks);
 
         // Receive and report messages from client model
         connect(_clientModel, &ClientModel::message,
                 [this](const QString &title, const QString &message,
                        unsigned int style) {
                     this->message(title, message, style);
                 });
 
         // Show progress dialog
         connect(_clientModel, &ClientModel::showProgress, this,
                 &BitcoinGUI::showProgress);
 
         rpcConsole->setClientModel(_clientModel, tip_info->block_height,
                                    tip_info->block_time,
                                    tip_info->verification_progress);
 
         updateProxyIcon();
 
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->setClientModel(_clientModel);
         }
 #endif // ENABLE_WALLET
         unitDisplayControl->setOptionsModel(_clientModel->getOptionsModel());
 
         OptionsModel *optionsModel = _clientModel->getOptionsModel();
         if (optionsModel && trayIcon) {
             // be aware of the tray icon disable state change reported by the
             // OptionsModel object.
             connect(optionsModel, &OptionsModel::hideTrayIconChanged, this,
                     &BitcoinGUI::setTrayIconVisible);
 
             // initialize the disable state of the tray icon with the current
             // value in the model.
             setTrayIconVisible(optionsModel->getHideTrayIcon());
         }
     } else {
         // Disable possibility to show main window via action
         toggleHideAction->setEnabled(false);
         if (trayIconMenu) {
             // Disable context menu on tray icon
             trayIconMenu->clear();
         }
         // Propagate cleared model to child objects
         rpcConsole->setClientModel(nullptr);
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->setClientModel(nullptr);
         }
 #endif // ENABLE_WALLET
         unitDisplayControl->setOptionsModel(nullptr);
     }
 }
 
 #ifdef ENABLE_WALLET
 void BitcoinGUI::setWalletController(WalletController *wallet_controller) {
     assert(!m_wallet_controller);
     assert(wallet_controller);
 
     m_wallet_controller = wallet_controller;
 
     m_create_wallet_action->setEnabled(true);
     m_open_wallet_action->setEnabled(true);
     m_open_wallet_action->setMenu(m_open_wallet_menu);
 
     connect(wallet_controller, &WalletController::walletAdded, this,
             &BitcoinGUI::addWallet);
     connect(wallet_controller, &WalletController::walletRemoved, this,
             &BitcoinGUI::removeWallet);
 
     for (WalletModel *wallet_model : m_wallet_controller->getOpenWallets()) {
         addWallet(wallet_model);
     }
 }
 
+WalletController *BitcoinGUI::getWalletController() {
+    return m_wallet_controller;
+}
+
 void BitcoinGUI::addWallet(WalletModel *walletModel) {
     if (!walletFrame) {
         return;
     }
     if (!walletFrame->addWallet(walletModel)) {
         return;
     }
     const QString display_name = walletModel->getDisplayName();
     setWalletActionsEnabled(true);
     rpcConsole->addWallet(walletModel);
     m_wallet_selector->addItem(display_name, QVariant::fromValue(walletModel));
     if (m_wallet_selector->count() == 2) {
         m_wallet_selector_label_action->setVisible(true);
         m_wallet_selector_action->setVisible(true);
     }
 }
 
 void BitcoinGUI::removeWallet(WalletModel *walletModel) {
     if (!walletFrame) {
         return;
     }
 
     labelWalletHDStatusIcon->hide();
     labelWalletEncryptionIcon->hide();
 
     int index = m_wallet_selector->findData(QVariant::fromValue(walletModel));
     m_wallet_selector->removeItem(index);
     if (m_wallet_selector->count() == 0) {
         setWalletActionsEnabled(false);
         overviewAction->setChecked(true);
     } else if (m_wallet_selector->count() == 1) {
         m_wallet_selector_label_action->setVisible(false);
         m_wallet_selector_action->setVisible(false);
     }
     rpcConsole->removeWallet(walletModel);
     walletFrame->removeWallet(walletModel);
     updateWindowTitle();
 }
 
 void BitcoinGUI::setCurrentWallet(WalletModel *wallet_model) {
     if (!walletFrame) {
         return;
     }
     walletFrame->setCurrentWallet(wallet_model);
     for (int index = 0; index < m_wallet_selector->count(); ++index) {
         if (m_wallet_selector->itemData(index).value<WalletModel *>() ==
             wallet_model) {
             m_wallet_selector->setCurrentIndex(index);
             break;
         }
     }
     updateWindowTitle();
 }
 
 void BitcoinGUI::setCurrentWalletBySelectorIndex(int index) {
     WalletModel *wallet_model =
         m_wallet_selector->itemData(index).value<WalletModel *>();
     if (wallet_model) {
         setCurrentWallet(wallet_model);
     }
 }
 
 void BitcoinGUI::removeAllWallets() {
     if (!walletFrame) {
         return;
     }
     setWalletActionsEnabled(false);
     walletFrame->removeAllWallets();
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::setWalletActionsEnabled(bool enabled) {
     overviewAction->setEnabled(enabled);
     sendCoinsAction->setEnabled(enabled);
     sendCoinsMenuAction->setEnabled(enabled);
     receiveCoinsAction->setEnabled(enabled);
     receiveCoinsMenuAction->setEnabled(enabled);
     historyAction->setEnabled(enabled);
     encryptWalletAction->setEnabled(enabled);
     backupWalletAction->setEnabled(enabled);
     changePassphraseAction->setEnabled(enabled);
     signMessageAction->setEnabled(enabled);
     verifyMessageAction->setEnabled(enabled);
     usedSendingAddressesAction->setEnabled(enabled);
     usedReceivingAddressesAction->setEnabled(enabled);
     openAction->setEnabled(enabled);
     m_close_wallet_action->setEnabled(enabled);
     m_close_all_wallets_action->setEnabled(enabled);
 }
 
 void BitcoinGUI::createTrayIcon() {
     assert(QSystemTrayIcon::isSystemTrayAvailable());
 
 #ifndef Q_OS_MAC
     if (QSystemTrayIcon::isSystemTrayAvailable()) {
         trayIcon =
             new QSystemTrayIcon(m_network_style->getTrayAndWindowIcon(), this);
         QString toolTip = tr("%1 client").arg(PACKAGE_NAME) + " " +
                           m_network_style->getTitleAddText();
         trayIcon->setToolTip(toolTip);
     }
 #endif
 }
 
 void BitcoinGUI::createTrayIconMenu() {
 #ifndef Q_OS_MAC
     // Return if trayIcon is unset (only on non-macOSes)
     if (!trayIcon) {
         return;
     }
 
     trayIcon->setContextMenu(trayIconMenu.get());
     connect(trayIcon, &QSystemTrayIcon::activated, this,
             &BitcoinGUI::trayIconActivated);
 #else
     // Note: On macOS, the Dock icon is used to provide the tray's
     // functionality.
     MacDockIconHandler *dockIconHandler = MacDockIconHandler::instance();
     connect(dockIconHandler, &MacDockIconHandler::dockIconClicked, this,
             &BitcoinGUI::macosDockIconActivated);
     trayIconMenu->setAsDockMenu();
 #endif
 
     // Configuration of the tray icon (or Dock icon) menu
 #ifndef Q_OS_MAC
     // Note: On macOS, the Dock icon's menu already has Show / Hide action.
     trayIconMenu->addAction(toggleHideAction);
     trayIconMenu->addSeparator();
 #endif
     if (enableWallet) {
         trayIconMenu->addAction(sendCoinsMenuAction);
         trayIconMenu->addAction(receiveCoinsMenuAction);
         trayIconMenu->addSeparator();
         trayIconMenu->addAction(signMessageAction);
         trayIconMenu->addAction(verifyMessageAction);
         trayIconMenu->addSeparator();
     }
     trayIconMenu->addAction(optionsAction);
     trayIconMenu->addAction(openRPCConsoleAction);
 #ifndef Q_OS_MAC
     // This is built-in on macOS
     trayIconMenu->addSeparator();
     trayIconMenu->addAction(quitAction);
 #endif
 }
 
 #ifndef Q_OS_MAC
 void BitcoinGUI::trayIconActivated(QSystemTrayIcon::ActivationReason reason) {
     if (reason == QSystemTrayIcon::Trigger) {
         // Click on system tray icon triggers show/hide of the main window
         toggleHidden();
     }
 }
 #else
 void BitcoinGUI::macosDockIconActivated() {
     show();
     activateWindow();
 }
 #endif
 
 void BitcoinGUI::optionsClicked() {
     openOptionsDialogWithTab(OptionsDialog::TAB_MAIN);
 }
 
 void BitcoinGUI::aboutClicked() {
     if (!clientModel) {
         return;
     }
 
     HelpMessageDialog dlg(this, true);
     dlg.exec();
 }
 
 void BitcoinGUI::showDebugWindow() {
     GUIUtil::bringToFront(rpcConsole);
     Q_EMIT consoleShown(rpcConsole);
 }
 
 void BitcoinGUI::showDebugWindowActivateConsole() {
     rpcConsole->setTabFocus(RPCConsole::TabTypes::CONSOLE);
     showDebugWindow();
 }
 
 void BitcoinGUI::showHelpMessageClicked() {
     helpMessageDialog->show();
 }
 
 #ifdef ENABLE_WALLET
 void BitcoinGUI::openClicked() {
     OpenURIDialog dlg(config->GetChainParams(), this);
     if (dlg.exec()) {
         Q_EMIT receivedURI(dlg.getURI());
     }
 }
 
 void BitcoinGUI::gotoOverviewPage() {
     overviewAction->setChecked(true);
     if (walletFrame) {
         walletFrame->gotoOverviewPage();
     }
 }
 
 void BitcoinGUI::gotoHistoryPage() {
     historyAction->setChecked(true);
     if (walletFrame) {
         walletFrame->gotoHistoryPage();
     }
 }
 
 void BitcoinGUI::gotoReceiveCoinsPage() {
     receiveCoinsAction->setChecked(true);
     if (walletFrame) {
         walletFrame->gotoReceiveCoinsPage();
     }
 }
 
 void BitcoinGUI::gotoSendCoinsPage(QString addr) {
     sendCoinsAction->setChecked(true);
     if (walletFrame) {
         walletFrame->gotoSendCoinsPage(addr);
     }
 }
 
 void BitcoinGUI::gotoSignMessageTab(QString addr) {
     if (walletFrame) {
         walletFrame->gotoSignMessageTab(addr);
     }
 }
 
 void BitcoinGUI::gotoVerifyMessageTab(QString addr) {
     if (walletFrame) {
         walletFrame->gotoVerifyMessageTab(addr);
     }
 }
 void BitcoinGUI::gotoLoadPSBT() {
     if (walletFrame) {
         walletFrame->gotoLoadPSBT();
     }
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::updateNetworkState() {
     int count = clientModel->getNumConnections();
     QString icon;
     switch (count) {
         case 0:
             icon = ":/icons/connect_0";
             break;
         case 1:
         case 2:
         case 3:
             icon = ":/icons/connect_1";
             break;
         case 4:
         case 5:
         case 6:
             icon = ":/icons/connect_2";
             break;
         case 7:
         case 8:
         case 9:
             icon = ":/icons/connect_3";
             break;
         default:
             icon = ":/icons/connect_4";
             break;
     }
 
     QString tooltip;
 
     if (m_node.getNetworkActive()) {
         tooltip = tr("%n active connection(s) to Bitcoin network", "", count) +
                   QString(".<br>") + tr("Click to disable network activity.");
     } else {
         tooltip = tr("Network activity disabled.") + QString("<br>") +
                   tr("Click to enable network activity again.");
         icon = ":/icons/network_disabled";
     }
 
     // Don't word-wrap this (fixed-width) tooltip
     tooltip = QString("<nobr>") + tooltip + QString("</nobr>");
     connectionsControl->setToolTip(tooltip);
 
     connectionsControl->setPixmap(platformStyle->SingleColorIcon(icon).pixmap(
         STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
 }
 
 void BitcoinGUI::setNumConnections(int count) {
     updateNetworkState();
 }
 
 void BitcoinGUI::setNetworkActive(bool networkActive) {
     updateNetworkState();
 }
 
 void BitcoinGUI::updateHeadersSyncProgressLabel() {
     int64_t headersTipTime = clientModel->getHeaderTipTime();
     int headersTipHeight = clientModel->getHeaderTipHeight();
     int estHeadersLeft =
         (GetTime() - headersTipTime) /
         config->GetChainParams().GetConsensus().nPowTargetSpacing;
     if (estHeadersLeft > HEADER_HEIGHT_DELTA_SYNC) {
         progressBarLabel->setText(
             tr("Syncing Headers (%1%)...")
                 .arg(QString::number(100.0 /
                                          (headersTipHeight + estHeadersLeft) *
                                          headersTipHeight,
                                      'f', 1)));
     }
 }
 
 void BitcoinGUI::openOptionsDialogWithTab(OptionsDialog::Tab tab) {
     if (!clientModel || !clientModel->getOptionsModel()) {
         return;
     }
 
     OptionsDialog dlg(this, enableWallet);
     dlg.setCurrentTab(tab);
     dlg.setModel(clientModel->getOptionsModel());
     dlg.exec();
 }
 
 void BitcoinGUI::setNumBlocks(int count, const QDateTime &blockDate,
                               double nVerificationProgress, bool header,
                               SynchronizationState sync_state) {
 // Disabling macOS App Nap on initial sync, disk and reindex operations.
 #ifdef Q_OS_MAC
     if (sync_state == SynchronizationState::POST_INIT) {
         m_app_nap_inhibitor->enableAppNap();
     } else {
         m_app_nap_inhibitor->disableAppNap();
     }
 #endif
 
     if (modalOverlay) {
         if (header) {
             modalOverlay->setKnownBestHeight(count, blockDate);
         } else {
             modalOverlay->tipUpdate(count, blockDate, nVerificationProgress);
         }
     }
     if (!clientModel) {
         return;
     }
 
     // Prevent orphan statusbar messages (e.g. hover Quit in main menu, wait
     // until chain-sync starts -> garbled text)
     statusBar()->clearMessage();
 
     // Acquire current block source
     enum BlockSource blockSource = clientModel->getBlockSource();
     switch (blockSource) {
         case BlockSource::NETWORK:
             if (header) {
                 updateHeadersSyncProgressLabel();
                 return;
             }
             progressBarLabel->setText(tr("Synchronizing with network..."));
             updateHeadersSyncProgressLabel();
             break;
         case BlockSource::DISK:
             if (header) {
                 progressBarLabel->setText(tr("Indexing blocks on disk..."));
             } else {
                 progressBarLabel->setText(tr("Processing blocks on disk..."));
             }
             break;
         case BlockSource::REINDEX:
             progressBarLabel->setText(tr("Reindexing blocks on disk..."));
             break;
         case BlockSource::NONE:
             if (header) {
                 return;
             }
             progressBarLabel->setText(tr("Connecting to peers..."));
             break;
     }
 
     QString tooltip;
 
     QDateTime currentDate = QDateTime::currentDateTime();
     qint64 secs = blockDate.secsTo(currentDate);
 
     tooltip = tr("Processed %n block(s) of transaction history.", "", count);
 
     // Set icon state: spinning if catching up, tick otherwise
     if (secs < MAX_BLOCK_TIME_GAP) {
         tooltip = tr("Up to date") + QString(".<br>") + tooltip;
         labelBlocksIcon->setPixmap(
             platformStyle->SingleColorIcon(":/icons/synced")
                 .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
 
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->showOutOfSyncWarning(false);
             modalOverlay->showHide(true, true);
         }
 #endif // ENABLE_WALLET
 
         progressBarLabel->setVisible(false);
         progressBar->setVisible(false);
     } else {
         QString timeBehindText = GUIUtil::formatNiceTimeOffset(secs);
 
         progressBarLabel->setVisible(true);
         progressBar->setFormat(tr("%1 behind").arg(timeBehindText));
         progressBar->setMaximum(1000000000);
         progressBar->setValue(nVerificationProgress * 1000000000.0 + 0.5);
         progressBar->setVisible(true);
 
         tooltip = tr("Catching up...") + QString("<br>") + tooltip;
         if (count != prevBlocks) {
             labelBlocksIcon->setPixmap(
                 platformStyle
                     ->SingleColorIcon(QString(":/animation/spinner-%1")
                                           .arg(spinnerFrame, 3, 10, QChar('0')))
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES;
         }
         prevBlocks = count;
 
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->showOutOfSyncWarning(true);
             modalOverlay->showHide();
         }
 #endif // ENABLE_WALLET
 
         tooltip += QString("<br>");
         tooltip +=
             tr("Last received block was generated %1 ago.").arg(timeBehindText);
         tooltip += QString("<br>");
         tooltip += tr("Transactions after this will not yet be visible.");
     }
 
     // Don't word-wrap this (fixed-width) tooltip
     tooltip = QString("<nobr>") + tooltip + QString("</nobr>");
 
     labelBlocksIcon->setToolTip(tooltip);
     progressBarLabel->setToolTip(tooltip);
     progressBar->setToolTip(tooltip);
 }
 
 void BitcoinGUI::message(const QString &title, QString message,
                          unsigned int style, bool *ret,
                          const QString &detailed_message) {
     // Default title. On macOS, the window title is ignored (as required by the
     // macOS Guidelines).
     QString strTitle{PACKAGE_NAME};
     // Default to information icon
     int nMBoxIcon = QMessageBox::Information;
     int nNotifyIcon = Notificator::Information;
 
     QString msgType;
     if (!title.isEmpty()) {
         msgType = title;
     } else {
         switch (style) {
             case CClientUIInterface::MSG_ERROR:
                 msgType = tr("Error");
                 message = tr("Error: %1").arg(message);
                 break;
             case CClientUIInterface::MSG_WARNING:
                 msgType = tr("Warning");
                 message = tr("Warning: %1").arg(message);
                 break;
             case CClientUIInterface::MSG_INFORMATION:
                 msgType = tr("Information");
                 // No need to prepend the prefix here.
                 break;
             default:
                 break;
         }
     }
 
     if (!msgType.isEmpty()) {
         strTitle += " - " + msgType;
     }
 
     if (style & CClientUIInterface::ICON_ERROR) {
         nMBoxIcon = QMessageBox::Critical;
         nNotifyIcon = Notificator::Critical;
     } else if (style & CClientUIInterface::ICON_WARNING) {
         nMBoxIcon = QMessageBox::Warning;
         nNotifyIcon = Notificator::Warning;
     }
 
     if (style & CClientUIInterface::MODAL) {
         // Check for buttons, use OK as default, if none was supplied
         QMessageBox::StandardButton buttons;
         if (!(buttons = (QMessageBox::StandardButton)(
                   style & CClientUIInterface::BTN_MASK))) {
             buttons = QMessageBox::Ok;
         }
 
         showNormalIfMinimized();
         QMessageBox mBox(static_cast<QMessageBox::Icon>(nMBoxIcon), strTitle,
                          message, buttons, this);
         mBox.setTextFormat(Qt::PlainText);
         mBox.setDetailedText(detailed_message);
         int r = mBox.exec();
         if (ret != nullptr) {
             *ret = r == QMessageBox::Ok;
         }
     } else {
         notificator->notify(static_cast<Notificator::Class>(nNotifyIcon),
                             strTitle, message);
     }
 }
 
 void BitcoinGUI::changeEvent(QEvent *e) {
     QMainWindow::changeEvent(e);
 #ifndef Q_OS_MAC // Ignored on Mac
     if (e->type() == QEvent::WindowStateChange) {
         if (clientModel && clientModel->getOptionsModel() &&
             clientModel->getOptionsModel()->getMinimizeToTray()) {
             QWindowStateChangeEvent *wsevt =
                 static_cast<QWindowStateChangeEvent *>(e);
             if (!(wsevt->oldState() & Qt::WindowMinimized) && isMinimized()) {
                 QTimer::singleShot(0, this, &BitcoinGUI::hide);
                 e->ignore();
             } else if ((wsevt->oldState() & Qt::WindowMinimized) &&
                        !isMinimized()) {
                 QTimer::singleShot(0, this, &BitcoinGUI::show);
                 e->ignore();
             }
         }
     }
 #endif
 }
 
 void BitcoinGUI::closeEvent(QCloseEvent *event) {
 #ifndef Q_OS_MAC // Ignored on Mac
     if (clientModel && clientModel->getOptionsModel()) {
         if (!clientModel->getOptionsModel()->getMinimizeOnClose()) {
             // close rpcConsole in case it was open to make some space for the
             // shutdown window
             rpcConsole->close();
 
             QApplication::quit();
         } else {
             QMainWindow::showMinimized();
             event->ignore();
         }
     }
 #else
     QMainWindow::closeEvent(event);
 #endif
 }
 
 void BitcoinGUI::showEvent(QShowEvent *event) {
     // enable the debug window when the main window shows up
     openRPCConsoleAction->setEnabled(true);
     aboutAction->setEnabled(true);
     optionsAction->setEnabled(true);
 }
 
 #ifdef ENABLE_WALLET
 void BitcoinGUI::incomingTransaction(const QString &date, int unit,
                                      const Amount amount, const QString &type,
                                      const QString &address,
                                      const QString &label,
                                      const QString &walletName) {
     // On new transaction, make an info balloon
     QString msg = tr("Date: %1\n").arg(date) +
                   tr("Amount: %1\n")
                       .arg(BitcoinUnits::formatWithUnit(unit, amount, true));
     if (m_node.walletClient().getWallets().size() > 1 &&
         !walletName.isEmpty()) {
         msg += tr("Wallet: %1\n").arg(walletName);
     }
     msg += tr("Type: %1\n").arg(type);
     if (!label.isEmpty()) {
         msg += tr("Label: %1\n").arg(label);
     } else if (!address.isEmpty()) {
         msg += tr("Address: %1\n").arg(address);
     }
     message(amount < Amount::zero() ? tr("Sent transaction")
                                     : tr("Incoming transaction"),
             msg, CClientUIInterface::MSG_INFORMATION);
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::dragEnterEvent(QDragEnterEvent *event) {
     // Accept only URIs
     if (event->mimeData()->hasUrls()) {
         event->acceptProposedAction();
     }
 }
 
 void BitcoinGUI::dropEvent(QDropEvent *event) {
     if (event->mimeData()->hasUrls()) {
         for (const QUrl &uri : event->mimeData()->urls()) {
             Q_EMIT receivedURI(uri.toString());
         }
     }
     event->acceptProposedAction();
 }
 
 bool BitcoinGUI::eventFilter(QObject *object, QEvent *event) {
     // Catch status tip events
     if (event->type() == QEvent::StatusTip) {
         // Prevent adding text from setStatusTip(), if we currently use the
         // status bar for displaying other stuff
         if (progressBarLabel->isVisible() || progressBar->isVisible()) {
             return true;
         }
     }
     return QMainWindow::eventFilter(object, event);
 }
 
 #ifdef ENABLE_WALLET
 bool BitcoinGUI::handlePaymentRequest(const SendCoinsRecipient &recipient) {
     // URI has to be valid
     if (walletFrame && walletFrame->handlePaymentRequest(recipient)) {
         showNormalIfMinimized();
         gotoSendCoinsPage();
         return true;
     }
     return false;
 }
 
 void BitcoinGUI::setHDStatus(bool privkeyDisabled, int hdEnabled) {
     labelWalletHDStatusIcon->setPixmap(
         platformStyle
             ->SingleColorIcon(privkeyDisabled
                                   ? ":/icons/eye"
                                   : hdEnabled ? ":/icons/hd_enabled"
                                               : ":/icons/hd_disabled")
             .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
     labelWalletHDStatusIcon->setToolTip(
         privkeyDisabled
             ? tr("Private key <b>disabled</b>")
             : hdEnabled ? tr("HD key generation is <b>enabled</b>")
                         : tr("HD key generation is <b>disabled</b>"));
     labelWalletHDStatusIcon->show();
     // eventually disable the QLabel to set its opacity to 50%
     labelWalletHDStatusIcon->setEnabled(hdEnabled);
 }
 
 void BitcoinGUI::setEncryptionStatus(int status) {
     switch (status) {
         case WalletModel::Unencrypted:
             labelWalletEncryptionIcon->hide();
             encryptWalletAction->setChecked(false);
             changePassphraseAction->setEnabled(false);
             encryptWalletAction->setEnabled(true);
             break;
         case WalletModel::Unlocked:
             labelWalletEncryptionIcon->show();
             labelWalletEncryptionIcon->setPixmap(
                 platformStyle->SingleColorIcon(":/icons/lock_open")
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             labelWalletEncryptionIcon->setToolTip(
                 tr("Wallet is <b>encrypted</b> and currently <b>unlocked</b>"));
             encryptWalletAction->setChecked(true);
             changePassphraseAction->setEnabled(true);
             encryptWalletAction->setEnabled(false);
             break;
         case WalletModel::Locked:
             labelWalletEncryptionIcon->show();
             labelWalletEncryptionIcon->setPixmap(
                 platformStyle->SingleColorIcon(":/icons/lock_closed")
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             labelWalletEncryptionIcon->setToolTip(
                 tr("Wallet is <b>encrypted</b> and currently <b>locked</b>"));
             encryptWalletAction->setChecked(true);
             changePassphraseAction->setEnabled(true);
             encryptWalletAction->setEnabled(false);
             break;
     }
 }
 
 void BitcoinGUI::updateWalletStatus() {
     if (!walletFrame) {
         return;
     }
     WalletView *const walletView = walletFrame->currentWalletView();
     if (!walletView) {
         return;
     }
     WalletModel *const walletModel = walletView->getWalletModel();
     setEncryptionStatus(walletModel->getEncryptionStatus());
     setHDStatus(walletModel->wallet().privateKeysDisabled(),
                 walletModel->wallet().hdEnabled());
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::updateProxyIcon() {
     std::string ip_port;
     bool proxy_enabled = clientModel->getProxyInfo(ip_port);
 
     if (proxy_enabled) {
         if (!labelProxyIcon->hasPixmap()) {
             QString ip_port_q = QString::fromStdString(ip_port);
             labelProxyIcon->setPixmap(
                 platformStyle->SingleColorIcon(":/icons/proxy")
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             labelProxyIcon->setToolTip(
                 tr("Proxy is <b>enabled</b>: %1").arg(ip_port_q));
         } else {
             labelProxyIcon->show();
         }
     } else {
         labelProxyIcon->hide();
     }
 }
 
 void BitcoinGUI::updateWindowTitle() {
     QString window_title = PACKAGE_NAME;
 #ifdef ENABLE_WALLET
     if (walletFrame) {
         WalletModel *const wallet_model = walletFrame->currentWalletModel();
         if (wallet_model && !wallet_model->getWalletName().isEmpty()) {
             window_title += " - " + wallet_model->getDisplayName();
         }
     }
 #endif
     if (!m_network_style->getTitleAddText().isEmpty()) {
         window_title += " - " + m_network_style->getTitleAddText();
     }
     setWindowTitle(window_title);
 }
 
 void BitcoinGUI::showNormalIfMinimized(bool fToggleHidden) {
     if (!clientModel) {
         return;
     }
 
     if (!isHidden() && !isMinimized() && !GUIUtil::isObscured(this) &&
         fToggleHidden) {
         hide();
     } else {
         GUIUtil::bringToFront(this);
     }
 }
 
 void BitcoinGUI::toggleHidden() {
     showNormalIfMinimized(true);
 }
 
 void BitcoinGUI::detectShutdown() {
     if (m_node.shutdownRequested()) {
         if (rpcConsole) {
             rpcConsole->hide();
         }
         qApp->quit();
     }
 }
 
 void BitcoinGUI::showProgress(const QString &title, int nProgress) {
     if (nProgress == 0) {
         progressDialog = new QProgressDialog(title, QString(), 0, 100);
         GUIUtil::PolishProgressDialog(progressDialog);
         progressDialog->setWindowModality(Qt::ApplicationModal);
         progressDialog->setMinimumDuration(0);
         progressDialog->setAutoClose(false);
         progressDialog->setValue(0);
     } else if (nProgress == 100) {
         if (progressDialog) {
             progressDialog->close();
             progressDialog->deleteLater();
             progressDialog = nullptr;
         }
     } else if (progressDialog) {
         progressDialog->setValue(nProgress);
     }
 }
 
 void BitcoinGUI::setTrayIconVisible(bool fHideTrayIcon) {
     if (trayIcon) {
         trayIcon->setVisible(!fHideTrayIcon);
     }
 }
 
 void BitcoinGUI::showModalOverlay() {
     if (modalOverlay &&
         (progressBar->isVisible() || modalOverlay->isLayerVisible())) {
         modalOverlay->toggleVisibility();
     }
 }
 
 static bool ThreadSafeMessageBox(BitcoinGUI *gui, const bilingual_str &message,
                                  const std::string &caption,
                                  unsigned int style) {
     bool modal = (style & CClientUIInterface::MODAL);
     // The SECURE flag has no effect in the Qt GUI.
     // bool secure = (style & CClientUIInterface::SECURE);
     style &= ~CClientUIInterface::SECURE;
     bool ret = false;
     // This is original message, in English, for googling and referencing.
     QString detailed_message;
     if (message.original != message.translated) {
         detailed_message = BitcoinGUI::tr("Original message:") + "\n" +
                            QString::fromStdString(message.original);
     }
 
     // In case of modal message, use blocking connection to wait for user to
     // click a button
     bool invoked = QMetaObject::invokeMethod(
         gui, "message",
         modal ? GUIUtil::blockingGUIThreadConnection() : Qt::QueuedConnection,
         Q_ARG(QString, QString::fromStdString(caption)),
         Q_ARG(QString, QString::fromStdString(message.translated)),
         Q_ARG(unsigned int, style), Q_ARG(bool *, &ret),
         Q_ARG(QString, detailed_message));
     assert(invoked);
     return ret;
 }
 
 void BitcoinGUI::subscribeToCoreSignals() {
     // Connect signals to client
     m_handler_message_box = m_node.handleMessageBox(
         std::bind(ThreadSafeMessageBox, this, std::placeholders::_1,
                   std::placeholders::_2, std::placeholders::_3));
     m_handler_question = m_node.handleQuestion(
         std::bind(ThreadSafeMessageBox, this, std::placeholders::_1,
                   std::placeholders::_3, std::placeholders::_4));
 }
 
 void BitcoinGUI::unsubscribeFromCoreSignals() {
     // Disconnect signals from client
     m_handler_message_box->disconnect();
     m_handler_question->disconnect();
 }
 
 bool BitcoinGUI::isPrivacyModeActivated() const {
     assert(m_mask_values_action);
     return m_mask_values_action->isChecked();
 }
 
 UnitDisplayStatusBarControl::UnitDisplayStatusBarControl(
     const PlatformStyle *platformStyle)
     : optionsModel(nullptr), menu(nullptr) {
     createContextMenu();
     setToolTip(tr("Unit to show amounts in. Click to select another unit."));
     QList<BitcoinUnits::Unit> units = BitcoinUnits::availableUnits();
     int max_width = 0;
     const QFontMetrics fm(font());
     for (const BitcoinUnits::Unit unit : units) {
         max_width = qMax(max_width,
                          GUIUtil::TextWidth(fm, BitcoinUnits::longName(unit)));
     }
     setMinimumSize(max_width, 0);
     setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     setStyleSheet(QString("QLabel { color : %1 }")
                       .arg(platformStyle->SingleColor().name()));
 }
 
 /** So that it responds to button clicks */
 void UnitDisplayStatusBarControl::mousePressEvent(QMouseEvent *event) {
     onDisplayUnitsClicked(event->pos());
 }
 
 /** Creates context menu, its actions, and wires up all the relevant signals for
  * mouse events. */
 void UnitDisplayStatusBarControl::createContextMenu() {
     menu = new QMenu(this);
     for (const BitcoinUnits::Unit u : BitcoinUnits::availableUnits()) {
         QAction *menuAction =
             new QAction(QString(BitcoinUnits::longName(u)), this);
         menuAction->setData(QVariant(u));
         menu->addAction(menuAction);
     }
     connect(menu, &QMenu::triggered, this,
             &UnitDisplayStatusBarControl::onMenuSelection);
 }
 
 /** Lets the control know about the Options Model (and its signals) */
 void UnitDisplayStatusBarControl::setOptionsModel(OptionsModel *_optionsModel) {
     if (_optionsModel) {
         this->optionsModel = _optionsModel;
 
         // be aware of a display unit change reported by the OptionsModel
         // object.
         connect(_optionsModel, &OptionsModel::displayUnitChanged, this,
                 &UnitDisplayStatusBarControl::updateDisplayUnit);
 
         // initialize the display units label with the current value in the
         // model.
         updateDisplayUnit(_optionsModel->getDisplayUnit());
     }
 }
 
 /** When Display Units are changed on OptionsModel it will refresh the display
  * text of the control on the status bar */
 void UnitDisplayStatusBarControl::updateDisplayUnit(int newUnits) {
     setText(BitcoinUnits::longName(newUnits));
 }
 
 /** Shows context menu with Display Unit options by the mouse coordinates */
 void UnitDisplayStatusBarControl::onDisplayUnitsClicked(const QPoint &point) {
     QPoint globalPos = mapToGlobal(point);
     menu->exec(globalPos);
 }
 
 /** Tells underlying optionsModel to update its current display unit. */
 void UnitDisplayStatusBarControl::onMenuSelection(QAction *action) {
     if (action) {
         optionsModel->setDisplayUnit(action->data());
     }
 }
diff --git a/src/qt/bitcoingui.h b/src/qt/bitcoingui.h
index 948bfd78d..e463aa9eb 100644
--- a/src/qt/bitcoingui.h
+++ b/src/qt/bitcoingui.h
@@ -1,376 +1,377 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_QT_BITCOINGUI_H
 #define BITCOIN_QT_BITCOINGUI_H
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/optionsdialog.h>
 
 #include <amount.h>
 
 #include <QLabel>
 #include <QMainWindow>
 #include <QMap>
 #include <QPoint>
 #include <QSystemTrayIcon>
 
 #ifdef Q_OS_MAC
 #include <qt/macos_appnap.h>
 #endif
 
 #include <memory>
 
 class ClientModel;
 class Config;
 class HelpMessageDialog;
 class ModalOverlay;
 class NetworkStyle;
 class Notificator;
 class OptionsModel;
 class PlatformStyle;
 class RPCConsole;
 class SendCoinsRecipient;
 enum class SynchronizationState;
 class UnitDisplayStatusBarControl;
 class WalletController;
 class WalletFrame;
 class WalletModel;
 
 namespace interfaces {
 class Handler;
 class Node;
 struct BlockAndHeaderTipInfo;
 } // namespace interfaces
 
 QT_BEGIN_NAMESPACE
 class QAction;
 class QComboBox;
 class QMenu;
 class QProgressBar;
 class QProgressDialog;
 QT_END_NAMESPACE
 
 namespace GUIUtil {
 class ClickableLabel;
 class ClickableProgressBar;
 } // namespace GUIUtil
 
 /**
  * Bitcoin GUI main class. This class represents the main window of the Bitcoin
  * UI. It communicates with both the client and wallet models to give the user
  * an up-to-date view of the current core state.
  */
 class BitcoinGUI : public QMainWindow {
     Q_OBJECT
 
 public:
     static const std::string DEFAULT_UIPLATFORM;
 
     explicit BitcoinGUI(interfaces::Node &node, const Config *,
                         const PlatformStyle *platformStyle,
                         const NetworkStyle *networkStyle,
                         QWidget *parent = nullptr);
     ~BitcoinGUI();
 
     /**
      * Set the client model.
      * The client model represents the part of the core that communicates with
      * the P2P network, and is wallet-agnostic.
      */
     void setClientModel(ClientModel *clientModel = nullptr,
                         interfaces::BlockAndHeaderTipInfo *tip_info = nullptr);
 #ifdef ENABLE_WALLET
     void setWalletController(WalletController *wallet_controller);
+    WalletController *getWalletController();
 #endif
 
 #ifdef ENABLE_WALLET
     /**
      * Set the wallet model.
      * The wallet model represents a bitcoin wallet, and offers access to the
      * list of transactions, address book and sending functionality.
      */
     void addWallet(WalletModel *walletModel);
     void removeWallet(WalletModel *walletModel);
     void removeAllWallets();
 #endif // ENABLE_WALLET
     bool enableWallet = false;
 
     /** Disconnect core signals from GUI client */
     void unsubscribeFromCoreSignals();
 
     bool isPrivacyModeActivated() const;
 
     /**
      * Get the tray icon status.
      * Some systems have not "system tray" or "notification area" available.
      */
     bool hasTrayIcon() const { return trayIcon; }
 
 protected:
     void changeEvent(QEvent *e) override;
     void closeEvent(QCloseEvent *event) override;
     void showEvent(QShowEvent *event) override;
     void dragEnterEvent(QDragEnterEvent *event) override;
     void dropEvent(QDropEvent *event) override;
     bool eventFilter(QObject *object, QEvent *event) override;
 
 private:
     interfaces::Node &m_node;
     WalletController *m_wallet_controller{nullptr};
     std::unique_ptr<interfaces::Handler> m_handler_message_box;
     std::unique_ptr<interfaces::Handler> m_handler_question;
     ClientModel *clientModel = nullptr;
     WalletFrame *walletFrame = nullptr;
 
     UnitDisplayStatusBarControl *unitDisplayControl = nullptr;
     QLabel *labelWalletEncryptionIcon = nullptr;
     QLabel *labelWalletHDStatusIcon = nullptr;
     GUIUtil::ClickableLabel *labelProxyIcon = nullptr;
     GUIUtil::ClickableLabel *connectionsControl = nullptr;
     GUIUtil::ClickableLabel *labelBlocksIcon = nullptr;
     QLabel *progressBarLabel = nullptr;
     GUIUtil::ClickableProgressBar *progressBar = nullptr;
     QProgressDialog *progressDialog = nullptr;
 
     QMenuBar *appMenuBar = nullptr;
     QToolBar *appToolBar = nullptr;
     QAction *overviewAction = nullptr;
     QAction *historyAction = nullptr;
     QAction *quitAction = nullptr;
     QAction *sendCoinsAction = nullptr;
     QAction *sendCoinsMenuAction = nullptr;
     QAction *usedSendingAddressesAction = nullptr;
     QAction *usedReceivingAddressesAction = nullptr;
     QAction *signMessageAction = nullptr;
     QAction *verifyMessageAction = nullptr;
     QAction *m_load_psbt_action = nullptr;
     QAction *aboutAction = nullptr;
     QAction *receiveCoinsAction = nullptr;
     QAction *receiveCoinsMenuAction = nullptr;
     QAction *optionsAction = nullptr;
     QAction *toggleHideAction = nullptr;
     QAction *encryptWalletAction = nullptr;
     QAction *backupWalletAction = nullptr;
     QAction *changePassphraseAction = nullptr;
     QAction *aboutQtAction = nullptr;
     QAction *openRPCConsoleAction = nullptr;
     QAction *openAction = nullptr;
     QAction *showHelpMessageAction = nullptr;
     QAction *m_create_wallet_action{nullptr};
     QAction *m_open_wallet_action{nullptr};
     QMenu *m_open_wallet_menu{nullptr};
     QAction *m_close_wallet_action{nullptr};
     QAction *m_close_all_wallets_action{nullptr};
     QAction *m_wallet_selector_label_action = nullptr;
     QAction *m_wallet_selector_action = nullptr;
     QAction *m_mask_values_action{nullptr};
 
     QLabel *m_wallet_selector_label = nullptr;
     QComboBox *m_wallet_selector = nullptr;
 
     QSystemTrayIcon *trayIcon = nullptr;
     const std::unique_ptr<QMenu> trayIconMenu;
     Notificator *notificator = nullptr;
     RPCConsole *rpcConsole = nullptr;
     HelpMessageDialog *helpMessageDialog = nullptr;
     ModalOverlay *modalOverlay = nullptr;
 
 #ifdef Q_OS_MAC
     CAppNapInhibitor *m_app_nap_inhibitor = nullptr;
 #endif
 
     /** Keep track of previous number of blocks, to detect progress */
     int prevBlocks = 0;
     int spinnerFrame = 0;
 
     const Config *config;
     const PlatformStyle *platformStyle;
     const NetworkStyle *const m_network_style;
 
     /** Create the main UI actions. */
     void createActions();
     /** Create the menu bar and sub-menus. */
     void createMenuBar();
     /** Create the toolbars */
     void createToolBars();
     /** Create system tray icon and notification */
     void createTrayIcon();
     /** Create system tray menu (or setup the dock menu) */
     void createTrayIconMenu();
 
     /** Enable or disable all wallet-related actions */
     void setWalletActionsEnabled(bool enabled);
 
     /** Connect core signals to GUI client */
     void subscribeToCoreSignals();
 
     /** Update UI with latest network info from model. */
     void updateNetworkState();
 
     void updateHeadersSyncProgressLabel();
 
     /** Open the OptionsDialog on the specified tab index */
     void openOptionsDialogWithTab(OptionsDialog::Tab tab);
 
 Q_SIGNALS:
     /** Signal raised when a URI was entered or dragged to the GUI */
     void receivedURI(const QString &uri);
     /** Signal raised when RPC console shown */
     void consoleShown(RPCConsole *console);
     void setPrivacy(bool privacy);
 
 public Q_SLOTS:
     /** Set number of connections shown in the UI */
     void setNumConnections(int count);
     /** Set network state shown in the UI */
     void setNetworkActive(bool networkActive);
     /** Set number of blocks and last block date shown in the UI */
     void setNumBlocks(int count, const QDateTime &blockDate,
                       double nVerificationProgress, bool headers,
                       SynchronizationState sync_state);
 
     /**
      * Notify the user of an event from the core network or transaction
      * handling code.
      * @param[in] title     the message box / notification title
      * @param[in] message   the displayed text
      * @param[in] style     modality and style definitions (icon and used
      * buttons - buttons only for message boxes)
      *                      @see CClientUIInterface::MessageBoxFlags
      * @param[in] ret       pointer to a bool that will be modified to whether
      * Ok was clicked (modal only)
      * @param[in] detailed_message  the text to be displayed in the details area
      */
     void message(const QString &title, QString message, unsigned int style,
                  bool *ret = nullptr,
                  const QString &detailed_message = QString());
 
 #ifdef ENABLE_WALLET
     void setCurrentWallet(WalletModel *wallet_model);
     void setCurrentWalletBySelectorIndex(int index);
     /** Set the UI status indicators based on the currently selected wallet.
      */
     void updateWalletStatus();
 
 private:
     /** Set the encryption status as shown in the UI.
        @param[in] status            current encryption status
        @see WalletModel::EncryptionStatus
      */
     void setEncryptionStatus(int status);
 
     /** Set the hd-enabled status as shown in the UI.
      @param[in] hdEnabled         current hd enabled status
      @see WalletModel::EncryptionStatus
      */
     void setHDStatus(bool privkeyDisabled, int hdEnabled);
 
 public Q_SLOTS:
     bool handlePaymentRequest(const SendCoinsRecipient &recipient);
 
     /** Show incoming transaction notification for new transactions. */
     void incomingTransaction(const QString &date, int unit, const Amount amount,
                              const QString &type, const QString &address,
                              const QString &label, const QString &walletName);
 #endif // ENABLE_WALLET
 
 private:
     /** Set the proxy-enabled icon as shown in the UI. */
     void updateProxyIcon();
     void updateWindowTitle();
 
 public Q_SLOTS:
 #ifdef ENABLE_WALLET
     /** Switch to overview (home) page */
     void gotoOverviewPage();
     /** Switch to history (transactions) page */
     void gotoHistoryPage();
     /** Switch to receive coins page */
     void gotoReceiveCoinsPage();
     /** Switch to send coins page */
     void gotoSendCoinsPage(QString addr = "");
 
     /** Show Sign/Verify Message dialog and switch to sign message tab */
     void gotoSignMessageTab(QString addr = "");
     /** Show Sign/Verify Message dialog and switch to verify message tab */
     void gotoVerifyMessageTab(QString addr = "");
     /** Show load Partially Signed Bitcoin Transaction dialog */
     void gotoLoadPSBT();
 
     /** Show open dialog */
     void openClicked();
 #endif // ENABLE_WALLET
     /** Show configuration dialog */
     void optionsClicked();
     /** Show about dialog */
     void aboutClicked();
     /** Show debug window */
     void showDebugWindow();
     /** Show debug window and set focus to the console */
     void showDebugWindowActivateConsole();
     /** Show help message dialog */
     void showHelpMessageClicked();
 #ifndef Q_OS_MAC
     /** Handle tray icon clicked */
     void trayIconActivated(QSystemTrayIcon::ActivationReason reason);
 #else
     /** Handle macOS Dock icon clicked */
     void macosDockIconActivated();
 #endif
 
     /** Show window if hidden, unminimize when minimized, rise when obscured or
      * show if hidden and fToggleHidden is true */
     void showNormalIfMinimized() { showNormalIfMinimized(false); }
     void showNormalIfMinimized(bool fToggleHidden);
     /** Simply calls showNormalIfMinimized(true) for use in SLOT() macro */
     void toggleHidden();
 
     /** called by a timer to check if ShutdownRequested() has been set **/
     void detectShutdown();
 
     /** Show progress dialog e.g. for verifychain */
     void showProgress(const QString &title, int nProgress);
 
     /** When hideTrayIcon setting is changed in OptionsModel hide or show the
      * icon accordingly. */
     void setTrayIconVisible(bool);
 
     void showModalOverlay();
 };
 
 class UnitDisplayStatusBarControl : public QLabel {
     Q_OBJECT
 
 public:
     explicit UnitDisplayStatusBarControl(const PlatformStyle *platformStyle);
     /** Lets the control know about the Options Model (and its signals) */
     void setOptionsModel(OptionsModel *optionsModel);
 
 protected:
     /** So that it responds to left-button clicks */
     void mousePressEvent(QMouseEvent *event) override;
 
 private:
     OptionsModel *optionsModel;
     QMenu *menu;
 
     /** Shows context menu with Display Unit options by the mouse coordinates */
     void onDisplayUnitsClicked(const QPoint &point);
     /** Creates context menu, its actions, and wires up all the relevant signals
      * for mouse events. */
     void createContextMenu();
 
 private Q_SLOTS:
     /** When Display Units are changed on OptionsModel it will refresh the
      * display text of the control on the status bar */
     void updateDisplayUnit(int newUnits);
     /** Tells underlying optionsModel to update its current display unit. */
     void onMenuSelection(QAction *action);
 };
 
 #endif // BITCOIN_QT_BITCOINGUI_H
diff --git a/src/qt/walletframe.cpp b/src/qt/walletframe.cpp
index f00b62a1d..adf12b515 100644
--- a/src/qt/walletframe.cpp
+++ b/src/qt/walletframe.cpp
@@ -1,234 +1,261 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <qt/createwalletdialog.h>
+#include <qt/walletcontroller.h>
 #include <qt/walletframe.h>
 
 #include <qt/bitcoingui.h>
 #include <qt/walletmodel.h>
 #include <qt/walletview.h>
 
+#include <QGroupBox>
 #include <QHBoxLayout>
 #include <QLabel>
+#include <QPushButton>
+#include <QVBoxLayout>
 
 #include <cassert>
 
 WalletFrame::WalletFrame(const PlatformStyle *_platformStyle, BitcoinGUI *_gui)
     : QFrame(_gui), gui(_gui), platformStyle(_platformStyle) {
     // Leave HBox hook for adding a list view later
     QHBoxLayout *walletFrameLayout = new QHBoxLayout(this);
     setContentsMargins(0, 0, 0, 0);
     walletStack = new QStackedWidget(this);
     walletFrameLayout->setContentsMargins(0, 0, 0, 0);
     walletFrameLayout->addWidget(walletStack);
 
-    QLabel *noWallet = new QLabel(tr("No wallet has been loaded."));
+    // hbox for no wallet
+    QGroupBox *no_wallet_group = new QGroupBox(walletStack);
+    QVBoxLayout *no_wallet_layout = new QVBoxLayout(no_wallet_group);
+
+    QLabel *noWallet = new QLabel(tr("No wallet has been loaded.\nGo to File > "
+                                     "Open Wallet to load a wallet.\n- OR -"));
     noWallet->setAlignment(Qt::AlignCenter);
-    walletStack->addWidget(noWallet);
+    no_wallet_layout->addWidget(noWallet, 0,
+                                Qt::AlignHCenter | Qt::AlignBottom);
+
+    // A button for create wallet dialog
+    QPushButton *create_wallet_button =
+        new QPushButton(tr("Create a new wallet"), walletStack);
+    connect(create_wallet_button, &QPushButton::clicked, [this] {
+        auto activity =
+            new CreateWalletActivity(gui->getWalletController(), this);
+        connect(activity, &CreateWalletActivity::finished, activity,
+                &QObject::deleteLater);
+        activity->create();
+    });
+    no_wallet_layout->addWidget(create_wallet_button, 0,
+                                Qt::AlignHCenter | Qt::AlignTop);
+    no_wallet_group->setLayout(no_wallet_layout);
+
+    walletStack->addWidget(no_wallet_group);
 }
 
 WalletFrame::~WalletFrame() {}
 
 void WalletFrame::setClientModel(ClientModel *_clientModel) {
     this->clientModel = _clientModel;
 
     for (auto i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd();
          ++i) {
         i.value()->setClientModel(_clientModel);
     }
 }
 
 bool WalletFrame::addWallet(WalletModel *walletModel) {
     if (!gui || !clientModel || !walletModel) {
         return false;
     }
 
     if (mapWalletViews.count(walletModel) > 0) {
         return false;
     }
 
     WalletView *walletView = new WalletView(platformStyle, walletModel, this);
     walletView->setClientModel(clientModel);
     walletView->showOutOfSyncWarning(bOutOfSync);
     walletView->setPrivacy(gui->isPrivacyModeActivated());
 
     WalletView *current_wallet_view = currentWalletView();
     if (current_wallet_view) {
         walletView->setCurrentIndex(current_wallet_view->currentIndex());
     } else {
         walletView->gotoOverviewPage();
     }
 
     walletStack->addWidget(walletView);
     mapWalletViews[walletModel] = walletView;
 
     connect(walletView, &WalletView::outOfSyncWarningClicked, this,
             &WalletFrame::outOfSyncWarningClicked);
     connect(walletView, &WalletView::transactionClicked, gui,
             &BitcoinGUI::gotoHistoryPage);
     connect(walletView, &WalletView::coinsSent, gui,
             &BitcoinGUI::gotoHistoryPage);
     connect(
         walletView, &WalletView::message,
         [this](const QString &title, const QString &message,
                unsigned int style) { gui->message(title, message, style); });
     connect(walletView, &WalletView::encryptionStatusChanged, gui,
             &BitcoinGUI::updateWalletStatus);
     connect(walletView, &WalletView::incomingTransaction, gui,
             &BitcoinGUI::incomingTransaction);
     connect(walletView, &WalletView::hdEnabledStatusChanged, gui,
             &BitcoinGUI::updateWalletStatus);
     connect(gui, &BitcoinGUI::setPrivacy, walletView, &WalletView::setPrivacy);
 
     return true;
 }
 
 void WalletFrame::setCurrentWallet(WalletModel *wallet_model) {
     if (mapWalletViews.count(wallet_model) == 0) {
         return;
     }
 
     WalletView *walletView = mapWalletViews.value(wallet_model);
     walletStack->setCurrentWidget(walletView);
     assert(walletView);
     walletView->updateEncryptionStatus();
 }
 
 void WalletFrame::removeWallet(WalletModel *wallet_model) {
     if (mapWalletViews.count(wallet_model) == 0) {
         return;
     }
 
     WalletView *walletView = mapWalletViews.take(wallet_model);
     walletStack->removeWidget(walletView);
     delete walletView;
 }
 
 void WalletFrame::removeAllWallets() {
     QMap<WalletModel *, WalletView *>::const_iterator i;
     for (i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd(); ++i) {
         walletStack->removeWidget(i.value());
     }
     mapWalletViews.clear();
 }
 
 bool WalletFrame::handlePaymentRequest(const SendCoinsRecipient &recipient) {
     WalletView *walletView = currentWalletView();
     if (!walletView) {
         return false;
     }
 
     return walletView->handlePaymentRequest(recipient);
 }
 
 void WalletFrame::showOutOfSyncWarning(bool fShow) {
     bOutOfSync = fShow;
     QMap<WalletModel *, WalletView *>::const_iterator i;
     for (i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd(); ++i) {
         i.value()->showOutOfSyncWarning(fShow);
     }
 }
 
 void WalletFrame::gotoOverviewPage() {
     QMap<WalletModel *, WalletView *>::const_iterator i;
     for (i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd(); ++i) {
         i.value()->gotoOverviewPage();
     }
 }
 
 void WalletFrame::gotoHistoryPage() {
     QMap<WalletModel *, WalletView *>::const_iterator i;
     for (i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd(); ++i) {
         i.value()->gotoHistoryPage();
     }
 }
 
 void WalletFrame::gotoReceiveCoinsPage() {
     QMap<WalletModel *, WalletView *>::const_iterator i;
     for (i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd(); ++i) {
         i.value()->gotoReceiveCoinsPage();
     }
 }
 
 void WalletFrame::gotoSendCoinsPage(QString addr) {
     QMap<WalletModel *, WalletView *>::const_iterator i;
     for (i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd(); ++i) {
         i.value()->gotoSendCoinsPage(addr);
     }
 }
 
 void WalletFrame::gotoSignMessageTab(QString addr) {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->gotoSignMessageTab(addr);
     }
 }
 
 void WalletFrame::gotoVerifyMessageTab(QString addr) {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->gotoVerifyMessageTab(addr);
     }
 }
 
 void WalletFrame::gotoLoadPSBT() {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->gotoLoadPSBT();
     }
 }
 
 void WalletFrame::encryptWallet(bool status) {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->encryptWallet(status);
     }
 }
 
 void WalletFrame::backupWallet() {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->backupWallet();
     }
 }
 
 void WalletFrame::changePassphrase() {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->changePassphrase();
     }
 }
 
 void WalletFrame::unlockWallet() {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->unlockWallet();
     }
 }
 
 void WalletFrame::usedSendingAddresses() {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->usedSendingAddresses();
     }
 }
 
 void WalletFrame::usedReceivingAddresses() {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->usedReceivingAddresses();
     }
 }
 
 WalletView *WalletFrame::currentWalletView() const {
     return qobject_cast<WalletView *>(walletStack->currentWidget());
 }
 
 WalletModel *WalletFrame::currentWalletModel() const {
     WalletView *wallet_view = currentWalletView();
     return wallet_view ? wallet_view->getWalletModel() : nullptr;
 }
 
 void WalletFrame::outOfSyncWarningClicked() {
     Q_EMIT requestedSyncWarningInfo();
 }
diff --git a/src/wallet/init.cpp b/src/wallet/init.cpp
index 9c45c8944..5a71288fe 100644
--- a/src/wallet/init.cpp
+++ b/src/wallet/init.cpp
@@ -1,221 +1,211 @@
 // 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 <interfaces/wallet.h>
 #include <net.h>
 #include <network.h>
 #include <node/context.h>
 #include <node/ui_interface.h>
 #include <univalue.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(ArgsManager &argsman) 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(ArgsManager &argsman) const {
     argsman.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);
 
     argsman.AddArg("-disablewallet",
                    "Do not load the wallet and disable wallet RPC calls",
                    ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     const auto &ticker = Currency::get().ticker;
     argsman.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)",
                              ticker, FormatMoney(DEFAULT_FALLBACK_FEE)),
                    ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     argsman.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);
     argsman.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)",
             ticker, FormatMoney(DEFAULT_MAX_AVOIDPARTIALSPEND_FEE)),
         ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     argsman.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)",
                   ticker, FormatMoney(DEFAULT_TRANSACTION_MAXFEE)),
         ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-mintxfee=<amt>",
                    strprintf("Fees (in %s/kB) smaller than this are considered "
                              "zero fee for transaction creation (default: %s)",
                              ticker,
                              FormatMoney(DEFAULT_TRANSACTION_MINFEE_PER_KB)),
                    ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     argsman.AddArg(
         "-paytxfee=<amt>",
         strprintf(
             "Fee (in %s/kB) to add to transactions you send (default: %s)",
             ticker, FormatMoney(CFeeRate{DEFAULT_PAY_TX_FEE}.GetFeePerK())),
         ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     argsman.AddArg(
         "-rescan",
         "Rescan the block chain for missing wallet transactions on startup",
         ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     argsman.AddArg(
         "-spendzeroconfchange",
         strprintf(
             "Spend unconfirmed change when sending transactions (default: %d)",
             DEFAULT_SPEND_ZEROCONF_CHANGE),
         ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     argsman.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);
     argsman.AddArg(
         "-walletbroadcast",
         strprintf("Make the wallet broadcast transactions (default: %d)",
                   DEFAULT_WALLETBROADCAST),
         ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
     argsman.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)
     argsman.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
     argsman.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);
     argsman.AddArg(
         "-flushwallet",
         strprintf("Run a thread to flush wallet periodically (default: %d)",
                   DEFAULT_FLUSHWALLET),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::WALLET_DEBUG_TEST);
     argsman.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);
     argsman.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);
 
     argsman.AddHiddenArgs({"-zapwallettxes"});
 }
 
 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;
     }
 
     if (gArgs.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY) &&
         gArgs.SoftSetBoolArg("-walletbroadcast", false)) {
         LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting "
                   "-walletbroadcast=0\n",
                   __func__);
     }
 
     if (gArgs.IsArgSet("-zapwallettxes")) {
         return InitError(
             Untranslated("-zapwallettxes has been removed. If you are "
                          "attempting to remove a stuck transaction from your "
                          "wallet, please use abandontransaction instead."));
     }
 
     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 {
     ArgsManager &args = *Assert(node.args);
     if (args.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET)) {
         LogPrintf("Wallet disabled!\n");
         return;
     }
-    // If there's no -wallet setting with a list of wallets to load, set it to
-    // load the default "" wallet.
-    if (!args.IsArgSet("wallet")) {
-        args.LockSettings([&](util::Settings &settings) {
-            util::SettingsValue wallets(util::SettingsValue::VARR);
-            wallets.push_back(""); // Default wallet name is ""
-            settings.rw_settings["wallet"] = wallets;
-        });
-    }
-    auto wallet_client = interfaces::MakeWalletClient(*node.chain, args,
-                                                      args.GetArgs("-wallet"));
+    auto wallet_client = interfaces::MakeWalletClient(*node.chain, args);
     node.wallet_client = wallet_client.get();
     node.chain_clients.emplace_back(std::move(wallet_client));
 }
diff --git a/src/wallet/load.cpp b/src/wallet/load.cpp
index 8ec90aeca..15e9904a2 100644
--- a/src/wallet/load.cpp
+++ b/src/wallet/load.cpp
@@ -1,155 +1,171 @@
 // 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 <fs.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>
 
 #include <univalue.h>
 
-bool VerifyWallets(interfaces::Chain &chain,
-                   const std::vector<std::string> &wallet_files) {
+bool VerifyWallets(interfaces::Chain &chain) {
     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);
 
+    // For backwards compatibility if an unnamed top level wallet exists in the
+    // wallets directory, include it in the default list of wallets to load.
+    if (!gArgs.IsArgSet("wallet")) {
+        DatabaseOptions options;
+        DatabaseStatus status;
+        bilingual_str error_string;
+        options.require_existing = true;
+        options.verify = false;
+        if (MakeWalletDatabase("", options, status, error_string)) {
+            gArgs.LockSettings([&](util::Settings &settings) {
+                util::SettingsValue wallets(util::SettingsValue::VARR);
+                // Default wallet name is ""
+                wallets.push_back("");
+                settings.rw_settings["wallet"] = wallets;
+            });
+        }
+    }
+
     // Keep track of each wallet absolute path to detect duplicates.
     std::set<fs::path> wallet_paths;
 
-    for (const auto &wallet_file : wallet_files) {
+    for (const auto &wallet_file : gArgs.GetArgs("-wallet")) {
         const fs::path path = fs::absolute(wallet_file, GetWalletDir());
 
         if (!wallet_paths.insert(path).second) {
             chain.initError(strprintf(_("Error loading wallet %s. Duplicate "
                                         "-wallet filename specified."),
                                       wallet_file));
             return false;
         }
 
         DatabaseOptions options;
         DatabaseStatus status;
         options.verify = true;
         bilingual_str error_string;
         if (!MakeWalletDatabase(wallet_file, options, status, error_string)) {
             chain.initError(error_string);
             return false;
         }
     }
 
     return true;
 }
 
-bool LoadWallets(interfaces::Chain &chain,
-                 const std::vector<std::string> &wallet_files) {
+bool LoadWallets(interfaces::Chain &chain) {
     try {
-        for (const std::string &name : wallet_files) {
+        for (const std::string &name : gArgs.GetArgs("-wallet")) {
             DatabaseOptions options;
             DatabaseStatus status;
             // No need to verify, assuming verified earlier in VerifyWallets()
             options.verify = false;
             bilingual_str error;
             std::vector<bilingual_str> warnings;
             std::unique_ptr<WalletDatabase> database =
                 MakeWalletDatabase(name, options, status, error);
             std::shared_ptr<CWallet> pwallet =
                 database
                     ? CWallet::Create(chain, name, std::move(database),
                                       options.create_flags, error, warnings)
                     : nullptr;
 
             if (!warnings.empty()) {
                 chain.initWarning(Join(warnings, Untranslated("\n")));
             }
             if (!pwallet) {
                 chain.initError(error);
                 return false;
             }
             AddWallet(pwallet);
         }
         return true;
     } catch (const std::runtime_error &e) {
         chain.initError(Untranslated(e.what()));
         return false;
     }
 }
 
 void StartWallets(CScheduler &scheduler, const ArgsManager &args) {
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         pwallet->postInitProcess();
     }
 
     // Schedule periodic wallet flushes and tx rebroadcasts
     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();
     }
 }
 
 void StopWallets() {
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         pwallet->Close();
     }
 }
 
 void UnloadWallets() {
     auto wallets = GetWallets();
     while (!wallets.empty()) {
         auto wallet = wallets.back();
         wallets.pop_back();
         std::vector<bilingual_str> warnings;
         RemoveWallet(wallet, std::nullopt, warnings);
         UnloadWallet(std::move(wallet));
     }
 }
diff --git a/src/wallet/load.h b/src/wallet/load.h
index dd6893e16..b45ef80a6 100644
--- a/src/wallet/load.h
+++ b/src/wallet/load.h
@@ -1,40 +1,38 @@
 // 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 CScheduler;
 
 namespace interfaces {
 class Chain;
 } // namespace interfaces
 
 //! Responsible for reading and validating the -wallet arguments and verifying
 //! the wallet database.
-bool VerifyWallets(interfaces::Chain &chain,
-                   const std::vector<std::string> &wallet_files);
+bool VerifyWallets(interfaces::Chain &chain);
 
 //! Load wallet databases.
-bool LoadWallets(interfaces::Chain &chain,
-                 const std::vector<std::string> &wallet_files);
+bool LoadWallets(interfaces::Chain &chain);
 
 //! Complete startup of wallets.
 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 7d083a0e5..ea89246ef 100644
--- a/src/wallet/test/init_test_fixture.cpp
+++ b/src/wallet/test/init_test_fixture.cpp
@@ -1,47 +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_wallet_client = MakeWalletClient(*m_chain, *Assert(m_node.args), {});
+    m_wallet_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 fc9c2916e..9cf09c594 100644
--- a/src/wallet/test/wallet_test_fixture.h
+++ b/src/wallet/test/wallet_test_fixture.h
@@ -1,32 +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::WalletClient> m_wallet_client =
-        interfaces::MakeWalletClient(*m_chain, *Assert(m_node.args), {});
+        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/test/functional/feature_dbcrash.py b/test/functional/feature_dbcrash.py
index 3fcc583bb..3ca4829c4 100755
--- a/test/functional/feature_dbcrash.py
+++ b/test/functional/feature_dbcrash.py
@@ -1,328 +1,329 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017-2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test recovery from a crash during chainstate writing.
 
 - 4 nodes
   * node0, node1, and node2 will have different dbcrash ratios, and different
     dbcache sizes
   * node3 will be a regular node, with no crashing.
   * The nodes will not connect to each other.
 
 - use default test framework starting chain. initialize starting_tip_height to
   tip height.
 
 - Main loop:
   * generate lots of transactions on node3, enough to fill up a block.
   * uniformly randomly pick a tip height from starting_tip_height to
     tip_height; with probability 1/(height_difference+4), invalidate this block.
   * mine enough blocks to overtake tip_height at start of loop.
   * for each node in [node0,node1,node2]:
      - for each mined block:
        * submit block to node
        * if node crashed on/after submitting:
          - restart until recovery succeeds
          - check that utxo matches node3 using gettxoutsetinfo"""
 
 import errno
 import http.client
 import random
 import time
 
 from test_framework.blocktools import create_confirmed_utxos
 from test_framework.cdefs import DEFAULT_MAX_BLOCK_SIZE
 from test_framework.messages import (
     XEC,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     ToHex,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, hex_str_to_bytes
 
 
 class ChainstateWriteCrashTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 4
         self.setup_clean_chain = False
         self.rpc_timeout = 480
         self.supports_cli = False
 
         # Set -maxmempool=0 to turn off mempool memory sharing with dbcache
         # Set -rpcservertimeout=900 to reduce socket disconnects in this
         # long-running test
         self.base_args = ["-limitdescendantsize=0", "-maxmempool=0",
                           "-rpcservertimeout=900", "-dbbatchsize=200000",
-                          "-noparkdeepreorg"]
+                          "-wallet=", "-noparkdeepreorg"]
 
         # Set different crash ratios and cache sizes.  Note that not all of
         # -dbcache goes to the in-memory coins cache.
         self.node0_args = ["-dbcrashratio=8", "-dbcache=4"] + self.base_args
         self.node1_args = ["-dbcrashratio=16", "-dbcache=8"] + self.base_args
         self.node2_args = ["-dbcrashratio=24", "-dbcache=16"] + self.base_args
 
         # Node3 is a normal node with default args, except will mine full blocks
         # and non-standard txs (e.g. txs with "dust" outputs)
         self.node3_args = [
-            "-blockmaxsize={}".format(DEFAULT_MAX_BLOCK_SIZE), "-acceptnonstdtxn"]
+            "-blockmaxsize={}".format(DEFAULT_MAX_BLOCK_SIZE),
+            "-acceptnonstdtxn", "-wallet="]
         self.extra_args = [self.node0_args, self.node1_args,
                            self.node2_args, self.node3_args]
 
     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()
         self.import_deterministic_coinbase_privkeys()
         # Leave them unconnected, we'll use submitblock directly in this test
 
     def restart_node(self, node_index, expected_tip):
         """Start up a given node id, wait for the tip to reach the given block hash, and calculate the utxo hash.
 
         Exceptions on startup should indicate node crash (due to -dbcrashratio), in which case we try again. Give up
         after 60 seconds. Returns the utxo hash of the given node."""
 
         time_start = time.time()
         while time.time() - time_start < 120:
             try:
                 # Any of these RPC calls could throw due to node crash
                 self.start_node(node_index)
                 self.nodes[node_index].waitforblock(expected_tip)
                 utxo_hash = self.nodes[node_index].gettxoutsetinfo()[
                     'hash_serialized']
                 return utxo_hash
             except Exception:
                 # An exception here should mean the node is about to crash.
                 # If bitcoind exits, then try again.  wait_for_node_exit()
                 # should raise an exception if bitcoind doesn't exit.
                 self.wait_for_node_exit(node_index, timeout=15)
             self.crashed_on_restart += 1
             time.sleep(1)
 
         # If we got here, bitcoind isn't coming back up on restart.  Could be a
         # bug in bitcoind, or we've gotten unlucky with our dbcrash ratio --
         # perhaps we generated a test case that blew up our cache?
         # TODO: If this happens a lot, we should try to restart without -dbcrashratio
         # and make sure that recovery happens.
         raise AssertionError(
             "Unable to successfully restart node {} in allotted time".format(node_index))
 
     def submit_block_catch_error(self, node_index, block):
         """Try submitting a block to the given node.
 
         Catch any exceptions that indicate the node has crashed.
         Returns true if the block was submitted successfully; false otherwise."""
 
         try:
             self.nodes[node_index].submitblock(block)
             return True
         except (http.client.CannotSendRequest, http.client.RemoteDisconnected) as e:
             self.log.debug(
                 "node {} submitblock raised exception: {}".format(node_index, e))
             return False
         except OSError as e:
             self.log.debug(
                 "node {} submitblock raised OSError exception: errno={}".format(node_index, e.errno))
             if e.errno in [errno.EPIPE, errno.ECONNREFUSED, errno.ECONNRESET]:
                 # The node has likely crashed
                 return False
             else:
                 # Unexpected exception, raise
                 raise
 
     def sync_node3blocks(self, block_hashes):
         """Use submitblock to sync node3's chain with the other nodes
 
         If submitblock fails, restart the node and get the new utxo hash.
         If any nodes crash while updating, we'll compare utxo hashes to
         ensure recovery was successful."""
 
         node3_utxo_hash = self.nodes[3].gettxoutsetinfo()['hash_serialized']
 
         # Retrieve all the blocks from node3
         blocks = []
         for block_hash in block_hashes:
             blocks.append(
                 [block_hash, self.nodes[3].getblock(block_hash, False)])
 
         # Deliver each block to each other node
         for i in range(3):
             nodei_utxo_hash = None
             self.log.debug("Syncing blocks to node {}".format(i))
             for (block_hash, block) in blocks:
                 # Get the block from node3, and submit to node_i
                 self.log.debug("submitting block {}".format(block_hash))
                 if not self.submit_block_catch_error(i, block):
                     # TODO: more carefully check that the crash is due to -dbcrashratio
                     # (change the exit code perhaps, and check that here?)
                     self.wait_for_node_exit(i, timeout=30)
                     self.log.debug(
                         "Restarting node {} after block hash {}".format(i, block_hash))
                     nodei_utxo_hash = self.restart_node(i, block_hash)
                     assert nodei_utxo_hash is not None
                     self.restart_counts[i] += 1
                 else:
                     # Clear it out after successful submitblock calls -- the cached
                     # utxo hash will no longer be correct
                     nodei_utxo_hash = None
 
             # Check that the utxo hash matches node3's utxo set
             # NOTE: we only check the utxo set if we had to restart the node
             # after the last block submitted:
             # - checking the utxo hash causes a cache flush, which we don't
             # want to do every time; so
             # - we only update the utxo cache after a node restart, since flushing
             # the cache is a no-op at that point
             if nodei_utxo_hash is not None:
                 self.log.debug(
                     "Checking txoutsetinfo matches for node {}".format(i))
                 assert_equal(nodei_utxo_hash, node3_utxo_hash)
 
     def verify_utxo_hash(self):
         """Verify that the utxo hash of each node matches node3.
 
         Restart any nodes that crash while querying."""
         node3_utxo_hash = self.nodes[3].gettxoutsetinfo()['hash_serialized']
         self.log.info("Verifying utxo hash matches for all nodes")
 
         for i in range(3):
             try:
                 nodei_utxo_hash = self.nodes[i].gettxoutsetinfo()[
                     'hash_serialized']
             except OSError:
                 # probably a crash on db flushing
                 nodei_utxo_hash = self.restart_node(
                     i, self.nodes[3].getbestblockhash())
             assert_equal(nodei_utxo_hash, node3_utxo_hash)
 
     def generate_small_transactions(self, node, count, utxo_list):
         FEE = 1000  # TODO: replace this with node relay fee based calculation
         num_transactions = 0
         random.shuffle(utxo_list)
         while len(utxo_list) >= 2 and num_transactions < count:
             tx = CTransaction()
             input_amount = 0
             for _ in range(2):
                 utxo = utxo_list.pop()
                 tx.vin.append(
                     CTxIn(COutPoint(int(utxo['txid'], 16), utxo['vout'])))
                 input_amount += int(utxo['amount'] * XEC)
             output_amount = (input_amount - FEE) // 3
 
             if output_amount <= 0:
                 # Sanity check -- if we chose inputs that are too small, skip
                 continue
 
             for _ in range(3):
                 tx.vout.append(
                     CTxOut(output_amount, hex_str_to_bytes(utxo['scriptPubKey'])))
 
             # Sign and send the transaction to get into the mempool
             tx_signed_hex = node.signrawtransactionwithwallet(ToHex(tx))['hex']
             node.sendrawtransaction(tx_signed_hex)
             num_transactions += 1
 
     def run_test(self):
         # Track test coverage statistics
         self.restart_counts = [0, 0, 0]  # Track the restarts for nodes 0-2
         self.crashed_on_restart = 0      # Track count of crashes during recovery
 
         # Start by creating a lot of utxos on node3
         initial_height = self.nodes[3].getblockcount()
         utxo_list = create_confirmed_utxos(self.nodes[3], 5000)
         self.log.info("Prepped {} utxo entries".format(len(utxo_list)))
 
         # Sync these blocks with the other nodes
         block_hashes_to_sync = []
         for height in range(initial_height + 1,
                             self.nodes[3].getblockcount() + 1):
             block_hashes_to_sync.append(self.nodes[3].getblockhash(height))
 
         self.log.debug("Syncing {} blocks with other nodes".format(
             len(block_hashes_to_sync)))
         # Syncing the blocks could cause nodes to crash, so the test begins
         # here.
         self.sync_node3blocks(block_hashes_to_sync)
 
         starting_tip_height = self.nodes[3].getblockcount()
 
         # Set mock time to the last block time. This will allow us to increase
         # the time at each loop so the block hash will always differ for the
         # same block height, and avoid duplication.
         # Note that the current time can be behind the block time due to the
         # way the miner sets the block time.
         tip = self.nodes[3].getbestblockhash()
         block_time = self.nodes[3].getblockheader(tip)['time']
         self.nodes[3].setmocktime(block_time)
 
         # Main test loop:
         # each time through the loop, generate a bunch of transactions,
         # and then either mine a single new block on the tip, or some-sized
         # reorg.
         for i in range(40):
             block_time += 10
             self.nodes[3].setmocktime(block_time)
 
             self.log.info(
                 "Iteration {}, generating 2500 transactions {}".format(
                     i, self.restart_counts))
             # Generate a bunch of small-ish transactions
             self.generate_small_transactions(self.nodes[3], 2500, utxo_list)
             # Pick a random block between current tip, and starting tip
             current_height = self.nodes[3].getblockcount()
             random_height = random.randint(starting_tip_height, current_height)
             self.log.debug("At height {}, considering height {}".format(
                            current_height, random_height))
             if random_height > starting_tip_height:
                 # Randomly reorg from this point with some probability (1/4 for
                 # tip, 1/5 for tip-1, ...)
                 if random.random() < 1.0 / (current_height + 4 - random_height):
                     self.log.debug(
                         "Invalidating block at height {}".format(random_height))
                     self.nodes[3].invalidateblock(
                         self.nodes[3].getblockhash(random_height))
 
             # Now generate new blocks until we pass the old tip height
             self.log.debug("Mining longer tip")
             block_hashes = []
             while current_height + 1 > self.nodes[3].getblockcount():
                 block_hashes.extend(self.nodes[3].generatetoaddress(
                     nblocks=min(10, current_height + 1 -
                                 self.nodes[3].getblockcount()),
                     # new address to avoid mining a block that has just been
                     # invalidated
                     address=self.nodes[3].getnewaddress(),
                 ))
             self.log.debug("Syncing %d new blocks...", len(block_hashes))
             self.sync_node3blocks(block_hashes)
             utxo_list = self.nodes[3].listunspent()
             self.log.debug("Node3 utxo count: {}".format(len(utxo_list)))
 
         # Check that the utxo hashes agree with node3
         # Useful side effect: each utxo cache gets flushed here, so that we
         # won't get crashes on shutdown at the end of the test.
         self.verify_utxo_hash()
 
         # Check the test coverage
         self.log.info("Restarted nodes: {}; crashes on restart: {}".format(
                       self.restart_counts, self.crashed_on_restart))
 
         # If no nodes were restarted, we didn't test anything.
         assert self.restart_counts != [0, 0, 0]
 
         # Make sure we tested the case of crash-during-recovery.
         assert self.crashed_on_restart > 0
 
         # Warn if any of the nodes escaped restart.
         for i in range(3):
             if self.restart_counts[i] == 0:
                 self.log.warning(
                     "Node {} never crashed during utxo flush!".format(i))
 
 
 if __name__ == "__main__":
     ChainstateWriteCrashTest().main()
diff --git a/test/functional/feature_filelock.py b/test/functional/feature_filelock.py
index 8b8f0b244..f4153302b 100755
--- a/test/functional/feature_filelock.py
+++ b/test/functional/feature_filelock.py
@@ -1,47 +1,48 @@
 #!/usr/bin/env python3
 # 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.
 """Check that it's not possible to start a second bitcoind instance using the same datadir or wallet."""
 import os
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.test_node import ErrorMatch
 
 
 class FilelockTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
 
     def setup_network(self):
         self.add_nodes(self.num_nodes, extra_args=None)
-        self.nodes[0].start([])
+        self.nodes[0].start(['-wallet='])
         self.nodes[0].wait_for_rpc_connection()
 
     def run_test(self):
         datadir = os.path.join(self.nodes[0].datadir, self.chain)
         self.log.info("Using datadir {}".format(datadir))
 
         self.log.info(
             "Check that we can't start a second bitcoind instance using the same datadir")
         expected_msg = "Error: Cannot obtain a lock on data directory {0}. {1} is probably already running.".format(
             datadir, self.config['environment']['PACKAGE_NAME'])
         self.nodes[1].assert_start_raises_init_error(extra_args=[
                                                      '-datadir={}'.format(self.nodes[0].datadir), '-noserver'], expected_msg=expected_msg)
 
         if self.is_wallet_compiled():
             wallet_dir = os.path.join(datadir, 'wallets')
             self.log.info(
                 "Check that we can't start a second bitcoind instance using the same wallet")
             expected_msg = "Error: Error initializing wallet database environment"
             self.nodes[1].assert_start_raises_init_error(
                 extra_args=[
                     '-walletdir={}'.format(wallet_dir),
+                    '-wallet=',
                     '-noserver'],
                 expected_msg=expected_msg,
                 match=ErrorMatch.PARTIAL_REGEX)
 
 
 if __name__ == '__main__':
     FilelockTest().main()
diff --git a/test/functional/feature_pruning.py b/test/functional/feature_pruning.py
index 017fb5cb7..c64032f87 100755
--- a/test/functional/feature_pruning.py
+++ b/test/functional/feature_pruning.py
@@ -1,520 +1,521 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the pruning code.
 
 WARNING:
 This test uses 4GB of disk space.
 This test takes 30 mins or more (up to 2 hours)
 """
 
 import os
 
 from test_framework.blocktools import create_coinbase
 from test_framework.messages import CBlock, ToHex
 from test_framework.script import OP_NOP, OP_RETURN, CScript
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
     connect_nodes,
     disconnect_nodes,
 )
 
 # Rescans start at the earliest block up to 2 hours before a key timestamp, so
 # the manual prune RPC avoids pruning blocks in the same window to be
 # compatible with pruning based on key creation time.
 TIMESTAMP_WINDOW = 2 * 60 * 60
 
 
 def mine_large_blocks(node, n):
     # Make a large scriptPubKey for the coinbase transaction. This is OP_RETURN
     # followed by 950k of OP_NOP. This would be non-standard in a non-coinbase
     # transaction but is consensus valid.
 
     # Set the nTime if this is the first time this function has been called.
     # A static variable ensures that time is monotonicly increasing and is therefore
     # different for each block created => blockhash is unique.
     if "nTimes" not in mine_large_blocks.__dict__:
         mine_large_blocks.nTime = 0
 
     # Get the block parameters for the first block
     big_script = CScript([OP_RETURN] + [OP_NOP] * 950000)
     best_block = node.getblock(node.getbestblockhash())
     height = int(best_block["height"]) + 1
     mine_large_blocks.nTime = max(
         mine_large_blocks.nTime, int(best_block["time"])) + 1
     previousblockhash = int(best_block["hash"], 16)
 
     for _ in range(n):
         # Build the coinbase transaction (with large scriptPubKey)
         coinbase_tx = create_coinbase(height)
         coinbase_tx.vin[0].nSequence = 2 ** 32 - 1
         coinbase_tx.vout[0].scriptPubKey = big_script
         coinbase_tx.rehash()
 
         # Build the block
         block = CBlock()
         block.nVersion = best_block["version"]
         block.hashPrevBlock = previousblockhash
         block.nTime = mine_large_blocks.nTime
         block.nBits = int('207fffff', 16)
         block.nNonce = 0
         block.vtx = [coinbase_tx]
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
         # Submit to the node
         node.submitblock(ToHex(block))
 
         previousblockhash = block.sha256
         height += 1
         mine_large_blocks.nTime += 1
 
 
 def calc_usage(blockdir):
     return sum(os.path.getsize(blockdir + f) for f in os.listdir(blockdir)
                if os.path.isfile(os.path.join(blockdir, f))) / (1024. * 1024.)
 
 
 class PruneTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 6
         self.supports_cli = False
 
         # Create nodes 0 and 1 to mine.
         # Create node 2 to test pruning.
         self.full_node_default_args = ["-maxreceivebuffer=20000", "-blockmaxsize=999000",
-                                       "-checkblocks=5", "-noparkdeepreorg", "-maxreorgdepth=-1"]
+                                       "-checkblocks=5", "-noparkdeepreorg", "-maxreorgdepth=-1",
+                                       "-wallet="]
         # Create nodes 3 and 4 to test manual pruning (they will be re-started with manual pruning later)
         # Create nodes 5 to test wallet in prune mode, but do not connect
         self.extra_args = [self.full_node_default_args,
                            self.full_node_default_args,
-                           ["-maxreceivebuffer=20000", "-prune=550",
+                           ["-wallet=", "-maxreceivebuffer=20000", "-prune=550",
                                "-noparkdeepreorg", "-maxreorgdepth=-1"],
-                           ["-maxreceivebuffer=20000", "-blockmaxsize=999000",
+                           ["-wallet=", "-maxreceivebuffer=20000", "-blockmaxsize=999000",
                                "-noparkdeepreorg", "-maxreorgdepth=-1"],
-                           ["-maxreceivebuffer=20000", "-blockmaxsize=999000",
+                           ["-wallet=", "-maxreceivebuffer=20000", "-blockmaxsize=999000",
                                "-noparkdeepreorg", "-maxreorgdepth=-1"],
-                           ["-prune=550"]]
+                           ["-wallet=", "-prune=550"]]
         self.rpc_timeout = 120
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def setup_network(self):
         self.setup_nodes()
 
         self.prunedir = os.path.join(
             self.nodes[2].datadir, self.chain, 'blocks', '')
 
         connect_nodes(self.nodes[0], self.nodes[1])
         connect_nodes(self.nodes[1], self.nodes[2])
         connect_nodes(self.nodes[0], self.nodes[2])
         connect_nodes(self.nodes[0], self.nodes[3])
         connect_nodes(self.nodes[0], self.nodes[4])
         self.sync_blocks(self.nodes[0:5])
 
     def setup_nodes(self):
         self.add_nodes(self.num_nodes, self.extra_args)
         self.start_nodes()
         for n in self.nodes:
             n.importprivkey(
                 privkey=n.get_deterministic_priv_key().key,
                 label='coinbase',
                 rescan=False)
 
     def create_big_chain(self):
         # Start by creating some coinbases we can spend later
         self.nodes[1].generate(200)
         self.sync_blocks(self.nodes[0:2])
         self.nodes[0].generate(150)
 
         # Then mine enough full blocks to create more than 550MiB of data
         mine_large_blocks(self.nodes[0], 645)
 
         self.sync_blocks(self.nodes[0:5])
 
     def test_height_min(self):
         assert os.path.isfile(os.path.join(
             self.prunedir, "blk00000.dat")), "blk00000.dat is missing, pruning too early"
         self.log.info("Success")
         self.log.info("Though we're already using more than 550MiB, current usage: {}".format(
                       calc_usage(self.prunedir)))
         self.log.info(
             "Mining 25 more blocks should cause the first block file to be pruned")
         # Pruning doesn't run until we're allocating another chunk, 20 full
         # blocks past the height cutoff will ensure this
         mine_large_blocks(self.nodes[0], 25)
 
         # Wait for blk00000.dat to be pruned
         self.wait_until(
             lambda: not os.path.isfile(
                 os.path.join(self.prunedir, "blk00000.dat")),
             timeout=30)
 
         self.log.info("Success")
         usage = calc_usage(self.prunedir)
         self.log.info("Usage should be below target: {}".format(usage))
         assert_greater_than(550, usage)
 
     def create_chain_with_staleblocks(self):
         # Create stale blocks in manageable sized chunks
         self.log.info(
             "Mine 24 (stale) blocks on Node 1, followed by 25 (main chain) block reorg from Node 0, for 12 rounds")
 
         for _ in range(12):
             # Disconnect node 0 so it can mine a longer reorg chain without knowing about node 1's soon-to-be-stale chain
             # Node 2 stays connected, so it hears about the stale blocks and
             # then reorg's when node0 reconnects
             disconnect_nodes(self.nodes[0], self.nodes[1])
             disconnect_nodes(self.nodes[0], self.nodes[2])
             # Mine 24 blocks in node 1
             mine_large_blocks(self.nodes[1], 24)
 
             # Reorg back with 25 block chain from node 0
             mine_large_blocks(self.nodes[0], 25)
 
             # Create connections in the order so both nodes can see the reorg
             # at the same time
             connect_nodes(self.nodes[0], self.nodes[1])
             connect_nodes(self.nodes[0], self.nodes[2])
             self.sync_blocks(self.nodes[0:3])
 
         self.log.info("Usage can be over target because of high stale rate: {}".format(
                       calc_usage(self.prunedir)))
 
     def reorg_test(self):
         # Node 1 will mine a 300 block chain starting 287 blocks back from Node
         # 0 and Node 2's tip. This will cause Node 2 to do a reorg requiring
         # 288 blocks of undo data to the reorg_test chain.
 
         height = self.nodes[1].getblockcount()
         self.log.info("Current block height: {}".format(height))
 
         self.forkheight = height - 287
         self.forkhash = self.nodes[1].getblockhash(self.forkheight)
         self.log.info("Invalidating block {} at height {}".format(
             self.forkhash, self.forkheight))
         self.nodes[1].invalidateblock(self.forkhash)
 
         # We've now switched to our previously mined-24 block fork on node 1, but that's not what we want.
         # So invalidate that fork as well, until we're on the same chain as
         # node 0/2 (but at an ancestor 288 blocks ago)
         mainchainhash = self.nodes[0].getblockhash(self.forkheight - 1)
         curhash = self.nodes[1].getblockhash(self.forkheight - 1)
         while curhash != mainchainhash:
             self.nodes[1].invalidateblock(curhash)
             curhash = self.nodes[1].getblockhash(self.forkheight - 1)
 
         assert self.nodes[1].getblockcount() == self.forkheight - 1
         self.log.info("New best height: {}".format(
                       self.nodes[1].getblockcount()))
 
         # Disconnect node1 and generate the new chain
         disconnect_nodes(self.nodes[0], self.nodes[1])
         disconnect_nodes(self.nodes[1], self.nodes[2])
 
         self.log.info("Generating new longer chain of 300 more blocks")
         self.nodes[1].generate(300)
 
         self.log.info("Reconnect nodes")
         connect_nodes(self.nodes[0], self.nodes[1])
         connect_nodes(self.nodes[1], self.nodes[2])
         self.sync_blocks(self.nodes[0:3], timeout=120)
 
         self.log.info("Verify height on node 2: {}".format(
                       self.nodes[2].getblockcount()))
         self.log.info("Usage possibly still high because of stale blocks in block files: {}".format(
                       calc_usage(self.prunedir)))
 
         self.log.info(
             "Mine 220 more large blocks so we have requisite history")
 
         mine_large_blocks(self.nodes[0], 220)
         self.sync_blocks(self.nodes[0:3], timeout=120)
 
         usage = calc_usage(self.prunedir)
         self.log.info("Usage should be below target: {}".format(usage))
         assert_greater_than(550, usage)
 
     def reorg_back(self):
         # Verify that a block on the old main chain fork has been pruned away
         assert_raises_rpc_error(
             -1, "Block not available (pruned data)", self.nodes[2].getblock, self.forkhash)
         with self.nodes[2].assert_debug_log(expected_msgs=['block verification stopping at height', '(pruning, no data)']):
             self.nodes[2].verifychain(checklevel=4, nblocks=0)
         self.log.info(
             "Will need to redownload block {}".format(self.forkheight))
 
         # Verify that we have enough history to reorg back to the fork point.
         # Although this is more than 288 blocks, because this chain was written
         # more recently and only its other 299 small and 220 large blocks are in
         # the block files after it, it is expected to still be retained.
         self.nodes[2].getblock(self.nodes[2].getblockhash(self.forkheight))
 
         first_reorg_height = self.nodes[2].getblockcount()
         curchainhash = self.nodes[2].getblockhash(self.mainchainheight)
         self.nodes[2].invalidateblock(curchainhash)
         goalbestheight = self.mainchainheight
         goalbesthash = self.mainchainhash2
 
         # As of 0.10 the current block download logic is not able to reorg to
         # the original chain created in create_chain_with_stale_blocks because
         # it doesn't know of any peer that's on that chain from which to
         # redownload its missing blocks. Invalidate the reorg_test chain in
         # node 0 as well, it can successfully switch to the original chain
         # because it has all the block data. However it must mine enough blocks
         # to have a more work chain than the reorg_test chain in order to
         # trigger node 2's block download logic. At this point node 2 is within
         # 288 blocks of the fork point so it will preserve its ability to
         # reorg.
         if self.nodes[2].getblockcount() < self.mainchainheight:
             blocks_to_mine = first_reorg_height + 1 - self.mainchainheight
             self.log.info(
                 "Rewind node 0 to prev main chain to mine longer chain to trigger redownload. Blocks needed: {}".format(
                     blocks_to_mine))
             self.nodes[0].invalidateblock(curchainhash)
             assert_equal(self.nodes[0].getblockcount(), self.mainchainheight)
             assert_equal(self.nodes[0].getbestblockhash(), self.mainchainhash2)
             goalbesthash = self.nodes[0].generate(blocks_to_mine)[-1]
             goalbestheight = first_reorg_height + 1
 
         self.log.info(
             "Verify node 2 reorged back to the main chain, some blocks of which it had to redownload")
         # Wait for Node 2 to reorg to proper height
         self.wait_until(lambda: self.nodes[2].getblockcount() >= goalbestheight,
                         timeout=900)
         assert_equal(self.nodes[2].getbestblockhash(), goalbesthash)
         # Verify we can now have the data for a block previously pruned
         assert_equal(self.nodes[2].getblock(
             self.forkhash)["height"], self.forkheight)
 
     def manual_test(self, node_number, use_timestamp):
         # at this point, node has 995 blocks and has not yet run in prune mode
         self.start_node(node_number)
         node = self.nodes[node_number]
         assert_equal(node.getblockcount(), 995)
         assert_raises_rpc_error(-1, "not in prune mode",
                                 node.pruneblockchain, 500)
 
         # now re-start in manual pruning mode
         self.restart_node(node_number, extra_args=["-prune=1"])
         node = self.nodes[node_number]
         assert_equal(node.getblockcount(), 995)
 
         def height(index):
             if use_timestamp:
                 return node.getblockheader(node.getblockhash(index))[
                     "time"] + TIMESTAMP_WINDOW
             else:
                 return index
 
         def prune(index):
             ret = node.pruneblockchain(height=height(index))
             assert_equal(ret, node.getblockchaininfo()['pruneheight'])
 
         def has_block(index):
             return os.path.isfile(os.path.join(
                 self.nodes[node_number].datadir, self.chain, "blocks", "blk{:05}.dat".format(index)))
 
         # should not prune because chain tip of node 3 (995) < PruneAfterHeight
         # (1000)
         assert_raises_rpc_error(
             -1, "Blockchain is too short for pruning", node.pruneblockchain, height(500))
 
         # Save block transaction count before pruning, assert value
         block1_details = node.getblock(node.getblockhash(1))
         assert_equal(block1_details["nTx"], len(block1_details["tx"]))
 
         # mine 6 blocks so we are at height 1001 (i.e., above PruneAfterHeight)
         node.generate(6)
         assert_equal(node.getblockchaininfo()["blocks"], 1001)
 
         # Pruned block should still know the number of transactions
         assert_equal(node.getblockheader(node.getblockhash(1))
                      ["nTx"], block1_details["nTx"])
 
         # negative heights should raise an exception
         assert_raises_rpc_error(-8, "Negative", node.pruneblockchain, -10)
 
         # height=100 too low to prune first block file so this is a no-op
         prune(100)
         assert has_block(
             0), "blk00000.dat is missing when should still be there"
 
         # Does nothing
         node.pruneblockchain(height(0))
         assert has_block(
             0), "blk00000.dat is missing when should still be there"
 
         # height=500 should prune first file
         prune(500)
         assert not has_block(
             0), "blk00000.dat is still there, should be pruned by now"
         assert has_block(
             1), "blk00001.dat is missing when should still be there"
 
         # height=650 should prune second file
         prune(650)
         assert not has_block(
             1), "blk00001.dat is still there, should be pruned by now"
 
         # height=1000 should not prune anything more, because tip-288 is in
         # blk00002.dat.
         prune(1000)
         assert has_block(
             2), "blk00002.dat is still there, should be pruned by now"
 
         # advance the tip so blk00002.dat and blk00003.dat can be pruned (the
         # last 288 blocks should now be in blk00004.dat)
         node.generate(288)
         prune(1000)
         assert not has_block(
             2), "blk00002.dat is still there, should be pruned by now"
         assert not has_block(
             3), "blk00003.dat is still there, should be pruned by now"
 
         # stop node, start back up with auto-prune at 550 MiB, make sure still
         # runs
         self.restart_node(node_number, extra_args=["-prune=550"])
 
         self.log.info("Success")
 
     def wallet_test(self):
         # check that the pruning node's wallet is still in good shape
         self.log.info("Stop and start pruning node to trigger wallet rescan")
         self.restart_node(
             2, extra_args=["-prune=550", "-noparkdeepreorg", "-maxreorgdepth=-1"])
         self.log.info("Success")
 
         # check that wallet loads successfully when restarting a pruned node after IBD.
         # this was reported to fail in #7494.
         self.log.info("Syncing node 5 to test wallet")
         connect_nodes(self.nodes[0], self.nodes[5])
         nds = [self.nodes[0], self.nodes[5]]
         self.sync_blocks(nds, wait=5, timeout=300)
         self.restart_node(
             5, extra_args=["-prune=550", "-noparkdeepreorg", "-maxreorgdepth=-1"])
         self.log.info("Success")
 
     def run_test(self):
         self.log.info("Warning! This test requires 4GB of disk space")
 
         self.log.info("Mining a big blockchain of 995 blocks")
         self.create_big_chain()
         # Chain diagram key:
         # *   blocks on main chain
         # +,&,$,@ blocks on other forks
         # X   invalidated block
         # N1  Node 1
         #
         # Start by mining a simple chain that all nodes have
         # N0=N1=N2 **...*(995)
 
         # stop manual-pruning node with 995 blocks
         self.stop_node(3)
         self.stop_node(4)
 
         self.log.info(
             "Check that we haven't started pruning yet because we're below PruneAfterHeight")
         self.test_height_min()
         # Extend this chain past the PruneAfterHeight
         # N0=N1=N2 **...*(1020)
 
         self.log.info(
             "Check that we'll exceed disk space target if we have a very high stale block rate")
         self.create_chain_with_staleblocks()
         # Disconnect N0
         # And mine a 24 block chain on N1 and a separate 25 block chain on N0
         # N1=N2 **...*+...+(1044)
         # N0    **...**...**(1045)
         #
         # reconnect nodes causing reorg on N1 and N2
         # N1=N2 **...*(1020) *...**(1045)
         #                   \
         #                    +...+(1044)
         #
         # repeat this process until you have 12 stale forks hanging off the
         # main chain on N1 and N2
         # N0    *************************...***************************(1320)
         #
         # N1=N2 **...*(1020) *...**(1045) *..         ..**(1295) *...**(1320)
         #                   \            \                      \
         #                    +...+(1044)  &..                    $...$(1319)
 
         # Save some current chain state for later use
         self.mainchainheight = self.nodes[2].getblockcount()  # 1320
         self.mainchainhash2 = self.nodes[2].getblockhash(self.mainchainheight)
 
         self.log.info("Check that we can survive a 288 block reorg still")
         self.reorg_test()  # (1033, )
         # Now create a 288 block reorg by mining a longer chain on N1
         # First disconnect N1
         # Then invalidate 1033 on main chain and 1032 on fork so height is 1032 on main chain
         # N1   **...*(1020) **...**(1032)X..
         #                  \
         #                   ++...+(1031)X..
         #
         # Now mine 300 more blocks on N1
         # N1    **...*(1020) **...**(1032) @@...@(1332)
         #                 \               \
         #                  \               X...
         #                   \                 \
         #                    ++...+(1031)X..   ..
         #
         # Reconnect nodes and mine 220 more blocks on N1
         # N1    **...*(1020) **...**(1032) @@...@@@(1552)
         #                 \               \
         #                  \               X...
         #                   \                 \
         #                    ++...+(1031)X..   ..
         #
         # N2    **...*(1020) **...**(1032) @@...@@@(1552)
         #                 \               \
         #                  \               *...**(1320)
         #                   \                 \
         #                    ++...++(1044)     ..
         #
         # N0    ********************(1032) @@...@@@(1552)
         #                                 \
         #                                  *...**(1320)
 
         self.log.info(
             "Test that we can rerequest a block we previously pruned if needed for a reorg")
         self.reorg_back()
         # Verify that N2 still has block 1033 on current chain (@), but not on main chain (*)
         # Invalidate 1033 on current chain (@) on N2 and we should be able to reorg to
         # original main chain (*), but will require redownload of some blocks
         # In order to have a peer we think we can download from, must also perform this invalidation
         # on N0 and mine a new longest chain to trigger.
         # Final result:
         # N0    ********************(1032) **...****(1553)
         #                                 \
         #                                  X@...@@@(1552)
         #
         # N2    **...*(1020) **...**(1032) **...****(1553)
         #                 \               \
         #                  \               X@...@@@(1552)
         #                   \
         #                    +..
         #
         # N1 doesn't change because 1033 on main chain (*) is invalid
 
         self.log.info("Test manual pruning with block indices")
         self.manual_test(3, use_timestamp=False)
 
         self.log.info("Test manual pruning with timestamps")
         self.manual_test(4, use_timestamp=True)
 
         self.log.info("Test wallet re-scan")
         self.wallet_test()
 
         self.log.info("Done")
 
 
 if __name__ == '__main__':
     PruneTest().main()
diff --git a/test/functional/wallet_backup.py b/test/functional/wallet_backup.py
index a84d4dbb8..126a22131 100755
--- a/test/functional/wallet_backup.py
+++ b/test/functional/wallet_backup.py
@@ -1,249 +1,249 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the wallet backup features.
 
 Test case is:
 4 nodes. 1 2 and 3 send transactions between each other,
 fourth node is a miner.
 1 2 3 each mine a block to start, then
 Miner creates 100 blocks so 1 2 3 each have 50 mature
 coins to spend.
 Then 5 iterations of 1/2/3 sending coins amongst
 themselves to get transactions in the wallets,
 and the miner mining one block.
 
 Wallets are backed up using dumpwallet/backupwallet.
 Then 5 more iterations of transactions and mining a block.
 
 Miner then generates 101 more blocks, so any
 transaction fees paid mature.
 
 Sanity check:
   Sum(1,2,3,4 balances) == 114*50
 
 1/2/3 are shutdown, and their wallets erased.
 Then restore using wallet.dat backup. And
 confirm 1/2/3/4 balances are same as before.
 
 Shutdown again, restore using importwallet,
 and confirm again balances are correct.
 """
 import os
 import shutil
 from decimal import Decimal
 from random import randint
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_raises_rpc_error,
     connect_nodes,
 )
 
 
 class WalletBackupTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 4
         self.setup_clean_chain = True
         # nodes 1, 2,3 are spenders, let's give them a keypool=100
         # whitelist all peers to speed up tx relay / mempool sync
         self.extra_args = [
-            ["-whitelist=noban@127.0.0.1", "-keypool=100"],
-            ["-whitelist=noban@127.0.0.1", "-keypool=100"],
-            ["-whitelist=noban@127.0.0.1", "-keypool=100"],
-            ["-whitelist=noban@127.0.0.1"],
+            ["-whitelist=noban@127.0.0.1", "-keypool=100", "-wallet="],
+            ["-whitelist=noban@127.0.0.1", "-keypool=100", "-wallet="],
+            ["-whitelist=noban@127.0.0.1", "-keypool=100", "-wallet="],
+            ["-whitelist=noban@127.0.0.1", "-wallet="],
         ]
         self.rpc_timeout = 120
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def setup_network(self):
         self.setup_nodes()
         connect_nodes(self.nodes[0], self.nodes[3])
         connect_nodes(self.nodes[1], self.nodes[3])
         connect_nodes(self.nodes[2], self.nodes[3])
         connect_nodes(self.nodes[2], self.nodes[0])
         self.sync_all()
 
     def one_send(self, from_node, to_address):
         if (randint(1, 2) == 1):
             amount = Decimal(randint(1, 10)) * Decimal(100000)
             self.nodes[from_node].sendtoaddress(to_address, amount)
 
     def do_one_round(self):
         a0 = self.nodes[0].getnewaddress()
         a1 = self.nodes[1].getnewaddress()
         a2 = self.nodes[2].getnewaddress()
 
         self.one_send(0, a1)
         self.one_send(0, a2)
         self.one_send(1, a0)
         self.one_send(1, a2)
         self.one_send(2, a0)
         self.one_send(2, a1)
 
         # Have the miner (node3) mine a block.
         # Must sync mempools before mining.
         self.sync_mempools()
         self.nodes[3].generate(1)
         self.sync_blocks()
 
     # As above, this mirrors the original bash test.
     def start_three(self):
         self.start_node(0)
         self.start_node(1)
         self.start_node(2)
         connect_nodes(self.nodes[0], self.nodes[3])
         connect_nodes(self.nodes[1], self.nodes[3])
         connect_nodes(self.nodes[2], self.nodes[3])
         connect_nodes(self.nodes[2], self.nodes[0])
 
     def stop_three(self):
         self.stop_node(0)
         self.stop_node(1)
         self.stop_node(2)
 
     def erase_three(self):
         os.remove(os.path.join(
             self.nodes[0].datadir, self.chain, 'wallets', 'wallet.dat'))
         os.remove(os.path.join(
             self.nodes[1].datadir, self.chain, 'wallets', 'wallet.dat'))
         os.remove(os.path.join(
             self.nodes[2].datadir, self.chain, 'wallets', 'wallet.dat'))
 
     def run_test(self):
         self.log.info("Generating initial blockchain")
         self.nodes[0].generate(1)
         self.sync_blocks()
         self.nodes[1].generate(1)
         self.sync_blocks()
         self.nodes[2].generate(1)
         self.sync_blocks()
         self.nodes[3].generate(100)
         self.sync_blocks()
 
         assert_equal(self.nodes[0].getbalance(), 50000000)
         assert_equal(self.nodes[1].getbalance(), 50000000)
         assert_equal(self.nodes[2].getbalance(), 50000000)
         assert_equal(self.nodes[3].getbalance(), 0)
 
         self.log.info("Creating transactions")
         # Five rounds of sending each other transactions.
         for _ in range(5):
             self.do_one_round()
 
         self.log.info("Backing up")
         self.nodes[0].backupwallet(os.path.join(
             self.nodes[0].datadir, 'wallet.bak'))
         self.nodes[0].dumpwallet(os.path.join(
             self.nodes[0].datadir, 'wallet.dump'))
         self.nodes[1].backupwallet(os.path.join(
             self.nodes[1].datadir, 'wallet.bak'))
         self.nodes[1].dumpwallet(os.path.join(
             self.nodes[1].datadir, 'wallet.dump'))
         self.nodes[2].backupwallet(os.path.join(
             self.nodes[2].datadir, 'wallet.bak'))
         self.nodes[2].dumpwallet(os.path.join(
             self.nodes[2].datadir, 'wallet.dump'))
 
         self.log.info("More transactions")
         for _ in range(5):
             self.do_one_round()
 
         # Generate 101 more blocks, so any fees paid mature
         self.nodes[3].generate(101)
         self.sync_all()
 
         balance0 = self.nodes[0].getbalance()
         balance1 = self.nodes[1].getbalance()
         balance2 = self.nodes[2].getbalance()
         balance3 = self.nodes[3].getbalance()
         total = balance0 + balance1 + balance2 + balance3
 
         # At this point, there are 214 blocks (103 for setup, then 10 rounds, then 101.)
         # 114 are mature, so the sum of all wallets should be 114 * 50 = 5700.
         assert_equal(total, 5700000000)
 
         ##
         # Test restoring spender wallets from backups
         ##
         self.log.info("Restoring using wallet.dat")
         self.stop_three()
         self.erase_three()
 
         # Start node2 with no chain
         shutil.rmtree(
             os.path.join(
                 self.nodes[2].datadir,
                 self.chain,
                 'blocks'))
         shutil.rmtree(os.path.join(
             self.nodes[2].datadir, self.chain, 'chainstate'))
 
         # Restore wallets from backup
         shutil.copyfile(os.path.join(self.nodes[0].datadir, 'wallet.bak'), os.path.join(
             self.nodes[0].datadir, self.chain, 'wallets', 'wallet.dat'))
         shutil.copyfile(os.path.join(self.nodes[1].datadir, 'wallet.bak'), os.path.join(
             self.nodes[1].datadir, self.chain, 'wallets', 'wallet.dat'))
         shutil.copyfile(os.path.join(self.nodes[2].datadir, 'wallet.bak'), os.path.join(
             self.nodes[2].datadir, self.chain, 'wallets', 'wallet.dat'))
 
         self.log.info("Re-starting nodes")
         self.start_three()
         self.sync_blocks()
 
         assert_equal(self.nodes[0].getbalance(), balance0)
         assert_equal(self.nodes[1].getbalance(), balance1)
         assert_equal(self.nodes[2].getbalance(), balance2)
 
         self.log.info("Restoring using dumped wallet")
         self.stop_three()
         self.erase_three()
 
         # start node2 with no chain
         shutil.rmtree(
             os.path.join(
                 self.nodes[2].datadir,
                 self.chain,
                 'blocks'))
         shutil.rmtree(os.path.join(
             self.nodes[2].datadir, self.chain, 'chainstate'))
 
         self.start_three()
 
         assert_equal(self.nodes[0].getbalance(), 0)
         assert_equal(self.nodes[1].getbalance(), 0)
         assert_equal(self.nodes[2].getbalance(), 0)
 
         self.nodes[0].importwallet(os.path.join(
             self.nodes[0].datadir, 'wallet.dump'))
         self.nodes[1].importwallet(os.path.join(
             self.nodes[1].datadir, 'wallet.dump'))
         self.nodes[2].importwallet(os.path.join(
             self.nodes[2].datadir, 'wallet.dump'))
 
         self.sync_blocks()
 
         assert_equal(self.nodes[0].getbalance(), balance0)
         assert_equal(self.nodes[1].getbalance(), balance1)
         assert_equal(self.nodes[2].getbalance(), balance2)
 
         # Backup to source wallet file must fail
         sourcePaths = [
             os.path.join(self.nodes[0].datadir,
                          self.chain, 'wallets', 'wallet.dat'),
             os.path.join(self.nodes[0].datadir, self.chain,
                          '.', 'wallets', 'wallet.dat'),
             os.path.join(self.nodes[0].datadir, self.chain, 'wallets', ''),
             os.path.join(self.nodes[0].datadir, self.chain, 'wallets')]
 
         for sourcePath in sourcePaths:
             assert_raises_rpc_error(-4, "backup failed",
                                     self.nodes[0].backupwallet, sourcePath)
 
 
 if __name__ == '__main__':
     WalletBackupTest().main()
diff --git a/test/functional/wallet_dump.py b/test/functional/wallet_dump.py
index 050cfa210..9c1e83ad3 100755
--- a/test/functional/wallet_dump.py
+++ b/test/functional/wallet_dump.py
@@ -1,218 +1,218 @@
 #!/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 datetime
 import os
 import time
 
 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_comments = []
         found_script_addr = 0
         found_addr_chg = 0
         found_addr_rsv = 0
         hd_master_addr_ret = None
         for line in inputfile:
             line = line.strip()
             if not line:
                 continue
             if line[0] == '#':
                 found_comments.append(line)
             else:
                 # 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_comments, 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.extra_args = [["-keypool=90", "-wallet=dump"]]
         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 _ in range(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"]
 
         self.log.info('Mine a block one second before the wallet is dumped')
         dump_time = int(time.time())
         self.nodes[0].setmocktime(dump_time - 1)
         self.nodes[0].generate(1)
         self.nodes[0].setmocktime(dump_time)
         dump_time_str = '# * Created on {}Z'.format(
             datetime.datetime.fromtimestamp(
                 dump_time,
                 tz=datetime.timezone.utc,
             ).replace(tzinfo=None).isoformat())
         dump_best_block_1 = '# * Best block at time of backup was {} ({}),'.format(
             self.nodes[0].getblockcount(),
             self.nodes[0].getbestblockhash(),
         )
         dump_best_block_2 = '#   mined on {}Z'.format(
             datetime.datetime.fromtimestamp(
                 dump_time - 1,
                 tz=datetime.timezone.utc,
             ).replace(tzinfo=None).isoformat())
 
         self.log.info('Dump unencrypted wallet')
         result = self.nodes[0].dumpwallet(wallet_unenc_dump)
         assert_equal(result['filename'], wallet_unenc_dump)
 
         found_comments, found_addr, found_script_addr, found_addr_chg, found_addr_rsv, hd_master_addr_unenc = \
             read_dump(wallet_unenc_dump, addrs, [multisig_addr], None)
         # Check that file is not corrupt
         assert '# End of dump' in found_comments
         assert_equal(
             dump_time_str, next(
                 c for c in found_comments if c.startswith('# * Created on')))
         assert_equal(
             dump_best_block_1, next(
                 c for c in found_comments if c.startswith('# * Best block')))
         assert_equal(
             dump_best_block_2, next(
                 c for c in found_comments if c.startswith('#   mined on')))
         # 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_comments, found_addr, found_script_addr, found_addr_chg, found_addr_rsv, _ = \
             read_dump(
                 wallet_enc_dump,
                 addrs,
                 [multisig_addr],
                 hd_master_addr_unenc)
         # Check that file is not corrupt
         assert '# End of dump' in found_comments
         assert_equal(found_addr, test_addr_count)
         assert_equal(
             dump_time_str, next(
                 c for c in found_comments if c.startswith('# * Created on')))
         assert_equal(
             dump_best_block_1, next(
                 c for c in found_comments if c.startswith('# * Best block')))
         assert_equal(
             dump_best_block_2, next(
                 c for c in found_comments if c.startswith('#   mined on')))
         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.restart_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()
diff --git a/test/functional/wallet_import_rescan.py b/test/functional/wallet_import_rescan.py
index 14d6afb3c..22aa32cc3 100755
--- a/test/functional/wallet_import_rescan.py
+++ b/test/functional/wallet_import_rescan.py
@@ -1,238 +1,238 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test wallet import RPCs.
 
 Test rescan behavior of importaddress, importpubkey, importprivkey, and
 importmulti RPCs with different types of keys and rescan options.
 
 In the first part of the test, node 0 creates an address for each type of
 import RPC call and node 0 sends XEC to it. Then other nodes import the
 addresses, and the test makes listtransactions and getbalance calls to confirm
 that the importing node either did or did not execute rescans picking up the
 send transactions.
 
 In the second part of the test, node 0 sends more XEC to each address, and the
 test makes more listtransactions and getbalance calls to confirm that the
 importing nodes pick up the new transactions regardless of whether rescans
 happened previously.
 """
 
 import collections
 import enum
 import itertools
 import random
 from decimal import Decimal
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, connect_nodes, set_node_times
 
 Call = enum.Enum("Call", "single multiaddress multiscript")
 Data = enum.Enum("Data", "address pub priv")
 Rescan = enum.Enum("Rescan", "no yes late_timestamp")
 
 
 class Variant(collections.namedtuple("Variant", "call data rescan prune")):
     """Helper for importing one key and verifying scanned transactions."""
 
     def do_import(self, timestamp):
         """Call one key import RPC."""
         rescan = self.rescan == Rescan.yes
 
         assert_equal(self.address["solvable"], True)
 
         if self.call == Call.single:
             if self.data == Data.address:
                 response = self.node.importaddress(
                     address=self.address["address"], label=self.label, rescan=rescan)
             elif self.data == Data.pub:
                 response = self.node.importpubkey(
                     pubkey=self.address["pubkey"], label=self.label, rescan=rescan)
             elif self.data == Data.priv:
                 response = self.node.importprivkey(
                     privkey=self.key, label=self.label, rescan=rescan)
             assert_equal(response, None)
 
         elif self.call in (Call.multiaddress, Call.multiscript):
             request = {
                 "scriptPubKey": {
                     "address": self.address["address"]
                 } if self.call == Call.multiaddress else self.address["scriptPubKey"],
                 "timestamp": timestamp + TIMESTAMP_WINDOW + (
                     1 if self.rescan == Rescan.late_timestamp else 0),
                 "pubkeys": [self.address["pubkey"]] if self.data == Data.pub else [],
                 "keys": [self.key] if self.data == Data.priv else [],
                 "label": self.label,
                 "watchonly": self.data != Data.priv
             }
             response = self.node.importmulti(
                 requests=[request],
                 options={
                     "rescan": self.rescan in (
                         Rescan.yes,
                         Rescan.late_timestamp)},
             )
             assert_equal(response, [{"success": True}])
 
     def check(self, txid=None, amount=None, confirmation_height=None):
         """Verify that listtransactions/listreceivedbyaddress return expected values."""
 
         txs = self.node.listtransactions(
             label=self.label, count=10000, include_watchonly=True)
         current_height = self.node.getblockcount()
         assert_equal(len(txs), self.expected_txs)
 
         addresses = self.node.listreceivedbyaddress(
             minconf=0, include_watchonly=True, address_filter=self.address['address'])
         if self.expected_txs:
             assert_equal(len(addresses[0]["txids"]), self.expected_txs)
 
         if txid is not None:
             tx, = [tx for tx in txs if tx["txid"] == txid]
             assert_equal(tx["label"], self.label)
             assert_equal(tx["address"], self.address["address"])
             assert_equal(tx["amount"], amount)
             assert_equal(tx["category"], "receive")
             assert_equal(tx["label"], self.label)
             assert_equal(tx["txid"], txid)
             assert_equal(tx["confirmations"],
                          1 + current_height - confirmation_height)
             assert_equal("trusted" not in tx, True)
 
             address, = [ad for ad in addresses if txid in ad["txids"]]
             assert_equal(address["address"], self.address["address"])
             assert_equal(address["amount"], self.expected_balance)
             assert_equal(address["confirmations"],
                          1 + current_height - confirmation_height)
             # Verify the transaction is correctly marked watchonly depending on
             # whether the transaction pays to an imported public key or
             # imported private key. The test setup ensures that transaction
             # inputs will not be from watchonly keys (important because
             # involvesWatchonly will be true if either the transaction output
             # or inputs are watchonly).
             if self.data != Data.priv:
                 assert_equal(address["involvesWatchonly"], True)
             else:
                 assert_equal("involvesWatchonly" not in address, True)
 
 
 # List of Variants for each way a key or address could be imported.
 IMPORT_VARIANTS = [Variant(*variants)
                    for variants in itertools.product(Call, Data, Rescan, (False, True))]
 
 # List of nodes to import keys to. Half the nodes will have pruning disabled,
 # half will have it enabled. Different nodes will be used for imports that are
 # expected to cause rescans, and imports that are not expected to cause
 # rescans, in order to prevent rescans during later imports picking up
 # transactions associated with earlier imports. This makes it easier to keep
 # track of expected balances and transactions.
 ImportNode = collections.namedtuple("ImportNode", "prune rescan")
 IMPORT_NODES = [ImportNode(*fields)
                 for fields in itertools.product((False, True), repeat=2)]
 
 # Rescans start at the earliest block up to 2 hours before the key timestamp.
 TIMESTAMP_WINDOW = 2 * 60 * 60
 
 AMOUNT_DUST = 5.46
 
 
 def get_rand_amount():
     r = random.uniform(AMOUNT_DUST, 1000000)
     return Decimal(str(round(r, 2)))
 
 
 class ImportRescanTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2 + len(IMPORT_NODES)
         self.supports_cli = False
         self.rpc_timeout = 120
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def setup_network(self):
-        self.extra_args = [[] for _ in range(self.num_nodes)]
+        self.extra_args = [["-wallet="] for _ in range(self.num_nodes)]
         for i, import_node in enumerate(IMPORT_NODES, 2):
             if import_node.prune:
                 self.extra_args[i] += ["-prune=1"]
 
         self.add_nodes(self.num_nodes, extra_args=self.extra_args)
 
         # Import keys with pruning disabled
-        self.start_nodes(extra_args=[[]] * self.num_nodes)
+        self.start_nodes(extra_args=[["-wallet="]] * self.num_nodes)
         for n in self.nodes:
             n.importprivkey(
                 privkey=n.get_deterministic_priv_key().key,
                 label='coinbase')
         self.stop_nodes()
 
         self.start_nodes()
         for i in range(1, self.num_nodes):
             connect_nodes(self.nodes[i], self.nodes[0])
 
     def run_test(self):
         # Create one transaction on node 0 with a unique amount for
         # each possible type of wallet import RPC.
         for i, variant in enumerate(IMPORT_VARIANTS):
             variant.label = "label {} {}".format(i, variant)
             variant.address = self.nodes[1].getaddressinfo(
                 self.nodes[1].getnewaddress(label=variant.label))
             variant.key = self.nodes[1].dumpprivkey(variant.address["address"])
             variant.initial_amount = get_rand_amount()
             variant.initial_txid = self.nodes[0].sendtoaddress(
                 variant.address["address"], variant.initial_amount)
             # Generate one block for each send
             self.nodes[0].generate(1)
             variant.confirmation_height = self.nodes[0].getblockcount()
             variant.timestamp = self.nodes[0].getblockheader(
                 self.nodes[0].getbestblockhash())["time"]
 
         # Generate a block further in the future (past the rescan window).
         assert_equal(self.nodes[0].getrawmempool(), [])
         set_node_times(self.nodes, self.nodes[0].getblockheader(
             self.nodes[0].getbestblockhash())["time"] + TIMESTAMP_WINDOW + 1)
         self.nodes[0].generate(1)
         self.sync_all()
 
         # For each variation of wallet key import, invoke the import RPC and
         # check the results from getbalance and listtransactions.
         for variant in IMPORT_VARIANTS:
             self.log.info('Run import for variant {}'.format(variant))
             expect_rescan = variant.rescan == Rescan.yes
             variant.node = self.nodes[2 + IMPORT_NODES.index(
                 ImportNode(variant.prune, expect_rescan))]
             variant.do_import(variant.timestamp)
             if expect_rescan:
                 variant.expected_balance = variant.initial_amount
                 variant.expected_txs = 1
                 variant.check(variant.initial_txid, variant.initial_amount,
                               variant.confirmation_height)
             else:
                 variant.expected_balance = 0
                 variant.expected_txs = 0
                 variant.check()
 
         # Create new transactions sending to each address.
         for i, variant in enumerate(IMPORT_VARIANTS):
             variant.sent_amount = get_rand_amount()
             variant.sent_txid = self.nodes[0].sendtoaddress(
                 variant.address["address"], variant.sent_amount)
             # Generate one block for each send
             self.nodes[0].generate(1)
             variant.confirmation_height = self.nodes[0].getblockcount()
 
         assert_equal(self.nodes[0].getrawmempool(), [])
         self.sync_all()
 
         # Check the latest results from getbalance and listtransactions.
         for variant in IMPORT_VARIANTS:
             self.log.info('Run check for variant {}'.format(variant))
             variant.expected_balance += variant.sent_amount
             variant.expected_txs += 1
             variant.check(variant.sent_txid, variant.sent_amount,
                           variant.confirmation_height)
 
 
 if __name__ == "__main__":
     ImportRescanTest().main()
diff --git a/test/functional/wallet_multiwallet.py b/test/functional/wallet_multiwallet.py
index ff6639f7f..b20088f7b 100755
--- a/test/functional/wallet_multiwallet.py
+++ b/test/functional/wallet_multiwallet.py
@@ -1,445 +1,447 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017-2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test multiwallet.
 
 Verify that a bitcoind node can load multiple wallet files
 """
 import os
 import shutil
 import time
 from decimal import Decimal
 from threading import Thread
 
 from test_framework.authproxy import JSONRPCException
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.test_node import ErrorMatch
 from test_framework.util import (
     assert_equal,
     assert_raises_rpc_error,
     get_rpc_proxy,
 )
 
 FEATURE_LATEST = 200300
 
 got_loading_error = False
 
 
 def test_load_unload(node, name):
     global got_loading_error
     for _ in range(10):
         if got_loading_error:
             return
         try:
             node.loadwallet(name)
             node.unloadwallet(name)
         except JSONRPCException as e:
             if e.error['code'] == - \
                     4 and 'Wallet already being loading' in e.error['message']:
                 got_loading_error = True
                 return
 
 
 class MultiWalletTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
+        self.extra_args = [["-wallet="], ["-wallet="]]
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def add_options(self, parser):
         parser.add_argument(
             '--data_wallets_dir',
             default=os.path.join(
                 os.path.dirname(
                     os.path.realpath(__file__)),
                 'data/wallets/'),
             help='Test data with wallet directories (default: %(default)s)',
         )
 
     def run_test(self):
         node = self.nodes[0]
 
         def data_dir(*p): return os.path.join(node.datadir, self.chain, *p)
 
         def wallet_dir(*p): return data_dir('wallets', *p)
 
         def wallet(name): return node.get_wallet_rpc(name)
 
         def wallet_file(name):
             if os.path.isdir(wallet_dir(name)):
                 return wallet_dir(name, "wallet.dat")
             return wallet_dir(name)
 
         assert_equal(self.nodes[0].listwalletdir(),
                      {'wallets': [{'name': ''}]})
 
         # check wallet.dat is created
         self.stop_nodes()
         assert_equal(os.path.isfile(wallet_dir('wallet.dat')), True)
 
         # create symlink to verify wallet directory path can be referenced
         # through symlink
         if os.name != 'nt':
             os.mkdir(wallet_dir('w7'))
             os.symlink('w7', wallet_dir('w7_symlink'))
 
         # rename wallet.dat to make sure plain wallet file paths (as opposed to
         # directory paths) can be loaded
         os.rename(wallet_dir("wallet.dat"), wallet_dir("w8"))
 
         # create another dummy wallet for use in testing backups later
-        self.start_node(0, [])
+        self.start_node(0, ["-wallet="])
         self.stop_nodes()
         empty_wallet = os.path.join(self.options.tmpdir, 'empty.dat')
         os.rename(wallet_dir("wallet.dat"), empty_wallet)
 
         # restart node with a mix of wallet names:
         #   w1, w2, w3 - to verify new wallets created when non-existing paths specified
         #   w          - to verify wallet name matching works when one wallet path is prefix of another
         #   sub/w5     - to verify relative wallet path is created correctly
         #   extern/w6  - to verify absolute wallet path is created correctly
         #   w7_symlink - to verify symlinked wallet path is initialized correctly
         #   w8         - to verify existing wallet file is loaded correctly
         #   ''         - to verify default wallet file is created correctly
         wallet_names = ['w1', 'w2', 'w3', 'w', 'sub/w5',
                         os.path.join(self.options.tmpdir, 'extern/w6'), 'w7_symlink', 'w8', '']
         if os.name == 'nt':
             wallet_names.remove('w7_symlink')
         extra_args = ['-wallet={}'.format(n) for n in wallet_names]
         self.start_node(0, extra_args)
         assert_equal(sorted(map(lambda w: w['name'], self.nodes[0].listwalletdir()['wallets'])), [
                      '', os.path.join('sub', 'w5'), 'w', 'w1', 'w2', 'w3', 'w7', 'w7_symlink', 'w8'])
 
         assert_equal(set(node.listwallets()), set(wallet_names))
 
         # check that all requested wallets were created
         self.stop_node(0)
         for wallet_name in wallet_names:
             assert_equal(os.path.isfile(wallet_file(wallet_name)), True)
 
         # should not initialize if wallet path can't be created
         exp_stderr = "boost::filesystem::create_directory:"
         self.nodes[0].assert_start_raises_init_error(
             ['-wallet=wallet.dat/bad'], exp_stderr, match=ErrorMatch.PARTIAL_REGEX)
 
         self.nodes[0].assert_start_raises_init_error(
             ['-walletdir=wallets'], 'Error: Specified -walletdir "wallets" does not exist')
         self.nodes[0].assert_start_raises_init_error(
             ['-walletdir=wallets'], 'Error: Specified -walletdir "wallets" is a relative path', cwd=data_dir())
         self.nodes[0].assert_start_raises_init_error(
             ['-walletdir=debug.log'], 'Error: Specified -walletdir "debug.log" is not a directory', cwd=data_dir())
 
         # should not initialize if there are duplicate wallets
         self.nodes[0].assert_start_raises_init_error(
             ['-wallet=w1', '-wallet=w1'], 'Error: Error loading wallet w1. Duplicate -wallet filename specified.')
 
         # should not initialize if one wallet is a copy of another
         shutil.copyfile(wallet_dir('w8'), wallet_dir('w8_copy'))
         exp_stderr = r"BerkeleyDatabase: Can't open database w8_copy \(duplicates fileid \w+ from w8\)"
         self.nodes[0].assert_start_raises_init_error(
             ['-wallet=w8', '-wallet=w8_copy'], exp_stderr, match=ErrorMatch.PARTIAL_REGEX)
 
         # should not initialize if wallet file is a symlink
         if os.name != 'nt':
             os.symlink('w8', wallet_dir('w8_symlink'))
             self.nodes[0].assert_start_raises_init_error(
                 ['-wallet=w8_symlink'], r'Error: Invalid -wallet path \'w8_symlink\'\. .*', match=ErrorMatch.FULL_REGEX)
 
         # should not initialize if the specified walletdir does not exist
         self.nodes[0].assert_start_raises_init_error(
             ['-walletdir=bad'], 'Error: Specified -walletdir "bad" does not exist')
         # should not initialize if the specified walletdir is not a directory
         not_a_dir = wallet_dir('notadir')
         open(not_a_dir, 'a', encoding="utf8").close()
         self.nodes[0].assert_start_raises_init_error(
             ['-walletdir=' + not_a_dir], 'Error: Specified -walletdir "' + not_a_dir + '" is not a directory')
 
         # if wallets/ doesn't exist, datadir should be the default wallet dir
         wallet_dir2 = data_dir('walletdir')
         os.rename(wallet_dir(), wallet_dir2)
         self.start_node(0, ['-wallet=w4', '-wallet=w5'])
         assert_equal(set(node.listwallets()), {"w4", "w5"})
         w5 = wallet("w5")
         node.generatetoaddress(nblocks=1, address=w5.getnewaddress())
 
         # now if wallets/ exists again, but the rootdir is specified as the
         # walletdir, w4 and w5 should still be loaded
         os.rename(wallet_dir2, wallet_dir())
         self.restart_node(0, ['-wallet=w4', '-wallet=w5',
                               '-walletdir=' + data_dir()])
         assert_equal(set(node.listwallets()), {"w4", "w5"})
         w5 = wallet("w5")
         w5_info = w5.getwalletinfo()
         assert_equal(w5_info['immature_balance'], 50000000)
 
         competing_wallet_dir = os.path.join(
             self.options.tmpdir, 'competing_walletdir')
         os.mkdir(competing_wallet_dir)
-        self.restart_node(0, ['-walletdir=' + competing_wallet_dir])
+        self.restart_node(
+            0, ['-walletdir=' + competing_wallet_dir, '-wallet='])
         exp_stderr = r"Error: Error initializing wallet database environment \"\S+competing_walletdir\"!"
         self.nodes[1].assert_start_raises_init_error(
             ['-walletdir=' + competing_wallet_dir], exp_stderr, match=ErrorMatch.PARTIAL_REGEX)
 
         self.restart_node(0, extra_args)
 
         assert_equal(sorted(map(lambda w: w['name'], self.nodes[0].listwalletdir()['wallets'])), [
                      '', os.path.join('sub', 'w5'), 'w', 'w1', 'w2', 'w3', 'w7', 'w7_symlink', 'w8', 'w8_copy'])
 
         wallets = [wallet(w) for w in wallet_names]
         wallet_bad = wallet("bad")
 
         # check wallet names and balances
         node.generatetoaddress(nblocks=1, address=wallets[0].getnewaddress())
         for wallet_name, wallet in zip(wallet_names, wallets):
             info = wallet.getwalletinfo()
             assert_equal(info['immature_balance'],
                          50000000 if wallet is wallets[0] else 0)
             assert_equal(info['walletname'], wallet_name)
 
         # accessing invalid wallet fails
         assert_raises_rpc_error(-18, "Requested wallet does not exist or is not loaded",
                                 wallet_bad.getwalletinfo)
 
         # accessing wallet RPC without using wallet endpoint fails
         assert_raises_rpc_error(-19, "Wallet file not specified (must request wallet RPC through /wallet/<filename> uri-path).",
                                 node.getwalletinfo)
 
         w1, w2, w3, w4, *_ = wallets
         node.generatetoaddress(nblocks=101, address=w1.getnewaddress())
         assert_equal(w1.getbalance(), 100000000)
         assert_equal(w2.getbalance(), 0)
         assert_equal(w3.getbalance(), 0)
         assert_equal(w4.getbalance(), 0)
 
         w1.sendtoaddress(w2.getnewaddress(), 1000000)
         w1.sendtoaddress(w3.getnewaddress(), 2000000)
         w1.sendtoaddress(w4.getnewaddress(), 3000000)
         node.generatetoaddress(nblocks=1, address=w1.getnewaddress())
         assert_equal(w2.getbalance(), 1000000)
         assert_equal(w3.getbalance(), 2000000)
         assert_equal(w4.getbalance(), 3000000)
 
         batch = w1.batch([w1.getblockchaininfo.get_request(),
                           w1.getwalletinfo.get_request()])
         assert_equal(batch[0]["result"]["chain"], self.chain)
         assert_equal(batch[1]["result"]["walletname"], "w1")
 
         self.log.info('Check for per-wallet settxfee call')
         assert_equal(w1.getwalletinfo()['paytxfee'], 0)
         assert_equal(w2.getwalletinfo()['paytxfee'], 0)
         w2.settxfee(1000)
         assert_equal(w1.getwalletinfo()['paytxfee'], 0)
         assert_equal(w2.getwalletinfo()['paytxfee'], Decimal('1000.00'))
 
         self.log.info("Test dynamic wallet loading")
 
         self.restart_node(0, ['-nowallet'])
         assert_equal(node.listwallets(), [])
         assert_raises_rpc_error(-32601, "Method not found", node.getwalletinfo)
 
         self.log.info("Load first wallet")
         loadwallet_name = node.loadwallet(wallet_names[0])
         assert_equal(loadwallet_name['name'], wallet_names[0])
         assert_equal(node.listwallets(), wallet_names[0:1])
         node.getwalletinfo()
         w1 = node.get_wallet_rpc(wallet_names[0])
         w1.getwalletinfo()
 
         self.log.info("Load second wallet")
         loadwallet_name = node.loadwallet(wallet_names[1])
         assert_equal(loadwallet_name['name'], wallet_names[1])
         assert_equal(node.listwallets(), wallet_names[0:2])
         assert_raises_rpc_error(-19,
                                 "Wallet file not specified", node.getwalletinfo)
         w2 = node.get_wallet_rpc(wallet_names[1])
         w2.getwalletinfo()
 
         self.log.info("Concurrent wallet loading")
         threads = []
         for _ in range(3):
             n = node.cli if self.options.usecli else get_rpc_proxy(
                 node.url, 1, timeout=600, coveragedir=node.coverage_dir)
             t = Thread(target=test_load_unload, args=(n, wallet_names[2], ))
             t.start()
             threads.append(t)
         for t in threads:
             t.join()
         global got_loading_error
         assert_equal(got_loading_error, True)
 
         self.log.info("Load remaining wallets")
         for wallet_name in wallet_names[2:]:
             loadwallet_name = self.nodes[0].loadwallet(wallet_name)
             assert_equal(loadwallet_name['name'], wallet_name)
 
         assert_equal(set(self.nodes[0].listwallets()), set(wallet_names))
 
         # Fail to load if wallet doesn't exist
         path = os.path.join(self.options.tmpdir, "node0", "regtest",
                             "wallets", "wallets")
         assert_raises_rpc_error(
             -18,
             "Wallet file verification failed. Failed to load database path "
             "'{}'. Path does not exist.".format(path),
             self.nodes[0].loadwallet, 'wallets')
 
         # Fail to load duplicate wallets
         path = os.path.join(
             self.options.tmpdir,
             "node0",
             "regtest",
             "wallets",
             "w1",
             "wallet.dat")
         assert_raises_rpc_error(
             -4,
             "Wallet file verification failed. Refusing to load database. Data file '{}' is already loaded.".format(
                 path),
             self.nodes[0].loadwallet,
             wallet_names[0])
 
         # Fail to load duplicate wallets by different ways (directory and
         # filepath)
         path = os.path.join(
             self.options.tmpdir,
             "node0",
             "regtest",
             "wallets",
             "wallet.dat")
         assert_raises_rpc_error(
             -4,
             "Wallet file verification failed. Refusing to load database. Data file '{}' is already loaded.".format(
                 path),
             self.nodes[0].loadwallet,
             'wallet.dat')
 
         # Fail to load if one wallet is a copy of another
         assert_raises_rpc_error(-4, "BerkeleyDatabase: Can't open database w8_copy (duplicates fileid",
                                 self.nodes[0].loadwallet, 'w8_copy')
 
         # Fail to load if one wallet is a copy of another.
         # Test this twice to make sure that we don't re-introduce
         # https://github.com/bitcoin/bitcoin/issues/14304
         assert_raises_rpc_error(-4, "BerkeleyDatabase: Can't open database w8_copy (duplicates fileid",
                                 self.nodes[0].loadwallet, 'w8_copy')
 
         # Fail to load if wallet file is a symlink
         if os.name != 'nt':
             assert_raises_rpc_error(
                 -4,
                 "Wallet file verification failed. Invalid -wallet path 'w8_symlink'",
                 self.nodes[0].loadwallet,
                 'w8_symlink')
 
         # Fail to load if a directory is specified that doesn't contain a
         # wallet
         os.mkdir(wallet_dir('empty_wallet_dir'))
         path = os.path.join(self.options.tmpdir, "node0", "regtest",
                             "wallets", "empty_wallet_dir")
         assert_raises_rpc_error(
             -18,
             "Wallet file verification failed. Failed to load database "
             "path '{}'. Data is not in recognized format.".format(path),
             self.nodes[0].loadwallet, 'empty_wallet_dir')
 
         self.log.info("Test dynamic wallet creation.")
 
         # Fail to create a wallet if it already exists.
         path = os.path.join(self.options.tmpdir, "node0", "regtest",
                             "wallets", "w2")
         assert_raises_rpc_error(
             -4,
             f"Failed to create database path '{path}'. Database already exists.",
             self.nodes[0].createwallet, 'w2')
 
         # Successfully create a wallet with a new name
         loadwallet_name = self.nodes[0].createwallet('w9')
         assert_equal(loadwallet_name['name'], 'w9')
         w9 = node.get_wallet_rpc('w9')
         assert_equal(w9.getwalletinfo()['walletname'], 'w9')
 
         assert 'w9' in self.nodes[0].listwallets()
 
         # Successfully create a wallet using a full path
         new_wallet_dir = os.path.join(self.options.tmpdir, 'new_walletdir')
         new_wallet_name = os.path.join(new_wallet_dir, 'w10')
         loadwallet_name = self.nodes[0].createwallet(new_wallet_name)
         assert_equal(loadwallet_name['name'], new_wallet_name)
         w10 = node.get_wallet_rpc(new_wallet_name)
         assert_equal(w10.getwalletinfo()['walletname'], new_wallet_name)
 
         assert new_wallet_name in self.nodes[0].listwallets()
 
         self.log.info("Test dynamic wallet unloading")
 
         # Test `unloadwallet` errors
         assert_raises_rpc_error(-1, "JSON value is not a string as expected",
                                 self.nodes[0].unloadwallet)
         assert_raises_rpc_error(-18, "Requested wallet does not exist or is not loaded",
                                 self.nodes[0].unloadwallet, "dummy")
         assert_raises_rpc_error(-18, "Requested wallet does not exist or is not loaded",
                                 node.get_wallet_rpc("dummy").unloadwallet)
         assert_raises_rpc_error(-8, "Cannot unload the requested wallet",
                                 w1.unloadwallet, "w2"),
 
         # Successfully unload the specified wallet name
         self.nodes[0].unloadwallet("w1")
         assert 'w1' not in self.nodes[0].listwallets()
 
         # Successfully unload the wallet referenced by the request endpoint
         # Also ensure unload works during walletpassphrase timeout
         w2.encryptwallet('test')
         w2.walletpassphrase('test', 1)
         w2.unloadwallet()
         time.sleep(1.1)
         assert 'w2' not in self.nodes[0].listwallets()
 
         # Successfully unload all wallets
         for wallet_name in self.nodes[0].listwallets():
             self.nodes[0].unloadwallet(wallet_name)
         assert_equal(self.nodes[0].listwallets(), [])
         assert_raises_rpc_error(-32601, "Method not found (wallet method is disabled because no wallet is loaded)",
                                 self.nodes[0].getwalletinfo)
 
         # Successfully load a previously unloaded wallet
         self.nodes[0].loadwallet('w1')
         assert_equal(self.nodes[0].listwallets(), ['w1'])
         assert_equal(w1.getwalletinfo()['walletname'], 'w1')
 
         assert_equal(sorted(map(lambda w: w['name'], self.nodes[0].listwalletdir()['wallets'])), [
                      '', os.path.join('sub', 'w5'), 'w', 'w1', 'w2', 'w3', 'w7', 'w7_symlink', 'w8', 'w8_copy', 'w9'])
 
         # Test backing up and restoring wallets
         self.log.info("Test wallet backup")
         self.restart_node(0, ['-nowallet'])
         for wallet_name in wallet_names:
             self.nodes[0].loadwallet(wallet_name)
         for wallet_name in wallet_names:
             rpc = self.nodes[0].get_wallet_rpc(wallet_name)
             addr = rpc.getnewaddress()
             backup = os.path.join(self.options.tmpdir, 'backup.dat')
             rpc.backupwallet(backup)
             self.nodes[0].unloadwallet(wallet_name)
             shutil.copyfile(empty_wallet, wallet_file(wallet_name))
             self.nodes[0].loadwallet(wallet_name)
             assert_equal(rpc.getaddressinfo(addr)['ismine'], False)
             self.nodes[0].unloadwallet(wallet_name)
             shutil.copyfile(backup, wallet_file(wallet_name))
             self.nodes[0].loadwallet(wallet_name)
             assert_equal(rpc.getaddressinfo(addr)['ismine'], True)
 
         # Test .walletlock file is closed
         self.start_node(1)
         wallet = os.path.join(self.options.tmpdir, 'my_wallet')
         self.nodes[0].createwallet(wallet)
         assert_raises_rpc_error(-4, "Error initializing wallet database environment",
                                 self.nodes[1].loadwallet, wallet)
         self.nodes[0].unloadwallet(wallet)
         self.nodes[1].loadwallet(wallet)
 
 
 if __name__ == '__main__':
     MultiWalletTest().main()
diff --git a/test/functional/wallet_startup.py b/test/functional/wallet_startup.py
index 76720a6ae..33ee6418a 100755
--- a/test/functional/wallet_startup.py
+++ b/test/functional/wallet_startup.py
@@ -1,48 +1,59 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017-2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test wallet load on startup.
 
 Verify that a bitcoind node can maintain list of wallets loading on startup
 """
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 
 
 class WalletStartupTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.supports_cli = True
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def setup_nodes(self):
         self.add_nodes(self.num_nodes)
         self.start_nodes()
 
     def run_test(self):
+        self.log.info('Should start without any wallets')
+        assert_equal(self.nodes[0].listwallets(), [])
+        assert_equal(self.nodes[0].listwalletdir(), {'wallets': []})
+
+        self.log.info(
+            'New default wallet should load by default when there are no other wallets')
+        self.nodes[0].createwallet(wallet_name='', load_on_startup=False)
+        self.restart_node(0)
+        assert_equal(self.nodes[0].listwallets(), [''])
+
+        self.log.info('Test load on startup behavior')
         self.nodes[0].createwallet(wallet_name='w0', load_on_startup=True)
         self.nodes[0].createwallet(wallet_name='w1', load_on_startup=False)
         self.nodes[0].createwallet(wallet_name='w2', load_on_startup=True)
         self.nodes[0].createwallet(wallet_name='w3', load_on_startup=False)
         self.nodes[0].createwallet(wallet_name='w4', load_on_startup=False)
         self.nodes[0].unloadwallet(wallet_name='w0', load_on_startup=False)
         self.nodes[0].unloadwallet(wallet_name='w4', load_on_startup=False)
         self.nodes[0].loadwallet(filename='w4', load_on_startup=True)
         assert_equal(set(self.nodes[0].listwallets()),
                      set(('', 'w1', 'w2', 'w3', 'w4')))
         self.restart_node(0)
         assert_equal(set(self.nodes[0].listwallets()), set(('', 'w2', 'w4')))
         self.nodes[0].unloadwallet(wallet_name='', load_on_startup=False)
         self.nodes[0].unloadwallet(wallet_name='w4', load_on_startup=False)
         self.nodes[0].loadwallet(filename='w3', load_on_startup=True)
         self.nodes[0].loadwallet(filename='')
         self.restart_node(0)
         assert_equal(set(self.nodes[0].listwallets()), set(('w2', 'w3')))
 
 
 if __name__ == '__main__':
     WalletStartupTest().main()