diff --git a/src/interfaces/node.h b/src/interfaces/node.h
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -6,6 +6,7 @@
 #define BITCOIN_INTERFACES_NODE_H
 
 #include <addrdb.h>     // For banmap_t
+#include <amount.h>     // For Amount
 #include <init.h>       // For HelpMessageMode
 #include <net.h>        // For CConnman::NumConnections
 #include <netaddress.h> // For Network
@@ -148,6 +149,9 @@
     //! Get network active.
     virtual bool getNetworkActive() = 0;
 
+    //! Get max tx fee.
+    virtual Amount getMaxTxFee() = 0;
+
     //! Execute rpc command.
     virtual UniValue executeRpc(Config &config, const std::string &command,
                                 const UniValue &params,
@@ -162,6 +166,9 @@
     //! Unset RPC timer interface.
     virtual void rpcUnsetTimerInterface(RPCTimerInterface *iface) = 0;
 
+    //! Return interfaces for accessing wallets (if any).
+    virtual std::vector<std::unique_ptr<Wallet>> getWallets() = 0;
+
     //! Register handler for init messages.
     using InitMessageFn = std::function<void(const std::string &message)>;
     virtual std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) = 0;
diff --git a/src/interfaces/node.cpp b/src/interfaces/node.cpp
--- a/src/interfaces/node.cpp
+++ b/src/interfaces/node.cpp
@@ -5,6 +5,7 @@
 #include <interfaces/node.h>
 
 #include <addrdb.h>
+#include <amount.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
@@ -29,6 +30,7 @@
 #include <config/bitcoin-config.h>
 #endif
 #ifdef ENABLE_WALLET
+#include <wallet/wallet.h>
 #define CHECK_WALLET(x) x
 #else
 #define CHECK_WALLET(x)                                                        \
@@ -40,7 +42,6 @@
 
 #include <atomic>
 
-class CWallet;
 class HTTPRPCRequestProcessor;
 
 namespace interfaces {
@@ -207,6 +208,7 @@
         bool getNetworkActive() override {
             return g_connman && g_connman->GetNetworkActive();
         }
+        Amount getMaxTxFee() override { return ::maxTxFee; }
         UniValue executeRpc(Config &config, const std::string &command,
                             const UniValue &params,
                             const std::string &uri) override {
@@ -225,6 +227,18 @@
         void rpcUnsetTimerInterface(RPCTimerInterface *iface) override {
             RPCUnsetTimerInterface(iface);
         }
+        std::vector<std::unique_ptr<Wallet>> getWallets() override {
+#ifdef ENABLE_WALLET
+            std::vector<std::unique_ptr<Wallet>> wallets;
+            for (CWalletRef wallet : ::vpwallets) {
+                wallets.emplace_back(MakeWallet(*wallet));
+            }
+            return wallets;
+#else
+            throw std::logic_error(
+                "Node::getWallets() called in non-wallet build.");
+#endif
+        }
         std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) override {
             return MakeHandler(::uiInterface.InitMessage.connect(fn));
         }
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -5,25 +5,211 @@
 #ifndef BITCOIN_INTERFACES_WALLET_H
 #define BITCOIN_INTERFACES_WALLET_H
 
+#include <amount.h>                    // For Amount
+#include <script/ismine.h>             // For isminefilter, isminetype
+#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 <utility>
+#include <vector>
 
+class CChainParams;
+class CCoinControl;
+class CKey;
+class CMutableTransaction;
+class COutPoint;
+class CTransaction;
 class CWallet;
+enum class OutputType;
+struct CRecipient;
+struct TxId;
 
 namespace interfaces {
 
 class Handler;
+class PendingWalletTx;
+struct WalletBalances;
+
+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;
+
+    //! 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 public key.
+    virtual bool getPubKey(const CKeyID &address, CPubKey &pub_key) = 0;
+
+    //! Get private key.
+    virtual bool getPrivKey(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;
+
+    //! Look up address in wallet, return whether exists.
+    virtual bool getAddress(const CTxDestination &dest,
+                            std::string *name = nullptr,
+                            isminetype *is_mine = nullptr) = 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 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) = 0;
+
+    //! Return whether transaction can be abandoned.
+    virtual bool transactionCanBeAbandoned(const TxId &txid) = 0;
+
+    //! Abandon transaction.
+    virtual bool abandonTransaction(const TxId &txid) = 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 HD enabled.
+    virtual bool hdEnabled() = 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;
+};
+
+//! Tracking object returned by CreateTransaction and passed to
+//! CommitTransaction.
+class PendingWalletTx {
+public:
+    virtual ~PendingWalletTx() {}
+
+    //! Get transaction data.
+    virtual const CTransaction &get() = 0;
+
+    //! Send pending transaction and commit to wallet.
+    virtual bool commit(WalletValueMap value_map, WalletOrderForm order_form,
+                        std::string from_account,
+                        std::string &reject_reason) = 0;
+};
+
+//! 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;
+    }
 };
 
 //! Return implementation of Wallet interface. This function will be undefined
diff --git a/src/interfaces/wallet.cpp b/src/interfaces/wallet.cpp
--- a/src/interfaces/wallet.cpp
+++ b/src/interfaces/wallet.cpp
@@ -4,7 +4,19 @@
 
 #include <interfaces/wallet.h>
 
+#include <amount.h>
+#include <chain.h>
+#include <consensus/validation.h>
 #include <interfaces/handler.h>
+#include <net.h>
+#include <policy/policy.h>
+#include <primitives/transaction.h>
+#include <script/ismine.h>
+#include <script/standard.h>
+#include <support/allocators/secure.h>
+#include <sync.h>
+#include <ui_interface.h>
+#include <validation.h>
 #include <wallet/wallet.h>
 
 #include <memory>
@@ -12,14 +24,201 @@
 namespace interfaces {
 namespace {
 
+    class PendingWalletTxImpl : public PendingWalletTx {
+    public:
+        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 from_account,
+                    std::string &reject_reason) override {
+            LOCK2(cs_main, m_wallet.cs_wallet);
+            CValidationState state;
+            if (!m_wallet.CommitTransaction(
+                    m_tx, std::move(value_map), std::move(order_form),
+                    std::move(from_account), m_key, g_connman.get(), state)) {
+                reject_reason = state.GetRejectReason();
+                return false;
+            }
+            return true;
+        }
+
+        CTransactionRef m_tx;
+        CWallet &m_wallet;
+        CReserveKey m_key;
+    };
+
     class WalletImpl : public Wallet {
     public:
         WalletImpl(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);
+        }
+        bool backupWallet(const std::string &filename) override {
+            return m_wallet.BackupWallet(filename);
+        }
+        std::string getWalletName() override { return m_wallet.GetName(); }
+        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 getAddress(const CTxDestination &dest, std::string *name,
+                        isminetype *is_mine) 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);
+            }
+            return true;
+        }
+        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 {
+            LOCK2(cs_main, m_wallet.cs_wallet);
+            return m_wallet.LockCoin(output);
+        }
+        void unlockCoin(const COutPoint &output) override {
+            LOCK2(cs_main, m_wallet.cs_wallet);
+            return m_wallet.UnlockCoin(output);
+        }
+        bool isLockedCoin(const COutPoint &output) override {
+            LOCK2(cs_main, m_wallet.cs_wallet);
+            return m_wallet.IsLockedCoin(output.GetTxId(), output.GetN());
+        }
+        void listLockedCoins(std::vector<COutPoint> &outputs) override {
+            LOCK2(cs_main, 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 {
+            LOCK2(cs_main, m_wallet.cs_wallet);
+            auto pending = std::make_unique<PendingWalletTxImpl>(m_wallet);
+            if (!m_wallet.CreateTransaction(recipients, pending->m_tx,
+                                            pending->m_key, fee, change_pos,
+                                            fail_reason, coin_control, sign)) {
+                return {};
+            }
+            return std::move(pending);
+        }
+        bool transactionCanBeAbandoned(const TxId &txid) override {
+            return m_wallet.TransactionCanBeAbandoned(txid);
+        }
+        bool abandonTransaction(const TxId &txid) override {
+            LOCK2(cs_main, m_wallet.cs_wallet);
+            return m_wallet.AbandonTransaction(txid);
+        }
+        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.GetWatchOnlyBalance();
+                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 {
+            TRY_LOCK(cs_main, locked_chain);
+            if (!locked_chain) {
+                return false;
+            }
+            TRY_LOCK(m_wallet.cs_wallet, locked_wallet);
+            if (!locked_wallet) {
+                return false;
+            }
+            balances = getBalances();
+            num_blocks = ::chainActive.Height();
+            return true;
+        }
+        Amount getBalance() override { return m_wallet.GetBalance(); }
+        Amount getAvailableBalance(const CCoinControl &coin_control) override {
+            return m_wallet.GetAvailableBalance(&coin_control);
+        }
+        bool hdEnabled() override { return m_wallet.IsHDEnabled(); }
         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, this](CWallet *, const TxId &txid, ChangeType status) {
+                    fn(txid, status);
+                }));
+        }
+        std::unique_ptr<Handler>
+        handleWatchOnlyChanged(WatchOnlyChangedFn fn) override {
+            return MakeHandler(m_wallet.NotifyWatchonlyChanged.connect(fn));
+        }
 
         CWallet &m_wallet;
     };
diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp
--- a/src/qt/bitcoin.cpp
+++ b/src/qt/bitcoin.cpp
@@ -474,9 +474,11 @@
 
 #ifdef ENABLE_WALLET
     bool fFirstWallet = true;
-    for (CWalletRef pwallet : vpwallets) {
-        WalletModel *const walletModel =
-            new WalletModel(platformStyle, pwallet, optionsModel);
+    auto wallets = m_node.getWallets();
+    auto cwallet = ::vpwallets.begin();
+    for (auto &wallet : wallets) {
+        WalletModel *const walletModel = new WalletModel(
+            std::move(wallet), m_node, platformStyle, *cwallet++, optionsModel);
 
         window->addWallet(walletModel);
         if (fFirstWallet) {
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -1044,7 +1044,7 @@
     QString msg = tr("Date: %1\n").arg(date) +
                   tr("Amount: %1\n")
                       .arg(BitcoinUnits::formatWithUnit(unit, amount, true));
-    if (WalletModel::isMultiwallet() && !walletName.isEmpty()) {
+    if (m_node.getWallets().size() > 1 && !walletName.isEmpty()) {
         msg += tr("Wallet: %1\n").arg(walletName);
     }
     msg += tr("Type: %1\n").arg(type);
@@ -1157,7 +1157,7 @@
     }
     WalletModel *const walletModel = walletView->getWalletModel();
     setEncryptionStatus(walletModel->getEncryptionStatus());
-    setHDStatus(walletModel->hdEnabled());
+    setHDStatus(walletModel->wallet().hdEnabled());
 }
 #endif // ENABLE_WALLET
 
diff --git a/src/qt/coincontroldialog.cpp b/src/qt/coincontroldialog.cpp
--- a/src/qt/coincontroldialog.cpp
+++ b/src/qt/coincontroldialog.cpp
@@ -235,8 +235,8 @@
             // transaction hash is 64 characters (this means its a child node,
             // so its not a parent node in tree mode)
             copyTransactionHashAction->setEnabled(true);
-            if (model->isLockedCoin(txid,
-                                    item->text(COLUMN_VOUT_INDEX).toUInt())) {
+            if (model->wallet().isLockedCoin(
+                    COutPoint(txid, item->text(COLUMN_VOUT_INDEX).toUInt()))) {
                 lockAction->setEnabled(false);
                 unlockAction->setEnabled(true);
             } else {
@@ -297,7 +297,7 @@
     COutPoint outpt(
         uint256S(contextMenuItem->text(COLUMN_TXHASH).toStdString()),
         contextMenuItem->text(COLUMN_VOUT_INDEX).toUInt());
-    model->lockCoin(outpt);
+    model->wallet().lockCoin(outpt);
     contextMenuItem->setDisabled(true);
     contextMenuItem->setIcon(
         COLUMN_CHECKBOX, platformStyle->SingleColorIcon(":/icons/lock_closed"));
@@ -309,7 +309,7 @@
     COutPoint outpt(
         uint256S(contextMenuItem->text(COLUMN_TXHASH).toStdString()),
         contextMenuItem->text(COLUMN_VOUT_INDEX).toUInt());
-    model->unlockCoin(outpt);
+    model->wallet().unlockCoin(outpt);
     contextMenuItem->setDisabled(false);
     contextMenuItem->setIcon(COLUMN_CHECKBOX, QIcon());
     updateLabelLocked();
@@ -445,7 +445,7 @@
 // shows count of locked unspent outputs
 void CoinControlDialog::updateLabelLocked() {
     std::vector<COutPoint> vOutpts;
-    model->listLockedCoins(vOutpts);
+    model->wallet().listLockedCoins(vOutpts);
     if (vOutpts.size() > 0) {
         ui->labelLocked->setText(tr("(%1 locked)").arg(vOutpts.size()));
         ui->labelLocked->setVisible(true);
@@ -511,7 +511,7 @@
         if (ExtractDestination(out.tx->tx->vout[out.i].scriptPubKey, address)) {
             CPubKey pubkey;
             CKeyID *keyid = boost::get<CKeyID>(&address);
-            if (keyid && model->getPubKey(*keyid, pubkey)) {
+            if (keyid && model->wallet().getPubKey(*keyid, pubkey)) {
                 nBytesInputs += (pubkey.IsCompressed() ? 148 : 180);
                 if (!pubkey.IsCompressed()) {
                     nQuantityUncompressed++;
@@ -794,7 +794,7 @@
             itemOutput->setText(COLUMN_VOUT_INDEX, QString::number(out.i));
 
             // disable locked coins
-            if (model->isLockedCoin(txid, out.i)) {
+            if (model->wallet().isLockedCoin(COutPoint(txid, out.i))) {
                 COutPoint outpt(txid, out.i);
                 // just to be sure
                 coinControl()->UnSelect(outpt);
diff --git a/src/qt/overviewpage.cpp b/src/qt/overviewpage.cpp
--- a/src/qt/overviewpage.cpp
+++ b/src/qt/overviewpage.cpp
@@ -252,10 +252,12 @@
         ui->listTransactions->setModelColumn(TransactionTableModel::ToAddress);
 
         // Keep up to date with wallet
-        setBalance(model->getBalance(), model->getUnconfirmedBalance(),
-                   model->getImmatureBalance(), model->getWatchBalance(),
-                   model->getWatchUnconfirmedBalance(),
-                   model->getWatchImmatureBalance());
+        interfaces::Wallet &wallet = model->wallet();
+        interfaces::WalletBalances balances = wallet.getBalances();
+        setBalance(balances.balance, balances.unconfirmed_balance,
+                   balances.immature_balance, balances.watch_only_balance,
+                   balances.unconfirmed_watch_only_balance,
+                   balances.immature_watch_only_balance);
         connect(
             model,
             SIGNAL(
@@ -266,7 +268,7 @@
         connect(model->getOptionsModel(), SIGNAL(displayUnitChanged(int)), this,
                 SLOT(updateDisplayUnit()));
 
-        updateWatchOnlyLabels(model->haveWatchOnly());
+        updateWatchOnlyLabels(wallet.haveWatchOnly());
         connect(model, SIGNAL(notifyWatchonlyChanged(bool)), this,
                 SLOT(updateWatchOnlyLabels(bool)));
     }
diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp
--- a/src/qt/sendcoinsdialog.cpp
+++ b/src/qt/sendcoinsdialog.cpp
@@ -2,27 +2,27 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "sendcoinsdialog.h"
-#include "ui_sendcoinsdialog.h"
-
-#include "addresstablemodel.h"
-#include "bitcoinunits.h"
-#include "clientmodel.h"
-#include "coincontroldialog.h"
-#include "guiutil.h"
-#include "optionsmodel.h"
-#include "platformstyle.h"
-#include "sendcoinsentry.h"
-#include "walletmodel.h"
-
-#include "chainparams.h"
-#include "dstencode.h"
-#include "txmempool.h"
-#include "ui_interface.h"
-#include "validation.h" // mempool and minRelayTxFee
-#include "wallet/coincontrol.h"
-#include "wallet/fees.h"
-#include "wallet/wallet.h"
+#include <qt/forms/ui_sendcoinsdialog.h>
+#include <qt/sendcoinsdialog.h>
+
+#include <chainparams.h>
+#include <dstencode.h>
+#include <interfaces/node.h>
+#include <qt/addresstablemodel.h>
+#include <qt/bitcoinunits.h>
+#include <qt/clientmodel.h>
+#include <qt/coincontroldialog.h>
+#include <qt/guiutil.h>
+#include <qt/optionsmodel.h>
+#include <qt/platformstyle.h>
+#include <qt/sendcoinsentry.h>
+#include <qt/walletmodel.h>
+#include <txmempool.h>
+#include <ui_interface.h>
+#include <validation.h> // mempool and minRelayTxFee
+#include <wallet/coincontrol.h>
+#include <wallet/fees.h>
+#include <wallet/wallet.h>
 
 #include <QMessageBox>
 #include <QScrollBar>
@@ -165,10 +165,11 @@
             }
         }
 
-        setBalance(_model->getBalance(), _model->getUnconfirmedBalance(),
-                   _model->getImmatureBalance(), _model->getWatchBalance(),
-                   _model->getWatchUnconfirmedBalance(),
-                   _model->getWatchImmatureBalance());
+        interfaces::WalletBalances balances = _model->wallet().getBalances();
+        setBalance(balances.balance, balances.unconfirmed_balance,
+                   balances.immature_balance, balances.watch_only_balance,
+                   balances.unconfirmed_watch_only_balance,
+                   balances.immature_watch_only_balance);
         connect(
             _model,
             SIGNAL(
@@ -401,7 +402,7 @@
         accept();
         CoinControlDialog::coinControl()->UnSelectAll();
         coinControlUpdateLabels();
-        Q_EMIT coinsSent(currentTransaction.getTransaction()->GetId());
+        Q_EMIT coinsSent(currentTransaction.getWtx()->get().GetId());
     }
     fNewRecipientAllowed = true;
 }
@@ -548,7 +549,7 @@
 }
 
 void SendCoinsDialog::updateDisplayUnit() {
-    setBalance(model->getBalance(), Amount::zero(), Amount::zero(),
+    setBalance(model->wallet().getBalance(), Amount::zero(), Amount::zero(),
                Amount::zero(), Amount::zero(), Amount::zero());
     ui->customFee->setDisplayUnit(model->getOptionsModel()->getDisplayUnit());
     updateMinFeeLabel();
@@ -643,7 +644,7 @@
     }
 
     // Calculate available amount to send.
-    Amount amount = model->getBalance(&coin_control);
+    Amount amount = model->wallet().getAvailableBalance(coin_control);
     for (int i = 0; i < ui->entries->count(); ++i) {
         SendCoinsEntry *e =
             qobject_cast<SendCoinsEntry *>(ui->entries->itemAt(i)->widget());
@@ -837,7 +838,7 @@
                 tr("Warning: Invalid Bitcoin address"));
         } else {
             // Valid address
-            if (!model->IsSpendable(dest)) {
+            if (!model->wallet().isSpendable(dest)) {
                 ui->labelCoinControlChangeLabel->setText(
                     tr("Warning: Unknown change address"));
 
diff --git a/src/qt/signverifymessagedialog.cpp b/src/qt/signverifymessagedialog.cpp
--- a/src/qt/signverifymessagedialog.cpp
+++ b/src/qt/signverifymessagedialog.cpp
@@ -137,7 +137,7 @@
     }
 
     CKey key;
-    if (!model->getPrivKey(*keyID, key)) {
+    if (!model->wallet().getPrivKey(*keyID, key)) {
         ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_SM->setText(
             tr("Private key for the entered address is not available."));
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
--- a/src/qt/test/wallettests.cpp
+++ b/src/qt/test/wallettests.cpp
@@ -142,7 +142,10 @@
     SendCoinsDialog sendCoinsDialog(platformStyle.get());
     auto node = interfaces::MakeNode();
     OptionsModel optionsModel(*node);
-    WalletModel walletModel(platformStyle.get(), &wallet, &optionsModel);
+    vpwallets.insert(vpwallets.begin(), &wallet);
+    WalletModel walletModel(std::move(node->getWallets()[0]), *node,
+                            platformStyle.get(), &wallet, &optionsModel);
+    vpwallets.erase(vpwallets.begin());
     sendCoinsDialog.setModel(&walletModel);
 
     // Send two transactions, and verify they are added to transaction list.
@@ -163,7 +166,7 @@
     QLabel *balanceLabel = overviewPage.findChild<QLabel *>("labelBalance");
     QString balanceText = balanceLabel->text();
     int unit = walletModel.getOptionsModel()->getDisplayUnit();
-    Amount balance = walletModel.getBalance();
+    Amount balance = walletModel.wallet().getBalance();
     QString balanceComparison = BitcoinUnits::formatWithUnit(
         unit, balance, false, BitcoinUnits::separatorAlways);
     QCOMPARE(balanceText, balanceComparison);
diff --git a/src/qt/transactionview.cpp b/src/qt/transactionview.cpp
--- a/src/qt/transactionview.cpp
+++ b/src/qt/transactionview.cpp
@@ -260,7 +260,7 @@
         }
 
         // show/hide column Watch-only
-        updateWatchOnlyColumn(_model->haveWatchOnly());
+        updateWatchOnlyColumn(_model->wallet().haveWatchOnly());
 
         // Watch-only signal
         connect(_model, SIGNAL(notifyWatchonlyChanged(bool)), this,
@@ -374,7 +374,7 @@
     // name, column, role
     writer.setModel(transactionProxyModel);
     writer.addColumn(tr("Confirmed"), 0, TransactionTableModel::ConfirmedRole);
-    if (model->haveWatchOnly()) {
+    if (model->wallet().haveWatchOnly()) {
         writer.addColumn(tr("Watch-only"), TransactionTableModel::Watchonly);
     }
     writer.addColumn(tr("Date"), 0, TransactionTableModel::DateRole);
@@ -416,7 +416,7 @@
                     .data(TransactionTableModel::TxHashRole)
                     .toString()
                     .toStdString());
-    abandonAction->setEnabled(model->transactionCanBeAbandoned(txid));
+    abandonAction->setEnabled(model->wallet().transactionCanBeAbandoned(txid));
 
     if (index.isValid()) {
         contextMenu->popup(transactionView->viewport()->mapToGlobal(point));
@@ -439,7 +439,7 @@
     txid.SetHex(hashQStr.toStdString());
 
     // Abandon the wallet transaction over the walletModel
-    model->abandonTransaction(txid);
+    model->wallet().abandonTransaction(txid);
 
     // Update the table
     model->getTransactionTableModel()->updateTransaction(hashQStr, CT_UPDATED,
diff --git a/src/qt/walletmodel.h b/src/qt/walletmodel.h
--- a/src/qt/walletmodel.h
+++ b/src/qt/walletmodel.h
@@ -5,17 +5,17 @@
 #ifndef BITCOIN_QT_WALLETMODEL_H
 #define BITCOIN_QT_WALLETMODEL_H
 
-#include "chainparams.h"
-#include "paymentrequestplus.h"
-#include "walletmodeltransaction.h"
+#include <chainparams.h>
+#include <interfaces/wallet.h>
+#include <qt/paymentrequestplus.h>
+#include <qt/walletmodeltransaction.h>
+#include <support/allocators/secure.h>
 
-#include "support/allocators/secure.h"
+#include <QObject>
 
 #include <map>
 #include <vector>
 
-#include <QObject>
-
 class AddressTableModel;
 class OptionsModel;
 class PlatformStyle;
@@ -28,8 +28,10 @@
 class COutPoint;
 class COutput;
 class CPubKey;
-class CWallet;
-class uint256;
+
+namespace interfaces {
+class Node;
+} // namespace interface
 
 QT_BEGIN_NAMESPACE
 class QTimer;
@@ -111,7 +113,9 @@
     Q_OBJECT
 
 public:
-    explicit WalletModel(const PlatformStyle *platformStyle, CWallet *wallet,
+    explicit WalletModel(std::unique_ptr<interfaces::Wallet> wallet,
+                         interfaces::Node &node,
+                         const PlatformStyle *platformStyle, CWallet *cwallet,
                          OptionsModel *optionsModel, QObject *parent = nullptr);
     ~WalletModel();
 
@@ -144,15 +148,6 @@
     TransactionTableModel *getTransactionTableModel();
     RecentRequestsTableModel *getRecentRequestsTableModel();
 
-    CWallet *getWallet() const { return wallet; };
-
-    Amount getBalance(const CCoinControl *coinControl = nullptr) const;
-    Amount getUnconfirmedBalance() const;
-    Amount getImmatureBalance() const;
-    bool haveWatchOnly() const;
-    Amount getWatchBalance() const;
-    Amount getWatchUnconfirmedBalance() const;
-    Amount getWatchImmatureBalance() const;
     EncryptionStatus getEncryptionStatus() const;
 
     // Check address for validity
@@ -181,8 +176,6 @@
                          const SecureString &passPhrase = SecureString());
     bool changePassphrase(const SecureString &oldPass,
                           const SecureString &newPass);
-    // Wallet backup
-    bool backupWallet(const QString &filename);
 
     // RAI object for unlocking wallet, returned by requestUnlock()
     class UnlockContext {
@@ -210,38 +203,36 @@
 
     UnlockContext requestUnlock();
 
-    bool getPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const;
-    bool IsSpendable(const CTxDestination &dest) const;
-    bool getPrivKey(const CKeyID &address, CKey &vchPrivKeyOut) const;
     void getOutputs(const std::vector<COutPoint> &vOutpoints,
                     std::vector<COutput> &vOutputs);
     bool isSpent(const COutPoint &outpoint) const;
     void listCoins(std::map<QString, std::vector<COutput>> &mapCoins) const;
 
-    bool isLockedCoin(const TxId &txid, uint32_t n) const;
-    void lockCoin(COutPoint &output);
-    void unlockCoin(COutPoint &output);
-    void listLockedCoins(std::vector<COutPoint> &vOutpts);
-
     void loadReceiveRequests(std::vector<std::string> &vReceiveRequests);
     bool saveReceiveRequest(const std::string &sAddress, const int64_t nId,
                             const std::string &sRequest);
 
-    bool transactionCanBeAbandoned(const TxId &txid) const;
-    bool abandonTransaction(const TxId &txid) const;
-
     static bool isWalletEnabled();
 
-    bool hdEnabled() const;
+    interfaces::Node &node() const { return m_node; }
+    interfaces::Wallet &wallet() const { return *m_wallet; }
 
     const CChainParams &getChainParams() const;
 
     QString getWalletName() const;
 
-    static bool isMultiwallet();
+    bool isMultiwallet();
 
 private:
-    CWallet *wallet;
+    std::unique_ptr<interfaces::Wallet> m_wallet;
+    std::unique_ptr<interfaces::Handler> m_handler_status_changed;
+    std::unique_ptr<interfaces::Handler> m_handler_address_book_changed;
+    std::unique_ptr<interfaces::Handler> m_handler_transaction_changed;
+    std::unique_ptr<interfaces::Handler> m_handler_show_progress;
+    std::unique_ptr<interfaces::Handler> m_handler_watch_only_changed;
+    interfaces::Node &m_node;
+
+    CWallet *cwallet;
     bool fHaveWatchOnly;
     bool fForceCheckBalanceChanged;
 
@@ -254,12 +245,7 @@
     RecentRequestsTableModel *recentRequestsTableModel;
 
     // Cache some values to be able to detect changes
-    Amount cachedBalance;
-    Amount cachedUnconfirmedBalance;
-    Amount cachedImmatureBalance;
-    Amount cachedWatchOnlyBalance;
-    Amount cachedWatchUnconfBalance;
-    Amount cachedWatchImmatureBalance;
+    interfaces::WalletBalances m_cached_balances;
     EncryptionStatus cachedEncryptionStatus;
     int cachedNumBlocks;
 
@@ -267,7 +253,7 @@
 
     void subscribeToCoreSignals();
     void unsubscribeFromCoreSignals();
-    void checkBalanceChanged();
+    void checkBalanceChanged(const interfaces::WalletBalances &new_balances);
 
 Q_SIGNALS:
     // Signal that balance in wallet changed
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
--- a/src/qt/walletmodel.cpp
+++ b/src/qt/walletmodel.cpp
@@ -2,49 +2,51 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "walletmodel.h"
-
-#include "addresstablemodel.h"
-#include "consensus/validation.h"
-#include "guiconstants.h"
-#include "guiutil.h"
-#include "paymentserver.h"
-#include "recentrequeststablemodel.h"
-#include "transactiontablemodel.h"
-
-#include "chain.h"
-#include "config.h"
-#include "dstencode.h"
-#include "keystore.h"
-#include "net.h" // for g_connman
-#include "sync.h"
-#include "ui_interface.h"
-#include "util.h" // for GetBoolArg
-#include "validation.h"
-#include "wallet/coincontrol.h"
-#include "wallet/wallet.h"
-#include "wallet/walletdb.h" // for BackupWallet
-
-#include <cstdint>
+#include <qt/walletmodel.h>
+
+#include <chain.h>
+#include <config.h>
+#include <consensus/validation.h>
+#include <dstencode.h>
+#include <interfaces/handler.h>
+#include <interfaces/node.h>
+#include <keystore.h>
+#include <net.h> // for g_connman
+#include <qt/addresstablemodel.h>
+#include <qt/guiconstants.h>
+#include <qt/guiutil.h>
+#include <qt/paymentserver.h>
+#include <qt/recentrequeststablemodel.h>
+#include <qt/transactiontablemodel.h>
+#include <sync.h>
+#include <ui_interface.h>
+#include <util.h> // for GetBoolArg
+#include <validation.h>
+#include <wallet/coincontrol.h>
+#include <wallet/wallet.h>
+#include <wallet/walletdb.h> // for BackupWallet
 
 #include <QDebug>
 #include <QSet>
 #include <QTimer>
 
-WalletModel::WalletModel(const PlatformStyle *platformStyle, CWallet *_wallet,
+#include <cstdint>
+
+WalletModel::WalletModel(std::unique_ptr<interfaces::Wallet> wallet,
+                         interfaces::Node &node,
+                         const PlatformStyle *platformStyle, CWallet *_wallet,
                          OptionsModel *_optionsModel, QObject *parent)
-    : QObject(parent), wallet(_wallet), optionsModel(_optionsModel),
-      addressTableModel(0), transactionTableModel(0),
-      recentRequestsTableModel(0), cachedBalance(), cachedUnconfirmedBalance(),
-      cachedImmatureBalance(), cachedEncryptionStatus(Unencrypted),
-      cachedNumBlocks(0) {
-    fHaveWatchOnly = wallet->HaveWatchOnly();
+    : QObject(parent), m_wallet(std::move(wallet)), m_node(node),
+      cwallet(_wallet), optionsModel(_optionsModel), addressTableModel(0),
+      transactionTableModel(0), recentRequestsTableModel(0),
+      cachedEncryptionStatus(Unencrypted), cachedNumBlocks(0) {
+    fHaveWatchOnly = m_wallet->haveWatchOnly();
     fForceCheckBalanceChanged = false;
 
-    addressTableModel = new AddressTableModel(wallet, this);
+    addressTableModel = new AddressTableModel(cwallet, this);
     transactionTableModel =
-        new TransactionTableModel(platformStyle, wallet, this);
-    recentRequestsTableModel = new RecentRequestsTableModel(wallet, this);
+        new TransactionTableModel(platformStyle, cwallet, this);
+    recentRequestsTableModel = new RecentRequestsTableModel(cwallet, this);
 
     // This timer will be fired repeatedly to update the balance
     pollTimer = new QTimer(this);
@@ -58,38 +60,6 @@
     unsubscribeFromCoreSignals();
 }
 
-Amount WalletModel::getBalance(const CCoinControl *coinControl) const {
-    if (coinControl) {
-        return wallet->GetAvailableBalance(coinControl);
-    }
-
-    return wallet->GetBalance();
-}
-
-Amount WalletModel::getUnconfirmedBalance() const {
-    return wallet->GetUnconfirmedBalance();
-}
-
-Amount WalletModel::getImmatureBalance() const {
-    return wallet->GetImmatureBalance();
-}
-
-bool WalletModel::haveWatchOnly() const {
-    return fHaveWatchOnly;
-}
-
-Amount WalletModel::getWatchBalance() const {
-    return wallet->GetWatchOnlyBalance();
-}
-
-Amount WalletModel::getWatchUnconfirmedBalance() const {
-    return wallet->GetUnconfirmedWatchOnlyBalance();
-}
-
-Amount WalletModel::getWatchImmatureBalance() const {
-    return wallet->GetImmatureWatchOnlyBalance();
-}
-
 void WalletModel::updateStatus() {
     EncryptionStatus newEncryptionStatus = getEncryptionStatus();
 
@@ -99,59 +69,38 @@
 }
 
 void WalletModel::pollBalanceChanged() {
-    // Get required locks upfront. This avoids the GUI from getting stuck on
-    // periodical polls if the core is holding the locks for a longer time - for
-    // example, during a wallet rescan.
-    TRY_LOCK(cs_main, lockMain);
-    if (!lockMain) {
-        return;
-    }
-    TRY_LOCK(wallet->cs_wallet, lockWallet);
-    if (!lockWallet) {
+    // Try to get balances and return early if locks can't be acquired. This
+    // avoids the GUI from getting stuck on periodical polls if the core is
+    // holding the locks for a longer time - for example, during a wallet
+    // rescan.
+    interfaces::WalletBalances new_balances;
+    int numBlocks = -1;
+    if (!m_wallet->tryGetBalances(new_balances, numBlocks)) {
         return;
     }
 
-    if (fForceCheckBalanceChanged || chainActive.Height() != cachedNumBlocks) {
+    if (fForceCheckBalanceChanged || m_node.getNumBlocks() != cachedNumBlocks) {
         fForceCheckBalanceChanged = false;
 
         // Balance and number of transactions might have changed
-        cachedNumBlocks = chainActive.Height();
+        cachedNumBlocks = m_node.getNumBlocks();
 
-        checkBalanceChanged();
+        checkBalanceChanged(new_balances);
         if (transactionTableModel) {
             transactionTableModel->updateConfirmations();
         }
     }
 }
 
-void WalletModel::checkBalanceChanged() {
-    Amount newBalance(getBalance());
-    Amount newUnconfirmedBalance(getUnconfirmedBalance());
-    Amount newImmatureBalance(getImmatureBalance());
-    Amount newWatchOnlyBalance = Amount::zero();
-    Amount newWatchUnconfBalance = Amount::zero();
-    Amount newWatchImmatureBalance = Amount::zero();
-    if (haveWatchOnly()) {
-        newWatchOnlyBalance = getWatchBalance();
-        newWatchUnconfBalance = getWatchUnconfirmedBalance();
-        newWatchImmatureBalance = getWatchImmatureBalance();
-    }
-
-    if (cachedBalance != newBalance ||
-        cachedUnconfirmedBalance != newUnconfirmedBalance ||
-        cachedImmatureBalance != newImmatureBalance ||
-        cachedWatchOnlyBalance != newWatchOnlyBalance ||
-        cachedWatchUnconfBalance != newWatchUnconfBalance ||
-        cachedWatchImmatureBalance != newWatchImmatureBalance) {
-        cachedBalance = newBalance;
-        cachedUnconfirmedBalance = newUnconfirmedBalance;
-        cachedImmatureBalance = newImmatureBalance;
-        cachedWatchOnlyBalance = newWatchOnlyBalance;
-        cachedWatchUnconfBalance = newWatchUnconfBalance;
-        cachedWatchImmatureBalance = newWatchImmatureBalance;
-        Q_EMIT balanceChanged(newBalance, newUnconfirmedBalance,
-                              newImmatureBalance, newWatchOnlyBalance,
-                              newWatchUnconfBalance, newWatchImmatureBalance);
+void WalletModel::checkBalanceChanged(
+    const interfaces::WalletBalances &new_balances) {
+    if (new_balances.balanceChanged(m_cached_balances)) {
+        m_cached_balances = new_balances;
+        Q_EMIT balanceChanged(
+            new_balances.balance, new_balances.unconfirmed_balance,
+            new_balances.immature_balance, new_balances.watch_only_balance,
+            new_balances.unconfirmed_watch_only_balance,
+            new_balances.immature_watch_only_balance);
     }
 }
 
@@ -174,8 +123,7 @@
 }
 
 bool WalletModel::validateAddress(const QString &address) {
-    return IsValidDestinationString(address.toStdString(),
-                                    GetConfig().GetChainParams());
+    return IsValidDestinationString(address.toStdString(), getChainParams());
 }
 
 WalletModel::SendCoinsReturn
@@ -234,8 +182,8 @@
             setAddress.insert(rcp.address);
             ++nAddresses;
 
-            CScript scriptPubKey = GetScriptForDestination(DecodeDestination(
-                rcp.address.toStdString(), wallet->chainParams));
+            CScript scriptPubKey = GetScriptForDestination(
+                DecodeDestination(rcp.address.toStdString(), getChainParams()));
             CRecipient recipient = {scriptPubKey, Amount(rcp.amount),
                                     rcp.fSubtractFeeFromAmount};
             vecSend.push_back(recipient);
@@ -247,47 +195,39 @@
         return DuplicateAddress;
     }
 
-    Amount nBalance = getBalance(&coinControl);
+    Amount nBalance = m_wallet->getAvailableBalance(coinControl);
 
     if (total > nBalance) {
         return AmountExceedsBalance;
     }
 
-    {
-        LOCK2(cs_main, wallet->cs_wallet);
-
-        transaction.newPossibleKeyChange(wallet);
-
-        Amount nFeeRequired = Amount::zero();
-        int nChangePosRet = -1;
-        std::string strFailReason;
-
-        CTransactionRef &newTx = transaction.getTransaction();
-        CReserveKey *keyChange = transaction.getPossibleKeyChange();
-        bool fCreated = wallet->CreateTransaction(vecSend, newTx, *keyChange,
-                                                  nFeeRequired, nChangePosRet,
-                                                  strFailReason, coinControl);
-        transaction.setTransactionFee(nFeeRequired);
-        if (fSubtractFeeFromAmount && fCreated) {
-            transaction.reassignAmounts(nChangePosRet);
-        }
+    Amount nFeeRequired = Amount::zero();
+    int nChangePosRet = -1;
+    std::string strFailReason;
+
+    auto &newTx = transaction.getWtx();
+    newTx =
+        m_wallet->createTransaction(vecSend, coinControl, true /* sign */,
+                                    nChangePosRet, nFeeRequired, strFailReason);
+    transaction.setTransactionFee(nFeeRequired);
+    if (fSubtractFeeFromAmount && newTx) {
+        transaction.reassignAmounts(nChangePosRet);
+    }
 
-        if (!fCreated) {
-            if (!fSubtractFeeFromAmount && (total + nFeeRequired) > nBalance) {
-                return SendCoinsReturn(AmountWithFeeExceedsBalance);
-            }
-            Q_EMIT message(tr("Send Coins"),
-                           QString::fromStdString(strFailReason),
-                           CClientUIInterface::MSG_ERROR);
-            return TransactionCreationFailed;
+    if (!newTx) {
+        if (!fSubtractFeeFromAmount && (total + nFeeRequired) > nBalance) {
+            return SendCoinsReturn(AmountWithFeeExceedsBalance);
         }
+        Q_EMIT message(tr("Send Coins"), QString::fromStdString(strFailReason),
+                       CClientUIInterface::MSG_ERROR);
+        return TransactionCreationFailed;
+    }
 
-        // reject absurdly high fee. (This can never happen because the wallet
-        // caps the fee at maxTxFee. This merely serves as a belt-and-suspenders
-        // check)
-        if (nFeeRequired > Amount(maxTxFee)) {
-            return AbsurdFee;
-        }
+    // reject absurdly high fee. (This can never happen because the
+    // wallet caps the fee at maxTxFee. This merely serves as a
+    // belt-and-suspenders check)
+    if (nFeeRequired > m_node.getMaxTxFee()) {
+        return AbsurdFee;
     }
 
     return SendCoinsReturn(OK);
@@ -298,45 +238,37 @@
     /* store serialized transaction */
     QByteArray transaction_array;
 
-    {
-        LOCK2(cs_main, wallet->cs_wallet);
-
-        std::vector<std::pair<std::string, std::string>> vOrderForm;
-        for (const SendCoinsRecipient &rcp : transaction.getRecipients()) {
-            if (rcp.paymentRequest.IsInitialized()) {
-                // Make sure any payment requests involved are still valid.
-                if (PaymentServer::verifyExpired(
-                        rcp.paymentRequest.getDetails())) {
-                    return PaymentRequestExpired;
-                }
-
-                // Store PaymentRequests in wtx.vOrderForm in wallet.
-                std::string value;
-                rcp.paymentRequest.SerializeToString(&value);
-                vOrderForm.emplace_back("PaymentRequest", std::move(value));
-            } else if (!rcp.message.isEmpty()) {
-                // Message from normal bitcoincash:URI
-                // (bitcoincash:123...?message=example)
-                vOrderForm.emplace_back("Message", rcp.message.toStdString());
+    std::vector<std::pair<std::string, std::string>> vOrderForm;
+    for (const SendCoinsRecipient &rcp : transaction.getRecipients()) {
+        if (rcp.paymentRequest.IsInitialized()) {
+            // Make sure any payment requests involved are still valid.
+            if (PaymentServer::verifyExpired(rcp.paymentRequest.getDetails())) {
+                return PaymentRequestExpired;
             }
-        }
 
-        CTransactionRef &newTx = transaction.getTransaction();
-        CReserveKey *keyChange = transaction.getPossibleKeyChange();
-        CValidationState state;
-        if (!wallet->CommitTransaction(
-                newTx, {} /* mapValue */, std::move(vOrderForm),
-                {} /* fromAccount */, *keyChange, g_connman.get(), state)) {
-            return SendCoinsReturn(
-                TransactionCommitFailed,
-                QString::fromStdString(state.GetRejectReason()));
+            // Store PaymentRequests in wtx.vOrderForm in wallet.
+            std::string value;
+            rcp.paymentRequest.SerializeToString(&value);
+            vOrderForm.emplace_back("PaymentRequest", std::move(value));
+        } else if (!rcp.message.isEmpty()) {
+            // Message from normal bitcoincash:URI
+            // (bitcoincash:123...?message=example)
+            vOrderForm.emplace_back("Message", rcp.message.toStdString());
         }
+    }
 
-        CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
-        ssTx << newTx;
-        transaction_array.append(&(ssTx[0]), ssTx.size());
+    auto &newTx = transaction.getWtx();
+    std::string rejectReason;
+    if (!newTx->commit({} /* mapValue */, std::move(vOrderForm),
+                       {} /* fromAccount */, rejectReason)) {
+        return SendCoinsReturn(TransactionCommitFailed,
+                               QString::fromStdString(rejectReason));
     }
 
+    CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
+    ssTx << newTx->get();
+    transaction_array.append(&(ssTx[0]), ssTx.size());
+
     // Add addresses / update labels that we've sent to to the address book, and
     // emit coinsSent signal for each recipient
     for (const SendCoinsRecipient &rcp : transaction.getRecipients()) {
@@ -344,29 +276,23 @@
         if (!rcp.paymentRequest.IsInitialized()) {
             std::string strAddress = rcp.address.toStdString();
             CTxDestination dest =
-                DecodeDestination(strAddress, wallet->chainParams);
+                DecodeDestination(strAddress, getChainParams());
             std::string strLabel = rcp.label.toStdString();
-            {
-                LOCK(wallet->cs_wallet);
-
-                std::map<CTxDestination, CAddressBookData>::iterator mi =
-                    wallet->mapAddressBook.find(dest);
-
-                // Check if we have a new address or an updated label
-                if (mi == wallet->mapAddressBook.end()) {
-                    wallet->SetAddressBook(dest, strLabel, "send");
-                } else if (mi->second.name != strLabel) {
-                    // "" means don't change purpose
-                    wallet->SetAddressBook(dest, strLabel, "");
-                }
+            // Check if we have a new address or an updated label
+            std::string name;
+            if (!m_wallet->getAddress(dest, &name)) {
+                m_wallet->setAddressBook(dest, strLabel, "send");
+            } else if (name != strLabel) {
+                // "" means don't change purpose
+                m_wallet->setAddressBook(dest, strLabel, "");
             }
         }
-        Q_EMIT coinsSent(wallet, rcp, transaction_array);
+        Q_EMIT coinsSent(cwallet, rcp, transaction_array);
     }
 
     // update balance immediately, otherwise there could be a short noticeable
     // delay until pollBalanceChanged hits
-    checkBalanceChanged();
+    checkBalanceChanged(m_wallet->getBalances());
 
     return SendCoinsReturn(OK);
 }
@@ -388,9 +314,9 @@
 }
 
 WalletModel::EncryptionStatus WalletModel::getEncryptionStatus() const {
-    if (!wallet->IsCrypted()) {
+    if (!m_wallet->isCrypted()) {
         return Unencrypted;
-    } else if (wallet->IsLocked()) {
+    } else if (m_wallet->isLocked()) {
         return Locked;
     } else {
         return Unlocked;
@@ -401,7 +327,7 @@
                                      const SecureString &passphrase) {
     if (encrypted) {
         // Encrypt
-        return wallet->EncryptWallet(passphrase);
+        return m_wallet->encryptWallet(passphrase);
     } else {
         // Decrypt -- TODO; not supported yet
         return false;
@@ -411,34 +337,28 @@
 bool WalletModel::setWalletLocked(bool locked, const SecureString &passPhrase) {
     if (locked) {
         // Lock
-        return wallet->Lock();
+        return m_wallet->lock();
     } else {
         // Unlock
-        return wallet->Unlock(passPhrase);
+        return m_wallet->unlock(passPhrase);
     }
 }
 
 bool WalletModel::changePassphrase(const SecureString &oldPass,
                                    const SecureString &newPass) {
-    LOCK(wallet->cs_wallet);
     // Make sure wallet is locked before attempting pass change
-    wallet->Lock();
-    return wallet->ChangeWalletPassphrase(oldPass, newPass);
-}
-
-bool WalletModel::backupWallet(const QString &filename) {
-    return wallet->BackupWallet(filename.toLocal8Bit().data());
+    m_wallet->lock();
+    return m_wallet->changeWalletPassphrase(oldPass, newPass);
 }
 
 // Handlers for core signals
-static void NotifyKeyStoreStatusChanged(WalletModel *walletmodel,
-                                        CCryptoKeyStore *wallet) {
+static void NotifyKeyStoreStatusChanged(WalletModel *walletmodel) {
     qDebug() << "NotifyKeyStoreStatusChanged";
     QMetaObject::invokeMethod(walletmodel, "updateStatus",
                               Qt::QueuedConnection);
 }
 
-static void NotifyAddressBookChanged(WalletModel *walletmodel, CWallet *wallet,
+static void NotifyAddressBookChanged(WalletModel *walletmodel,
                                      const CTxDestination &address,
                                      const std::string &label, bool isMine,
                                      const std::string &purpose,
@@ -457,9 +377,8 @@
                               Q_ARG(QString, strPurpose), Q_ARG(int, status));
 }
 
-static void NotifyTransactionChanged(WalletModel *walletmodel, CWallet *wallet,
-                                     const uint256 &hash, ChangeType status) {
-    Q_UNUSED(wallet);
+static void NotifyTransactionChanged(WalletModel *walletmodel, const TxId &hash,
+                                     ChangeType status) {
     Q_UNUSED(hash);
     Q_UNUSED(status);
     QMetaObject::invokeMethod(walletmodel, "updateTransaction",
@@ -483,28 +402,25 @@
 
 void WalletModel::subscribeToCoreSignals() {
     // Connect signals to wallet
-    wallet->NotifyStatusChanged.connect(
-        boost::bind(&NotifyKeyStoreStatusChanged, this, _1));
-    wallet->NotifyAddressBookChanged.connect(
-        boost::bind(NotifyAddressBookChanged, this, _1, _2, _3, _4, _5, _6));
-    wallet->NotifyTransactionChanged.connect(
-        boost::bind(NotifyTransactionChanged, this, _1, _2, _3));
-    wallet->ShowProgress.connect(boost::bind(ShowProgress, this, _1, _2));
-    wallet->NotifyWatchonlyChanged.connect(
+    m_handler_status_changed = m_wallet->handleStatusChanged(
+        boost::bind(&NotifyKeyStoreStatusChanged, this));
+    m_handler_address_book_changed = m_wallet->handleAddressBookChanged(
+        boost::bind(NotifyAddressBookChanged, this, _1, _2, _3, _4, _5));
+    m_handler_transaction_changed = m_wallet->handleTransactionChanged(
+        boost::bind(NotifyTransactionChanged, this, _1, _2));
+    m_handler_show_progress =
+        m_wallet->handleShowProgress(boost::bind(ShowProgress, this, _1, _2));
+    m_handler_watch_only_changed = m_wallet->handleWatchOnlyChanged(
         boost::bind(NotifyWatchonlyChanged, this, _1));
 }
 
 void WalletModel::unsubscribeFromCoreSignals() {
     // Disconnect signals from wallet
-    wallet->NotifyStatusChanged.disconnect(
-        boost::bind(&NotifyKeyStoreStatusChanged, this, _1));
-    wallet->NotifyAddressBookChanged.disconnect(
-        boost::bind(NotifyAddressBookChanged, this, _1, _2, _3, _4, _5, _6));
-    wallet->NotifyTransactionChanged.disconnect(
-        boost::bind(NotifyTransactionChanged, this, _1, _2, _3));
-    wallet->ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
-    wallet->NotifyWatchonlyChanged.disconnect(
-        boost::bind(NotifyWatchonlyChanged, this, _1));
+    m_handler_status_changed->disconnect();
+    m_handler_address_book_changed->disconnect();
+    m_handler_transaction_changed->disconnect();
+    m_handler_show_progress->disconnect();
+    m_handler_watch_only_changed->disconnect();
 }
 
 // WalletModel::UnlockContext implementation
@@ -537,26 +453,13 @@
     rhs.relock = false;
 }
 
-bool WalletModel::getPubKey(const CKeyID &address,
-                            CPubKey &vchPubKeyOut) const {
-    return wallet->GetPubKey(address, vchPubKeyOut);
-}
-
-bool WalletModel::IsSpendable(const CTxDestination &dest) const {
-    return IsMine(*wallet, dest) & ISMINE_SPENDABLE;
-}
-
-bool WalletModel::getPrivKey(const CKeyID &address, CKey &vchPrivKeyOut) const {
-    return wallet->GetKey(address, vchPrivKeyOut);
-}
-
 // returns a list of COutputs from COutPoints
 void WalletModel::getOutputs(const std::vector<COutPoint> &vOutpoints,
                              std::vector<COutput> &vOutputs) {
-    LOCK2(cs_main, wallet->cs_wallet);
+    LOCK2(cs_main, cwallet->cs_wallet);
     for (const COutPoint &outpoint : vOutpoints) {
-        auto it = wallet->mapWallet.find(outpoint.GetTxId());
-        if (it == wallet->mapWallet.end()) {
+        auto it = cwallet->mapWallet.find(outpoint.GetTxId());
+        if (it == cwallet->mapWallet.end()) {
             continue;
         }
         int nDepth = it->second.GetDepthInMainChain();
@@ -570,15 +473,15 @@
 }
 
 bool WalletModel::isSpent(const COutPoint &outpoint) const {
-    LOCK2(cs_main, wallet->cs_wallet);
-    return wallet->IsSpent(outpoint.GetTxId(), outpoint.GetN());
+    LOCK2(cs_main, cwallet->cs_wallet);
+    return cwallet->IsSpent(outpoint.GetTxId(), outpoint.GetN());
 }
 
 // AvailableCoins + LockedCoins grouped by wallet address (put change in one
 // group with wallet address)
 void WalletModel::listCoins(
     std::map<QString, std::vector<COutput>> &mapCoins) const {
-    for (auto &group : wallet->ListCoins()) {
+    for (auto &group : cwallet->ListCoins()) {
         auto &resultGroup =
             mapCoins[QString::fromStdString(EncodeDestination(group.first))];
         for (auto &coin : group.second) {
@@ -587,73 +490,38 @@
     }
 }
 
-bool WalletModel::isLockedCoin(const TxId &txid, uint32_t n) const {
-    LOCK2(cs_main, wallet->cs_wallet);
-    return wallet->IsLockedCoin(txid, n);
-}
-
-void WalletModel::lockCoin(COutPoint &output) {
-    LOCK2(cs_main, wallet->cs_wallet);
-    wallet->LockCoin(output);
-}
-
-void WalletModel::unlockCoin(COutPoint &output) {
-    LOCK2(cs_main, wallet->cs_wallet);
-    wallet->UnlockCoin(output);
-}
-
-void WalletModel::listLockedCoins(std::vector<COutPoint> &vOutpts) {
-    LOCK2(cs_main, wallet->cs_wallet);
-    wallet->ListLockedCoins(vOutpts);
-}
-
 void WalletModel::loadReceiveRequests(
     std::vector<std::string> &vReceiveRequests) {
     // receive request
-    vReceiveRequests = wallet->GetDestValues("rr");
+    vReceiveRequests = m_wallet->getDestValues("rr");
 }
 
 bool WalletModel::saveReceiveRequest(const std::string &sAddress,
                                      const int64_t nId,
                                      const std::string &sRequest) {
-    CTxDestination dest = DecodeDestination(sAddress, wallet->chainParams);
+    CTxDestination dest = DecodeDestination(sAddress, getChainParams());
 
     std::stringstream ss;
     ss << nId;
     // "rr" prefix = "receive request" in destdata
     std::string key = "rr" + ss.str();
 
-    LOCK(wallet->cs_wallet);
-    return sRequest.empty() ? wallet->EraseDestData(dest, key)
-                            : wallet->AddDestData(dest, key, sRequest);
-}
-
-bool WalletModel::transactionCanBeAbandoned(const TxId &txid) const {
-    return wallet->TransactionCanBeAbandoned(txid);
-}
-
-bool WalletModel::abandonTransaction(const TxId &txid) const {
-    LOCK2(cs_main, wallet->cs_wallet);
-    return wallet->AbandonTransaction(txid);
+    return sRequest.empty() ? m_wallet->eraseDestData(dest, key)
+                            : m_wallet->addDestData(dest, key, sRequest);
 }
 
 bool WalletModel::isWalletEnabled() {
     return !gArgs.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET);
 }
 
-bool WalletModel::hdEnabled() const {
-    return wallet->IsHDEnabled();
-}
-
 QString WalletModel::getWalletName() const {
-    LOCK(wallet->cs_wallet);
-    return QString::fromStdString(wallet->GetName());
+    return QString::fromStdString(m_wallet->getWalletName());
 }
 
 bool WalletModel::isMultiwallet() {
-    return gArgs.GetArgs("-wallet").size() > 1;
+    return m_node.getWallets().size() > 1;
 }
 
 const CChainParams &WalletModel::getChainParams() const {
-    return wallet->chainParams;
+    return GetConfig().GetChainParams();
 }
diff --git a/src/qt/walletmodeltransaction.h b/src/qt/walletmodeltransaction.h
--- a/src/qt/walletmodeltransaction.h
+++ b/src/qt/walletmodeltransaction.h
@@ -5,15 +5,16 @@
 #ifndef BITCOIN_QT_WALLETMODELTRANSACTION_H
 #define BITCOIN_QT_WALLETMODELTRANSACTION_H
 
-#include "walletmodel.h"
+#include <qt/walletmodel.h>
 
 #include <QObject>
 
 class SendCoinsRecipient;
 
-class CReserveKey;
-class CWallet;
-class CWalletTx;
+namespace interfaces {
+class Node;
+class PendingWalletTx;
+}
 
 /** Data model for a walletmodel transaction. */
 class WalletModelTransaction {
@@ -23,7 +24,7 @@
 
     QList<SendCoinsRecipient> getRecipients() const;
 
-    CTransactionRef &getTransaction();
+    std::unique_ptr<interfaces::PendingWalletTx> &getWtx();
     unsigned int getTransactionSize();
 
     void setTransactionFee(const Amount newFee);
@@ -31,16 +32,12 @@
 
     Amount getTotalTransactionAmount() const;
 
-    void newPossibleKeyChange(CWallet *wallet);
-    CReserveKey *getPossibleKeyChange();
-
     // needed for the subtract-fee-from-amount feature
     void reassignAmounts(int nChangePosRet);
 
 private:
     QList<SendCoinsRecipient> recipients;
-    CTransactionRef walletTransaction;
-    std::unique_ptr<CReserveKey> keyChange;
+    std::unique_ptr<interfaces::PendingWalletTx> wtx;
     Amount fee;
 };
 
diff --git a/src/qt/walletmodeltransaction.cpp b/src/qt/walletmodeltransaction.cpp
--- a/src/qt/walletmodeltransaction.cpp
+++ b/src/qt/walletmodeltransaction.cpp
@@ -2,26 +2,25 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "walletmodeltransaction.h"
+#include <qt/walletmodeltransaction.h>
 
-#include "policy/policy.h"
-#include "wallet/wallet.h"
+#include <interfaces/node.h>
+#include <policy/policy.h>
 
 WalletModelTransaction::WalletModelTransaction(
     const QList<SendCoinsRecipient> &_recipients)
-    : recipients(_recipients), walletTransaction(0), fee() {}
+    : recipients(_recipients), fee() {}
 
 QList<SendCoinsRecipient> WalletModelTransaction::getRecipients() const {
     return recipients;
 }
 
-CTransactionRef &WalletModelTransaction::getTransaction() {
-    return walletTransaction;
+std::unique_ptr<interfaces::PendingWalletTx> &WalletModelTransaction::getWtx() {
+    return wtx;
 }
 
 unsigned int WalletModelTransaction::getTransactionSize() {
-    return !walletTransaction ? 0
-                              : CTransaction(*walletTransaction).GetTotalSize();
+    return wtx ? wtx->get().GetTotalSize() : 0;
 }
 
 Amount WalletModelTransaction::getTransactionFee() const {
@@ -33,6 +32,7 @@
 }
 
 void WalletModelTransaction::reassignAmounts(int nChangePosRet) {
+    const CTransaction *walletTransaction = &wtx->get();
     int i = 0;
     for (SendCoinsRecipient &rcp : recipients) {
         if (rcp.paymentRequest.IsInitialized()) {
@@ -72,11 +72,3 @@
     }
     return totalTransactionAmount;
 }
-
-void WalletModelTransaction::newPossibleKeyChange(CWallet *wallet) {
-    keyChange.reset(new CReserveKey(wallet));
-}
-
-CReserveKey *WalletModelTransaction::getPossibleKeyChange() {
-    return keyChange.get();
-}
diff --git a/src/qt/walletview.cpp b/src/qt/walletview.cpp
--- a/src/qt/walletview.cpp
+++ b/src/qt/walletview.cpp
@@ -294,7 +294,7 @@
         return;
     }
 
-    if (!walletModel->backupWallet(filename)) {
+    if (!walletModel->wallet().backupWallet(filename.toLocal8Bit().data())) {
         Q_EMIT message(
             tr("Backup Failed"),
             tr("There was an error trying to save the wallet data to %1.")