diff --git a/src/interfaces/wallet.cpp b/src/interfaces/wallet.cpp
index 7cd954f4a..77885ed36 100644
--- a/src/interfaces/wallet.cpp
+++ b/src/interfaces/wallet.cpp
@@ -1,536 +1,532 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <interfaces/wallet.h>
 
 #include <amount.h>
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
 #include <policy/fees.h>
 #include <primitives/transaction.h>
 #include <script/standard.h>
 #include <support/allocators/secure.h>
 #include <sync.h>
 #include <ui_interface.h>
 #include <util/system.h>
 #include <wallet/fees.h>
 #include <wallet/ismine.h>
 #include <wallet/load.h>
 #include <wallet/psbtwallet.h>
 #include <wallet/rpcdump.h>
 #include <wallet/wallet.h>
 
 namespace interfaces {
 namespace {
 
     //! Construct wallet tx struct.
     WalletTx MakeWalletTx(CWallet &wallet, const CWalletTx &wtx) {
         WalletTx result;
         result.tx = wtx.tx;
         result.txin_is_mine.reserve(wtx.tx->vin.size());
         for (const auto &txin : wtx.tx->vin) {
             result.txin_is_mine.emplace_back(wallet.IsMine(txin));
         }
         result.txout_is_mine.reserve(wtx.tx->vout.size());
         result.txout_address.reserve(wtx.tx->vout.size());
         result.txout_address_is_mine.reserve(wtx.tx->vout.size());
         for (const auto &txout : wtx.tx->vout) {
             result.txout_is_mine.emplace_back(wallet.IsMine(txout));
             result.txout_address.emplace_back();
             result.txout_address_is_mine.emplace_back(
                 ExtractDestination(txout.scriptPubKey,
                                    result.txout_address.back())
                     ? wallet.IsMine(result.txout_address.back())
                     : ISMINE_NO);
         }
         result.credit = wtx.GetCredit(ISMINE_ALL);
         result.debit = wtx.GetDebit(ISMINE_ALL);
         result.change = wtx.GetChange();
         result.time = wtx.GetTxTime();
         result.value_map = wtx.mapValue;
         result.is_coinbase = wtx.IsCoinBase();
         return result;
     }
 
     //! Construct wallet tx status struct.
     WalletTxStatus MakeWalletTxStatus(interfaces::Chain::Lock &locked_chain,
                                       const CWalletTx &wtx) {
         WalletTxStatus result;
         result.block_height =
             locked_chain.getBlockHeight(wtx.m_confirm.hashBlock)
                 .get_value_or(std::numeric_limits<int>::max());
         result.blocks_to_maturity = wtx.GetBlocksToMaturity();
         result.depth_in_main_chain = wtx.GetDepthInMainChain();
         result.time_received = wtx.nTimeReceived;
         result.lock_time = wtx.tx->nLockTime;
         TxValidationState state;
         result.is_final =
             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();
         return result;
     }
 
     //! Construct wallet TxOut struct.
     WalletTxOut MakeWalletTxOut(CWallet &wallet, const CWalletTx &wtx, int n,
                                 int depth)
         EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) {
         WalletTxOut result;
         result.txout = wtx.tx->vout[n];
         result.time = wtx.GetTxTime();
         result.depth_in_main_chain = depth;
         result.is_spent = wallet.IsSpent(COutPoint(wtx.GetId(), n));
         return result;
     }
 
     class WalletImpl : public Wallet {
     public:
         explicit WalletImpl(const std::shared_ptr<CWallet> &wallet)
             : m_wallet(wallet) {}
 
         bool encryptWallet(const SecureString &wallet_passphrase) override {
             return m_wallet->EncryptWallet(wallet_passphrase);
         }
         bool isCrypted() override { return m_wallet->IsCrypted(); }
         bool lock() override { return m_wallet->Lock(); }
         bool unlock(const SecureString &wallet_passphrase) override {
             return m_wallet->Unlock(wallet_passphrase);
         }
         bool isLocked() override { return m_wallet->IsLocked(); }
         bool changeWalletPassphrase(
             const SecureString &old_wallet_passphrase,
             const SecureString &new_wallet_passphrase) override {
             return m_wallet->ChangeWalletPassphrase(old_wallet_passphrase,
                                                     new_wallet_passphrase);
         }
         void abortRescan() override { m_wallet->AbortRescan(); }
         bool backupWallet(const std::string &filename) override {
             return m_wallet->BackupWallet(filename);
         }
         std::string getWalletName() override { return m_wallet->GetName(); }
         std::set<CTxDestination>
         getLabelAddresses(const std::string &label) override {
             return m_wallet->GetLabelAddresses(label);
         };
         bool getNewDestination(const OutputType type, const std::string label,
                                CTxDestination &dest) override {
             LOCK(m_wallet->cs_wallet);
             std::string error;
             return m_wallet->GetNewDestination(type, label, dest, error);
         }
         const CChainParams &getChainParams() override {
             return m_wallet->chainParams;
         }
         bool getPubKey(const CScript &script, const CKeyID &address,
                        CPubKey &pub_key) override {
             const SigningProvider *provider =
                 m_wallet->GetSigningProvider(script);
             if (provider) {
                 return provider->GetPubKey(address, pub_key);
             }
             return false;
         }
         bool getPrivKey(const CScript &script, const CKeyID &address,
                         CKey &key) override {
             const SigningProvider *provider =
                 m_wallet->GetSigningProvider(script);
             if (provider) {
                 return provider->GetKey(address, key);
             }
             return false;
         }
         bool isSpendable(const CTxDestination &dest) override {
             return m_wallet->IsMine(dest) & ISMINE_SPENDABLE;
         }
         bool haveWatchOnly() override {
             auto spk_man = m_wallet->GetLegacyScriptPubKeyMan();
             if (spk_man) {
                 return spk_man->HaveWatchOnly();
             }
             return false;
         };
         bool setAddressBook(const CTxDestination &dest, const std::string &name,
                             const std::string &purpose) override {
             return m_wallet->SetAddressBook(dest, name, purpose);
         }
         bool delAddressBook(const CTxDestination &dest) override {
             return m_wallet->DelAddressBook(dest);
         }
         bool getAddress(const CTxDestination &dest, std::string *name,
                         isminetype *is_mine, std::string *purpose) override {
             LOCK(m_wallet->cs_wallet);
             auto it = m_wallet->m_address_book.find(dest);
             if (it == m_wallet->m_address_book.end() || it->second.IsChange()) {
                 return false;
             }
             if (name) {
                 *name = it->second.GetLabel();
             }
             if (is_mine) {
                 *is_mine = m_wallet->IsMine(dest);
             }
             if (purpose) {
                 *purpose = it->second.purpose;
             }
             return true;
         }
         std::vector<WalletAddress> getAddresses() override {
             LOCK(m_wallet->cs_wallet);
             std::vector<WalletAddress> result;
             for (const auto &item : m_wallet->m_address_book) {
                 if (item.second.IsChange()) {
                     continue;
                 }
                 result.emplace_back(item.first, m_wallet->IsMine(item.first),
                                     item.second.GetLabel(),
                                     item.second.purpose);
             }
             return result;
         }
-        void learnRelatedScripts(const CPubKey &key, OutputType type) override {
-            m_wallet->GetLegacyScriptPubKeyMan()->LearnRelatedScripts(key,
-                                                                      type);
-        }
         bool addDestData(const CTxDestination &dest, const std::string &key,
                          const std::string &value) override {
             LOCK(m_wallet->cs_wallet);
             WalletBatch batch{m_wallet->GetDatabase()};
             return m_wallet->AddDestData(batch, dest, key, value);
         }
         bool eraseDestData(const CTxDestination &dest,
                            const std::string &key) override {
             LOCK(m_wallet->cs_wallet);
             WalletBatch batch{m_wallet->GetDatabase()};
             return m_wallet->EraseDestData(batch, dest, key);
         }
         std::vector<std::string>
         getDestValues(const std::string &prefix) override {
             LOCK(m_wallet->cs_wallet);
             return m_wallet->GetDestValues(prefix);
         }
         void lockCoin(const COutPoint &output) override {
             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);
         }
         CTransactionRef
         createTransaction(const std::vector<CRecipient> &recipients,
                           const CCoinControl &coin_control, bool sign,
                           int &change_pos, Amount &fee,
                           bilingual_str &fail_reason) override {
             auto locked_chain = m_wallet->chain().lock();
             LOCK(m_wallet->cs_wallet);
             CTransactionRef tx;
             if (!m_wallet->CreateTransaction(*locked_chain, recipients, tx, fee,
                                              change_pos, fail_reason,
                                              coin_control, sign)) {
                 return {};
             }
             return tx;
         }
         void commitTransaction(CTransactionRef tx, WalletValueMap value_map,
                                WalletOrderForm order_form) override {
             auto locked_chain = m_wallet->chain().lock();
             LOCK(m_wallet->cs_wallet);
             m_wallet->CommitTransaction(std::move(tx), std::move(value_map),
                                         std::move(order_form));
         }
         bool transactionCanBeAbandoned(const TxId &txid) override {
             return m_wallet->TransactionCanBeAbandoned(txid);
         }
         bool abandonTransaction(const TxId &txid) override {
             auto locked_chain = m_wallet->chain().lock();
             LOCK(m_wallet->cs_wallet);
             return m_wallet->AbandonTransaction(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(*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(*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(*m_wallet, mi->second);
             }
             return {};
         }
         TransactionError
         fillPSBT(PartiallySignedTransaction &psbtx, bool &complete,
                  SigHashType sighash_type =
                      SigHashType().withForkId() /* SIGHASH_ALL|FORKID */,
                  bool sign = true, bool bip32derivs = false) override {
             return FillPSBT(m_wallet.get(), psbtx, complete, sighash_type, sign,
                             bip32derivs);
         }
         WalletBalances getBalances() override {
             const auto bal = m_wallet->GetBalance();
             WalletBalances result;
             result.balance = bal.m_mine_trusted;
             result.unconfirmed_balance = bal.m_mine_untrusted_pending;
             result.immature_balance = bal.m_mine_immature;
             result.have_watch_only = haveWatchOnly();
             if (result.have_watch_only) {
                 result.watch_only_balance = bal.m_watchonly_trusted;
                 result.unconfirmed_watch_only_balance =
                     bal.m_watchonly_untrusted_pending;
                 result.immature_watch_only_balance = bal.m_watchonly_immature;
             }
             return result;
         }
         bool tryGetBalances(WalletBalances &balances,
                             int &num_blocks) override {
             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().m_mine_trusted;
         }
         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(*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();
                     if (depth >= 0) {
                         result.back() = MakeWalletTxOut(*m_wallet, it->second,
                                                         output.GetN(), depth);
                     }
                 }
             }
             return result;
         }
         bool hdEnabled() override { return m_wallet->IsHDEnabled(); }
         OutputType getDefaultAddressType() override {
             return m_wallet->m_default_address_type;
         }
         bool canGetAddresses() 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;
         }
         Amount getDefaultMaxTxFee() override {
             return m_wallet->m_default_max_tx_fee;
         }
         void remove() override { RemoveWallet(m_wallet); }
         std::unique_ptr<Handler> handleUnload(UnloadFn fn) override {
             return MakeHandler(m_wallet->NotifyUnload.connect(fn));
         }
         std::unique_ptr<Handler>
         handleShowProgress(ShowProgressFn fn) override {
             return MakeHandler(m_wallet->ShowProgress.connect(fn));
         }
         std::unique_ptr<Handler>
         handleStatusChanged(StatusChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyStatusChanged.connect(
                 [fn](CWallet *) { fn(); }));
         }
         std::unique_ptr<Handler>
         handleAddressBookChanged(AddressBookChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyAddressBookChanged.connect(
                 [fn](CWallet *, const CTxDestination &address,
                      const std::string &label, bool is_mine,
                      const std::string &purpose, ChangeType status) {
                     fn(address, label, is_mine, purpose, status);
                 }));
         }
         std::unique_ptr<Handler>
         handleTransactionChanged(TransactionChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyTransactionChanged.connect(
                 [fn](CWallet *, const TxId &txid, ChangeType status) {
                     fn(txid, status);
                 }));
         }
         std::unique_ptr<Handler>
         handleWatchOnlyChanged(WatchOnlyChangedFn fn) override {
             return MakeHandler(m_wallet->NotifyWatchonlyChanged.connect(fn));
         }
         std::unique_ptr<Handler>
         handleCanGetAddressesChanged(CanGetAddressesChangedFn fn) override {
             return MakeHandler(
                 m_wallet->NotifyCanGetAddressesChanged.connect(fn));
         }
         Amount getRequiredFee(unsigned int tx_bytes) override {
             return GetRequiredFee(*m_wallet, tx_bytes);
         }
         Amount getMinimumFee(unsigned int tx_bytes,
                              const CCoinControl &coin_control) override {
             return GetMinimumFee(*m_wallet, tx_bytes, coin_control);
         }
 
         std::shared_ptr<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 {
             g_rpc_chain = &m_chain;
             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 wallet ? std::make_unique<WalletImpl>(wallet) : nullptr;
 }
 
 std::unique_ptr<ChainClient>
 MakeWalletClient(Chain &chain, std::vector<std::string> wallet_filenames) {
     return std::make_unique<WalletClientImpl>(chain,
                                               std::move(wallet_filenames));
 }
 
 } // namespace interfaces
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index 9ca79dc32..3de559206 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -1,377 +1,373 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_INTERFACES_WALLET_H
 #define BITCOIN_INTERFACES_WALLET_H
 
 #include <amount.h>                 // For Amount
 #include <primitives/transaction.h> // For CTxOut
 #include <psbt.h>
 #include <pubkey.h> // For CKeyID and CScriptID (definitions needed in CTxDestination instantiation)
 #include <script/standard.h>           // For CTxDestination
 #include <support/allocators/secure.h> // For SecureString
 #include <ui_interface.h>              // For ChangeType
 
 #include <cstdint>
 #include <functional>
 #include <map>
 #include <memory>
 #include <string>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 class CChainParams;
 class CCoinControl;
 class CKey;
 class CMutableTransaction;
 class COutPoint;
 class CTransaction;
 class CWallet;
 enum isminetype : unsigned int;
 enum class FeeReason;
 typedef uint8_t isminefilter;
 
 enum class OutputType;
 struct CRecipient;
 struct TxId;
 struct bilingual_str;
 
 namespace interfaces {
 
 class Handler;
 struct WalletAddress;
 struct WalletBalances;
 struct WalletTx;
 struct WalletTxOut;
 struct WalletTxStatus;
 
 using WalletOrderForm = std::vector<std::pair<std::string, std::string>>;
 using WalletValueMap = std::map<std::string, std::string>;
 
 //! Interface for accessing a wallet.
 class Wallet {
 public:
     virtual ~Wallet() {}
 
     //! Encrypt wallet.
     virtual bool encryptWallet(const SecureString &wallet_passphrase) = 0;
 
     //! Return whether wallet is encrypted.
     virtual bool isCrypted() = 0;
 
     //! Lock wallet.
     virtual bool lock() = 0;
 
     //! Unlock wallet.
     virtual bool unlock(const SecureString &wallet_passphrase) = 0;
 
     //! Return whether wallet is locked.
     virtual bool isLocked() = 0;
 
     //! Change wallet passphrase.
     virtual bool
     changeWalletPassphrase(const SecureString &old_wallet_passphrase,
                            const SecureString &new_wallet_passphrase) = 0;
 
     //! Abort a rescan.
     virtual void abortRescan() = 0;
 
     //! Back up wallet.
     virtual bool backupWallet(const std::string &filename) = 0;
 
     //! Get wallet name.
     virtual std::string getWalletName() = 0;
 
     //! Get chainparams.
     virtual const CChainParams &getChainParams() = 0;
 
     //! Get set of addresses corresponding to a given label.
     virtual std::set<CTxDestination>
     getLabelAddresses(const std::string &label) = 0;
 
     // Get a new address.
     virtual bool getNewDestination(const OutputType type,
                                    const std::string label,
                                    CTxDestination &dest) = 0;
 
     //! Get public key.
     virtual bool getPubKey(const CScript &script, const CKeyID &address,
                            CPubKey &pub_key) = 0;
 
     //! Get private key.
     virtual bool getPrivKey(const CScript &script, const CKeyID &address,
                             CKey &key) = 0;
 
     //! Return whether wallet has private key.
     virtual bool isSpendable(const CTxDestination &dest) = 0;
 
     //! Return whether wallet has watch only keys.
     virtual bool haveWatchOnly() = 0;
 
     //! Add or update address.
     virtual bool setAddressBook(const CTxDestination &dest,
                                 const std::string &name,
                                 const std::string &purpose) = 0;
 
     // Remove address.
     virtual bool delAddressBook(const CTxDestination &dest) = 0;
 
     //! Look up address in wallet, return whether exists.
     virtual bool getAddress(const CTxDestination &dest, std::string *name,
                             isminetype *is_mine, std::string *purpose) = 0;
 
     //! Get wallet address list.
     virtual std::vector<WalletAddress> getAddresses() = 0;
 
-    //! Add scripts to key store so old so software versions opening the wallet
-    //! database can detect payments to newer address types.
-    virtual void learnRelatedScripts(const CPubKey &key, OutputType type) = 0;
-
     //! Add dest data.
     virtual bool addDestData(const CTxDestination &dest, const std::string &key,
                              const std::string &value) = 0;
 
     //! Erase dest data.
     virtual bool eraseDestData(const CTxDestination &dest,
                                const std::string &key) = 0;
 
     //! Get dest values with prefix.
     virtual std::vector<std::string>
     getDestValues(const std::string &prefix) = 0;
 
     //! Lock coin.
     virtual void lockCoin(const COutPoint &output) = 0;
 
     //! Unlock coin.
     virtual void unlockCoin(const COutPoint &output) = 0;
 
     //! Return whether coin is locked.
     virtual bool isLockedCoin(const COutPoint &output) = 0;
 
     //! List locked coins.
     virtual void listLockedCoins(std::vector<COutPoint> &outputs) = 0;
 
     //! Create transaction.
     virtual CTransactionRef
     createTransaction(const std::vector<CRecipient> &recipients,
                       const CCoinControl &coin_control, bool sign,
                       int &change_pos, Amount &fee,
                       bilingual_str &fail_reason) = 0;
 
     //! Commit transaction.
     virtual void commitTransaction(CTransactionRef tx, WalletValueMap value_map,
                                    WalletOrderForm order_form) = 0;
 
     //! Return whether transaction can be abandoned.
     virtual bool transactionCanBeAbandoned(const TxId &txid) = 0;
 
     //! Abandon transaction.
     virtual bool abandonTransaction(const TxId &txid) = 0;
 
     //! Get a transaction.
     virtual CTransactionRef getTx(const TxId &txid) = 0;
 
     //! Get transaction information.
     virtual WalletTx getWalletTx(const TxId &txid) = 0;
 
     //! Get list of all wallet transactions.
     virtual std::vector<WalletTx> getWalletTxs() = 0;
 
     //! Try to get updated status for a particular transaction, if possible
     //! without blocking.
     virtual bool tryGetTxStatus(const TxId &txid, WalletTxStatus &tx_status,
                                 int &num_blocks, int64_t &block_time) = 0;
 
     //! Get transaction details.
     virtual WalletTx getWalletTxDetails(const TxId &txid,
                                         WalletTxStatus &tx_status,
                                         WalletOrderForm &order_form,
                                         bool &in_mempool, int &num_blocks) = 0;
 
     //! Fill PSBT.
     virtual TransactionError
     fillPSBT(PartiallySignedTransaction &psbtx, bool &complete,
              SigHashType sighash_type =
                  SigHashType().withForkId() /* SIGHASH_ALL|FORKID */,
              bool sign = true, bool bip32derivs = false) = 0;
 
     //! Get balances.
     virtual WalletBalances getBalances() = 0;
 
     //! Get balances if possible without blocking.
     virtual bool tryGetBalances(WalletBalances &balances, int &num_blocks) = 0;
 
     //! Get balance.
     virtual Amount getBalance() = 0;
 
     //! Get available balance.
     virtual Amount getAvailableBalance(const CCoinControl &coin_control) = 0;
 
     //! Return whether transaction input belongs to wallet.
     virtual isminetype txinIsMine(const CTxIn &txin) = 0;
 
     //! Return whether transaction output belongs to wallet.
     virtual isminetype txoutIsMine(const CTxOut &txout) = 0;
 
     //! Return debit amount if transaction input belongs to wallet.
     virtual Amount getDebit(const CTxIn &txin, isminefilter filter) = 0;
 
     //! Return credit amount if transaction input belongs to wallet.
     virtual Amount getCredit(const CTxOut &txout, isminefilter filter) = 0;
 
     //! Return AvailableCoins + LockedCoins grouped by wallet address.
     //! (put change in one group with wallet address)
     using CoinsList = std::map<CTxDestination,
                                std::vector<std::tuple<COutPoint, WalletTxOut>>>;
     virtual CoinsList listCoins() = 0;
 
     //! Return wallet transaction output information.
     virtual std::vector<WalletTxOut>
     getCoins(const std::vector<COutPoint> &outputs) = 0;
 
     //! Get required fee.
     virtual Amount getRequiredFee(unsigned int tx_bytes) = 0;
 
     //! Get minimum fee.
     virtual Amount getMinimumFee(unsigned int tx_bytes,
                                  const CCoinControl &coin_control) = 0;
 
     // Return whether HD enabled.
     virtual bool hdEnabled() = 0;
 
     // Return whether the wallet is blank.
     virtual bool canGetAddresses() = 0;
 
     // Check if a certain wallet flag is set.
     virtual bool IsWalletFlagSet(uint64_t flag) = 0;
 
     // Get default address type.
     virtual OutputType getDefaultAddressType() = 0;
 
     // Get default change type.
     virtual OutputType getDefaultChangeType() = 0;
 
     //! Get max tx fee.
     virtual Amount getDefaultMaxTxFee() = 0;
 
     // Remove wallet.
     virtual void remove() = 0;
 
     //! Register handler for unload message.
     using UnloadFn = std::function<void()>;
     virtual std::unique_ptr<Handler> handleUnload(UnloadFn fn) = 0;
 
     //! Register handler for show progress messages.
     using ShowProgressFn =
         std::function<void(const std::string &title, int progress)>;
     virtual std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) = 0;
 
     //! Register handler for status changed messages.
     using StatusChangedFn = std::function<void()>;
     virtual std::unique_ptr<Handler>
     handleStatusChanged(StatusChangedFn fn) = 0;
 
     //! Register handler for address book changed messages.
     using AddressBookChangedFn = std::function<void(
         const CTxDestination &address, const std::string &label, bool is_mine,
         const std::string &purpose, ChangeType status)>;
     virtual std::unique_ptr<Handler>
     handleAddressBookChanged(AddressBookChangedFn fn) = 0;
 
     //! Register handler for transaction changed messages.
     using TransactionChangedFn =
         std::function<void(const TxId &txid, ChangeType status)>;
     virtual std::unique_ptr<Handler>
     handleTransactionChanged(TransactionChangedFn fn) = 0;
 
     //! Register handler for watchonly changed messages.
     using WatchOnlyChangedFn = std::function<void(bool have_watch_only)>;
     virtual std::unique_ptr<Handler>
     handleWatchOnlyChanged(WatchOnlyChangedFn fn) = 0;
 
     //! Register handler for keypool changed messages.
     using CanGetAddressesChangedFn = std::function<void()>;
     virtual std::unique_ptr<Handler>
     handleCanGetAddressesChanged(CanGetAddressesChangedFn fn) = 0;
 };
 
 //! Information about one wallet address.
 struct WalletAddress {
     CTxDestination dest;
     isminetype is_mine;
     std::string name;
     std::string purpose;
 
     WalletAddress(CTxDestination destIn, isminetype isMineIn,
                   std::string nameIn, std::string purposeIn)
         : dest(std::move(destIn)), is_mine(isMineIn), name(std::move(nameIn)),
           purpose(std::move(purposeIn)) {}
 };
 
 //! Collection of wallet balances.
 struct WalletBalances {
     Amount balance = Amount::zero();
     Amount unconfirmed_balance = Amount::zero();
     Amount immature_balance = Amount::zero();
     bool have_watch_only = false;
     Amount watch_only_balance = Amount::zero();
     Amount unconfirmed_watch_only_balance = Amount::zero();
     Amount immature_watch_only_balance = Amount::zero();
 
     bool balanceChanged(const WalletBalances &prev) const {
         return balance != prev.balance ||
                unconfirmed_balance != prev.unconfirmed_balance ||
                immature_balance != prev.immature_balance ||
                watch_only_balance != prev.watch_only_balance ||
                unconfirmed_watch_only_balance !=
                    prev.unconfirmed_watch_only_balance ||
                immature_watch_only_balance != prev.immature_watch_only_balance;
     }
 };
 
 // Wallet transaction information.
 struct WalletTx {
     CTransactionRef tx;
     std::vector<isminetype> txin_is_mine;
     std::vector<isminetype> txout_is_mine;
     std::vector<CTxDestination> txout_address;
     std::vector<isminetype> txout_address_is_mine;
     Amount credit;
     Amount debit;
     Amount change;
     int64_t time;
     std::map<std::string, std::string> value_map;
     bool is_coinbase;
 };
 
 //! Updated transaction status.
 struct WalletTxStatus {
     int block_height;
     int blocks_to_maturity;
     int depth_in_main_chain;
     unsigned int time_received;
     uint32_t lock_time;
     bool is_final;
     bool is_trusted;
     bool is_abandoned;
     bool is_coinbase;
     bool is_in_main_chain;
 };
 
 //! Wallet transaction output.
 struct WalletTxOut {
     CTxOut txout;
     int64_t time;
     int depth_in_main_chain = -1;
     bool is_spent = false;
 };
 
 //! Return implementation of Wallet interface. This function is defined in
 //! dummywallet.cpp and throws if the wallet component is not compiled.
 std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet> &wallet);
 
 } // namespace interfaces
 
 #endif // BITCOIN_INTERFACES_WALLET_H