diff --git a/src/interfaces/handler.cpp b/src/interfaces/handler.cpp
index 1a26fa5f0..783199aec 100644
--- a/src/interfaces/handler.cpp
+++ b/src/interfaces/handler.cpp
@@ -1,32 +1,32 @@
 // 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/handler.h>
 
 #include <util/system.h>
 
 #include <boost/signals2/connection.hpp>
 #include <memory>
 #include <utility>
 
 namespace interfaces {
 namespace {
 
     class HandlerImpl : public Handler {
     public:
-        HandlerImpl(boost::signals2::connection connection)
+        explicit HandlerImpl(boost::signals2::connection connection)
             : m_connection(std::move(connection)) {}
 
         void disconnect() override { m_connection.disconnect(); }
 
         boost::signals2::scoped_connection m_connection;
     };
 
 } // namespace
 
 std::unique_ptr<Handler> MakeHandler(boost::signals2::connection connection) {
     return std::make_unique<HandlerImpl>(std::move(connection));
 }
 
 } // namespace interfaces
diff --git a/src/interfaces/wallet.cpp b/src/interfaces/wallet.cpp
index d98e28777..32645dd33 100644
--- a/src/interfaces/wallet.cpp
+++ b/src/interfaces/wallet.cpp
@@ -1,533 +1,533 @@
 // 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 <chain.h>
 #include <consensus/validation.h>
 #include <init.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
 #include <net.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
 #include <scheduler.h>
 #include <script/ismine.h>
 #include <script/standard.h>
 #include <support/allocators/secure.h>
 #include <sync.h>
 #include <timedata.h>
 #include <ui_interface.h>
 #include <util/system.h>
 #include <validation.h>
 #include <wallet/fees.h>
 #include <wallet/load.h>
 #include <wallet/rpcdump.h>
 #include <wallet/rpcwallet.h>
 #include <wallet/wallet.h>
 #include <wallet/walletutil.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace interfaces {
 namespace {
 
     class PendingWalletTxImpl : public PendingWalletTx {
     public:
-        PendingWalletTxImpl(CWallet &wallet)
+        explicit PendingWalletTxImpl(CWallet &wallet)
             : m_wallet(wallet), m_key(&wallet) {}
 
         const CTransaction &get() override { return *m_tx; }
 
         bool commit(WalletValueMap value_map, WalletOrderForm order_form,
                     std::string &reject_reason) override {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             CValidationState state;
             if (!m_wallet.CommitTransaction(m_tx, std::move(value_map),
                                             std::move(order_form), m_key,
                                             state)) {
                 reject_reason = state.GetRejectReason();
                 return false;
             }
             return true;
         }
 
         CTransactionRef m_tx;
         CWallet &m_wallet;
         CReserveKey m_key;
     };
 
     //! Construct wallet tx struct.
     static WalletTx MakeWalletTx(interfaces::Chain::Lock &locked_chain,
                                  CWallet &wallet, const CWalletTx &wtx) {
         WalletTx result;
         result.tx = wtx.tx;
         result.txin_is_mine.reserve(wtx.tx->vin.size());
         for (const auto &txin : wtx.tx->vin) {
             result.txin_is_mine.emplace_back(wallet.IsMine(txin));
         }
         result.txout_is_mine.reserve(wtx.tx->vout.size());
         result.txout_address.reserve(wtx.tx->vout.size());
         result.txout_address_is_mine.reserve(wtx.tx->vout.size());
         for (const auto &txout : wtx.tx->vout) {
             result.txout_is_mine.emplace_back(wallet.IsMine(txout));
             result.txout_address.emplace_back();
             result.txout_address_is_mine.emplace_back(
                 ExtractDestination(txout.scriptPubKey,
                                    result.txout_address.back())
                     ? IsMine(wallet, result.txout_address.back())
                     : ISMINE_NO);
         }
         result.credit = wtx.GetCredit(locked_chain, 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.
     static WalletTxStatus
     MakeWalletTxStatus(interfaces::Chain::Lock &locked_chain,
                        const CWalletTx &wtx) {
         WalletTxStatus result;
         result.block_height =
             locked_chain.getBlockHeight(wtx.hashBlock)
                 .get_value_or(std::numeric_limits<int>::max());
         result.blocks_to_maturity = wtx.GetBlocksToMaturity(locked_chain);
         result.depth_in_main_chain = wtx.GetDepthInMainChain(locked_chain);
         result.time_received = wtx.nTimeReceived;
         result.lock_time = wtx.tx->nLockTime;
         CValidationState state;
         result.is_final =
             locked_chain.contextualCheckTransactionForCurrentBlock(
                 Params().GetConsensus(), *wtx.tx, state);
         result.is_trusted = wtx.IsTrusted(locked_chain);
         result.is_abandoned = wtx.isAbandoned();
         result.is_coinbase = wtx.IsCoinBase();
         result.is_in_main_chain = wtx.IsInMainChain(locked_chain);
         return result;
     }
 
     //! Construct wallet TxOut struct.
     static WalletTxOut MakeWalletTxOut(interfaces::Chain::Lock &locked_chain,
                                        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(locked_chain, COutPoint(wtx.GetId(), n));
         return result;
     }
 
     class WalletImpl : public Wallet {
     public:
-        WalletImpl(const std::shared_ptr<CWallet> &wallet)
+        explicit WalletImpl(const std::shared_ptr<CWallet> &wallet)
             : m_shared_wallet(wallet), m_wallet(*wallet.get()) {}
 
         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 getKeyFromPool(bool internal, CPubKey &pub_key) override {
             return m_wallet.GetKeyFromPool(pub_key, internal);
         }
         const CChainParams &getChainParams() override {
             return m_wallet.chainParams;
         }
         bool getPubKey(const CKeyID &address, CPubKey &pub_key) override {
             return m_wallet.GetPubKey(address, pub_key);
         }
         bool getPrivKey(const CKeyID &address, CKey &key) override {
             return m_wallet.GetKey(address, key);
         }
         bool isSpendable(const CTxDestination &dest) override {
             return IsMine(m_wallet, dest) & ISMINE_SPENDABLE;
         }
         bool haveWatchOnly() override { return m_wallet.HaveWatchOnly(); };
         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.mapAddressBook.find(dest);
             if (it == m_wallet.mapAddressBook.end()) {
                 return false;
             }
             if (name) {
                 *name = it->second.name;
             }
             if (is_mine) {
                 *is_mine = IsMine(m_wallet, 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.mapAddressBook) {
                 result.emplace_back(item.first, IsMine(m_wallet, item.first),
                                     item.second.name, item.second.purpose);
             }
             return result;
         }
         void learnRelatedScripts(const CPubKey &key, OutputType type) override {
             m_wallet.LearnRelatedScripts(key, type);
         }
         bool addDestData(const CTxDestination &dest, const std::string &key,
                          const std::string &value) override {
             LOCK(m_wallet.cs_wallet);
             return m_wallet.AddDestData(dest, key, value);
         }
         bool eraseDestData(const CTxDestination &dest,
                            const std::string &key) override {
             LOCK(m_wallet.cs_wallet);
             return m_wallet.EraseDestData(dest, key);
         }
         std::vector<std::string>
         getDestValues(const std::string &prefix) override {
             return m_wallet.GetDestValues(prefix);
         }
         void lockCoin(const COutPoint &output) override {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             return m_wallet.LockCoin(output);
         }
         void unlockCoin(const COutPoint &output) override {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             return m_wallet.UnlockCoin(output);
         }
         bool isLockedCoin(const COutPoint &output) override {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             return m_wallet.IsLockedCoin(output);
         }
         void listLockedCoins(std::vector<COutPoint> &outputs) override {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             return m_wallet.ListLockedCoins(outputs);
         }
         std::unique_ptr<PendingWalletTx>
         createTransaction(const std::vector<CRecipient> &recipients,
                           const CCoinControl &coin_control, bool sign,
                           int &change_pos, Amount &fee,
                           std::string &fail_reason) override {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             auto pending = std::make_unique<PendingWalletTxImpl>(m_wallet);
             if (!m_wallet.CreateTransaction(
                     *locked_chain, recipients, pending->m_tx, pending->m_key,
                     fee, change_pos, fail_reason, coin_control, sign)) {
                 return {};
             }
             return pending;
         }
         bool transactionCanBeAbandoned(const TxId &txid) override {
             return m_wallet.TransactionCanBeAbandoned(txid);
         }
         bool abandonTransaction(const TxId &txid) override {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             return m_wallet.AbandonTransaction(*locked_chain, txid);
         }
         CTransactionRef getTx(const TxId &txid) override {
             auto locked_chain = m_wallet.chain().lock();
             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 {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             auto mi = m_wallet.mapWallet.find(txid);
             if (mi != m_wallet.mapWallet.end()) {
                 return MakeWalletTx(*locked_chain, m_wallet, mi->second);
             }
             return {};
         }
         std::vector<WalletTx> getWalletTxs() override {
             auto locked_chain = m_wallet.chain().lock();
             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(*locked_chain, m_wallet, entry.second));
             }
             return result;
         }
         bool tryGetTxStatus(const TxId &txid,
                             interfaces::WalletTxStatus &tx_status,
                             int &num_blocks, int64_t &block_time) override {
             auto locked_chain = m_wallet.chain().lock(true /* try_lock */);
             if (!locked_chain) {
                 return false;
             }
             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;
             }
             if (Optional<int> height = locked_chain->getHeight()) {
                 num_blocks = *height;
                 block_time = locked_chain->getBlockTime(*height);
             } else {
                 num_blocks = -1;
                 block_time = -1;
             }
             tx_status = MakeWalletTxStatus(*locked_chain, mi->second);
             return true;
         }
         WalletTx getWalletTxDetails(const TxId &txid, WalletTxStatus &tx_status,
                                     WalletOrderForm &order_form,
                                     bool &in_mempool,
                                     int &num_blocks) override {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             auto mi = m_wallet.mapWallet.find(txid);
             if (mi != m_wallet.mapWallet.end()) {
                 num_blocks = locked_chain->getHeight().value_or(-1);
                 in_mempool = mi->second.InMempool();
                 order_form = mi->second.vOrderForm;
                 tx_status = MakeWalletTxStatus(*locked_chain, mi->second);
                 return MakeWalletTx(*locked_chain, m_wallet, mi->second);
             }
             return {};
         }
         WalletBalances getBalances() override {
             WalletBalances result;
             result.balance = m_wallet.GetBalance();
             result.unconfirmed_balance = m_wallet.GetUnconfirmedBalance();
             result.immature_balance = m_wallet.GetImmatureBalance();
             result.have_watch_only = m_wallet.HaveWatchOnly();
             if (result.have_watch_only) {
                 result.watch_only_balance =
                     m_wallet.GetBalance(ISMINE_WATCH_ONLY);
                 result.unconfirmed_watch_only_balance =
                     m_wallet.GetUnconfirmedWatchOnlyBalance();
                 result.immature_watch_only_balance =
                     m_wallet.GetImmatureWatchOnlyBalance();
             }
             return result;
         }
         bool tryGetBalances(WalletBalances &balances,
                             int &num_blocks) override {
             auto locked_chain = m_wallet.chain().lock(true /* try_lock */);
             if (!locked_chain) {
                 return false;
             }
             TRY_LOCK(m_wallet.cs_wallet, locked_wallet);
             if (!locked_wallet) {
                 return false;
             }
             balances = getBalances();
             num_blocks = locked_chain->getHeight().value_or(-1);
             return true;
         }
         Amount getBalance() override { return m_wallet.GetBalance(); }
         Amount getAvailableBalance(const CCoinControl &coin_control) override {
             return m_wallet.GetAvailableBalance(&coin_control);
         }
         isminetype txinIsMine(const CTxIn &txin) override {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             return m_wallet.IsMine(txin);
         }
         isminetype txoutIsMine(const CTxOut &txout) override {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             return m_wallet.IsMine(txout);
         }
         Amount getDebit(const CTxIn &txin, isminefilter filter) override {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             return m_wallet.GetDebit(txin, filter);
         }
         Amount getCredit(const CTxOut &txout, isminefilter filter) override {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             return m_wallet.GetCredit(txout, filter);
         }
         CoinsList listCoins() override {
             auto locked_chain = m_wallet.chain().lock();
             LOCK(m_wallet.cs_wallet);
             CoinsList result;
             for (const auto &entry : m_wallet.ListCoins(*locked_chain)) {
                 auto &group = result[entry.first];
                 for (const auto &coin : entry.second) {
                     group.emplace_back(COutPoint(coin.tx->GetId(), coin.i),
                                        MakeWalletTxOut(*locked_chain, m_wallet,
                                                        *coin.tx, coin.i,
                                                        coin.nDepth));
                 }
             }
             return result;
         }
         std::vector<WalletTxOut>
         getCoins(const std::vector<COutPoint> &outputs) override {
             auto locked_chain = m_wallet.chain().lock();
             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(*locked_chain);
                     if (depth >= 0) {
                         result.back() =
                             MakeWalletTxOut(*locked_chain, 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() override { return m_wallet.CanGetAddresses(); }
         bool IsWalletFlagSet(uint64_t flag) override {
             return m_wallet.IsWalletFlagSet(flag);
         }
         OutputType getDefaultChangeType() override {
             return m_wallet.m_default_change_type;
         }
         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](CCryptoKeyStore *) { 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);
         }
 
         std::shared_ptr<CWallet> m_shared_wallet;
         CWallet &m_wallet;
     };
 
     class WalletClientImpl : public ChainClient {
     public:
         WalletClientImpl(Chain &chain,
                          std::vector<std::string> wallet_filenames)
             : m_chain(chain), m_wallet_filenames(std::move(wallet_filenames)) {}
 
         void registerRpcs() override {
             RegisterWalletRPCCommands(m_chain, m_rpc_handlers);
             RegisterDumpRPCCommands(m_chain, m_rpc_handlers);
         }
         bool verify(const CChainParams &chainParams) override {
             return VerifyWallets(chainParams, m_chain, m_wallet_filenames);
         }
         bool load(const CChainParams &chainParams) override {
             return LoadWallets(chainParams, m_chain, m_wallet_filenames);
         }
         void start(CScheduler &scheduler) override {
             return StartWallets(scheduler);
         }
         void flush() override { return FlushWallets(); }
         void stop() override { return StopWallets(); }
         ~WalletClientImpl() override { UnloadWallets(); }
 
         Chain &m_chain;
         std::vector<std::string> m_wallet_filenames;
         std::vector<std::unique_ptr<Handler>> m_rpc_handlers;
     };
 
 } // namespace
 
 std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet> &wallet) {
     return std::make_unique<WalletImpl>(wallet);
 }
 
 std::unique_ptr<ChainClient>
 MakeWalletClient(Chain &chain, std::vector<std::string> wallet_filenames) {
     return std::make_unique<WalletClientImpl>(chain,
                                               std::move(wallet_filenames));
 }
 
 } // namespace interfaces
diff --git a/src/key_io.cpp b/src/key_io.cpp
index e875dad8c..a2abd215d 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -1,191 +1,192 @@
 // Copyright (c) 2014-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <key_io.h>
 
 #include <base58.h>
 #include <cashaddrenc.h>
 #include <chainparams.h>
 #include <config.h>
 #include <script/script.h>
 #include <util/strencodings.h>
 
 #include <boost/variant/apply_visitor.hpp>
 #include <boost/variant/static_visitor.hpp>
 
 #include <algorithm>
 #include <cassert>
 #include <cstring>
 
 namespace {
 class DestinationEncoder : public boost::static_visitor<std::string> {
 private:
     const CChainParams &m_params;
 
 public:
-    DestinationEncoder(const CChainParams &params) : m_params(params) {}
+    explicit DestinationEncoder(const CChainParams &params)
+        : m_params(params) {}
 
     std::string operator()(const CKeyID &id) const {
         std::vector<uint8_t> data =
             m_params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
         data.insert(data.end(), id.begin(), id.end());
         return EncodeBase58Check(data);
     }
 
     std::string operator()(const CScriptID &id) const {
         std::vector<uint8_t> data =
             m_params.Base58Prefix(CChainParams::SCRIPT_ADDRESS);
         data.insert(data.end(), id.begin(), id.end());
         return EncodeBase58Check(data);
     }
 
     std::string operator()(const CNoDestination &no) const { return {}; }
 };
 
 CTxDestination DecodeLegacyDestination(const std::string &str,
                                        const CChainParams &params) {
     std::vector<uint8_t> data;
     uint160 hash;
     if (!DecodeBase58Check(str, data)) {
         return CNoDestination();
     }
     // base58-encoded Bitcoin addresses.
     // Public-key-hash-addresses have version 0 (or 111 testnet).
     // The data vector contains RIPEMD160(SHA256(pubkey)), where pubkey is
     // the serialized public key.
     const std::vector<uint8_t> &pubkey_prefix =
         params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
     if (data.size() == hash.size() + pubkey_prefix.size() &&
         std::equal(pubkey_prefix.begin(), pubkey_prefix.end(), data.begin())) {
         std::copy(data.begin() + pubkey_prefix.size(), data.end(),
                   hash.begin());
         return CKeyID(hash);
     }
     // Script-hash-addresses have version 5 (or 196 testnet).
     // The data vector contains RIPEMD160(SHA256(cscript)), where cscript is
     // the serialized redemption script.
     const std::vector<uint8_t> &script_prefix =
         params.Base58Prefix(CChainParams::SCRIPT_ADDRESS);
     if (data.size() == hash.size() + script_prefix.size() &&
         std::equal(script_prefix.begin(), script_prefix.end(), data.begin())) {
         std::copy(data.begin() + script_prefix.size(), data.end(),
                   hash.begin());
         return CScriptID(hash);
     }
     return CNoDestination();
 }
 } // namespace
 
 CKey DecodeSecret(const std::string &str) {
     CKey key;
     std::vector<uint8_t> data;
     if (DecodeBase58Check(str, data)) {
         const std::vector<uint8_t> &privkey_prefix =
             Params().Base58Prefix(CChainParams::SECRET_KEY);
         if ((data.size() == 32 + privkey_prefix.size() ||
              (data.size() == 33 + privkey_prefix.size() && data.back() == 1)) &&
             std::equal(privkey_prefix.begin(), privkey_prefix.end(),
                        data.begin())) {
             bool compressed = data.size() == 33 + privkey_prefix.size();
             key.Set(data.begin() + privkey_prefix.size(),
                     data.begin() + privkey_prefix.size() + 32, compressed);
         }
     }
     if (!data.empty()) {
         memory_cleanse(data.data(), data.size());
     }
     return key;
 }
 
 std::string EncodeSecret(const CKey &key) {
     assert(key.IsValid());
     std::vector<uint8_t> data = Params().Base58Prefix(CChainParams::SECRET_KEY);
     data.insert(data.end(), key.begin(), key.end());
     if (key.IsCompressed()) {
         data.push_back(1);
     }
     std::string ret = EncodeBase58Check(data);
     memory_cleanse(data.data(), data.size());
     return ret;
 }
 
 CExtPubKey DecodeExtPubKey(const std::string &str) {
     CExtPubKey key;
     std::vector<uint8_t> data;
     if (DecodeBase58Check(str, data)) {
         const std::vector<uint8_t> &prefix =
             Params().Base58Prefix(CChainParams::EXT_PUBLIC_KEY);
         if (data.size() == BIP32_EXTKEY_SIZE + prefix.size() &&
             std::equal(prefix.begin(), prefix.end(), data.begin())) {
             key.Decode(data.data() + prefix.size());
         }
     }
     return key;
 }
 
 std::string EncodeExtPubKey(const CExtPubKey &key) {
     std::vector<uint8_t> data =
         Params().Base58Prefix(CChainParams::EXT_PUBLIC_KEY);
     size_t size = data.size();
     data.resize(size + BIP32_EXTKEY_SIZE);
     key.Encode(data.data() + size);
     std::string ret = EncodeBase58Check(data);
     return ret;
 }
 
 CExtKey DecodeExtKey(const std::string &str) {
     CExtKey key;
     std::vector<uint8_t> data;
     if (DecodeBase58Check(str, data)) {
         const std::vector<uint8_t> &prefix =
             Params().Base58Prefix(CChainParams::EXT_SECRET_KEY);
         if (data.size() == BIP32_EXTKEY_SIZE + prefix.size() &&
             std::equal(prefix.begin(), prefix.end(), data.begin())) {
             key.Decode(data.data() + prefix.size());
         }
     }
     return key;
 }
 
 std::string EncodeExtKey(const CExtKey &key) {
     std::vector<uint8_t> data =
         Params().Base58Prefix(CChainParams::EXT_SECRET_KEY);
     size_t size = data.size();
     data.resize(size + BIP32_EXTKEY_SIZE);
     key.Encode(data.data() + size);
     std::string ret = EncodeBase58Check(data);
     memory_cleanse(data.data(), data.size());
     return ret;
 }
 
 std::string EncodeDestination(const CTxDestination &dest,
                               const Config &config) {
     const CChainParams &params = config.GetChainParams();
     return config.UseCashAddrEncoding() ? EncodeCashAddr(dest, params)
                                         : EncodeLegacyAddr(dest, params);
 }
 
 CTxDestination DecodeDestination(const std::string &addr,
                                  const CChainParams &params) {
     CTxDestination dst = DecodeCashAddr(addr, params);
     if (IsValidDestination(dst)) {
         return dst;
     }
     return DecodeLegacyAddr(addr, params);
 }
 
 bool IsValidDestinationString(const std::string &str,
                               const CChainParams &params) {
     return IsValidDestination(DecodeDestination(str, params));
 }
 
 std::string EncodeLegacyAddr(const CTxDestination &dest,
                              const CChainParams &params) {
     return boost::apply_visitor(DestinationEncoder(params), dest);
 }
 
 CTxDestination DecodeLegacyAddr(const std::string &str,
                                 const CChainParams &params) {
     return DecodeLegacyDestination(str, params);
 }
diff --git a/src/qt/addresstablemodel.cpp b/src/qt/addresstablemodel.cpp
index 344b72981..e5cf17b47 100644
--- a/src/qt/addresstablemodel.cpp
+++ b/src/qt/addresstablemodel.cpp
@@ -1,432 +1,432 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/addresstablemodel.h>
 
 #include <cashaddrenc.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <qt/guiutil.h>
 #include <qt/walletmodel.h>
 #include <wallet/wallet.h>
 
 #include <algorithm>
 
 #include <QDebug>
 #include <QFont>
 
 const QString AddressTableModel::Send = "S";
 const QString AddressTableModel::Receive = "R";
 
 struct AddressTableEntry {
     enum Type {
         Sending,
         Receiving,
         /* QSortFilterProxyModel will filter these out */
         Hidden
     };
 
     Type type;
     QString label;
     QString address;
 
     AddressTableEntry() {}
     AddressTableEntry(Type _type, const QString &_label,
                       const QString &_address)
         : type(_type), label(_label), address(_address) {}
 };
 
 struct AddressTableEntryLessThan {
     bool operator()(const AddressTableEntry &a,
                     const AddressTableEntry &b) const {
         return a.address < b.address;
     }
     bool operator()(const AddressTableEntry &a, const QString &b) const {
         return a.address < b;
     }
     bool operator()(const QString &a, const AddressTableEntry &b) const {
         return a < b.address;
     }
 };
 
 /* Determine address type from address purpose */
 static AddressTableEntry::Type
 translateTransactionType(const QString &strPurpose, bool isMine) {
     AddressTableEntry::Type addressType = AddressTableEntry::Hidden;
     // "refund" addresses aren't shown, and change addresses aren't in
     // mapAddressBook at all.
     if (strPurpose == "send") {
         addressType = AddressTableEntry::Sending;
     } else if (strPurpose == "receive") {
         addressType = AddressTableEntry::Receiving;
     } else if (strPurpose == "unknown" || strPurpose == "") {
         // if purpose not set, guess
         addressType = (isMine ? AddressTableEntry::Receiving
                               : AddressTableEntry::Sending);
     }
     return addressType;
 }
 
 // Private implementation
 class AddressTablePriv {
 public:
     QList<AddressTableEntry> cachedAddressTable;
     AddressTableModel *parent;
 
-    AddressTablePriv(AddressTableModel *_parent) : parent(_parent) {}
+    explicit AddressTablePriv(AddressTableModel *_parent) : parent(_parent) {}
 
     void refreshAddressTable(interfaces::Wallet &wallet) {
         cachedAddressTable.clear();
         for (const auto &address : wallet.getAddresses()) {
             AddressTableEntry::Type addressType = translateTransactionType(
                 QString::fromStdString(address.purpose), address.is_mine);
             cachedAddressTable.append(AddressTableEntry(
                 addressType, QString::fromStdString(address.name),
                 QString::fromStdString(EncodeCashAddr(
                     address.dest, parent->walletModel->getChainParams()))));
         }
         // std::lower_bound() and std::upper_bound() require our
         // cachedAddressTable list to be sorted in asc order Even though the map
         // is already sorted this re-sorting step is needed because the
         // originating map is sorted by binary address, not by base58() address.
         std::sort(cachedAddressTable.begin(), cachedAddressTable.end(),
                   AddressTableEntryLessThan());
     }
 
     void updateEntry(const QString &address, const QString &label, bool isMine,
                      const QString &purpose, int status) {
         // Find address / label in model
         QList<AddressTableEntry>::iterator lower = std::lower_bound(
             cachedAddressTable.begin(), cachedAddressTable.end(), address,
             AddressTableEntryLessThan());
         QList<AddressTableEntry>::iterator upper = std::upper_bound(
             cachedAddressTable.begin(), cachedAddressTable.end(), address,
             AddressTableEntryLessThan());
         int lowerIndex = (lower - cachedAddressTable.begin());
         int upperIndex = (upper - cachedAddressTable.begin());
         bool inModel = (lower != upper);
         AddressTableEntry::Type newEntryType =
             translateTransactionType(purpose, isMine);
 
         switch (status) {
             case CT_NEW:
                 if (inModel) {
                     qWarning() << "AddressTablePriv::updateEntry: Warning: Got "
                                   "CT_NEW, but entry is already in model";
                     break;
                 }
                 parent->beginInsertRows(QModelIndex(), lowerIndex, lowerIndex);
                 cachedAddressTable.insert(
                     lowerIndex,
                     AddressTableEntry(newEntryType, label, address));
                 parent->endInsertRows();
                 break;
             case CT_UPDATED:
                 if (!inModel) {
                     qWarning() << "AddressTablePriv::updateEntry: Warning: Got "
                                   "CT_UPDATED, but entry is not in model";
                     break;
                 }
                 lower->type = newEntryType;
                 lower->label = label;
                 parent->emitDataChanged(lowerIndex);
                 break;
             case CT_DELETED:
                 if (!inModel) {
                     qWarning() << "AddressTablePriv::updateEntry: Warning: Got "
                                   "CT_DELETED, but entry is not in model";
                     break;
                 }
                 parent->beginRemoveRows(QModelIndex(), lowerIndex,
                                         upperIndex - 1);
                 cachedAddressTable.erase(lower, upper);
                 parent->endRemoveRows();
                 break;
         }
     }
 
     int size() { return cachedAddressTable.size(); }
 
     AddressTableEntry *index(int idx) {
         if (idx >= 0 && idx < cachedAddressTable.size()) {
             return &cachedAddressTable[idx];
         } else {
             return nullptr;
         }
     }
 };
 
 AddressTableModel::AddressTableModel(WalletModel *parent)
     : QAbstractTableModel(parent), walletModel(parent) {
     columns << tr("Label") << tr("Address");
     priv = new AddressTablePriv(this);
     priv->refreshAddressTable(parent->wallet());
 }
 
 AddressTableModel::~AddressTableModel() {
     delete priv;
 }
 
 int AddressTableModel::rowCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return priv->size();
 }
 
 int AddressTableModel::columnCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return columns.length();
 }
 
 QVariant AddressTableModel::data(const QModelIndex &index, int role) const {
     if (!index.isValid()) {
         return QVariant();
     }
 
     AddressTableEntry *rec =
         static_cast<AddressTableEntry *>(index.internalPointer());
 
     if (role == Qt::DisplayRole || role == Qt::EditRole) {
         switch (index.column()) {
             case Label:
                 if (rec->label.isEmpty() && role == Qt::DisplayRole) {
                     return tr("(no label)");
                 } else {
                     return rec->label;
                 }
             case Address:
                 return rec->address;
         }
     } else if (role == Qt::FontRole) {
         QFont font;
         if (index.column() == Address) {
             font = GUIUtil::fixedPitchFont();
         }
         return font;
     } else if (role == TypeRole) {
         switch (rec->type) {
             case AddressTableEntry::Sending:
                 return Send;
             case AddressTableEntry::Receiving:
                 return Receive;
             default:
                 break;
         }
     }
     return QVariant();
 }
 
 bool AddressTableModel::setData(const QModelIndex &index, const QVariant &value,
                                 int role) {
     if (!index.isValid()) {
         return false;
     }
     AddressTableEntry *rec =
         static_cast<AddressTableEntry *>(index.internalPointer());
     std::string strPurpose =
         (rec->type == AddressTableEntry::Sending ? "send" : "receive");
     editStatus = OK;
 
     if (role == Qt::EditRole) {
         CTxDestination curAddress = DecodeDestination(
             rec->address.toStdString(), walletModel->getChainParams());
         if (index.column() == Label) {
             // Do nothing, if old label == new label
             if (rec->label == value.toString()) {
                 editStatus = NO_CHANGES;
                 return false;
             }
             walletModel->wallet().setAddressBook(
                 curAddress, value.toString().toStdString(), strPurpose);
         } else if (index.column() == Address) {
             CTxDestination newAddress = DecodeDestination(
                 value.toString().toStdString(), walletModel->getChainParams());
             // Refuse to set invalid address, set error status and return false
             if (boost::get<CNoDestination>(&newAddress)) {
                 editStatus = INVALID_ADDRESS;
                 return false;
             }
             // Do nothing, if old address == new address
             else if (newAddress == curAddress) {
                 editStatus = NO_CHANGES;
                 return false;
             }
             // Check for duplicate addresses to prevent accidental deletion of
             // addresses, if you try to paste an existing address over another
             // address (with a different label)
             if (walletModel->wallet().getAddress(
                     newAddress, /* name= */ nullptr, /* is_mine= */ nullptr,
                     /* purpose= */ nullptr)) {
                 editStatus = DUPLICATE_ADDRESS;
                 return false;
             }
             // Double-check that we're not overwriting a receiving address
             else if (rec->type == AddressTableEntry::Sending) {
                 // Remove old entry
                 walletModel->wallet().delAddressBook(curAddress);
                 // Add new entry with new address
                 walletModel->wallet().setAddressBook(
                     newAddress, value.toString().toStdString(), strPurpose);
             }
         }
         return true;
     }
     return false;
 }
 
 QVariant AddressTableModel::headerData(int section, Qt::Orientation orientation,
                                        int role) const {
     if (orientation == Qt::Horizontal) {
         if (role == Qt::DisplayRole && section < columns.size()) {
             return columns[section];
         }
     }
     return QVariant();
 }
 
 Qt::ItemFlags AddressTableModel::flags(const QModelIndex &index) const {
     if (!index.isValid()) {
         return Qt::NoItemFlags;
     }
     AddressTableEntry *rec =
         static_cast<AddressTableEntry *>(index.internalPointer());
 
     Qt::ItemFlags retval = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
     // Can edit address and label for sending addresses, and only label for
     // receiving addresses.
     if (rec->type == AddressTableEntry::Sending ||
         (rec->type == AddressTableEntry::Receiving &&
          index.column() == Label)) {
         retval |= Qt::ItemIsEditable;
     }
     return retval;
 }
 
 QModelIndex AddressTableModel::index(int row, int column,
                                      const QModelIndex &parent) const {
     Q_UNUSED(parent);
     AddressTableEntry *data = priv->index(row);
     if (data) {
         return createIndex(row, column, priv->index(row));
     } else {
         return QModelIndex();
     }
 }
 
 void AddressTableModel::updateEntry(const QString &address,
                                     const QString &label, bool isMine,
                                     const QString &purpose, int status) {
     // Update address book model from Bitcoin core
     priv->updateEntry(address, label, isMine, purpose, status);
 }
 
 QString AddressTableModel::addRow(const QString &type, const QString &label,
                                   const QString &address,
                                   const OutputType address_type) {
     std::string strLabel = label.toStdString();
     std::string strAddress = address.toStdString();
 
     editStatus = OK;
 
     if (type == Send) {
         if (!walletModel->validateAddress(address)) {
             editStatus = INVALID_ADDRESS;
             return QString();
         }
         // Check for duplicate addresses
         if (walletModel->wallet().getAddress(
                 DecodeDestination(strAddress, walletModel->getChainParams()),
                 /* name= */ nullptr, /* is_mine= */ nullptr,
                 /* purpose= */ nullptr)) {
             editStatus = DUPLICATE_ADDRESS;
             return QString();
         }
     } else if (type == Receive) {
         // Generate a new address to associate with given label
         CPubKey newKey;
         if (!walletModel->wallet().getKeyFromPool(false /* internal */,
                                                   newKey)) {
             WalletModel::UnlockContext ctx(walletModel->requestUnlock());
             if (!ctx.isValid()) {
                 // Unlock wallet failed or was cancelled
                 editStatus = WALLET_UNLOCK_FAILURE;
                 return QString();
             }
             if (!walletModel->wallet().getKeyFromPool(false /* internal */,
                                                       newKey)) {
                 editStatus = KEY_GENERATION_FAILURE;
                 return QString();
             }
         }
         walletModel->wallet().learnRelatedScripts(newKey, address_type);
         strAddress = EncodeCashAddr(GetDestinationForKey(newKey, address_type),
                                     walletModel->getChainParams());
     } else {
         return QString();
     }
 
     // Add entry
     walletModel->wallet().setAddressBook(
         DecodeDestination(strAddress, walletModel->getChainParams()), strLabel,
         (type == Send ? "send" : "receive"));
     return QString::fromStdString(strAddress);
 }
 
 bool AddressTableModel::removeRows(int row, int count,
                                    const QModelIndex &parent) {
     Q_UNUSED(parent);
     AddressTableEntry *rec = priv->index(row);
     if (count != 1 || !rec || rec->type == AddressTableEntry::Receiving) {
         // Can only remove one row at a time, and cannot remove rows not in
         // model.
         // Also refuse to remove receiving addresses.
         return false;
     }
     walletModel->wallet().delAddressBook(DecodeDestination(
         rec->address.toStdString(), walletModel->getChainParams()));
     return true;
 }
 
 QString AddressTableModel::labelForAddress(const QString &address) const {
     std::string name;
     if (getAddressData(address, &name, /* purpose= */ nullptr)) {
         return QString::fromStdString(name);
     }
     return QString();
 }
 
 QString AddressTableModel::purposeForAddress(const QString &address) const {
     std::string purpose;
     if (getAddressData(address, /* name= */ nullptr, &purpose)) {
         return QString::fromStdString(purpose);
     }
     return QString();
 }
 
 bool AddressTableModel::getAddressData(const QString &address,
                                        std::string *name,
                                        std::string *purpose) const {
     CTxDestination destination =
         DecodeDestination(address.toStdString(), walletModel->getChainParams());
     return walletModel->wallet().getAddress(destination, name,
                                             /* is_mine= */ nullptr, purpose);
 }
 
 int AddressTableModel::lookupAddress(const QString &address) const {
     QModelIndexList lst = match(index(0, Address, QModelIndex()), Qt::EditRole,
                                 address, 1, Qt::MatchExactly);
     if (lst.isEmpty()) {
         return -1;
     } else {
         return lst.at(0).row();
     }
 }
 
 OutputType AddressTableModel::GetDefaultAddressType() const {
     return walletModel->wallet().getDefaultAddressType();
 };
 
 void AddressTableModel::emitDataChanged(int idx) {
     Q_EMIT dataChanged(index(idx, 0, QModelIndex()),
                        index(idx, columns.length() - 1, QModelIndex()));
 }
diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
index 500a33746..4084d2e7a 100644
--- a/src/qt/rpcconsole.cpp
+++ b/src/qt/rpcconsole.cpp
@@ -1,1467 +1,1467 @@
 // 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.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/rpcconsole.h>
 
 #include <chainparams.h>
 #include <config.h>
 #include <interfaces/node.h>
 #include <netbase.h>
 #include <qt/bantablemodel.h>
 #include <qt/clientmodel.h>
 #include <qt/forms/ui_debugwindow.h>
 #include <qt/guiutil.h>
 #include <qt/platformstyle.h>
 #include <qt/walletmodel.h>
 #include <rpc/client.h>
 #include <rpc/server.h>
 #include <util/system.h>
 
 #ifdef ENABLE_WALLET
 #include <wallet/wallet.h>
 
 #include <db_cxx.h>
 #endif
 
 #include <univalue.h>
 
 #include <QKeyEvent>
 #include <QMenu>
 #include <QMessageBox>
 #include <QScreen>
 #include <QScrollBar>
 #include <QSettings>
 #include <QSignalMapper>
 #include <QStringList>
 #include <QThread>
 #include <QTime>
 #include <QTimer>
 
 // TODO: add a scrollback limit, as there is currently none
 // TODO: make it possible to filter out categories (esp debug messages when
 // implemented)
 // TODO: receive errors and debug messages through ClientModel
 
 const int CONSOLE_HISTORY = 50;
 const int INITIAL_TRAFFIC_GRAPH_MINS = 30;
 const QSize FONT_RANGE(4, 40);
 const char fontSizeSettingsKey[] = "consoleFontSize";
 
 const struct {
     const char *url;
     const char *source;
 } ICON_MAPPING[] = {{"cmd-request", ":/icons/tx_input"},
                     {"cmd-reply", ":/icons/tx_output"},
                     {"cmd-error", ":/icons/tx_output"},
                     {"misc", ":/icons/tx_inout"},
                     {nullptr, nullptr}};
 
 namespace {
 
 // don't add private key handling cmd's to the history
 const QStringList historyFilter = QStringList() << "importprivkey"
                                                 << "importmulti"
                                                 << "sethdseed"
                                                 << "signmessagewithprivkey"
                                                 << "signrawtransactionwithkey"
                                                 << "walletpassphrase"
                                                 << "walletpassphrasechange"
                                                 << "encryptwallet";
 } // namespace
 
 /* Object for executing console RPC commands in a separate thread.
  */
 class RPCExecutor : public QObject {
     Q_OBJECT
 public:
-    RPCExecutor(interfaces::Node &node) : m_node(node) {}
+    explicit RPCExecutor(interfaces::Node &node) : m_node(node) {}
 
 public Q_SLOTS:
     void request(const QString &command, const WalletModel *wallet_model);
 
 Q_SIGNALS:
     void reply(int category, const QString &command);
 
 private:
     interfaces::Node &m_node;
 };
 
 /** Class for handling RPC timers
  * (used for e.g. re-locking the wallet after a timeout)
  */
 class QtRPCTimerBase : public QObject, public RPCTimerBase {
     Q_OBJECT
 public:
     QtRPCTimerBase(std::function<void()> &_func, int64_t millis) : func(_func) {
         timer.setSingleShot(true);
         connect(&timer, &QTimer::timeout, [this] { func(); });
         timer.start(millis);
     }
     ~QtRPCTimerBase() {}
 
 private:
     QTimer timer;
     std::function<void()> func;
 };
 
 class QtRPCTimerInterface : public RPCTimerInterface {
 public:
     ~QtRPCTimerInterface() {}
     const char *Name() override { return "Qt"; }
     RPCTimerBase *NewTimer(std::function<void()> &func,
                            int64_t millis) override {
         return new QtRPCTimerBase(func, millis);
     }
 };
 
 #include <qt/rpcconsole.moc>
 
 /**
  * Split shell command line into a list of arguments and optionally execute the
  * command(s).
  * Aims to emulate \c bash and friends.
  *
  * - Command nesting is possible with parenthesis; for example:
  * validateaddress(getnewaddress())
  * - Arguments are delimited with whitespace or comma
  * - Extra whitespace at the beginning and end and between arguments will be
  * ignored
  * - Text can be "double" or 'single' quoted
  * - The backslash \c \ is used as escape character
  *   - Outside quotes, any character can be escaped
  *   - Within double quotes, only escape \c " and backslashes before a \c " or
  * another backslash
  *   - Within single quotes, no escaping is possible and no special
  * interpretation takes place
  *
  * @param[in]    node    optional node to execute command on
  * @param[out]   result      stringified Result from the executed command(chain)
  * @param[in]    strCommand  Command line to split
  * @param[in]    fExecute    set true if you want the command to be executed
  * @param[out]   pstrFilteredOut  Command line, filtered to remove any sensitive
  * data
  */
 
 bool RPCConsole::RPCParseCommandLine(interfaces::Node *node,
                                      std::string &strResult,
                                      const std::string &strCommand,
                                      const bool fExecute,
                                      std::string *const pstrFilteredOut,
                                      const WalletModel *wallet_model) {
     std::vector<std::vector<std::string>> stack;
     stack.push_back(std::vector<std::string>());
 
     enum CmdParseState {
         STATE_EATING_SPACES,
         STATE_EATING_SPACES_IN_ARG,
         STATE_EATING_SPACES_IN_BRACKETS,
         STATE_ARGUMENT,
         STATE_SINGLEQUOTED,
         STATE_DOUBLEQUOTED,
         STATE_ESCAPE_OUTER,
         STATE_ESCAPE_DOUBLEQUOTED,
         STATE_COMMAND_EXECUTED,
         STATE_COMMAND_EXECUTED_INNER
     } state = STATE_EATING_SPACES;
     std::string curarg;
     UniValue lastResult;
     unsigned nDepthInsideSensitive = 0;
     size_t filter_begin_pos = 0, chpos;
     std::vector<std::pair<size_t, size_t>> filter_ranges;
 
     auto add_to_current_stack = [&](const std::string &strArg) {
         if (stack.back().empty() && (!nDepthInsideSensitive) &&
             historyFilter.contains(QString::fromStdString(strArg),
                                    Qt::CaseInsensitive)) {
             nDepthInsideSensitive = 1;
             filter_begin_pos = chpos;
         }
         // Make sure stack is not empty before adding something
         if (stack.empty()) {
             stack.push_back(std::vector<std::string>());
         }
         stack.back().push_back(strArg);
     };
 
     auto close_out_params = [&]() {
         if (nDepthInsideSensitive) {
             if (!--nDepthInsideSensitive) {
                 assert(filter_begin_pos);
                 filter_ranges.push_back(
                     std::make_pair(filter_begin_pos, chpos));
                 filter_begin_pos = 0;
             }
         }
         stack.pop_back();
     };
 
     std::string strCommandTerminated = strCommand;
     if (strCommandTerminated.back() != '\n') {
         strCommandTerminated += "\n";
     }
     for (chpos = 0; chpos < strCommandTerminated.size(); ++chpos) {
         char ch = strCommandTerminated[chpos];
         switch (state) {
             case STATE_COMMAND_EXECUTED_INNER:
             case STATE_COMMAND_EXECUTED: {
                 bool breakParsing = true;
                 switch (ch) {
                     case '[':
                         curarg.clear();
                         state = STATE_COMMAND_EXECUTED_INNER;
                         break;
                     default:
                         if (state == STATE_COMMAND_EXECUTED_INNER) {
                             if (ch != ']') {
                                 // append char to the current argument (which is
                                 // also used for the query command)
                                 curarg += ch;
                                 break;
                             }
                             if (curarg.size() && fExecute) {
                                 // if we have a value query, query arrays with
                                 // index and objects with a string key
                                 UniValue subelement;
                                 if (lastResult.isArray()) {
                                     for (char argch : curarg) {
                                         if (!std::isdigit(argch)) {
                                             throw std::runtime_error(
                                                 "Invalid result query");
                                         }
                                     }
                                     subelement =
                                         lastResult[atoi(curarg.c_str())];
                                 } else if (lastResult.isObject()) {
                                     subelement = find_value(lastResult, curarg);
                                 } else {
                                     // no array or object: abort
                                     throw std::runtime_error(
                                         "Invalid result query");
                                 }
                                 lastResult = subelement;
                             }
 
                             state = STATE_COMMAND_EXECUTED;
                             break;
                         }
                         // don't break parsing when the char is required for the
                         // next argument
                         breakParsing = false;
 
                         // pop the stack and return the result to the current
                         // command arguments
                         close_out_params();
 
                         // don't stringify the json in case of a string to avoid
                         // doublequotes
                         if (lastResult.isStr()) {
                             curarg = lastResult.get_str();
                         } else {
                             curarg = lastResult.write(2);
                         }
 
                         // if we have a non empty result, use it as stack
                         // argument otherwise as general result
                         if (curarg.size()) {
                             if (stack.size()) {
                                 add_to_current_stack(curarg);
                             } else {
                                 strResult = curarg;
                             }
                         }
                         curarg.clear();
                         // assume eating space state
                         state = STATE_EATING_SPACES;
                 }
 
                 if (breakParsing) {
                     break;
                 }
             }
             // FALLTHROUGH
             case STATE_ARGUMENT: // In or after argument
             case STATE_EATING_SPACES_IN_ARG:
             case STATE_EATING_SPACES_IN_BRACKETS:
             case STATE_EATING_SPACES: // Handle runs of whitespace
                 switch (ch) {
                     case '"':
                         state = STATE_DOUBLEQUOTED;
                         break;
                     case '\'':
                         state = STATE_SINGLEQUOTED;
                         break;
                     case '\\':
                         state = STATE_ESCAPE_OUTER;
                         break;
                     case '(':
                     case ')':
                     case '\n':
                         if (state == STATE_EATING_SPACES_IN_ARG) {
                             throw std::runtime_error("Invalid Syntax");
                         }
                         if (state == STATE_ARGUMENT) {
                             if (ch == '(' && stack.size() &&
                                 stack.back().size() > 0) {
                                 if (nDepthInsideSensitive) {
                                     ++nDepthInsideSensitive;
                                 }
                                 stack.push_back(std::vector<std::string>());
                             }
 
                             // don't allow commands after executed commands on
                             // baselevel
                             if (!stack.size()) {
                                 throw std::runtime_error("Invalid Syntax");
                             }
 
                             add_to_current_stack(curarg);
                             curarg.clear();
                             state = STATE_EATING_SPACES_IN_BRACKETS;
                         }
                         if ((ch == ')' || ch == '\n') && stack.size() > 0) {
                             if (fExecute) {
                                 // Convert argument list to JSON objects in
                                 // method-dependent way, and pass it along with
                                 // the method name to the dispatcher.
                                 UniValue params = RPCConvertValues(
                                     stack.back()[0],
                                     std::vector<std::string>(
                                         stack.back().begin() + 1,
                                         stack.back().end()));
                                 std::string method = stack.back()[0];
                                 std::string uri;
 
 #ifdef ENABLE_WALLET
                                 if (wallet_model) {
                                     QByteArray encodedName =
                                         QUrl::toPercentEncoding(
                                             wallet_model->getWalletName());
                                     uri = "/wallet/" +
                                           std::string(encodedName.constData(),
                                                       encodedName.length());
                                 }
 #endif
 
                                 GlobalConfig config;
                                 assert(node);
                                 lastResult = node->executeRpc(config, method,
                                                               params, uri);
                             }
 
                             state = STATE_COMMAND_EXECUTED;
                             curarg.clear();
                         }
                         break;
                     case ' ':
                     case ',':
                     case '\t':
                         if (state == STATE_EATING_SPACES_IN_ARG &&
                             curarg.empty() && ch == ',') {
                             throw std::runtime_error("Invalid Syntax");
                         } else if (state == STATE_ARGUMENT) {
                             // Space ends argument
                             add_to_current_stack(curarg);
                             curarg.clear();
                         }
                         if ((state == STATE_EATING_SPACES_IN_BRACKETS ||
                              state == STATE_ARGUMENT) &&
                             ch == ',') {
                             state = STATE_EATING_SPACES_IN_ARG;
                             break;
                         }
                         state = STATE_EATING_SPACES;
                         break;
                     default:
                         curarg += ch;
                         state = STATE_ARGUMENT;
                 }
                 break;
             case STATE_SINGLEQUOTED: // Single-quoted string
                 switch (ch) {
                     case '\'':
                         state = STATE_ARGUMENT;
                         break;
                     default:
                         curarg += ch;
                 }
                 break;
             case STATE_DOUBLEQUOTED: // Double-quoted string
                 switch (ch) {
                     case '"':
                         state = STATE_ARGUMENT;
                         break;
                     case '\\':
                         state = STATE_ESCAPE_DOUBLEQUOTED;
                         break;
                     default:
                         curarg += ch;
                 }
                 break;
             case STATE_ESCAPE_OUTER: // '\' outside quotes
                 curarg += ch;
                 state = STATE_ARGUMENT;
                 break;
             case STATE_ESCAPE_DOUBLEQUOTED: // '\' in double-quoted text
                 if (ch != '"' && ch != '\\') {
                     // keep '\' for everything but the quote and '\' itself
                     curarg += '\\';
                 }
                 curarg += ch;
                 state = STATE_DOUBLEQUOTED;
                 break;
         }
     }
     if (pstrFilteredOut) {
         if (STATE_COMMAND_EXECUTED == state) {
             assert(!stack.empty());
             close_out_params();
         }
         *pstrFilteredOut = strCommand;
         for (auto i = filter_ranges.rbegin(); i != filter_ranges.rend(); ++i) {
             pstrFilteredOut->replace(i->first, i->second - i->first, "(…)");
         }
     }
 
     // final state
     switch (state) {
         case STATE_COMMAND_EXECUTED:
             if (lastResult.isStr()) {
                 strResult = lastResult.get_str();
             } else {
                 strResult = lastResult.write(2);
             }
         // FALLTHROUGH
         case STATE_ARGUMENT:
         case STATE_EATING_SPACES:
             return true;
         default: // ERROR to end in one of the other states
             return false;
     }
 }
 
 void RPCExecutor::request(const QString &command,
                           const WalletModel *wallet_model) {
     try {
         std::string result;
         std::string executableCommand = command.toStdString() + "\n";
 
         // Catch the console-only-help command before RPC call is executed and
         // reply with help text as-if a RPC reply.
         if (executableCommand == "help-console\n") {
             Q_EMIT reply(
                 RPCConsole::CMD_REPLY,
                 QString(("\n"
                          "This console accepts RPC commands using the standard "
                          "syntax.\n"
                          "   example:    getblockhash 0\n\n"
 
                          "This console can also accept RPC commands using "
                          "parenthesized syntax.\n"
                          "   example:    getblockhash(0)\n\n"
 
                          "Commands may be nested when specified with the "
                          "parenthesized syntax.\n"
                          "   example:    getblock(getblockhash(0) 1)\n\n"
 
                          "A space or a comma can be used to delimit arguments "
                          "for either syntax.\n"
                          "   example:    getblockhash 0\n"
                          "               getblockhash,0\n\n"
 
                          "Named results can be queried with a non-quoted key "
                          "string in brackets.\n"
                          "   example:    getblock(getblockhash(0) true)[tx]\n\n"
 
                          "Results without keys can be queried using an integer "
                          "in brackets.\n"
                          "   example:    "
                          "getblock(getblockhash(0),true)[tx][0]\n\n")));
             return;
         }
         if (!RPCConsole::RPCExecuteCommandLine(
                 m_node, result, executableCommand, nullptr, wallet_model)) {
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString("Parse error: unbalanced ' or \""));
             return;
         }
 
         Q_EMIT reply(RPCConsole::CMD_REPLY, QString::fromStdString(result));
     } catch (UniValue &objError) {
         // Nice formatting for standard-format error
         try {
             int code = find_value(objError, "code").get_int();
             std::string message = find_value(objError, "message").get_str();
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString::fromStdString(message) + " (code " +
                              QString::number(code) + ")");
         } catch (const std::runtime_error &) {
             // raised when converting to invalid type, i.e. missing code or
             // message. Show raw JSON object.
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString::fromStdString(objError.write()));
         }
     } catch (const std::exception &e) {
         Q_EMIT reply(RPCConsole::CMD_ERROR,
                      QString("Error: ") + QString::fromStdString(e.what()));
     }
 }
 
 RPCConsole::RPCConsole(interfaces::Node &node,
                        const PlatformStyle *_platformStyle, QWidget *parent)
     : QWidget(parent), m_node(node), ui(new Ui::RPCConsole),
       platformStyle(_platformStyle) {
     ui->setupUi(this);
     QSettings settings;
     if (!restoreGeometry(
             settings.value("RPCConsoleWindowGeometry").toByteArray())) {
         // Restore failed (perhaps missing setting), center the window
         move(QGuiApplication::primaryScreen()->availableGeometry().center() -
              frameGeometry().center());
     }
 
     QChar nonbreaking_hyphen(8209);
     ui->dataDir->setToolTip(
         ui->dataDir->toolTip().arg(QString(nonbreaking_hyphen) + "datadir"));
     ui->blocksDir->setToolTip(ui->blocksDir->toolTip().arg(
         QString(nonbreaking_hyphen) + "blocksdir"));
     ui->openDebugLogfileButton->setToolTip(
         ui->openDebugLogfileButton->toolTip().arg(PACKAGE_NAME));
 
     if (platformStyle->getImagesOnButtons()) {
         ui->openDebugLogfileButton->setIcon(
             platformStyle->SingleColorIcon(":/icons/export"));
     }
     ui->clearButton->setIcon(platformStyle->SingleColorIcon(":/icons/remove"));
     ui->fontBiggerButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/fontbigger"));
     ui->fontSmallerButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/fontsmaller"));
 
     // Install event filter for up and down arrow
     ui->lineEdit->installEventFilter(this);
     ui->messagesWidget->installEventFilter(this);
 
     connect(ui->clearButton, &QPushButton::clicked, this, &RPCConsole::clear);
     connect(ui->fontBiggerButton, &QPushButton::clicked, this,
             &RPCConsole::fontBigger);
     connect(ui->fontSmallerButton, &QPushButton::clicked, this,
             &RPCConsole::fontSmaller);
     connect(ui->btnClearTrafficGraph, &QPushButton::clicked, ui->trafficGraph,
             &TrafficGraphWidget::clear);
 
     // disable the wallet selector by default
     ui->WalletSelector->setVisible(false);
     ui->WalletSelectorLabel->setVisible(false);
 
 // set library version labels
 #ifdef ENABLE_WALLET
     ui->berkeleyDBVersion->setText(DbEnv::version(nullptr, nullptr, nullptr));
 #else
     ui->label_berkeleyDBVersion->hide();
     ui->berkeleyDBVersion->hide();
 #endif
     // Register RPC timer interface
     rpcTimerInterface = new QtRPCTimerInterface();
     // avoid accidentally overwriting an existing, non QTThread
     // based timer interface
     m_node.rpcSetTimerInterfaceIfUnset(rpcTimerInterface);
 
     setTrafficGraphRange(INITIAL_TRAFFIC_GRAPH_MINS);
 
     ui->detailWidget->hide();
     ui->peerHeading->setText(tr("Select a peer to view detailed information."));
 
     consoleFontSize =
         settings.value(fontSizeSettingsKey, QFontInfo(QFont()).pointSize())
             .toInt();
     clear();
 }
 
 RPCConsole::~RPCConsole() {
     QSettings settings;
     settings.setValue("RPCConsoleWindowGeometry", saveGeometry());
     m_node.rpcUnsetTimerInterface(rpcTimerInterface);
     delete rpcTimerInterface;
     delete ui;
 }
 
 bool RPCConsole::eventFilter(QObject *obj, QEvent *event) {
     // Special key handling
     if (event->type() == QEvent::KeyPress) {
         QKeyEvent *keyevt = static_cast<QKeyEvent *>(event);
         int key = keyevt->key();
         Qt::KeyboardModifiers mod = keyevt->modifiers();
         switch (key) {
             case Qt::Key_Up:
                 if (obj == ui->lineEdit) {
                     browseHistory(-1);
                     return true;
                 }
                 break;
             case Qt::Key_Down:
                 if (obj == ui->lineEdit) {
                     browseHistory(1);
                     return true;
                 }
                 break;
             case Qt::Key_PageUp: /* pass paging keys to messages widget */
             case Qt::Key_PageDown:
                 if (obj == ui->lineEdit) {
                     QApplication::postEvent(ui->messagesWidget,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
                 break;
             case Qt::Key_Return:
             case Qt::Key_Enter:
                 // forward these events to lineEdit
                 if (obj == autoCompleter->popup()) {
                     QApplication::postEvent(ui->lineEdit,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
                 break;
             default:
                 // Typing in messages widget brings focus to line edit, and
                 // redirects key there. Exclude most combinations and keys that
                 // emit no text, except paste shortcuts.
                 if (obj == ui->messagesWidget &&
                     ((!mod && !keyevt->text().isEmpty() &&
                       key != Qt::Key_Tab) ||
                      ((mod & Qt::ControlModifier) && key == Qt::Key_V) ||
                      ((mod & Qt::ShiftModifier) && key == Qt::Key_Insert))) {
                     ui->lineEdit->setFocus();
                     QApplication::postEvent(ui->lineEdit,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
         }
     }
     return QWidget::eventFilter(obj, event);
 }
 
 void RPCConsole::setClientModel(ClientModel *model) {
     clientModel = model;
     ui->trafficGraph->setClientModel(model);
     if (model && clientModel->getPeerTableModel() &&
         clientModel->getBanTableModel()) {
         // Keep up to date with client
         setNumConnections(model->getNumConnections());
         connect(model, &ClientModel::numConnectionsChanged, this,
                 &RPCConsole::setNumConnections);
 
         interfaces::Node &node = clientModel->node();
         setNumBlocks(node.getNumBlocks(),
                      QDateTime::fromTime_t(node.getLastBlockTime()),
                      node.getVerificationProgress(), false);
         connect(model, &ClientModel::numBlocksChanged, this,
                 &RPCConsole::setNumBlocks);
 
         updateNetworkState();
         connect(model, &ClientModel::networkActiveChanged, this,
                 &RPCConsole::setNetworkActive);
 
         updateTrafficStats(node.getTotalBytesRecv(), node.getTotalBytesSent());
         connect(model, &ClientModel::bytesChanged, this,
                 &RPCConsole::updateTrafficStats);
 
         connect(model, &ClientModel::mempoolSizeChanged, this,
                 &RPCConsole::setMempoolSize);
 
         // set up peer table
         ui->peerWidget->setModel(model->getPeerTableModel());
         ui->peerWidget->verticalHeader()->hide();
         ui->peerWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
         ui->peerWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
         ui->peerWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
         ui->peerWidget->setContextMenuPolicy(Qt::CustomContextMenu);
         ui->peerWidget->setColumnWidth(PeerTableModel::Address,
                                        ADDRESS_COLUMN_WIDTH);
         ui->peerWidget->setColumnWidth(PeerTableModel::Subversion,
                                        SUBVERSION_COLUMN_WIDTH);
         ui->peerWidget->setColumnWidth(PeerTableModel::Ping, PING_COLUMN_WIDTH);
         ui->peerWidget->horizontalHeader()->setStretchLastSection(true);
 
         // create peer table context menu actions
         QAction *disconnectAction = new QAction(tr("&Disconnect"), this);
         QAction *banAction1h =
             new QAction(tr("Ban for") + " " + tr("1 &hour"), this);
         QAction *banAction24h =
             new QAction(tr("Ban for") + " " + tr("1 &day"), this);
         QAction *banAction7d =
             new QAction(tr("Ban for") + " " + tr("1 &week"), this);
         QAction *banAction365d =
             new QAction(tr("Ban for") + " " + tr("1 &year"), this);
 
         // create peer table context menu
         peersTableContextMenu = new QMenu(this);
         peersTableContextMenu->addAction(disconnectAction);
         peersTableContextMenu->addAction(banAction1h);
         peersTableContextMenu->addAction(banAction24h);
         peersTableContextMenu->addAction(banAction7d);
         peersTableContextMenu->addAction(banAction365d);
 
         // Add a signal mapping to allow dynamic context menu arguments. We need
         // to use int (instead of int64_t), because signal mapper only supports
         // int or objects, which is okay because max bantime (1 year) is <
         // int_max.
         QSignalMapper *signalMapper = new QSignalMapper(this);
         signalMapper->setMapping(banAction1h, 60 * 60);
         signalMapper->setMapping(banAction24h, 60 * 60 * 24);
         signalMapper->setMapping(banAction7d, 60 * 60 * 24 * 7);
         signalMapper->setMapping(banAction365d, 60 * 60 * 24 * 365);
         connect(banAction1h, &QAction::triggered, signalMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(banAction24h, &QAction::triggered, signalMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(banAction7d, &QAction::triggered, signalMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(banAction365d, &QAction::triggered, signalMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(
             signalMapper,
             static_cast<void (QSignalMapper::*)(int)>(&QSignalMapper::mapped),
             this, &RPCConsole::banSelectedNode);
 
         // peer table context menu signals
         connect(ui->peerWidget, &QTableView::customContextMenuRequested, this,
                 &RPCConsole::showPeersTableContextMenu);
         connect(disconnectAction, &QAction::triggered, this,
                 &RPCConsole::disconnectSelectedNode);
 
         // peer table signal handling - update peer details when selecting new
         // node
         connect(ui->peerWidget->selectionModel(),
                 &QItemSelectionModel::selectionChanged, this,
                 &RPCConsole::peerSelected);
         // peer table signal handling - update peer details when new nodes are
         // added to the model
         connect(model->getPeerTableModel(), &PeerTableModel::layoutChanged,
                 this, &RPCConsole::peerLayoutChanged);
         // peer table signal handling - cache selected node ids
         connect(model->getPeerTableModel(),
                 &PeerTableModel::layoutAboutToBeChanged, this,
                 &RPCConsole::peerLayoutAboutToChange);
 
         // set up ban table
         ui->banlistWidget->setModel(model->getBanTableModel());
         ui->banlistWidget->verticalHeader()->hide();
         ui->banlistWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
         ui->banlistWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
         ui->banlistWidget->setSelectionMode(QAbstractItemView::SingleSelection);
         ui->banlistWidget->setContextMenuPolicy(Qt::CustomContextMenu);
         ui->banlistWidget->setColumnWidth(BanTableModel::Address,
                                           BANSUBNET_COLUMN_WIDTH);
         ui->banlistWidget->setColumnWidth(BanTableModel::Bantime,
                                           BANTIME_COLUMN_WIDTH);
         ui->banlistWidget->horizontalHeader()->setStretchLastSection(true);
 
         // create ban table context menu action
         QAction *unbanAction = new QAction(tr("&Unban"), this);
 
         // create ban table context menu
         banTableContextMenu = new QMenu(this);
         banTableContextMenu->addAction(unbanAction);
 
         // ban table context menu signals
         connect(ui->banlistWidget, &QTableView::customContextMenuRequested,
                 this, &RPCConsole::showBanTableContextMenu);
         connect(unbanAction, &QAction::triggered, this,
                 &RPCConsole::unbanSelectedNode);
 
         // ban table signal handling - clear peer details when clicking a peer
         // in the ban table
         connect(ui->banlistWidget, &QTableView::clicked, this,
                 &RPCConsole::clearSelectedNode);
         // ban table signal handling - ensure ban table is shown or hidden (if
         // empty)
         connect(model->getBanTableModel(), &BanTableModel::layoutChanged, this,
                 &RPCConsole::showOrHideBanTableIfRequired);
         showOrHideBanTableIfRequired();
 
         // Provide initial values
         ui->clientVersion->setText(model->formatFullVersion());
         ui->clientUserAgent->setText(model->formatSubVersion());
         ui->dataDir->setText(model->dataDir());
         ui->blocksDir->setText(model->blocksDir());
         ui->startupTime->setText(model->formatClientStartupTime());
         ui->networkName->setText(
             QString::fromStdString(Params().NetworkIDString()));
 
         // Setup autocomplete and attach it
         QStringList wordList;
         std::vector<std::string> commandList = m_node.listRpcCommands();
         for (size_t i = 0; i < commandList.size(); ++i) {
             wordList << commandList[i].c_str();
             wordList << ("help " + commandList[i]).c_str();
         }
 
         wordList << "help-console";
         wordList.sort();
         autoCompleter = new QCompleter(wordList, this);
         autoCompleter->setModelSorting(QCompleter::CaseSensitivelySortedModel);
         ui->lineEdit->setCompleter(autoCompleter);
         autoCompleter->popup()->installEventFilter(this);
         // Start thread to execute RPC commands.
         startExecutor();
     }
     if (!model) {
         // Client model is being set to 0, this means shutdown() is about to be
         // called. Make sure we clean up the executor thread
         Q_EMIT stopExecutor();
         thread.wait();
     }
 }
 
 #ifdef ENABLE_WALLET
 void RPCConsole::addWallet(WalletModel *const walletModel) {
     // use name for text and wallet model for internal data object (to allow to
     // move to a wallet id later)
     ui->WalletSelector->addItem(walletModel->getDisplayName(),
                                 QVariant::fromValue(walletModel));
     if (ui->WalletSelector->count() == 2 && !isVisible()) {
         // First wallet added, set to default so long as the window isn't
         // presently visible (and potentially in use)
         ui->WalletSelector->setCurrentIndex(1);
     }
     if (ui->WalletSelector->count() > 2) {
         ui->WalletSelector->setVisible(true);
         ui->WalletSelectorLabel->setVisible(true);
     }
 }
 
 void RPCConsole::removeWallet(WalletModel *const walletModel) {
     ui->WalletSelector->removeItem(
         ui->WalletSelector->findData(QVariant::fromValue(walletModel)));
     if (ui->WalletSelector->count() == 2) {
         ui->WalletSelector->setVisible(false);
         ui->WalletSelectorLabel->setVisible(false);
     }
 }
 #endif
 
 static QString categoryClass(int category) {
     switch (category) {
         case RPCConsole::CMD_REQUEST:
             return "cmd-request";
             break;
         case RPCConsole::CMD_REPLY:
             return "cmd-reply";
             break;
         case RPCConsole::CMD_ERROR:
             return "cmd-error";
             break;
         default:
             return "misc";
     }
 }
 
 void RPCConsole::fontBigger() {
     setFontSize(consoleFontSize + 1);
 }
 
 void RPCConsole::fontSmaller() {
     setFontSize(consoleFontSize - 1);
 }
 
 void RPCConsole::setFontSize(int newSize) {
     QSettings settings;
 
     // don't allow an insane font size
     if (newSize < FONT_RANGE.width() || newSize > FONT_RANGE.height()) {
         return;
     }
 
     // temp. store the console content
     QString str = ui->messagesWidget->toHtml();
 
     // replace font tags size in current content
     str.replace(QString("font-size:%1pt").arg(consoleFontSize),
                 QString("font-size:%1pt").arg(newSize));
 
     // store the new font size
     consoleFontSize = newSize;
     settings.setValue(fontSizeSettingsKey, consoleFontSize);
 
     // clear console (reset icon sizes, default stylesheet) and re-add the
     // content
     float oldPosFactor = 1.0 /
                          ui->messagesWidget->verticalScrollBar()->maximum() *
                          ui->messagesWidget->verticalScrollBar()->value();
     clear(false);
     ui->messagesWidget->setHtml(str);
     ui->messagesWidget->verticalScrollBar()->setValue(
         oldPosFactor * ui->messagesWidget->verticalScrollBar()->maximum());
 }
 
 void RPCConsole::clear(bool clearHistory) {
     ui->messagesWidget->clear();
     if (clearHistory) {
         history.clear();
         historyPtr = 0;
     }
     ui->lineEdit->clear();
     ui->lineEdit->setFocus();
 
     // Add smoothly scaled icon images.
     // (when using width/height on an img, Qt uses nearest instead of linear
     // interpolation)
     for (int i = 0; ICON_MAPPING[i].url; ++i) {
         ui->messagesWidget->document()->addResource(
             QTextDocument::ImageResource, QUrl(ICON_MAPPING[i].url),
             platformStyle->SingleColorImage(ICON_MAPPING[i].source)
                 .scaled(QSize(consoleFontSize * 2, consoleFontSize * 2),
                         Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
     }
 
     // Set default style sheet
     QFontInfo fixedFontInfo(GUIUtil::fixedPitchFont());
     ui->messagesWidget->document()->setDefaultStyleSheet(
         QString("table { }"
                 "td.time { color: #808080; font-size: %2; padding-top: 3px; } "
                 "td.message { font-family: %1; font-size: %2; "
                 "white-space:pre-wrap; } "
                 "td.cmd-request { color: #006060; } "
                 "td.cmd-error { color: red; } "
                 ".secwarning { color: red; }"
                 "b { color: #006060; } ")
             .arg(fixedFontInfo.family(), QString("%1pt").arg(consoleFontSize)));
 
 #ifdef Q_OS_MAC
     QString clsKey = "(⌘)-L";
 #else
     QString clsKey = "Ctrl-L";
 #endif
 
     message(CMD_REPLY,
             (tr("Welcome to the %1 RPC console.").arg(PACKAGE_NAME) + "<br>" +
              tr("Use up and down arrows to navigate history, and "
                 "%1 to clear screen.")
                  .arg("<b>" + clsKey + "</b>") +
              "<br>" +
              tr("Type %1 for an overview of available commands.")
                  .arg("<b>help</b>") +
              "<br>" +
              tr("For more information on using this console type %1.")
                  .arg("<b>help-console</b>") +
              "<br><span class=\"secwarning\"><br>" +
              tr("WARNING: Scammers have been active, telling users to type "
                 "commands here, stealing their wallet contents. Do not use "
                 "this console without fully understanding the ramifications "
                 "of a command.") +
              "</span>"),
             true);
 }
 
 void RPCConsole::keyPressEvent(QKeyEvent *event) {
     if (windowType() != Qt::Widget && event->key() == Qt::Key_Escape) {
         close();
     }
 }
 
 void RPCConsole::message(int category, const QString &message, bool html) {
     QTime time = QTime::currentTime();
     QString timeString = time.toString();
     QString out;
     out += "<table><tr><td class=\"time\" width=\"65\">" + timeString + "</td>";
     out += "<td class=\"icon\" width=\"32\"><img src=\"" +
            categoryClass(category) + "\"></td>";
     out += "<td class=\"message " + categoryClass(category) +
            "\" valign=\"middle\">";
     if (html) {
         out += message;
     } else {
         out += GUIUtil::HtmlEscape(message, false);
     }
     out += "</td></tr></table>";
     ui->messagesWidget->append(out);
 }
 
 void RPCConsole::updateNetworkState() {
     QString connections =
         QString::number(clientModel->getNumConnections()) + " (";
     connections += tr("In:") + " " +
                    QString::number(clientModel->getNumConnections(
                        ClientModel::CONNECTIONS_IN)) +
                    " / ";
     connections += tr("Out:") + " " +
                    QString::number(clientModel->getNumConnections(
                        ClientModel::CONNECTIONS_OUT)) +
                    ")";
 
     if (!clientModel->node().getNetworkActive()) {
         connections += " (" + tr("Network activity disabled") + ")";
     }
 
     ui->numberOfConnections->setText(connections);
 }
 
 void RPCConsole::setNumConnections(int count) {
     if (!clientModel) {
         return;
     }
 
     updateNetworkState();
 }
 
 void RPCConsole::setNetworkActive(bool networkActive) {
     updateNetworkState();
 }
 
 void RPCConsole::setNumBlocks(int count, const QDateTime &blockDate,
                               double nVerificationProgress, bool headers) {
     if (!headers) {
         ui->numberOfBlocks->setText(QString::number(count));
         ui->lastBlockTime->setText(blockDate.toString());
     }
 }
 
 void RPCConsole::setMempoolSize(long numberOfTxs, size_t dynUsage) {
     ui->mempoolNumberTxs->setText(QString::number(numberOfTxs));
 
     if (dynUsage < 1000000) {
         ui->mempoolSize->setText(QString::number(dynUsage / 1000.0, 'f', 2) +
                                  " KB");
     } else {
         ui->mempoolSize->setText(QString::number(dynUsage / 1000000.0, 'f', 2) +
                                  " MB");
     }
 }
 
 void RPCConsole::on_lineEdit_returnPressed() {
     QString cmd = ui->lineEdit->text();
 
     if (!cmd.isEmpty()) {
         std::string strFilteredCmd;
         try {
             std::string dummy;
             if (!RPCParseCommandLine(nullptr, dummy, cmd.toStdString(), false,
                                      &strFilteredCmd)) {
                 // Failed to parse command, so we cannot even filter it for the
                 // history
                 throw std::runtime_error("Invalid command line");
             }
         } catch (const std::exception &e) {
             QMessageBox::critical(this, "Error",
                                   QString("Error: ") +
                                       QString::fromStdString(e.what()));
             return;
         }
 
         ui->lineEdit->clear();
 
         cmdBeforeBrowsing = QString();
 
 #ifdef ENABLE_WALLET
         WalletModel *wallet_model{nullptr};
         const int wallet_index = ui->WalletSelector->currentIndex();
         if (wallet_index > 0) {
             wallet_model = ui->WalletSelector->itemData(wallet_index)
                                .value<WalletModel *>();
         }
 
         if (m_last_wallet_model != wallet_model) {
             if (wallet_model) {
                 message(CMD_REQUEST, tr("Executing command using \"%1\" wallet")
                                          .arg(wallet_model->getWalletName()));
             } else {
                 message(CMD_REQUEST,
                         tr("Executing command without any wallet"));
             }
             m_last_wallet_model = wallet_model;
         }
 #endif
 
         message(CMD_REQUEST, QString::fromStdString(strFilteredCmd));
         Q_EMIT cmdRequest(cmd, m_last_wallet_model);
 
         cmd = QString::fromStdString(strFilteredCmd);
 
         // Remove command, if already in history
         history.removeOne(cmd);
         // Append command to history
         history.append(cmd);
         // Enforce maximum history size
         while (history.size() > CONSOLE_HISTORY) {
             history.removeFirst();
         }
         // Set pointer to end of history
         historyPtr = history.size();
 
         // Scroll console view to end
         scrollToEnd();
     }
 }
 
 void RPCConsole::browseHistory(int offset) {
     // store current text when start browsing through the history
     if (historyPtr == history.size()) {
         cmdBeforeBrowsing = ui->lineEdit->text();
     }
 
     historyPtr += offset;
     if (historyPtr < 0) {
         historyPtr = 0;
     }
     if (historyPtr > history.size()) {
         historyPtr = history.size();
     }
     QString cmd;
     if (historyPtr < history.size()) {
         cmd = history.at(historyPtr);
     } else if (!cmdBeforeBrowsing.isNull()) {
         cmd = cmdBeforeBrowsing;
     }
     ui->lineEdit->setText(cmd);
 }
 
 void RPCConsole::startExecutor() {
     RPCExecutor *executor = new RPCExecutor(m_node);
     executor->moveToThread(&thread);
 
     // Replies from executor object must go to this object
     connect(executor, &RPCExecutor::reply, this,
             static_cast<void (RPCConsole::*)(int, const QString &)>(
                 &RPCConsole::message));
 
     // Requests from this object must go to executor
     connect(this, &RPCConsole::cmdRequest, executor, &RPCExecutor::request);
 
     // On stopExecutor signal
     // - quit the Qt event loop in the execution thread
     connect(this, &RPCConsole::stopExecutor, &thread, &QThread::quit);
     // - queue executor for deletion (in execution thread)
     connect(&thread, &QThread::finished, executor, &RPCExecutor::deleteLater,
             Qt::DirectConnection);
 
     // Default implementation of QThread::run() simply spins up an event loop in
     // the thread, which is what we want.
     thread.start();
 }
 
 void RPCConsole::on_tabWidget_currentChanged(int index) {
     if (ui->tabWidget->widget(index) == ui->tab_console) {
         ui->lineEdit->setFocus();
     } else if (ui->tabWidget->widget(index) != ui->tab_peers) {
         clearSelectedNode();
     }
 }
 
 void RPCConsole::on_openDebugLogfileButton_clicked() {
     GUIUtil::openDebugLogfile();
 }
 
 void RPCConsole::scrollToEnd() {
     QScrollBar *scrollbar = ui->messagesWidget->verticalScrollBar();
     scrollbar->setValue(scrollbar->maximum());
 }
 
 void RPCConsole::on_sldGraphRange_valueChanged(int value) {
     const int multiplier = 5; // each position on the slider represents 5 min
     int mins = value * multiplier;
     setTrafficGraphRange(mins);
 }
 
 void RPCConsole::setTrafficGraphRange(int mins) {
     ui->trafficGraph->setGraphRangeMins(mins);
     ui->lblGraphRange->setText(GUIUtil::formatDurationStr(mins * 60));
 }
 
 void RPCConsole::updateTrafficStats(quint64 totalBytesIn,
                                     quint64 totalBytesOut) {
     ui->lblBytesIn->setText(GUIUtil::formatBytes(totalBytesIn));
     ui->lblBytesOut->setText(GUIUtil::formatBytes(totalBytesOut));
 }
 
 void RPCConsole::peerSelected(const QItemSelection &selected,
                               const QItemSelection &deselected) {
     Q_UNUSED(deselected);
 
     if (!clientModel || !clientModel->getPeerTableModel() ||
         selected.indexes().isEmpty()) {
         return;
     }
 
     const CNodeCombinedStats *stats =
         clientModel->getPeerTableModel()->getNodeStats(
             selected.indexes().first().row());
     if (stats) {
         updateNodeDetail(stats);
     }
 }
 
 void RPCConsole::peerLayoutAboutToChange() {
     QModelIndexList selected =
         ui->peerWidget->selectionModel()->selectedIndexes();
     cachedNodeids.clear();
     for (int i = 0; i < selected.size(); i++) {
         const CNodeCombinedStats *stats =
             clientModel->getPeerTableModel()->getNodeStats(
                 selected.at(i).row());
         cachedNodeids.append(stats->nodeStats.nodeid);
     }
 }
 
 void RPCConsole::peerLayoutChanged() {
     if (!clientModel || !clientModel->getPeerTableModel()) {
         return;
     }
 
     const CNodeCombinedStats *stats = nullptr;
     bool fUnselect = false;
     bool fReselect = false;
 
     // no node selected yet
     if (cachedNodeids.empty()) {
         return;
     }
 
     // find the currently selected row
     int selectedRow = -1;
     QModelIndexList selectedModelIndex =
         ui->peerWidget->selectionModel()->selectedIndexes();
     if (!selectedModelIndex.isEmpty()) {
         selectedRow = selectedModelIndex.first().row();
     }
 
     // check if our detail node has a row in the table (it may not necessarily
     // be at selectedRow since its position can change after a layout change)
     int detailNodeRow =
         clientModel->getPeerTableModel()->getRowByNodeId(cachedNodeids.first());
 
     if (detailNodeRow < 0) {
         // detail node disappeared from table (node disconnected)
         fUnselect = true;
     } else {
         if (detailNodeRow != selectedRow) {
             // detail node moved position
             fUnselect = true;
             fReselect = true;
         }
 
         // get fresh stats on the detail node.
         stats = clientModel->getPeerTableModel()->getNodeStats(detailNodeRow);
     }
 
     if (fUnselect && selectedRow >= 0) {
         clearSelectedNode();
     }
 
     if (fReselect) {
         for (int i = 0; i < cachedNodeids.size(); i++) {
             ui->peerWidget->selectRow(
                 clientModel->getPeerTableModel()->getRowByNodeId(
                     cachedNodeids.at(i)));
         }
     }
 
     if (stats) {
         updateNodeDetail(stats);
     }
 }
 
 void RPCConsole::updateNodeDetail(const CNodeCombinedStats *stats) {
     // update the detail ui with latest node information
     QString peerAddrDetails(QString::fromStdString(stats->nodeStats.addrName) +
                             " ");
     peerAddrDetails +=
         tr("(node id: %1)").arg(QString::number(stats->nodeStats.nodeid));
     if (!stats->nodeStats.addrLocal.empty()) {
         peerAddrDetails += "<br />" + tr("via %1").arg(QString::fromStdString(
                                           stats->nodeStats.addrLocal));
     }
     ui->peerHeading->setText(peerAddrDetails);
     ui->peerServices->setText(
         GUIUtil::formatServicesStr(stats->nodeStats.nServices));
     ui->peerLastSend->setText(
         stats->nodeStats.nLastSend
             ? GUIUtil::formatDurationStr(GetSystemTimeInSeconds() -
                                          stats->nodeStats.nLastSend)
             : tr("never"));
     ui->peerLastRecv->setText(
         stats->nodeStats.nLastRecv
             ? GUIUtil::formatDurationStr(GetSystemTimeInSeconds() -
                                          stats->nodeStats.nLastRecv)
             : tr("never"));
     ui->peerBytesSent->setText(
         GUIUtil::formatBytes(stats->nodeStats.nSendBytes));
     ui->peerBytesRecv->setText(
         GUIUtil::formatBytes(stats->nodeStats.nRecvBytes));
     ui->peerConnTime->setText(GUIUtil::formatDurationStr(
         GetSystemTimeInSeconds() - stats->nodeStats.nTimeConnected));
     ui->peerPingTime->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dPingTime));
     ui->peerPingWait->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dPingWait));
     ui->peerMinPing->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dMinPing));
     ui->timeoffset->setText(
         GUIUtil::formatTimeOffset(stats->nodeStats.nTimeOffset));
     ui->peerVersion->setText(
         QString("%1").arg(QString::number(stats->nodeStats.nVersion)));
     ui->peerSubversion->setText(
         QString::fromStdString(stats->nodeStats.cleanSubVer));
     ui->peerDirection->setText(stats->nodeStats.fInbound ? tr("Inbound")
                                                          : tr("Outbound"));
     ui->peerHeight->setText(
         QString("%1").arg(QString::number(stats->nodeStats.nStartingHeight)));
     ui->peerWhitelisted->setText(
         stats->nodeStats.m_legacyWhitelisted ? tr("Yes") : tr("No"));
 
     // This check fails for example if the lock was busy and
     // nodeStateStats couldn't be fetched.
     if (stats->fNodeStateStatsAvailable) {
         // Ban score is init to 0
         ui->peerBanScore->setText(
             QString("%1").arg(stats->nodeStateStats.nMisbehavior));
 
         // Sync height is init to -1
         if (stats->nodeStateStats.nSyncHeight > -1) {
             ui->peerSyncHeight->setText(
                 QString("%1").arg(stats->nodeStateStats.nSyncHeight));
         } else {
             ui->peerSyncHeight->setText(tr("Unknown"));
         }
 
         // Common height is init to -1
         if (stats->nodeStateStats.nCommonHeight > -1) {
             ui->peerCommonHeight->setText(
                 QString("%1").arg(stats->nodeStateStats.nCommonHeight));
         } else {
             ui->peerCommonHeight->setText(tr("Unknown"));
         }
     }
 
     ui->detailWidget->show();
 }
 
 void RPCConsole::resizeEvent(QResizeEvent *event) {
     QWidget::resizeEvent(event);
 }
 
 void RPCConsole::showEvent(QShowEvent *event) {
     QWidget::showEvent(event);
 
     if (!clientModel || !clientModel->getPeerTableModel()) {
         return;
     }
 
     // start PeerTableModel auto refresh
     clientModel->getPeerTableModel()->startAutoRefresh();
 }
 
 void RPCConsole::hideEvent(QHideEvent *event) {
     QWidget::hideEvent(event);
 
     if (!clientModel || !clientModel->getPeerTableModel()) {
         return;
     }
 
     // stop PeerTableModel auto refresh
     clientModel->getPeerTableModel()->stopAutoRefresh();
 }
 
 void RPCConsole::showPeersTableContextMenu(const QPoint &point) {
     QModelIndex index = ui->peerWidget->indexAt(point);
     if (index.isValid()) {
         peersTableContextMenu->exec(QCursor::pos());
     }
 }
 
 void RPCConsole::showBanTableContextMenu(const QPoint &point) {
     QModelIndex index = ui->banlistWidget->indexAt(point);
     if (index.isValid()) {
         banTableContextMenu->exec(QCursor::pos());
     }
 }
 
 void RPCConsole::disconnectSelectedNode() {
     // Get selected peer addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected peer address
         NodeId id = nodes.at(i).data().toLongLong();
         // Find the node, disconnect it and clear the selected node
         if (m_node.disconnect(id)) {
             clearSelectedNode();
         }
     }
 }
 
 void RPCConsole::banSelectedNode(int bantime) {
     if (!clientModel) {
         return;
     }
 
     // Get selected peer addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected peer address
         NodeId id = nodes.at(i).data().toLongLong();
 
         // Get currently selected peer address
         int detailNodeRow =
             clientModel->getPeerTableModel()->getRowByNodeId(id);
         if (detailNodeRow < 0) {
             return;
         }
 
         // Find possible nodes, ban it and clear the selected node
         const CNodeCombinedStats *stats =
             clientModel->getPeerTableModel()->getNodeStats(detailNodeRow);
         if (stats) {
             m_node.ban(stats->nodeStats.addr, BanReasonManuallyAdded, bantime);
             m_node.disconnect(stats->nodeStats.addr);
         }
     }
     clearSelectedNode();
     clientModel->getBanTableModel()->refresh();
 }
 
 void RPCConsole::unbanSelectedNode() {
     if (!clientModel) {
         return;
     }
 
     // Get selected ban addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->banlistWidget, BanTableModel::Address);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected ban address
         QString strNode = nodes.at(i).data().toString();
         CSubNet possibleSubnet;
 
         LookupSubNet(strNode.toStdString().c_str(), possibleSubnet);
         if (possibleSubnet.IsValid() && m_node.unban(possibleSubnet)) {
             clientModel->getBanTableModel()->refresh();
         }
     }
 }
 
 void RPCConsole::clearSelectedNode() {
     ui->peerWidget->selectionModel()->clearSelection();
     cachedNodeids.clear();
     ui->detailWidget->hide();
     ui->peerHeading->setText(tr("Select a peer to view detailed information."));
 }
 
 void RPCConsole::showOrHideBanTableIfRequired() {
     if (!clientModel) {
         return;
     }
 
     bool visible = clientModel->getBanTableModel()->shouldShow();
     ui->banlistWidget->setVisible(visible);
     ui->banHeading->setVisible(visible);
 }
 
 void RPCConsole::setTabFocus(enum TabTypes tabType) {
     ui->tabWidget->setCurrentIndex(tabType);
 }
diff --git a/src/qt/transactiontablemodel.cpp b/src/qt/transactiontablemodel.cpp
index 3db825753..b7d6c2150 100644
--- a/src/qt/transactiontablemodel.cpp
+++ b/src/qt/transactiontablemodel.cpp
@@ -1,775 +1,776 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/transactiontablemodel.h>
 
 #include <core_io.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <qt/addresstablemodel.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/transactiondesc.h>
 #include <qt/transactionrecord.h>
 #include <qt/walletmodel.h>
 #include <sync.h>
 #include <uint256.h>
 #include <util/system.h>
 #include <validation.h>
 
 #include <algorithm>
 
 #include <QColor>
 #include <QDateTime>
 #include <QDebug>
 #include <QIcon>
 #include <QList>
 
 // Amount column is right-aligned it contains numbers
 static int column_alignments[] = {
     Qt::AlignLeft | Qt::AlignVCenter, /* status */
     Qt::AlignLeft | Qt::AlignVCenter, /* watchonly */
     Qt::AlignLeft | Qt::AlignVCenter, /* date */
     Qt::AlignLeft | Qt::AlignVCenter, /* type */
     Qt::AlignLeft | Qt::AlignVCenter, /* address */
     Qt::AlignRight | Qt::AlignVCenter /* amount */
 };
 
 // Comparison operator for sort/binary search of model tx list
 struct TxLessThan {
     bool operator()(const TransactionRecord &a,
                     const TransactionRecord &b) const {
         return a.txid < b.txid;
     }
     bool operator()(const TransactionRecord &a, const TxId &b) const {
         return a.txid < b;
     }
     bool operator()(const TxId &a, const TransactionRecord &b) const {
         return a < b.txid;
     }
 };
 
 // Private implementation
 class TransactionTablePriv {
 public:
-    TransactionTablePriv(TransactionTableModel *_parent) : parent(_parent) {}
+    explicit TransactionTablePriv(TransactionTableModel *_parent)
+        : parent(_parent) {}
 
     TransactionTableModel *parent;
 
     /* Local cache of wallet.
      * As it is in the same order as the CWallet, by definition this is sorted
      * by sha256.
      */
     QList<TransactionRecord> cachedWallet;
 
     /**
      * Query entire wallet anew from core.
      */
     void refreshWallet(interfaces::Wallet &wallet) {
         qDebug() << "TransactionTablePriv::refreshWallet";
         cachedWallet.clear();
         for (const auto &wtx : wallet.getWalletTxs()) {
             if (TransactionRecord::showTransaction()) {
                 cachedWallet.append(
                     TransactionRecord::decomposeTransaction(wtx));
             }
         }
     }
 
     /**
      * Update our model of the wallet incrementally, to synchronize our model of
      * the wallet with that of the core.
      * Call with transaction that was added, removed or changed.
      */
     void updateWallet(interfaces::Wallet &wallet, const TxId &txid, int status,
                       bool showTransaction) {
         qDebug() << "TransactionTablePriv::updateWallet: " +
                         QString::fromStdString(txid.ToString()) + " " +
                         QString::number(status);
 
         // Find bounds of this transaction in model
         QList<TransactionRecord>::iterator lower = std::lower_bound(
             cachedWallet.begin(), cachedWallet.end(), txid, TxLessThan());
         QList<TransactionRecord>::iterator upper = std::upper_bound(
             cachedWallet.begin(), cachedWallet.end(), txid, TxLessThan());
         int lowerIndex = (lower - cachedWallet.begin());
         int upperIndex = (upper - cachedWallet.begin());
         bool inModel = (lower != upper);
 
         if (status == CT_UPDATED) {
             // Not in model, but want to show, treat as new.
             if (showTransaction && !inModel) {
                 status = CT_NEW;
             }
             // In model, but want to hide, treat as deleted.
             if (!showTransaction && inModel) {
                 status = CT_DELETED;
             }
         }
 
         qDebug() << "    inModel=" + QString::number(inModel) +
                         " Index=" + QString::number(lowerIndex) + "-" +
                         QString::number(upperIndex) +
                         " showTransaction=" + QString::number(showTransaction) +
                         " derivedStatus=" + QString::number(status);
 
         switch (status) {
             case CT_NEW:
                 if (inModel) {
                     qWarning() << "TransactionTablePriv::updateWallet: "
                                   "Warning: Got CT_NEW, but transaction is "
                                   "already in model";
                     break;
                 }
                 if (showTransaction) {
                     // Find transaction in wallet
                     interfaces::WalletTx wtx = wallet.getWalletTx(txid);
                     if (!wtx.tx) {
                         qWarning() << "TransactionTablePriv::updateWallet: "
                                       "Warning: Got CT_NEW, but transaction is "
                                       "not in wallet";
                         break;
                     }
                     // Added -- insert at the right position
                     QList<TransactionRecord> toInsert =
                         TransactionRecord::decomposeTransaction(wtx);
                     /* only if something to insert */
                     if (!toInsert.isEmpty()) {
                         parent->beginInsertRows(QModelIndex(), lowerIndex,
                                                 lowerIndex + toInsert.size() -
                                                     1);
                         int insert_idx = lowerIndex;
                         for (const TransactionRecord &rec : toInsert) {
                             cachedWallet.insert(insert_idx, rec);
                             insert_idx += 1;
                         }
                         parent->endInsertRows();
                     }
                 }
                 break;
             case CT_DELETED:
                 if (!inModel) {
                     qWarning() << "TransactionTablePriv::updateWallet: "
                                   "Warning: Got CT_DELETED, but transaction is "
                                   "not in model";
                     break;
                 }
                 // Removed -- remove entire transaction from table
                 parent->beginRemoveRows(QModelIndex(), lowerIndex,
                                         upperIndex - 1);
                 cachedWallet.erase(lower, upper);
                 parent->endRemoveRows();
                 break;
             case CT_UPDATED:
                 // Miscellaneous updates -- nothing to do, status update will
                 // take care of this, and is only computed for visible
                 // transactions.
                 break;
         }
     }
 
     int size() { return cachedWallet.size(); }
 
     TransactionRecord *index(interfaces::Wallet &wallet, int idx) {
         if (idx >= 0 && idx < cachedWallet.size()) {
             TransactionRecord *rec = &cachedWallet[idx];
 
             // Get required locks upfront. This avoids the GUI from getting
             // stuck if the core is holding the locks for a longer time - for
             // example, during a wallet rescan.
             //
             // If a status update is needed (blocks came in since last check),
             // update the status of this transaction from the wallet. Otherwise,
             // simply re-use the cached status.
             interfaces::WalletTxStatus wtx;
             int numBlocks;
             int64_t block_time;
             if (wallet.tryGetTxStatus(rec->txid, wtx, numBlocks, block_time) &&
                 rec->statusUpdateNeeded(numBlocks)) {
                 rec->updateStatus(wtx, numBlocks, block_time);
             }
             return rec;
         }
         return nullptr;
     }
 
     QString describe(interfaces::Node &node, interfaces::Wallet &wallet,
                      TransactionRecord *rec, int unit) {
         return TransactionDesc::toHTML(node, wallet, rec, unit);
     }
 
     QString getTxHex(interfaces::Wallet &wallet, TransactionRecord *rec) {
         auto tx = wallet.getTx(rec->txid);
         if (tx) {
             std::string strHex = EncodeHexTx(*tx);
             return QString::fromStdString(strHex);
         }
         return QString();
     }
 };
 
 TransactionTableModel::TransactionTableModel(
     const PlatformStyle *_platformStyle, WalletModel *parent)
     : QAbstractTableModel(parent), walletModel(parent),
       priv(new TransactionTablePriv(this)),
       fProcessingQueuedTransactions(false), platformStyle(_platformStyle) {
     columns << QString() << QString() << tr("Date") << tr("Type") << tr("Label")
             << BitcoinUnits::getAmountColumnTitle(
                    walletModel->getOptionsModel()->getDisplayUnit());
     priv->refreshWallet(walletModel->wallet());
 
     connect(walletModel->getOptionsModel(), &OptionsModel::displayUnitChanged,
             this, &TransactionTableModel::updateDisplayUnit);
 
     subscribeToCoreSignals();
 }
 
 TransactionTableModel::~TransactionTableModel() {
     unsubscribeFromCoreSignals();
     delete priv;
 }
 
 /** Updates the column title to "Amount (DisplayUnit)" and emits
  * headerDataChanged() signal for table headers to react. */
 void TransactionTableModel::updateAmountColumnTitle() {
     columns[Amount] = BitcoinUnits::getAmountColumnTitle(
         walletModel->getOptionsModel()->getDisplayUnit());
     Q_EMIT headerDataChanged(Qt::Horizontal, Amount, Amount);
 }
 
 void TransactionTableModel::updateTransaction(const QString &hash, int status,
                                               bool showTransaction) {
     TxId updated;
     updated.SetHex(hash.toStdString());
 
     priv->updateWallet(walletModel->wallet(), updated, status, showTransaction);
 }
 
 void TransactionTableModel::updateConfirmations() {
     // Blocks came in since last poll.
     // Invalidate status (number of confirmations) and (possibly) description
     // for all rows. Qt is smart enough to only actually request the data for
     // the visible rows.
     Q_EMIT dataChanged(index(0, Status), index(priv->size() - 1, Status));
     Q_EMIT dataChanged(index(0, ToAddress), index(priv->size() - 1, ToAddress));
 }
 
 int TransactionTableModel::rowCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return priv->size();
 }
 
 int TransactionTableModel::columnCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return columns.length();
 }
 
 QString
 TransactionTableModel::formatTxStatus(const TransactionRecord *wtx) const {
     QString status;
 
     switch (wtx->status.status) {
         case TransactionStatus::OpenUntilBlock:
             status = tr("Open for %n more block(s)", "", wtx->status.open_for);
             break;
         case TransactionStatus::OpenUntilDate:
             status = tr("Open until %1")
                          .arg(GUIUtil::dateTimeStr(wtx->status.open_for));
             break;
         case TransactionStatus::Unconfirmed:
             status = tr("Unconfirmed");
             break;
         case TransactionStatus::Abandoned:
             status = tr("Abandoned");
             break;
         case TransactionStatus::Confirming:
             status = tr("Confirming (%1 of %2 recommended confirmations)")
                          .arg(wtx->status.depth)
                          .arg(TransactionRecord::RecommendedNumConfirmations);
             break;
         case TransactionStatus::Confirmed:
             status = tr("Confirmed (%1 confirmations)").arg(wtx->status.depth);
             break;
         case TransactionStatus::Conflicted:
             status = tr("Conflicted");
             break;
         case TransactionStatus::Immature:
             status =
                 tr("Immature (%1 confirmations, will be available after %2)")
                     .arg(wtx->status.depth)
                     .arg(wtx->status.depth + wtx->status.matures_in);
             break;
         case TransactionStatus::NotAccepted:
             status = tr("Generated but not accepted");
             break;
     }
 
     return status;
 }
 
 QString
 TransactionTableModel::formatTxDate(const TransactionRecord *wtx) const {
     if (wtx->time) {
         return GUIUtil::dateTimeStr(wtx->time);
     }
     return QString();
 }
 
 /**
  * Look up address in address book, if found return label (address)  otherwise
  * just return (address)
  */
 QString TransactionTableModel::lookupAddress(const std::string &address,
                                              bool tooltip) const {
     QString label = walletModel->getAddressTableModel()->labelForAddress(
         QString::fromStdString(address));
     QString description;
     if (!label.isEmpty()) {
         description += label;
     }
     if (label.isEmpty() || tooltip) {
         description +=
             QString(" (") + QString::fromStdString(address) + QString(")");
     }
     return description;
 }
 
 QString
 TransactionTableModel::formatTxType(const TransactionRecord *wtx) const {
     switch (wtx->type) {
         case TransactionRecord::RecvWithAddress:
             return tr("Received with");
         case TransactionRecord::RecvFromOther:
             return tr("Received from");
         case TransactionRecord::SendToAddress:
         case TransactionRecord::SendToOther:
             return tr("Sent to");
         case TransactionRecord::SendToSelf:
             return tr("Payment to yourself");
         case TransactionRecord::Generated:
             return tr("Mined");
         default:
             return QString();
     }
 }
 
 QVariant
 TransactionTableModel::txAddressDecoration(const TransactionRecord *wtx) const {
     switch (wtx->type) {
         case TransactionRecord::Generated:
             return QIcon(":/icons/tx_mined");
         case TransactionRecord::RecvWithAddress:
         case TransactionRecord::RecvFromOther:
             return QIcon(":/icons/tx_input");
         case TransactionRecord::SendToAddress:
         case TransactionRecord::SendToOther:
             return QIcon(":/icons/tx_output");
         default:
             return QIcon(":/icons/tx_inout");
     }
 }
 
 QString TransactionTableModel::formatTxToAddress(const TransactionRecord *wtx,
                                                  bool tooltip) const {
     QString watchAddress;
     if (tooltip) {
         // Mark transactions involving watch-only addresses by adding "
         // (watch-only)"
         watchAddress = wtx->involvesWatchAddress
                            ? QString(" (") + tr("watch-only") + QString(")")
                            : "";
     }
 
     switch (wtx->type) {
         case TransactionRecord::RecvFromOther:
             return QString::fromStdString(wtx->address) + watchAddress;
         case TransactionRecord::RecvWithAddress:
         case TransactionRecord::SendToAddress:
         case TransactionRecord::Generated:
             return lookupAddress(wtx->address, tooltip) + watchAddress;
         case TransactionRecord::SendToOther:
             return QString::fromStdString(wtx->address) + watchAddress;
         case TransactionRecord::SendToSelf:
         default:
             return tr("(n/a)") + watchAddress;
     }
 }
 
 QVariant
 TransactionTableModel::addressColor(const TransactionRecord *wtx) const {
     // Show addresses without label in a less visible color
     switch (wtx->type) {
         case TransactionRecord::RecvWithAddress:
         case TransactionRecord::SendToAddress:
         case TransactionRecord::Generated: {
             QString label =
                 walletModel->getAddressTableModel()->labelForAddress(
                     QString::fromStdString(wtx->address));
             if (label.isEmpty()) {
                 return COLOR_BAREADDRESS;
             }
         } break;
         case TransactionRecord::SendToSelf:
             return COLOR_BAREADDRESS;
         default:
             break;
     }
     return QVariant();
 }
 
 QString TransactionTableModel::formatTxAmount(
     const TransactionRecord *wtx, bool showUnconfirmed,
     BitcoinUnits::SeparatorStyle separators) const {
     QString str =
         BitcoinUnits::format(walletModel->getOptionsModel()->getDisplayUnit(),
                              wtx->credit + wtx->debit, false, separators);
     if (showUnconfirmed) {
         if (!wtx->status.countsForBalance) {
             str = QString("[") + str + QString("]");
         }
     }
     return QString(str);
 }
 
 QVariant
 TransactionTableModel::txStatusDecoration(const TransactionRecord *wtx) const {
     switch (wtx->status.status) {
         case TransactionStatus::OpenUntilBlock:
         case TransactionStatus::OpenUntilDate:
             return COLOR_TX_STATUS_OPENUNTILDATE;
         case TransactionStatus::Unconfirmed:
             return QIcon(":/icons/transaction_0");
         case TransactionStatus::Abandoned:
             return QIcon(":/icons/transaction_abandoned");
         case TransactionStatus::Confirming:
             switch (wtx->status.depth) {
                 case 1:
                     return QIcon(":/icons/transaction_1");
                 case 2:
                     return QIcon(":/icons/transaction_2");
                 case 3:
                     return QIcon(":/icons/transaction_3");
                 case 4:
                     return QIcon(":/icons/transaction_4");
                 default:
                     return QIcon(":/icons/transaction_5");
             };
         case TransactionStatus::Confirmed:
             return QIcon(":/icons/transaction_confirmed");
         case TransactionStatus::Conflicted:
             return QIcon(":/icons/transaction_conflicted");
         case TransactionStatus::Immature: {
             int total = wtx->status.depth + wtx->status.matures_in;
             int part = (wtx->status.depth * 4 / total) + 1;
             return QIcon(QString(":/icons/transaction_%1").arg(part));
         }
         case TransactionStatus::NotAccepted:
             return QIcon(":/icons/transaction_0");
         default:
             return COLOR_BLACK;
     }
 }
 
 QVariant TransactionTableModel::txWatchonlyDecoration(
     const TransactionRecord *wtx) const {
     if (wtx->involvesWatchAddress) {
         return QIcon(":/icons/eye");
     }
 
     return QVariant();
 }
 
 QString
 TransactionTableModel::formatTooltip(const TransactionRecord *rec) const {
     QString tooltip = formatTxStatus(rec) + QString("\n") + formatTxType(rec);
     if (rec->type == TransactionRecord::RecvFromOther ||
         rec->type == TransactionRecord::SendToOther ||
         rec->type == TransactionRecord::SendToAddress ||
         rec->type == TransactionRecord::RecvWithAddress) {
         tooltip += QString(" ") + formatTxToAddress(rec, true);
     }
     return tooltip;
 }
 
 QVariant TransactionTableModel::data(const QModelIndex &index, int role) const {
     if (!index.isValid()) {
         return QVariant();
     }
 
     TransactionRecord *rec =
         static_cast<TransactionRecord *>(index.internalPointer());
 
     switch (role) {
         case RawDecorationRole:
             switch (index.column()) {
                 case Status:
                     return txStatusDecoration(rec);
                 case Watchonly:
                     return txWatchonlyDecoration(rec);
                 case ToAddress:
                     return txAddressDecoration(rec);
             }
             break;
         case Qt::DecorationRole: {
             QIcon icon = qvariant_cast<QIcon>(index.data(RawDecorationRole));
             return platformStyle->TextColorIcon(icon);
         }
         case Qt::DisplayRole:
             switch (index.column()) {
                 case Date:
                     return formatTxDate(rec);
                 case Type:
                     return formatTxType(rec);
                 case ToAddress:
                     return formatTxToAddress(rec, false);
                 case Amount:
                     return formatTxAmount(rec, true,
                                           BitcoinUnits::separatorAlways);
             }
             break;
         case Qt::EditRole:
             // Edit role is used for sorting, so return the unformatted values
             switch (index.column()) {
                 case Status:
                     return QString::fromStdString(rec->status.sortKey);
                 case Date:
                     return rec->time;
                 case Type:
                     return formatTxType(rec);
                 case Watchonly:
                     return (rec->involvesWatchAddress ? 1 : 0);
                 case ToAddress:
                     return formatTxToAddress(rec, true);
                 case Amount:
                     return qint64((rec->credit + rec->debit) / SATOSHI);
             }
             break;
         case Qt::ToolTipRole:
             return formatTooltip(rec);
         case Qt::TextAlignmentRole:
             return column_alignments[index.column()];
         case Qt::ForegroundRole:
             // Use the "danger" color for abandoned transactions
             if (rec->status.status == TransactionStatus::Abandoned) {
                 return COLOR_TX_STATUS_DANGER;
             }
             // Non-confirmed (but not immature) as transactions are grey
             if (!rec->status.countsForBalance &&
                 rec->status.status != TransactionStatus::Immature) {
                 return COLOR_UNCONFIRMED;
             }
             if (index.column() == Amount &&
                 (rec->credit + rec->debit) < ::Amount::zero()) {
                 return COLOR_NEGATIVE;
             }
             if (index.column() == ToAddress) {
                 return addressColor(rec);
             }
             break;
         case TypeRole:
             return rec->type;
         case DateRole:
             return QDateTime::fromTime_t(static_cast<uint>(rec->time));
         case WatchonlyRole:
             return rec->involvesWatchAddress;
         case WatchonlyDecorationRole:
             return txWatchonlyDecoration(rec);
         case LongDescriptionRole:
             return priv->describe(
                 walletModel->node(), walletModel->wallet(), rec,
                 walletModel->getOptionsModel()->getDisplayUnit());
         case AddressRole:
             return QString::fromStdString(rec->address);
         case LabelRole:
             return walletModel->getAddressTableModel()->labelForAddress(
                 QString::fromStdString(rec->address));
         case AmountRole:
             return qint64((rec->credit + rec->debit) / SATOSHI);
         case TxIDRole:
             return rec->getTxID();
         case TxHashRole:
             return QString::fromStdString(rec->txid.ToString());
         case TxHexRole:
             return priv->getTxHex(walletModel->wallet(), rec);
         case TxPlainTextRole: {
             QString details;
             QDateTime date =
                 QDateTime::fromTime_t(static_cast<uint>(rec->time));
             QString txLabel =
                 walletModel->getAddressTableModel()->labelForAddress(
                     QString::fromStdString(rec->address));
 
             details.append(date.toString("M/d/yy HH:mm"));
             details.append(" ");
             details.append(formatTxStatus(rec));
             details.append(". ");
             if (!formatTxType(rec).isEmpty()) {
                 details.append(formatTxType(rec));
                 details.append(" ");
             }
             if (!rec->address.empty()) {
                 if (txLabel.isEmpty()) {
                     details.append(tr("(no label)") + " ");
                 } else {
                     details.append("(");
                     details.append(txLabel);
                     details.append(") ");
                 }
                 details.append(QString::fromStdString(rec->address));
                 details.append(" ");
             }
             details.append(
                 formatTxAmount(rec, false, BitcoinUnits::separatorNever));
             return details;
         }
         case ConfirmedRole:
             return rec->status.countsForBalance;
         case FormattedAmountRole:
             // Used for copy/export, so don't include separators
             return formatTxAmount(rec, false, BitcoinUnits::separatorNever);
         case StatusRole:
             return rec->status.status;
     }
     return QVariant();
 }
 
 QVariant TransactionTableModel::headerData(int section,
                                            Qt::Orientation orientation,
                                            int role) const {
     if (orientation == Qt::Horizontal) {
         if (role == Qt::DisplayRole) {
             return columns[section];
         } else if (role == Qt::TextAlignmentRole) {
             return column_alignments[section];
         } else if (role == Qt::ToolTipRole) {
             switch (section) {
                 case Status:
                     return tr("Transaction status. Hover over this field to "
                               "show number of confirmations.");
                 case Date:
                     return tr(
                         "Date and time that the transaction was received.");
                 case Type:
                     return tr("Type of transaction.");
                 case Watchonly:
                     return tr("Whether or not a watch-only address is involved "
                               "in this transaction.");
                 case ToAddress:
                     return tr(
                         "User-defined intent/purpose of the transaction.");
                 case Amount:
                     return tr("Amount removed from or added to balance.");
             }
         }
     }
     return QVariant();
 }
 
 QModelIndex TransactionTableModel::index(int row, int column,
                                          const QModelIndex &parent) const {
     Q_UNUSED(parent);
     TransactionRecord *data = priv->index(walletModel->wallet(), row);
     if (data) {
         return createIndex(row, column,
                            priv->index(walletModel->wallet(), row));
     }
     return QModelIndex();
 }
 
 void TransactionTableModel::updateDisplayUnit() {
     // emit dataChanged to update Amount column with the current unit
     updateAmountColumnTitle();
     Q_EMIT dataChanged(index(0, Amount), index(priv->size() - 1, Amount));
 }
 
 // queue notifications to show a non freezing progress dialog e.g. for rescan
 struct TransactionNotification {
 public:
     TransactionNotification() {}
     TransactionNotification(TxId _txid, ChangeType _status,
                             bool _showTransaction)
         : txid(_txid), status(_status), showTransaction(_showTransaction) {}
 
     void invoke(QObject *ttm) {
         QString strHash = QString::fromStdString(txid.GetHex());
         qDebug() << "NotifyTransactionChanged: " + strHash +
                         " status= " + QString::number(status);
         QMetaObject::invokeMethod(ttm, "updateTransaction",
                                   Qt::QueuedConnection, Q_ARG(QString, strHash),
                                   Q_ARG(int, status),
                                   Q_ARG(bool, showTransaction));
     }
 
 private:
     TxId txid;
     ChangeType status;
     bool showTransaction;
 };
 
 static bool fQueueNotifications = false;
 static std::vector<TransactionNotification> vQueueNotifications;
 
 static void NotifyTransactionChanged(TransactionTableModel *ttm,
                                      const TxId &txid, ChangeType status) {
     // Find transaction in wallet
     // Determine whether to show transaction or not (determine this here so that
     // no relocking is needed in GUI thread)
     bool showTransaction = TransactionRecord::showTransaction();
 
     TransactionNotification notification(txid, status, showTransaction);
 
     if (fQueueNotifications) {
         vQueueNotifications.push_back(notification);
         return;
     }
     notification.invoke(ttm);
 }
 
 static void ShowProgress(TransactionTableModel *ttm, const std::string &title,
                          int nProgress) {
     if (nProgress == 0) {
         fQueueNotifications = true;
     }
 
     if (nProgress == 100) {
         fQueueNotifications = false;
         if (vQueueNotifications.size() > 10) {
             // prevent balloon spam, show maximum 10 balloons
             QMetaObject::invokeMethod(ttm, "setProcessingQueuedTransactions",
                                       Qt::QueuedConnection, Q_ARG(bool, true));
         }
 
         for (size_t i = 0; i < vQueueNotifications.size(); ++i) {
             if (vQueueNotifications.size() - i <= 10) {
                 QMetaObject::invokeMethod(
                     ttm, "setProcessingQueuedTransactions",
                     Qt::QueuedConnection, Q_ARG(bool, false));
             }
 
             vQueueNotifications[i].invoke(ttm);
         }
 
         // clear
         std::vector<TransactionNotification>().swap(vQueueNotifications);
     }
 }
 
 void TransactionTableModel::subscribeToCoreSignals() {
     // Connect signals to wallet
     m_handler_transaction_changed =
         walletModel->wallet().handleTransactionChanged(
             std::bind(NotifyTransactionChanged, this, std::placeholders::_1,
                       std::placeholders::_2));
     m_handler_show_progress =
         walletModel->wallet().handleShowProgress(std::bind(
             ShowProgress, this, std::placeholders::_1, std::placeholders::_2));
 }
 
 void TransactionTableModel::unsubscribeFromCoreSignals() {
     // Disconnect signals from wallet
     m_handler_transaction_changed->disconnect();
     m_handler_show_progress->disconnect();
 }
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index b90e05c26..12608947d 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -1,783 +1,783 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <miner.h>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <coins.h>
 #include <config.h>
 #include <consensus/consensus.h>
 #include <consensus/merkle.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <policy/policy.h>
 #include <script/standard.h>
 #include <txmempool.h>
 #include <uint256.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <validation.h>
 
 #include <test/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <memory>
 
 BOOST_FIXTURE_TEST_SUITE(miner_tests, TestingSetup)
 
 // BOOST_CHECK_EXCEPTION predicates to check the specific validation error
 class HasReason {
 public:
-    HasReason(const std::string &reason) : m_reason(reason) {}
+    explicit HasReason(const std::string &reason) : m_reason(reason) {}
     bool operator()(const std::runtime_error &e) const {
         return std::string(e.what()).find(m_reason) != std::string::npos;
     };
 
 private:
     const std::string m_reason;
 };
 
 static CFeeRate blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE_PER_KB);
 
 static BlockAssembler AssemblerForTest(const CChainParams &params,
                                        const CTxMemPool &mempool) {
     BlockAssembler::Options options;
     options.blockMinFeeRate = blockMinFeeRate;
     return BlockAssembler(params, mempool, options);
 }
 
 static struct {
     uint8_t extranonce;
     uint32_t nonce;
 } blockinfo[] = {
     {4, 0xa4a3e223}, {2, 0x15c32f9e}, {1, 0x0375b547}, {1, 0x7004a8a5},
     {2, 0xce440296}, {2, 0x52cfe198}, {1, 0x77a72cd0}, {2, 0xbb5d6f84},
     {2, 0x83f30c2c}, {1, 0x48a73d5b}, {1, 0xef7dcd01}, {2, 0x6809c6c4},
     {2, 0x0883ab3c}, {1, 0x087bbbe2}, {2, 0x2104a814}, {2, 0xdffb6daa},
     {1, 0xee8a0a08}, {2, 0xba4237c1}, {1, 0xa70349dc}, {1, 0x344722bb},
     {3, 0xd6294733}, {2, 0xec9f5c94}, {2, 0xca2fbc28}, {1, 0x6ba4f406},
     {2, 0x015d4532}, {1, 0x6e119b7c}, {2, 0x43e8f314}, {2, 0x27962f38},
     {2, 0xb571b51b}, {2, 0xb36bee23}, {2, 0xd17924a8}, {2, 0x6bc212d9},
     {1, 0x630d4948}, {2, 0x9a4c4ebb}, {2, 0x554be537}, {1, 0xd63ddfc7},
     {2, 0xa10acc11}, {1, 0x759a8363}, {2, 0xfb73090d}, {1, 0xe82c6a34},
     {1, 0xe33e92d7}, {3, 0x658ef5cb}, {2, 0xba32ff22}, {5, 0x0227a10c},
     {1, 0xa9a70155}, {5, 0xd096d809}, {1, 0x37176174}, {1, 0x830b8d0f},
     {1, 0xc6e3910e}, {2, 0x823f3ca8}, {1, 0x99850849}, {1, 0x7521fb81},
     {1, 0xaacaabab}, {1, 0xd645a2eb}, {5, 0x7aea1781}, {5, 0x9d6e4b78},
     {1, 0x4ce90fd8}, {1, 0xabdc832d}, {6, 0x4a34f32a}, {2, 0xf2524c1c},
     {2, 0x1bbeb08a}, {1, 0xad47f480}, {1, 0x9f026aeb}, {1, 0x15a95049},
     {2, 0xd1cb95b2}, {2, 0xf84bbda5}, {1, 0x0fa62cd1}, {1, 0xe05f9169},
     {1, 0x78d194a9}, {5, 0x3e38147b}, {5, 0x737ba0d4}, {1, 0x63378e10},
     {1, 0x6d5f91cf}, {2, 0x88612eb8}, {2, 0xe9639484}, {1, 0xb7fabc9d},
     {2, 0x19b01592}, {1, 0x5a90dd31}, {2, 0x5bd7e028}, {2, 0x94d00323},
     {1, 0xa9b9c01a}, {1, 0x3a40de61}, {1, 0x56e7eec7}, {5, 0x859f7ef6},
     {1, 0xfd8e5630}, {1, 0x2b0c9f7f}, {1, 0xba700e26}, {1, 0x7170a408},
     {1, 0x70de86a8}, {1, 0x74d64cd5}, {1, 0x49e738a1}, {2, 0x6910b602},
     {0, 0x643c565f}, {1, 0x54264b3f}, {2, 0x97ea6396}, {2, 0x55174459},
     {2, 0x03e8779a}, {1, 0x98f34d8f}, {1, 0xc07b2b07}, {1, 0xdfe29668},
     {1, 0x3141c7c1}, {1, 0xb3b595f4}, {1, 0x735abf08}, {5, 0x623bfbce},
     {2, 0xd351e722}, {1, 0xf4ca48c9}, {1, 0x5b19c670}, {1, 0xa164bf0e},
     {2, 0xbbbeb305}, {2, 0xfe1c810a},
 };
 
 static CBlockIndex CreateBlockIndex(int nHeight) {
     CBlockIndex index;
     index.nHeight = nHeight;
     index.pprev = ::ChainActive().Tip();
     return index;
 }
 
 static bool TestSequenceLocks(const CTransaction &tx, int flags)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     LOCK(::g_mempool.cs);
     return CheckSequenceLocks(::g_mempool, tx, flags);
 }
 
 // Test suite for ancestor feerate transaction selection.
 // Implemented as an additional function, rather than a separate test case, to
 // allow reusing the blockchain created in CreateNewBlock_validity.
 static void TestPackageSelection(const CChainParams &chainparams,
                                  const CScript &scriptPubKey,
                                  const std::vector<CTransactionRef> &txFirst)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main, ::g_mempool.cs) {
     // Test the ancestor feerate transaction selection.
     TestMemPoolEntryHelper entry;
 
     // Test that a medium fee transaction will be selected after a higher fee
     // rate package with a low fee rate parent.
     CMutableTransaction tx;
     tx.vin.resize(1);
     tx.vin[0].scriptSig = CScript() << OP_1;
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vout.resize(1);
     tx.vout[0].nValue = int64_t(5000000000LL - 1000) * SATOSHI;
     // This tx has a low fee: 1000 satoshis.
     // Save this txid for later use.
     TxId parentTxId = tx.GetId();
     g_mempool.addUnchecked(entry.Fee(1000 * SATOSHI)
                                .Time(GetTime())
                                .SpendsCoinbase(true)
                                .FromTx(tx));
 
     // This tx has a medium fee: 10000 satoshis.
     tx.vin[0].prevout = COutPoint(txFirst[1]->GetId(), 0);
     tx.vout[0].nValue = int64_t(5000000000LL - 10000) * SATOSHI;
     TxId mediumFeeTxId = tx.GetId();
     g_mempool.addUnchecked(entry.Fee(10000 * SATOSHI)
                                .Time(GetTime())
                                .SpendsCoinbase(true)
                                .FromTx(tx));
 
     // This tx has a high fee, but depends on the first transaction.
     tx.vin[0].prevout = COutPoint(parentTxId, 0);
     // 50k satoshi fee.
     tx.vout[0].nValue = int64_t(5000000000LL - 1000 - 50000) * SATOSHI;
     TxId highFeeTxId = tx.GetId();
     g_mempool.addUnchecked(entry.Fee(50000 * SATOSHI)
                                .Time(GetTime())
                                .SpendsCoinbase(false)
                                .FromTx(tx));
 
     std::unique_ptr<CBlockTemplate> pblocktemplate =
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey);
     BOOST_CHECK(pblocktemplate->block.vtx[1]->GetId() == parentTxId);
     BOOST_CHECK(pblocktemplate->block.vtx[2]->GetId() == highFeeTxId);
     BOOST_CHECK(pblocktemplate->block.vtx[3]->GetId() == mediumFeeTxId);
 
     // Test that a package below the block min tx fee doesn't get included
     tx.vin[0].prevout = COutPoint(highFeeTxId, 0);
     // 0 fee.
     tx.vout[0].nValue = int64_t(5000000000LL - 1000 - 50000) * SATOSHI;
     TxId freeTxId = tx.GetId();
     g_mempool.addUnchecked(entry.Fee(Amount::zero()).FromTx(tx));
     size_t freeTxSize = GetSerializeSize(tx, PROTOCOL_VERSION);
 
     // Calculate a fee on child transaction that will put the package just
     // below the block min tx fee (assuming 1 child tx of the same size).
     Amount feeToUse = blockMinFeeRate.GetFee(2 * freeTxSize) - SATOSHI;
 
     tx.vin[0].prevout = COutPoint(freeTxId, 0);
     tx.vout[0].nValue =
         int64_t(5000000000LL - 1000 - 50000) * SATOSHI - feeToUse;
     TxId lowFeeTxId = tx.GetId();
     g_mempool.addUnchecked(entry.Fee(feeToUse).FromTx(tx));
     pblocktemplate =
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey);
     // Verify that the free tx and the low fee tx didn't get selected.
     for (const auto &txn : pblocktemplate->block.vtx) {
         BOOST_CHECK(txn->GetId() != freeTxId);
         BOOST_CHECK(txn->GetId() != lowFeeTxId);
     }
 
     // Test that packages above the min relay fee do get included, even if one
     // of the transactions is below the min relay fee. Remove the low fee
     // transaction and replace with a higher fee transaction
     g_mempool.removeRecursive(CTransaction(tx));
     // Now we should be just over the min relay fee.
     tx.vout[0].nValue -= 2 * SATOSHI;
     lowFeeTxId = tx.GetId();
     g_mempool.addUnchecked(entry.Fee(feeToUse + 2 * SATOSHI).FromTx(tx));
     pblocktemplate =
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey);
     BOOST_CHECK(pblocktemplate->block.vtx[4]->GetId() == freeTxId);
     BOOST_CHECK(pblocktemplate->block.vtx[5]->GetId() == lowFeeTxId);
 
     // Test that transaction selection properly updates ancestor fee
     // calculations as ancestor transactions get included in a block. Add a
     // 0-fee transaction that has 2 outputs.
     tx.vin[0].prevout = COutPoint(txFirst[2]->GetId(), 0);
     tx.vout.resize(2);
     tx.vout[0].nValue = int64_t(5000000000LL - 100000000) * SATOSHI;
     // 1BCC output.
     tx.vout[1].nValue = 100000000 * SATOSHI;
     TxId freeTxId2 = tx.GetId();
     g_mempool.addUnchecked(
         entry.Fee(Amount::zero()).SpendsCoinbase(true).FromTx(tx));
 
     // This tx can't be mined by itself.
     tx.vin[0].prevout = COutPoint(freeTxId2, 0);
     tx.vout.resize(1);
     feeToUse = blockMinFeeRate.GetFee(freeTxSize);
     tx.vout[0].nValue = int64_t(5000000000LL - 100000000) * SATOSHI - feeToUse;
     TxId lowFeeTxId2 = tx.GetId();
     g_mempool.addUnchecked(
         entry.Fee(feeToUse).SpendsCoinbase(false).FromTx(tx));
     pblocktemplate =
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey);
 
     // Verify that this tx isn't selected.
     for (const auto &txn : pblocktemplate->block.vtx) {
         BOOST_CHECK(txn->GetId() != freeTxId2);
         BOOST_CHECK(txn->GetId() != lowFeeTxId2);
     }
 
     // This tx will be mineable, and should cause lowFeeTxId2 to be selected as
     // well.
     tx.vin[0].prevout = COutPoint(freeTxId2, 1);
     // 10k satoshi fee.
     tx.vout[0].nValue = (100000000 - 10000) * SATOSHI;
     g_mempool.addUnchecked(entry.Fee(10000 * SATOSHI).FromTx(tx));
     pblocktemplate =
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey);
     BOOST_CHECK(pblocktemplate->block.vtx[8]->GetId() == lowFeeTxId2);
 }
 
 void TestCoinbaseMessageEB(uint64_t eb, std::string cbmsg) {
     GlobalConfig config;
     config.SetMaxBlockSize(eb);
 
     CScript scriptPubKey =
         CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112"
                               "de5c384df7ba0b8d578a4c702b6bf11d5f")
                   << OP_CHECKSIG;
 
     std::unique_ptr<CBlockTemplate> pblocktemplate =
         BlockAssembler(config, g_mempool).CreateNewBlock(scriptPubKey);
 
     CBlock *pblock = &pblocktemplate->block;
 
     // IncrementExtraNonce creates a valid coinbase and merkleRoot
     unsigned int extraNonce = 0;
     IncrementExtraNonce(pblock, ::ChainActive().Tip(), config.GetMaxBlockSize(),
                         extraNonce);
     unsigned int nHeight = ::ChainActive().Tip()->nHeight + 1;
     std::vector<uint8_t> vec(cbmsg.begin(), cbmsg.end());
     BOOST_CHECK(pblock->vtx[0]->vin[0].scriptSig ==
                 ((CScript() << nHeight << CScriptNum(extraNonce) << vec) +
                  COINBASE_FLAGS));
 }
 
 // Coinbase scriptSig has to contains the correct EB value
 // converted to MB, rounded down to the first decimal
 BOOST_AUTO_TEST_CASE(CheckCoinbase_EB) {
     TestCoinbaseMessageEB(1000001, "/EB1.0/");
     TestCoinbaseMessageEB(2000000, "/EB2.0/");
     TestCoinbaseMessageEB(8000000, "/EB8.0/");
     TestCoinbaseMessageEB(8320000, "/EB8.3/");
 }
 
 // NOTE: These tests rely on CreateNewBlock doing its own self-validation!
 BOOST_AUTO_TEST_CASE(CreateNewBlock_validity) {
     // Note that by default, these tests run with size accounting enabled.
     GlobalConfig config;
     const CChainParams &chainparams = config.GetChainParams();
     CScript scriptPubKey =
         CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112"
                               "de5c384df7ba0b8d578a4c702b6bf11d5f")
                   << OP_CHECKSIG;
     std::unique_ptr<CBlockTemplate> pblocktemplate;
     CMutableTransaction tx;
     CScript script;
     TestMemPoolEntryHelper entry;
     entry.nFee = 11 * SATOSHI;
     entry.nHeight = 11;
 
     fCheckpointsEnabled = false;
 
     // Simple block creation, nothing special yet:
     BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams, g_mempool)
                                      .CreateNewBlock(scriptPubKey));
 
     // We can't make transactions until we have inputs.
     // Therefore, load 100 blocks :)
     int baseheight = 0;
     std::vector<CTransactionRef> txFirst;
     for (size_t i = 0; i < sizeof(blockinfo) / sizeof(*blockinfo); ++i) {
         // pointer for convenience.
         CBlock *pblock = &pblocktemplate->block;
         {
             LOCK(cs_main);
             pblock->nVersion = 1;
             pblock->nTime = ::ChainActive().Tip()->GetMedianTimePast() + 1;
             CMutableTransaction txCoinbase(*pblock->vtx[0]);
             txCoinbase.nVersion = 1;
             txCoinbase.vin[0].scriptSig = CScript();
             txCoinbase.vin[0].scriptSig.push_back(blockinfo[i].extranonce);
             txCoinbase.vin[0].scriptSig.push_back(::ChainActive().Height());
             txCoinbase.vout.resize(1);
             txCoinbase.vout[0].scriptPubKey = CScript();
             pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
             if (txFirst.size() == 0) {
                 baseheight = ::ChainActive().Height();
             }
             if (txFirst.size() < 4) {
                 txFirst.push_back(pblock->vtx[0]);
             }
             pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
             pblock->nNonce = blockinfo[i].nonce;
         }
         std::shared_ptr<const CBlock> shared_pblock =
             std::make_shared<const CBlock>(*pblock);
         BOOST_CHECK(ProcessNewBlock(config, shared_pblock, true, nullptr));
         pblock->hashPrevBlock = pblock->GetHash();
     }
 
     LOCK(cs_main);
     LOCK(::g_mempool.cs);
 
     // Just to make sure we can still make simple blocks.
     BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams, g_mempool)
                                      .CreateNewBlock(scriptPubKey));
 
     const Amount BLOCKSUBSIDY = 50 * COIN;
     const Amount LOWFEE = CENT;
     const Amount HIGHFEE = COIN;
     const Amount HIGHERFEE = 4 * COIN;
 
     // block sigops > limit: 1000 CHECKMULTISIG + 1
     tx.vin.resize(1);
     // NOTE: OP_NOP is used to force 20 SigOps for the CHECKMULTISIG
     tx.vin[0].scriptSig = CScript() << OP_0 << OP_0 << OP_0 << OP_NOP
                                     << OP_CHECKMULTISIG << OP_1;
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vout.resize(1);
     tx.vout[0].nValue = BLOCKSUBSIDY;
     for (unsigned int i = 0; i < 1001; ++i) {
         tx.vout[0].nValue -= LOWFEE;
         const TxId txid = tx.GetId();
         // Only first tx spends coinbase.
         bool spendsCoinbase = i == 0;
         // If we don't set the # of sig ops in the CTxMemPoolEntry, template
         // creation fails.
         g_mempool.addUnchecked(entry.Fee(LOWFEE)
                                    .Time(GetTime())
                                    .SpendsCoinbase(spendsCoinbase)
                                    .FromTx(tx));
         tx.vin[0].prevout = COutPoint(txid, 0);
     }
 
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("bad-blk-sigops"));
     g_mempool.clear();
 
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vout[0].nValue = BLOCKSUBSIDY;
     for (unsigned int i = 0; i < 1001; ++i) {
         tx.vout[0].nValue -= LOWFEE;
         const TxId txid = tx.GetId();
         // Only first tx spends coinbase.
         bool spendsCoinbase = i == 0;
         // If we do set the # of sig ops in the CTxMemPoolEntry, template
         // creation passes.
         g_mempool.addUnchecked(entry.Fee(LOWFEE)
                                    .Time(GetTime())
                                    .SpendsCoinbase(spendsCoinbase)
                                    .SigOpCount(20)
                                    .FromTx(tx));
         tx.vin[0].prevout = COutPoint(txid, 0);
     }
 
     BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams, g_mempool)
                                      .CreateNewBlock(scriptPubKey));
     g_mempool.clear();
 
     // block size > limit
     tx.vin[0].scriptSig = CScript();
     // 18 * (520char + DROP) + OP_1 = 9433 bytes
     std::vector<uint8_t> vchData(520);
     for (unsigned int i = 0; i < 18; ++i) {
         tx.vin[0].scriptSig << vchData << OP_DROP;
     }
 
     tx.vin[0].scriptSig << OP_1;
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vout[0].nValue = BLOCKSUBSIDY;
     for (unsigned int i = 0; i < 128; ++i) {
         tx.vout[0].nValue -= LOWFEE;
         const TxId txid = tx.GetId();
         // Only first tx spends coinbase.
         bool spendsCoinbase = i == 0;
         g_mempool.addUnchecked(entry.Fee(LOWFEE)
                                    .Time(GetTime())
                                    .SpendsCoinbase(spendsCoinbase)
                                    .FromTx(tx));
         tx.vin[0].prevout = COutPoint(txid, 0);
     }
 
     BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams, g_mempool)
                                      .CreateNewBlock(scriptPubKey));
     g_mempool.clear();
 
     // Orphan in mempool, template creation fails.
     g_mempool.addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).FromTx(tx));
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
     g_mempool.clear();
 
     // Child with higher priority than parent.
     tx.vin[0].scriptSig = CScript() << OP_1;
     tx.vin[0].prevout = COutPoint(txFirst[1]->GetId(), 0);
     tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
     TxId txid = tx.GetId();
     g_mempool.addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     tx.vin[0].prevout = COutPoint(txid, 0);
     tx.vin.resize(2);
     tx.vin[1].scriptSig = CScript() << OP_1;
     tx.vin[1].prevout = COutPoint(txFirst[0]->GetId(), 0);
     // First txn output + fresh coinbase - new txn fee.
     tx.vout[0].nValue = tx.vout[0].nValue + BLOCKSUBSIDY - HIGHERFEE;
     txid = tx.GetId();
     g_mempool.addUnchecked(
         entry.Fee(HIGHERFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams, g_mempool)
                                      .CreateNewBlock(scriptPubKey));
     g_mempool.clear();
 
     // Coinbase in mempool, template creation fails.
     tx.vin.resize(1);
     tx.vin[0].prevout = COutPoint();
     tx.vin[0].scriptSig = CScript() << OP_0 << OP_1;
     tx.vout[0].nValue = Amount::zero();
     txid = tx.GetId();
     // Give it a fee so it'll get mined.
     g_mempool.addUnchecked(
         entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
     // Should throw bad-tx-coinbase
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("bad-tx-coinbase"));
     g_mempool.clear();
 
     // Double spend txn pair in mempool, template creation fails.
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vin[0].scriptSig = CScript() << OP_1;
     tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
     tx.vout[0].scriptPubKey = CScript() << OP_1;
     txid = tx.GetId();
     g_mempool.addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     tx.vout[0].scriptPubKey = CScript() << OP_2;
     txid = tx.GetId();
     g_mempool.addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
     g_mempool.clear();
 
     // Subsidy changing.
     int nHeight = ::ChainActive().Height();
     // Create an actual 209999-long block chain (without valid blocks).
     while (::ChainActive().Tip()->nHeight < 209999) {
         CBlockIndex *prev = ::ChainActive().Tip();
         CBlockIndex *next = new CBlockIndex();
         next->phashBlock = new BlockHash(InsecureRand256());
         pcoinsTip->SetBestBlock(next->GetBlockHash());
         next->pprev = prev;
         next->nHeight = prev->nHeight + 1;
         next->BuildSkip();
         ::ChainActive().SetTip(next);
     }
     BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams, g_mempool)
                                      .CreateNewBlock(scriptPubKey));
     // Extend to a 210000-long block chain.
     while (::ChainActive().Tip()->nHeight < 210000) {
         CBlockIndex *prev = ::ChainActive().Tip();
         CBlockIndex *next = new CBlockIndex();
         next->phashBlock = new BlockHash(InsecureRand256());
         pcoinsTip->SetBestBlock(next->GetBlockHash());
         next->pprev = prev;
         next->nHeight = prev->nHeight + 1;
         next->BuildSkip();
         ::ChainActive().SetTip(next);
     }
 
     BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams, g_mempool)
                                      .CreateNewBlock(scriptPubKey));
 
     // Invalid p2sh txn in mempool, template creation fails
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vin[0].scriptSig = CScript() << OP_1;
     tx.vout[0].nValue = BLOCKSUBSIDY - LOWFEE;
     script = CScript() << OP_0;
     tx.vout[0].scriptPubKey = GetScriptForDestination(CScriptID(script));
     txid = tx.GetId();
     g_mempool.addUnchecked(
         entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     tx.vin[0].prevout = COutPoint(txid, 0);
     tx.vin[0].scriptSig = CScript()
                           << std::vector<uint8_t>(script.begin(), script.end());
     tx.vout[0].nValue -= LOWFEE;
     txid = tx.GetId();
     g_mempool.addUnchecked(
         entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
     // Should throw blk-bad-inputs
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("blk-bad-inputs"));
     g_mempool.clear();
 
     // Delete the dummy blocks again.
     while (::ChainActive().Tip()->nHeight > nHeight) {
         CBlockIndex *del = ::ChainActive().Tip();
         ::ChainActive().SetTip(del->pprev);
         pcoinsTip->SetBestBlock(del->pprev->GetBlockHash());
         delete del->phashBlock;
         delete del;
     }
 
     // non-final txs in mempool
     SetMockTime(::ChainActive().Tip()->GetMedianTimePast() + 1);
     uint32_t flags = LOCKTIME_VERIFY_SEQUENCE | LOCKTIME_MEDIAN_TIME_PAST;
     // height map
     std::vector<int> prevheights;
 
     // Relative height locked.
     tx.nVersion = 2;
     tx.vin.resize(1);
     prevheights.resize(1);
     // Only 1 transaction.
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vin[0].scriptSig = CScript() << OP_1;
     // txFirst[0] is the 2nd block
     tx.vin[0].nSequence = ::ChainActive().Tip()->nHeight + 1;
     prevheights[0] = baseheight + 1;
     tx.vout.resize(1);
     tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
     tx.vout[0].scriptPubKey = CScript() << OP_1;
     tx.nLockTime = 0;
     txid = tx.GetId();
     g_mempool.addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
 
     const Consensus::Params &params = chainparams.GetConsensus();
 
     {
         // Locktime passes.
         CValidationState state;
         BOOST_CHECK(ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
     }
 
     // Sequence locks fail.
     BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags));
     // Sequence locks pass on 2nd block.
     BOOST_CHECK(
         SequenceLocks(CTransaction(tx), flags, &prevheights,
                       CreateBlockIndex(::ChainActive().Tip()->nHeight + 2)));
 
     // Relative time locked.
     tx.vin[0].prevout = COutPoint(txFirst[1]->GetId(), 0);
     // txFirst[1] is the 3rd block.
     tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG |
                           (((::ChainActive().Tip()->GetMedianTimePast() + 1 -
                              ::ChainActive()[1]->GetMedianTimePast()) >>
                             CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) +
                            1);
     prevheights[0] = baseheight + 2;
     txid = tx.GetId();
     g_mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx));
 
     {
         // Locktime passes.
         CValidationState state;
         BOOST_CHECK(ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
     }
 
     // Sequence locks fail.
     BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags));
 
     for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++) {
         // Trick the MedianTimePast.
         ::ChainActive()
             .Tip()
             ->GetAncestor(::ChainActive().Tip()->nHeight - i)
             ->nTime += 512;
     }
     // Sequence locks pass 512 seconds later.
     BOOST_CHECK(
         SequenceLocks(CTransaction(tx), flags, &prevheights,
                       CreateBlockIndex(::ChainActive().Tip()->nHeight + 1)));
     for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++) {
         // Undo tricked MTP.
         ::ChainActive()
             .Tip()
             ->GetAncestor(::ChainActive().Tip()->nHeight - i)
             ->nTime -= 512;
     }
 
     // Absolute height locked.
     tx.vin[0].prevout = COutPoint(txFirst[2]->GetId(), 0);
     tx.vin[0].nSequence = CTxIn::SEQUENCE_FINAL - 1;
     prevheights[0] = baseheight + 3;
     tx.nLockTime = ::ChainActive().Tip()->nHeight + 1;
     txid = tx.GetId();
     g_mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx));
 
     {
         // Locktime fails.
         CValidationState state;
         BOOST_CHECK(!ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
         BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-txns-nonfinal");
     }
 
     // Sequence locks pass.
     BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags));
 
     {
         // Locktime passes on 2nd block.
         CValidationState state;
         int64_t nMedianTimePast = ::ChainActive().Tip()->GetMedianTimePast();
         BOOST_CHECK(ContextualCheckTransaction(
             params, CTransaction(tx), state, ::ChainActive().Tip()->nHeight + 2,
             nMedianTimePast, nMedianTimePast));
     }
 
     // Absolute time locked.
     tx.vin[0].prevout = COutPoint(txFirst[3]->GetId(), 0);
     tx.nLockTime = ::ChainActive().Tip()->GetMedianTimePast();
     prevheights.resize(1);
     prevheights[0] = baseheight + 4;
     txid = tx.GetId();
     g_mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx));
 
     {
         // Locktime fails.
         CValidationState state;
         BOOST_CHECK(!ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
         BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-txns-nonfinal");
     }
 
     // Sequence locks pass.
     BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags));
 
     {
         // Locktime passes 1 second later.
         CValidationState state;
         int64_t nMedianTimePast =
             ::ChainActive().Tip()->GetMedianTimePast() + 1;
         BOOST_CHECK(ContextualCheckTransaction(
             params, CTransaction(tx), state, ::ChainActive().Tip()->nHeight + 1,
             nMedianTimePast, nMedianTimePast));
     }
 
     // mempool-dependent transactions (not added)
     tx.vin[0].prevout = COutPoint(txid, 0);
     prevheights[0] = ::ChainActive().Tip()->nHeight + 1;
     tx.nLockTime = 0;
     tx.vin[0].nSequence = 0;
 
     {
         // Locktime passes.
         CValidationState state;
         BOOST_CHECK(ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
     }
 
     // Sequence locks pass.
     BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags));
     tx.vin[0].nSequence = 1;
     // Sequence locks fail.
     BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags));
     tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;
     // Sequence locks pass.
     BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags));
     tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | 1;
     // Sequence locks fail.
     BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags));
 
     pblocktemplate =
         AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey);
     BOOST_CHECK(pblocktemplate);
 
     // None of the of the absolute height/time locked tx should have made it
     // into the template because we still check IsFinalTx in CreateNewBlock, but
     // relative locked txs will if inconsistently added to g_mempool. For now
     // these will still generate a valid template until BIP68 soft fork.
     BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 3UL);
     // However if we advance height by 1 and time by 512, all of them should be
     // mined.
     for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++) {
         // Trick the MedianTimePast.
         ::ChainActive()
             .Tip()
             ->GetAncestor(::ChainActive().Tip()->nHeight - i)
             ->nTime += 512;
     }
     ::ChainActive().Tip()->nHeight++;
     SetMockTime(::ChainActive().Tip()->GetMedianTimePast() + 1);
 
     BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams, g_mempool)
                                      .CreateNewBlock(scriptPubKey));
     BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 5UL);
 
     ::ChainActive().Tip()->nHeight--;
     SetMockTime(0);
     g_mempool.clear();
 
     TestPackageSelection(chainparams, scriptPubKey, txFirst);
 
     fCheckpointsEnabled = true;
 }
 
 void CheckBlockMaxSize(const Config &config, uint64_t size, uint64_t expected) {
     gArgs.ForceSetArg("-blockmaxsize", std::to_string(size));
 
     BlockAssembler ba(config, g_mempool);
     BOOST_CHECK_EQUAL(ba.GetMaxGeneratedBlockSize(), expected);
 }
 
 BOOST_AUTO_TEST_CASE(BlockAssembler_construction) {
     GlobalConfig config;
 
     // We are working on a fake chain and need to protect ourselves.
     LOCK(cs_main);
 
     // Test around historical 1MB (plus one byte because that's mandatory)
     config.SetMaxBlockSize(ONE_MEGABYTE + 1);
     CheckBlockMaxSize(config, 0, 1000);
     CheckBlockMaxSize(config, 1000, 1000);
     CheckBlockMaxSize(config, 1001, 1001);
     CheckBlockMaxSize(config, 12345, 12345);
 
     CheckBlockMaxSize(config, ONE_MEGABYTE - 1001, ONE_MEGABYTE - 1001);
     CheckBlockMaxSize(config, ONE_MEGABYTE - 1000, ONE_MEGABYTE - 1000);
     CheckBlockMaxSize(config, ONE_MEGABYTE - 999, ONE_MEGABYTE - 999);
     CheckBlockMaxSize(config, ONE_MEGABYTE, ONE_MEGABYTE - 999);
 
     // Test around default cap
     config.SetMaxBlockSize(DEFAULT_MAX_BLOCK_SIZE);
 
     // Now we can use the default max block size.
     CheckBlockMaxSize(config, DEFAULT_MAX_BLOCK_SIZE - 1001,
                       DEFAULT_MAX_BLOCK_SIZE - 1001);
     CheckBlockMaxSize(config, DEFAULT_MAX_BLOCK_SIZE - 1000,
                       DEFAULT_MAX_BLOCK_SIZE - 1000);
     CheckBlockMaxSize(config, DEFAULT_MAX_BLOCK_SIZE - 999,
                       DEFAULT_MAX_BLOCK_SIZE - 1000);
     CheckBlockMaxSize(config, DEFAULT_MAX_BLOCK_SIZE,
                       DEFAULT_MAX_BLOCK_SIZE - 1000);
 
     // If the parameter is not specified, we use
     // DEFAULT_MAX_GENERATED_BLOCK_SIZE
     {
         gArgs.ClearForcedArg("-blockmaxsize");
         BlockAssembler ba(config, g_mempool);
         BOOST_CHECK_EQUAL(ba.GetMaxGeneratedBlockSize(),
                           DEFAULT_MAX_GENERATED_BLOCK_SIZE);
     }
 }
 
 BOOST_AUTO_TEST_CASE(TestCBlockTemplateEntry) {
     const CTransaction tx;
     CTransactionRef txRef = MakeTransactionRef(tx);
     CBlockTemplateEntry txEntry(txRef, 1 * SATOSHI, 10);
     BOOST_CHECK_MESSAGE(txEntry.tx == txRef, "Transactions did not match");
     BOOST_CHECK_EQUAL(txEntry.fees, 1 * SATOSHI);
     BOOST_CHECK_EQUAL(txEntry.sigOpCount, 10);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/validation_block_tests.cpp b/src/test/validation_block_tests.cpp
index 2cce15fb8..244941c87 100644
--- a/src/test/validation_block_tests.cpp
+++ b/src/test/validation_block_tests.cpp
@@ -1,214 +1,214 @@
 // Copyright (c) 2018-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <boost/test/unit_test.hpp>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
 #include <miner.h>
 #include <pow.h>
 #include <random.h>
 #include <test/setup_common.h>
 #include <util/time.h>
 #include <validation.h>
 #include <validationinterface.h>
 
 #include <thread>
 
 struct RegtestingSetup : public TestingSetup {
     RegtestingSetup() : TestingSetup(CBaseChainParams::REGTEST) {}
 };
 
 BOOST_FIXTURE_TEST_SUITE(validation_block_tests, RegtestingSetup)
 
 struct TestSubscriber : public CValidationInterface {
     uint256 m_expected_tip;
 
-    TestSubscriber(uint256 tip) : m_expected_tip(tip) {}
+    explicit TestSubscriber(uint256 tip) : m_expected_tip(tip) {}
 
     void UpdatedBlockTip(const CBlockIndex *pindexNew,
                          const CBlockIndex *pindexFork,
                          bool fInitialDownload) override {
         BOOST_CHECK_EQUAL(m_expected_tip, pindexNew->GetBlockHash());
     }
 
     void
     BlockConnected(const std::shared_ptr<const CBlock> &block,
                    const CBlockIndex *pindex,
                    const std::vector<CTransactionRef> &txnConflicted) override {
         BOOST_CHECK_EQUAL(m_expected_tip, block->hashPrevBlock);
         BOOST_CHECK_EQUAL(m_expected_tip, pindex->pprev->GetBlockHash());
 
         m_expected_tip = block->GetHash();
     }
 
     void
     BlockDisconnected(const std::shared_ptr<const CBlock> &block) override {
         BOOST_CHECK_EQUAL(m_expected_tip, block->GetHash());
 
         m_expected_tip = block->hashPrevBlock;
     }
 };
 
 std::shared_ptr<CBlock> Block(const Config &config,
                               const BlockHash &prev_hash) {
     static int i = 0;
     static uint64_t time = config.GetChainParams().GenesisBlock().nTime;
 
     CScript pubKey;
     pubKey << i++ << OP_TRUE;
 
     auto ptemplate = BlockAssembler(config, g_mempool).CreateNewBlock(pubKey);
     auto pblock = std::make_shared<CBlock>(ptemplate->block);
     pblock->hashPrevBlock = prev_hash;
     pblock->nTime = ++time;
 
     CMutableTransaction txCoinbase(*pblock->vtx[0]);
     txCoinbase.vout.resize(1);
     pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
 
     return pblock;
 }
 
 std::shared_ptr<CBlock> FinalizeBlock(const Consensus::Params &params,
                                       std::shared_ptr<CBlock> pblock) {
     pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
 
     while (!CheckProofOfWork(pblock->GetHash(), pblock->nBits, params)) {
         ++(pblock->nNonce);
     }
 
     return pblock;
 }
 
 // construct a valid block
 const std::shared_ptr<const CBlock> GoodBlock(const Config &config,
                                               const BlockHash &prev_hash) {
     return FinalizeBlock(config.GetChainParams().GetConsensus(),
                          Block(config, prev_hash));
 }
 
 // construct an invalid block (but with a valid header)
 const std::shared_ptr<const CBlock> BadBlock(const Config &config,
                                              const BlockHash &prev_hash) {
     auto pblock = Block(config, prev_hash);
 
     CMutableTransaction coinbase_spend;
     coinbase_spend.vin.push_back(
         CTxIn(COutPoint(pblock->vtx[0]->GetId(), 0), CScript(), 0));
     coinbase_spend.vout.push_back(pblock->vtx[0]->vout[0]);
 
     CTransactionRef tx = MakeTransactionRef(coinbase_spend);
     pblock->vtx.push_back(tx);
 
     auto ret = FinalizeBlock(config.GetChainParams().GetConsensus(), pblock);
     return ret;
 }
 
 void BuildChain(const Config &config, const BlockHash &root, int height,
                 const unsigned int invalid_rate, const unsigned int branch_rate,
                 const unsigned int max_size,
                 std::vector<std::shared_ptr<const CBlock>> &blocks) {
     if (height <= 0 || blocks.size() >= max_size) {
         return;
     }
 
     bool gen_invalid = InsecureRandRange(100) < invalid_rate;
     bool gen_fork = InsecureRandRange(100) < branch_rate;
 
     const std::shared_ptr<const CBlock> pblock =
         gen_invalid ? BadBlock(config, root) : GoodBlock(config, root);
     blocks.push_back(pblock);
     if (!gen_invalid) {
         BuildChain(config, pblock->GetHash(), height - 1, invalid_rate,
                    branch_rate, max_size, blocks);
     }
 
     if (gen_fork) {
         blocks.push_back(GoodBlock(config, root));
         BuildChain(config, blocks.back()->GetHash(), height - 1, invalid_rate,
                    branch_rate, max_size, blocks);
     }
 }
 
 BOOST_AUTO_TEST_CASE(processnewblock_signals_ordering) {
     GlobalConfig config;
     const CChainParams &chainParams = config.GetChainParams();
 
     // build a large-ish chain that's likely to have some forks
     std::vector<std::shared_ptr<const CBlock>> blocks;
     while (blocks.size() < 50) {
         blocks.clear();
         BuildChain(config, chainParams.GenesisBlock().GetHash(), 100, 15, 10,
                    500, blocks);
     }
 
     bool ignored;
     CValidationState state;
     std::vector<CBlockHeader> headers;
     std::transform(
         blocks.begin(), blocks.end(), std::back_inserter(headers),
         [](std::shared_ptr<const CBlock> b) { return b->GetBlockHeader(); });
 
     // Process all the headers so we understand the toplogy of the chain
     BOOST_CHECK(ProcessNewBlockHeaders(config, headers, state));
 
     // Connect the genesis block and drain any outstanding events
     ProcessNewBlock(config,
                     std::make_shared<CBlock>(chainParams.GenesisBlock()), true,
                     &ignored);
     SyncWithValidationInterfaceQueue();
 
     // subscribe to events (this subscriber will validate event ordering)
     const CBlockIndex *initial_tip = nullptr;
     {
         LOCK(cs_main);
         initial_tip = ::ChainActive().Tip();
     }
     TestSubscriber sub(initial_tip->GetBlockHash());
     RegisterValidationInterface(&sub);
 
     // create a bunch of threads that repeatedly process a block generated above
     // at random this will create parallelism and randomness inside validation -
     // the ValidationInterface will subscribe to events generated during block
     // validation and assert on ordering invariance
     std::vector<std::thread> threads;
     for (int i = 0; i < 10; i++) {
         threads.emplace_back([&config, &blocks]() {
             bool tlignored;
             FastRandomContext insecure;
             for (int j = 0; j < 1000; j++) {
                 auto block = blocks[insecure.randrange(blocks.size() - 1)];
                 ProcessNewBlock(config, block, true, &tlignored);
             }
 
             // to make sure that eventually we process the full chain - do it
             // here
             for (auto block : blocks) {
                 if (block->vtx.size() == 1) {
                     bool processed =
                         ProcessNewBlock(config, block, true, &tlignored);
                     assert(processed);
                 }
             }
         });
     }
 
     for (auto &t : threads) {
         t.join();
     }
     while (GetMainSignals().CallbacksPending() > 0) {
         MilliSleep(100);
     }
 
     UnregisterValidationInterface(&sub);
 
     BOOST_CHECK_EQUAL(sub.m_expected_tip,
                       ::ChainActive().Tip()->GetBlockHash());
 }
 
 BOOST_AUTO_TEST_SUITE_END()