diff --git a/src/interfaces/node.h b/src/interfaces/node.h
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -23,6 +23,7 @@
 class CFeeRate;
 struct CNodeStateStats;
 struct CNodeStats;
+class Coin;
 class Config;
 class HTTPRPCRequestProcessor;
 class proxyType;
@@ -181,6 +182,9 @@
     //! Unset RPC timer interface.
     virtual void rpcUnsetTimerInterface(RPCTimerInterface *iface) = 0;
 
+    //! Get unspent outputs associated with a transaction.
+    virtual bool getUnspentOutput(const COutPoint &output, Coin &coin) = 0;
+
     //! Return interfaces for accessing wallets (if any).
     virtual std::vector<std::unique_ptr<Wallet>> getWallets() = 0;
 
diff --git a/src/interfaces/node.cpp b/src/interfaces/node.cpp
--- a/src/interfaces/node.cpp
+++ b/src/interfaces/node.cpp
@@ -240,6 +240,10 @@
         void rpcUnsetTimerInterface(RPCTimerInterface *iface) override {
             RPCUnsetTimerInterface(iface);
         }
+        bool getUnspentOutput(const COutPoint &output, Coin &coin) override {
+            LOCK(::cs_main);
+            return ::pcoinsTip->GetCoin(output, coin);
+        }
         std::vector<std::unique_ptr<Wallet>> getWallets() override {
 #ifdef ENABLE_WALLET
             std::vector<std::unique_ptr<Wallet>> wallets;
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -39,7 +39,9 @@
 class PendingWalletTx;
 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>;
@@ -150,6 +152,27 @@
     //! 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 &adjusted_time) = 0;
+
+    //! Get transaction details.
+    virtual WalletTx getWalletTxDetails(const TxId &txid,
+                                        WalletTxStatus &tx_status,
+                                        WalletOrderForm &order_form,
+                                        bool &in_mempool, int &num_blocks,
+                                        int64_t &adjusted_time) = 0;
+
     //! Get balances.
     virtual WalletBalances getBalances() = 0;
 
@@ -162,6 +185,18 @@
     //! 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,
@@ -253,6 +288,36 @@
     }
 };
 
+// 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;
+    int request_count;
+    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;
diff --git a/src/interfaces/wallet.cpp b/src/interfaces/wallet.cpp
--- a/src/interfaces/wallet.cpp
+++ b/src/interfaces/wallet.cpp
@@ -15,8 +15,10 @@
 #include <script/standard.h>
 #include <support/allocators/secure.h>
 #include <sync.h>
+#include <timedata.h>
 #include <ui_interface.h>
 #include <validation.h>
+#include <wallet/finaltx.h>
 #include <wallet/wallet.h>
 
 #include <memory>
@@ -50,6 +52,54 @@
         CReserveKey m_key;
     };
 
+    //! 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())
+                    ? IsMine(wallet, 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(const CWalletTx &wtx) {
+        WalletTxStatus result;
+        CBlockIndex *block = LookupBlockIndex(wtx.hashBlock);
+        result.block_height =
+            (block ? block->nHeight : std::numeric_limits<int>::max()),
+        result.blocks_to_maturity = wtx.GetBlocksToMaturity();
+        result.depth_in_main_chain = wtx.GetDepthInMainChain();
+        result.request_count = wtx.GetRequestCount();
+        result.time_received = wtx.nTimeReceived;
+        result.lock_time = wtx.tx->nLockTime;
+        result.is_final = CheckFinalTx(*wtx.tx);
+        result.is_trusted = wtx.IsTrusted();
+        result.is_abandoned = wtx.isAbandoned();
+        result.is_coinbase = wtx.IsCoinBase();
+        result.is_in_main_chain = wtx.IsInMainChain();
+        return result;
+    }
+
     //! Construct wallet TxOut struct.
     WalletTxOut MakeWalletTxOut(CWallet &wallet, const CWalletTx &wtx, int n,
                                 int depth) {
@@ -186,6 +236,67 @@
             LOCK2(cs_main, m_wallet.cs_wallet);
             return m_wallet.AbandonTransaction(txid);
         }
+        CTransactionRef getTx(const TxId &txid) override {
+            LOCK2(::cs_main, 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 {
+            LOCK2(::cs_main, 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 {
+            LOCK2(::cs_main, 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 &adjusted_time) 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;
+            }
+            auto mi = m_wallet.mapWallet.find(txid);
+            if (mi == m_wallet.mapWallet.end()) {
+                return false;
+            }
+            num_blocks = ::chainActive.Height();
+            adjusted_time = GetAdjustedTime();
+            tx_status = MakeWalletTxStatus(mi->second);
+            return true;
+        }
+        WalletTx getWalletTxDetails(const TxId &txid, WalletTxStatus &tx_status,
+                                    WalletOrderForm &order_form,
+                                    bool &in_mempool, int &num_blocks,
+                                    int64_t &adjusted_time) override {
+            LOCK2(::cs_main, m_wallet.cs_wallet);
+            auto mi = m_wallet.mapWallet.find(txid);
+            if (mi != m_wallet.mapWallet.end()) {
+                num_blocks = ::chainActive.Height();
+                adjusted_time = GetAdjustedTime();
+                in_mempool = mi->second.InMempool();
+                order_form = mi->second.vOrderForm;
+                tx_status = MakeWalletTxStatus(mi->second);
+                return MakeWalletTx(m_wallet, mi->second);
+            }
+            return {};
+        }
         WalletBalances getBalances() override {
             WalletBalances result;
             result.balance = m_wallet.GetBalance();
@@ -219,6 +330,22 @@
         Amount getAvailableBalance(const CCoinControl &coin_control) override {
             return m_wallet.GetAvailableBalance(&coin_control);
         }
+        isminetype txinIsMine(const CTxIn &txin) override {
+            LOCK2(::cs_main, m_wallet.cs_wallet);
+            return m_wallet.IsMine(txin);
+        }
+        isminetype txoutIsMine(const CTxOut &txout) override {
+            LOCK2(::cs_main, m_wallet.cs_wallet);
+            return m_wallet.IsMine(txout);
+        }
+        Amount getDebit(const CTxIn &txin, isminefilter filter) override {
+            LOCK2(::cs_main, m_wallet.cs_wallet);
+            return m_wallet.GetDebit(txin, filter);
+        }
+        Amount getCredit(const CTxOut &txout, isminefilter filter) override {
+            LOCK2(::cs_main, m_wallet.cs_wallet);
+            return m_wallet.GetCredit(txout, filter);
+        }
         CoinsList listCoins() override {
             LOCK2(::cs_main, m_wallet.cs_wallet);
             CoinsList result;
diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp
--- a/src/qt/bitcoin.cpp
+++ b/src/qt/bitcoin.cpp
@@ -3,46 +3,39 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
-#include "config/bitcoin-config.h"
+#include <config/bitcoin-config.h>
 #endif
 
-#include "bitcoingui.h"
-
-#include "chainparams.h"
-#include "clientmodel.h"
-#include "config.h"
-#include "guiconstants.h"
-#include "guiutil.h"
-#include "httprpc.h"
-#include "intro.h"
-#include "networkstyle.h"
-#include "optionsmodel.h"
-#include "platformstyle.h"
-#include "splashscreen.h"
-#include "utilitydialog.h"
-#include "winshutdownmonitor.h"
+#include <qt/bitcoingui.h>
+
+#include <chainparams.h>
+#include <config.h>
+#include <httprpc.h>
+#include <init.h>
+#include <interfaces/handler.h>
+#include <interfaces/node.h>
+#include <qt/clientmodel.h>
+#include <qt/guiconstants.h>
+#include <qt/guiutil.h>
+#include <qt/intro.h>
+#include <qt/networkstyle.h>
+#include <qt/optionsmodel.h>
+#include <qt/platformstyle.h>
+#include <qt/splashscreen.h>
+#include <qt/utilitydialog.h>
+#include <qt/winshutdownmonitor.h>
+#include <rpc/server.h>
+#include <ui_interface.h>
+#include <uint256.h>
+#include <util.h>
+#include <walletinitinterface.h>
+#include <warnings.h>
 
 #ifdef ENABLE_WALLET
-#include "paymentserver.h"
-#include "walletmodel.h"
+#include <qt/paymentserver.h>
+#include <qt/walletmodel.h>
 #endif
 
-#include "init.h"
-#include "interfaces/handler.h"
-#include "interfaces/node.h"
-#include "rpc/server.h"
-#include "ui_interface.h"
-#include "uint256.h"
-#include "util.h"
-#include "warnings.h"
-
-#ifdef ENABLE_WALLET
-#include "wallet/wallet.h"
-#endif
-#include "walletinitinterface.h"
-
-#include <cstdint>
-
 #include <boost/filesystem/operations.hpp>
 #include <boost/thread.hpp>
 
@@ -71,6 +64,8 @@
 #endif
 #endif
 
+#include <cstdint>
+
 // Declare meta types used for QMetaObject::invokeMethod
 Q_DECLARE_METATYPE(bool *)
 Q_DECLARE_METATYPE(Amount)
@@ -475,10 +470,9 @@
 #ifdef ENABLE_WALLET
     bool fFirstWallet = true;
     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);
+            std::move(wallet), m_node, platformStyle, optionsModel);
 
         window->addWallet(walletModel);
         if (fFirstWallet) {
diff --git a/src/qt/recentrequeststablemodel.h b/src/qt/recentrequeststablemodel.h
--- a/src/qt/recentrequeststablemodel.h
+++ b/src/qt/recentrequeststablemodel.h
@@ -5,14 +5,12 @@
 #ifndef BITCOIN_QT_RECENTREQUESTSTABLEMODEL_H
 #define BITCOIN_QT_RECENTREQUESTSTABLEMODEL_H
 
-#include "walletmodel.h"
+#include <qt/walletmodel.h>
 
 #include <QAbstractTableModel>
 #include <QDateTime>
 #include <QStringList>
 
-class CWallet;
-
 class RecentRequestEntry {
 public:
     RecentRequestEntry()
@@ -58,7 +56,7 @@
     Q_OBJECT
 
 public:
-    explicit RecentRequestsTableModel(CWallet *wallet, WalletModel *parent);
+    explicit RecentRequestsTableModel(WalletModel *parent);
     ~RecentRequestsTableModel();
 
     enum ColumnIndex {
diff --git a/src/qt/recentrequeststablemodel.cpp b/src/qt/recentrequeststablemodel.cpp
--- a/src/qt/recentrequeststablemodel.cpp
+++ b/src/qt/recentrequeststablemodel.cpp
@@ -2,19 +2,17 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "recentrequeststablemodel.h"
+#include <qt/recentrequeststablemodel.h>
 
-#include "bitcoinunits.h"
-#include "guiutil.h"
-#include "optionsmodel.h"
+#include <qt/bitcoinunits.h>
+#include <qt/guiutil.h>
+#include <qt/optionsmodel.h>
 
-#include "clientversion.h"
-#include "streams.h"
+#include <clientversion.h>
+#include <streams.h>
 
-RecentRequestsTableModel::RecentRequestsTableModel(CWallet *wallet,
-                                                   WalletModel *parent)
+RecentRequestsTableModel::RecentRequestsTableModel(WalletModel *parent)
     : QAbstractTableModel(parent), walletModel(parent) {
-    Q_UNUSED(wallet);
     nReceiveRequestsMaxId = 0;
 
     // Load entries from wallet
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
@@ -144,7 +144,7 @@
     OptionsModel optionsModel(*node);
     vpwallets.insert(vpwallets.begin(), &wallet);
     WalletModel walletModel(std::move(node->getWallets()[0]), *node,
-                            platformStyle.get(), &wallet, &optionsModel);
+                            platformStyle.get(), &optionsModel);
     vpwallets.erase(vpwallets.begin());
     sendCoinsDialog.setModel(&walletModel);
 
diff --git a/src/qt/transactiondesc.h b/src/qt/transactiondesc.h
--- a/src/qt/transactiondesc.h
+++ b/src/qt/transactiondesc.h
@@ -10,8 +10,12 @@
 
 class TransactionRecord;
 
-class CWallet;
-class CWalletTx;
+namespace interfaces {
+class Node;
+class Wallet;
+struct WalletTx;
+struct WalletTxStatus;
+}
 
 /**
  * Provide a human-readable extended HTML description of a transaction.
@@ -20,13 +24,16 @@
     Q_OBJECT
 
 public:
-    static QString toHTML(CWallet *wallet, CWalletTx &wtx,
+    static QString toHTML(interfaces::Node &node, interfaces::Wallet &wallet,
                           TransactionRecord *rec, int unit);
 
 private:
     TransactionDesc() {}
 
-    static QString FormatTxStatus(const CWalletTx &wtx);
+    static QString FormatTxStatus(const interfaces::WalletTx &wtx,
+                                  const interfaces::WalletTxStatus &status,
+                                  bool inMempool, int numBlocks,
+                                  int64_t adjustedTime);
 };
 
 #endif // BITCOIN_QT_TRANSACTIONDESC_H
diff --git a/src/qt/transactiondesc.cpp b/src/qt/transactiondesc.cpp
--- a/src/qt/transactiondesc.cpp
+++ b/src/qt/transactiondesc.cpp
@@ -2,50 +2,51 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "transactiondesc.h"
-
-#include "bitcoinunits.h"
-#include "guiutil.h"
-#include "paymentserver.h"
-#include "transactionrecord.h"
-
-#include "chain.h"
-#include "consensus/consensus.h"
-#include "dstencode.h"
-#include "script/script.h"
-#include "timedata.h"
-#include "util.h"
-#include "validation.h"
-#include "wallet/db.h"
-#include "wallet/finaltx.h"
-#include "wallet/wallet.h"
+#include <qt/transactiondesc.h>
+
+#include <chain.h>
+#include <consensus/consensus.h>
+#include <dstencode.h>
+#include <interfaces/node.h>
+#include <qt/bitcoinunits.h>
+#include <qt/guiutil.h>
+#include <qt/paymentserver.h>
+#include <qt/transactionrecord.h>
+#include <script/script.h>
+#include <timedata.h>
+#include <util.h>
+#include <validation.h>
+#include <wallet/db.h>
+#include <wallet/finaltx.h>
+#include <wallet/wallet.h>
 
 #include <cstdint>
 #include <string>
 
-QString TransactionDesc::FormatTxStatus(const CWalletTx &wtx) {
-    AssertLockHeld(cs_main);
-    if (!CheckFinalTx(*wtx.tx)) {
+QString TransactionDesc::FormatTxStatus(
+    const interfaces::WalletTx &wtx, const interfaces::WalletTxStatus &status,
+    bool inMempool, int numBlocks, int64_t adjustedTime) {
+    if (!status.is_final) {
         if (wtx.tx->nLockTime < LOCKTIME_THRESHOLD) {
             return tr("Open for %n more block(s)", "",
-                      wtx.tx->nLockTime - chainActive.Height());
+                      wtx.tx->nLockTime - numBlocks);
         } else {
             return tr("Open until %1")
                 .arg(GUIUtil::dateTimeStr(wtx.tx->nLockTime));
         }
     } else {
-        int nDepth = wtx.GetDepthInMainChain();
+        int nDepth = status.depth_in_main_chain;
         if (nDepth < 0) {
             return tr("conflicted with a transaction with %1 confirmations")
                 .arg(-nDepth);
-        } else if (GetAdjustedTime() - wtx.nTimeReceived > 2 * 60 &&
-                   wtx.GetRequestCount() == 0) {
+        } else if (adjustedTime - status.time_received > 2 * 60 &&
+                   status.request_count == 0) {
             return tr("%1/offline").arg(nDepth);
         } else if (nDepth == 0) {
             return tr("0/unconfirmed, %1")
-                       .arg((wtx.InMempool() ? tr("in memory pool")
-                                             : tr("not in memory pool"))) +
-                   (wtx.isAbandoned() ? ", " + tr("abandoned") : "");
+                       .arg((inMempool ? tr("in memory pool")
+                                       : tr("not in memory pool"))) +
+                   (status.is_abandoned ? ", " + tr("abandoned") : "");
         } else if (nDepth < 6) {
             return tr("%1/unconfirmed").arg(nDepth);
         } else {
@@ -54,21 +55,30 @@
     }
 }
 
-QString TransactionDesc::toHTML(CWallet *wallet, CWalletTx &wtx,
+QString TransactionDesc::toHTML(interfaces::Node &node,
+                                interfaces::Wallet &wallet,
                                 TransactionRecord *rec, int unit) {
+    int numBlocks;
+    int64_t adjustedTime;
+    interfaces::WalletTxStatus status;
+    interfaces::WalletOrderForm orderForm;
+    bool inMempool;
+    interfaces::WalletTx wtx = wallet.getWalletTxDetails(
+        rec->txid, status, orderForm, inMempool, numBlocks, adjustedTime);
+
     QString strHTML;
 
-    LOCK2(cs_main, wallet->cs_wallet);
     strHTML.reserve(4000);
     strHTML += "<html><font face='verdana, arial, helvetica, sans-serif'>";
 
-    int64_t nTime = wtx.GetTxTime();
-    Amount nCredit = wtx.GetCredit(ISMINE_ALL);
-    Amount nDebit = wtx.GetDebit(ISMINE_ALL);
+    int64_t nTime = wtx.time;
+    Amount nCredit = wtx.credit;
+    Amount nDebit = wtx.debit;
     Amount nNet = nCredit - nDebit;
 
-    strHTML += "<b>" + tr("Status") + ":</b> " + FormatTxStatus(wtx);
-    int nRequests = wtx.GetRequestCount();
+    strHTML += "<b>" + tr("Status") + ":</b> " +
+               FormatTxStatus(wtx, status, inMempool, numBlocks, adjustedTime);
+    int nRequests = status.request_count;
     if (nRequests != -1) {
         if (nRequests == 0) {
             strHTML += tr(", has not been successfully broadcast yet");
@@ -84,34 +94,32 @@
     //
     // From
     //
-    if (wtx.IsCoinBase()) {
+    if (wtx.is_coinbase) {
         strHTML += "<b>" + tr("Source") + ":</b> " + tr("Generated") + "<br>";
-    } else if (wtx.mapValue.count("from") && !wtx.mapValue["from"].empty()) {
+    } else if (wtx.value_map.count("from") && !wtx.value_map["from"].empty()) {
         // Online transaction
         strHTML += "<b>" + tr("From") + ":</b> " +
-                   GUIUtil::HtmlEscape(wtx.mapValue["from"]) + "<br>";
+                   GUIUtil::HtmlEscape(wtx.value_map["from"]) + "<br>";
     } else {
         // Offline transaction
         if (nNet > Amount::zero()) {
             // Credit
             CTxDestination address =
-                DecodeDestination(rec->address, wallet->chainParams);
+                DecodeDestination(rec->address, wallet.getChainParams());
             if (IsValidDestination(address)) {
-                if (wallet->mapAddressBook.count(address)) {
+                std::string name;
+                isminetype ismine;
+                if (wallet.getAddress(address, &name, &ismine)) {
                     strHTML +=
                         "<b>" + tr("From") + ":</b> " + tr("unknown") + "<br>";
                     strHTML += "<b>" + tr("To") + ":</b> ";
                     strHTML += GUIUtil::HtmlEscape(rec->address);
-                    QString addressOwned =
-                        (::IsMine(*wallet, address) == ISMINE_SPENDABLE)
-                            ? tr("own address")
-                            : tr("watch-only");
-                    if (!wallet->mapAddressBook[address].name.empty()) {
+                    QString addressOwned = ismine == ISMINE_SPENDABLE
+                                               ? tr("own address")
+                                               : tr("watch-only");
+                    if (!name.empty()) {
                         strHTML += " (" + addressOwned + ", " + tr("label") +
-                                   ": " +
-                                   GUIUtil::HtmlEscape(
-                                       wallet->mapAddressBook[address].name) +
-                                   ")";
+                                   ": " + GUIUtil::HtmlEscape(name) + ")";
                     } else {
                         strHTML += " (" + addressOwned + ")";
                     }
@@ -124,16 +132,15 @@
     //
     // To
     //
-    if (wtx.mapValue.count("to") && !wtx.mapValue["to"].empty()) {
+    if (wtx.value_map.count("to") && !wtx.value_map["to"].empty()) {
         // Online transaction
-        std::string strAddress = wtx.mapValue["to"];
+        std::string strAddress = wtx.value_map["to"];
         strHTML += "<b>" + tr("To") + ":</b> ";
         CTxDestination dest =
-            DecodeDestination(strAddress, wallet->chainParams);
-        if (wallet->mapAddressBook.count(dest) &&
-            !wallet->mapAddressBook[dest].name.empty()) {
-            strHTML +=
-                GUIUtil::HtmlEscape(wallet->mapAddressBook[dest].name) + " ";
+            DecodeDestination(strAddress, wallet.getChainParams());
+        std::string name;
+        if (wallet.getAddress(dest, &name) && !name.empty()) {
+            strHTML += GUIUtil::HtmlEscape(name) + " ";
         }
         strHTML += GUIUtil::HtmlEscape(strAddress) + "<br>";
     }
@@ -141,20 +148,20 @@
     //
     // Amount
     //
-    if (wtx.IsCoinBase() && nCredit == Amount::zero()) {
+    if (wtx.is_coinbase && nCredit == Amount::zero()) {
         //
         // Coinbase
         //
         Amount nUnmatured = Amount::zero();
         for (const CTxOut &txout : wtx.tx->vout) {
-            nUnmatured += wallet->GetCredit(txout, ISMINE_ALL);
+            nUnmatured += wallet.getCredit(txout, ISMINE_ALL);
         }
         strHTML += "<b>" + tr("Credit") + ":</b> ";
-        if (wtx.IsInMainChain()) {
+        if (status.is_in_main_chain) {
             strHTML += BitcoinUnits::formatHtmlWithUnit(unit, nUnmatured) +
                        " (" +
                        tr("matures in %n more block(s)", "",
-                          wtx.GetBlocksToMaturity()) +
+                          status.blocks_to_maturity) +
                        ")";
         } else {
             strHTML += "(" + tr("not accepted") + ")";
@@ -168,16 +175,14 @@
                    BitcoinUnits::formatHtmlWithUnit(unit, nNet) + "<br>";
     } else {
         isminetype fAllFromMe = ISMINE_SPENDABLE;
-        for (const CTxIn &txin : wtx.tx->vin) {
-            isminetype mine = wallet->IsMine(txin);
+        for (isminetype mine : wtx.txin_is_mine) {
             if (fAllFromMe > mine) {
                 fAllFromMe = mine;
             }
         }
 
         isminetype fAllToMe = ISMINE_SPENDABLE;
-        for (const CTxOut &txout : wtx.tx->vout) {
-            isminetype mine = wallet->IsMine(txout);
+        for (isminetype mine : wtx.txout_is_mine) {
             if (fAllToMe > mine) {
                 fAllToMe = mine;
             }
@@ -192,25 +197,24 @@
             //
             // Debit
             //
+            auto mine = wtx.txout_is_mine.begin();
             for (const CTxOut &txout : wtx.tx->vout) {
                 // Ignore change
-                isminetype toSelf = wallet->IsMine(txout);
+                isminetype toSelf = *(mine++);
                 if ((toSelf == ISMINE_SPENDABLE) &&
                     (fAllFromMe == ISMINE_SPENDABLE)) {
                     continue;
                 }
 
-                if (!wtx.mapValue.count("to") || wtx.mapValue["to"].empty()) {
+                if (!wtx.value_map.count("to") || wtx.value_map["to"].empty()) {
                     // Offline transaction
                     CTxDestination address;
                     if (ExtractDestination(txout.scriptPubKey, address)) {
                         strHTML += "<b>" + tr("To") + ":</b> ";
-                        if (wallet->mapAddressBook.count(address) &&
-                            !wallet->mapAddressBook[address].name.empty()) {
-                            strHTML +=
-                                GUIUtil::HtmlEscape(
-                                    wallet->mapAddressBook[address].name) +
-                                " ";
+                        std::string name;
+                        if (wallet.getAddress(address, &name) &&
+                            !name.empty()) {
+                            strHTML += GUIUtil::HtmlEscape(name) + " ";
                         }
                         strHTML +=
                             GUIUtil::HtmlEscape(EncodeDestination(address));
@@ -237,7 +241,7 @@
 
             if (fAllToMe) {
                 // Payment to self
-                Amount nChange = wtx.GetChange();
+                Amount nChange = wtx.change;
                 Amount nValue = nCredit - nChange;
                 strHTML += "<b>" + tr("Total debit") + ":</b> " +
                            BitcoinUnits::formatHtmlWithUnit(unit, -1 * nValue) +
@@ -256,20 +260,21 @@
             //
             // Mixed debit transaction
             //
+            auto mine = wtx.txin_is_mine.begin();
             for (const CTxIn &txin : wtx.tx->vin) {
-                if (wallet->IsMine(txin)) {
-                    strHTML +=
-                        "<b>" + tr("Debit") + ":</b> " +
-                        BitcoinUnits::formatHtmlWithUnit(
-                            unit, -1 * wallet->GetDebit(txin, ISMINE_ALL)) +
-                        "<br>";
+                if (*(mine++)) {
+                    strHTML += "<b>" + tr("Debit") + ":</b> " +
+                               BitcoinUnits::formatHtmlWithUnit(
+                                   unit, -wallet.getDebit(txin, ISMINE_ALL)) +
+                               "<br>";
                 }
             }
+            mine = wtx.txout_is_mine.begin();
             for (const CTxOut &txout : wtx.tx->vout) {
-                if (wallet->IsMine(txout)) {
+                if (*(mine++)) {
                     strHTML += "<b>" + tr("Credit") + ":</b> " +
                                BitcoinUnits::formatHtmlWithUnit(
-                                   unit, wallet->GetCredit(txout, ISMINE_ALL)) +
+                                   unit, wallet.getCredit(txout, ISMINE_ALL)) +
                                "<br>";
                 }
             }
@@ -282,13 +287,13 @@
     //
     // Message
     //
-    if (wtx.mapValue.count("message") && !wtx.mapValue["message"].empty()) {
+    if (wtx.value_map.count("message") && !wtx.value_map["message"].empty()) {
         strHTML += "<br><b>" + tr("Message") + ":</b><br>" +
-                   GUIUtil::HtmlEscape(wtx.mapValue["message"], true) + "<br>";
+                   GUIUtil::HtmlEscape(wtx.value_map["message"], true) + "<br>";
     }
-    if (wtx.mapValue.count("comment") && !wtx.mapValue["comment"].empty()) {
+    if (wtx.value_map.count("comment") && !wtx.value_map["comment"].empty()) {
         strHTML += "<br><b>" + tr("Comment") + ":</b><br>" +
-                   GUIUtil::HtmlEscape(wtx.mapValue["comment"], true) + "<br>";
+                   GUIUtil::HtmlEscape(wtx.value_map["comment"], true) + "<br>";
     }
 
     strHTML +=
@@ -299,7 +304,7 @@
                QString::number(rec->getOutputIndex()) + "<br>";
 
     // Message from normal bitcoincash:URI (bitcoincash:123...?message=example)
-    for (const std::pair<std::string, std::string> &r : wtx.vOrderForm) {
+    for (const std::pair<std::string, std::string> &r : orderForm) {
         if (r.first == "Message") {
             strHTML += "<br><b>" + tr("Message") + ":</b><br>" +
                        GUIUtil::HtmlEscape(r.second, true) + "<br>";
@@ -309,7 +314,7 @@
     //
     // PaymentRequest info:
     //
-    for (const std::pair<std::string, std::string> &r : wtx.vOrderForm) {
+    for (const std::pair<std::string, std::string> &r : orderForm) {
         if (r.first == "PaymentRequest") {
             PaymentRequestPlus req;
             req.parse(
@@ -322,7 +327,7 @@
         }
     }
 
-    if (wtx.IsCoinBase()) {
+    if (wtx.is_coinbase) {
         quint32 numBlocksToMaturity = COINBASE_MATURITY + 1;
         strHTML +=
             "<br>" +
@@ -342,18 +347,18 @@
     if (gArgs.GetBoolArg("-debug", false)) {
         strHTML += "<hr><br>" + tr("Debug information") + "<br><br>";
         for (const CTxIn &txin : wtx.tx->vin) {
-            if (wallet->IsMine(txin)) {
+            if (wallet.txinIsMine(txin)) {
                 strHTML += "<b>" + tr("Debit") + ":</b> " +
                            BitcoinUnits::formatHtmlWithUnit(
-                               unit, -1 * wallet->GetDebit(txin, ISMINE_ALL)) +
+                               unit, -wallet.getDebit(txin, ISMINE_ALL)) +
                            "<br>";
             }
         }
         for (const CTxOut &txout : wtx.tx->vout) {
-            if (wallet->IsMine(txout)) {
+            if (wallet.txoutIsMine(txout)) {
                 strHTML += "<b>" + tr("Credit") + ":</b> " +
                            BitcoinUnits::formatHtmlWithUnit(
-                               unit, wallet->GetCredit(txout, ISMINE_ALL)) +
+                               unit, wallet.getCredit(txout, ISMINE_ALL)) +
                            "<br>";
             }
         }
@@ -368,32 +373,30 @@
             COutPoint prevout = txin.prevout;
 
             Coin prev;
-            if (pcoinsTip->GetCoin(prevout, prev)) {
+            if (node.getUnspentOutput(prevout, prev)) {
                 strHTML += "<li>";
                 const CTxOut &vout = prev.GetTxOut();
                 CTxDestination address;
                 if (ExtractDestination(vout.scriptPubKey, address)) {
-                    if (wallet->mapAddressBook.count(address) &&
-                        !wallet->mapAddressBook[address].name.empty()) {
-                        strHTML += GUIUtil::HtmlEscape(
-                                       wallet->mapAddressBook[address].name) +
-                                   " ";
+                    std::string name;
+                    if (wallet.getAddress(address, &name) && !name.empty()) {
+                        strHTML += GUIUtil::HtmlEscape(name) + " ";
                     }
                     strHTML +=
                         QString::fromStdString(EncodeDestination(address));
                 }
                 strHTML = strHTML + " " + tr("Amount") + "=" +
                           BitcoinUnits::formatHtmlWithUnit(unit, vout.nValue);
-                strHTML =
-                    strHTML + " IsMine=" +
-                    (wallet->IsMine(vout) & ISMINE_SPENDABLE ? tr("true")
-                                                             : tr("false")) +
-                    "</li>";
-                strHTML =
-                    strHTML + " IsWatchOnly=" +
-                    (wallet->IsMine(vout) & ISMINE_WATCH_ONLY ? tr("true")
-                                                              : tr("false")) +
-                    "</li>";
+                strHTML = strHTML + " IsMine=" +
+                          (wallet.txoutIsMine(vout) & ISMINE_SPENDABLE
+                               ? tr("true")
+                               : tr("false")) +
+                          "</li>";
+                strHTML = strHTML + " IsWatchOnly=" +
+                          (wallet.txoutIsMine(vout) & ISMINE_WATCH_ONLY
+                               ? tr("true")
+                               : tr("false")) +
+                          "</li>";
             }
         }
 
diff --git a/src/qt/transactionrecord.h b/src/qt/transactionrecord.h
--- a/src/qt/transactionrecord.h
+++ b/src/qt/transactionrecord.h
@@ -5,14 +5,18 @@
 #ifndef BITCOIN_QT_TRANSACTIONRECORD_H
 #define BITCOIN_QT_TRANSACTIONRECORD_H
 
-#include "amount.h"
-#include "primitives/txid.h"
+#include <amount.h>
+#include <primitives/txid.h>
 
 #include <QList>
 #include <QString>
 
-class CWallet;
-class CWalletTx;
+namespace interfaces {
+class Node;
+class Wallet;
+struct WalletTx;
+struct WalletTxStatus;
+}
 
 /**
  * UI model for transaction status. The transaction status is the part of a
@@ -114,9 +118,9 @@
 
     /** Decompose CWallet transaction to model transaction records.
      */
-    static bool showTransaction(const CWalletTx &wtx);
-    static QList<TransactionRecord> decomposeTransaction(const CWallet *wallet,
-                                                         const CWalletTx &wtx);
+    static bool showTransaction();
+    static QList<TransactionRecord>
+    decomposeTransaction(const interfaces::WalletTx &wtx);
 
     /** @name Immutable transaction attributes
       @{*/
@@ -145,11 +149,12 @@
 
     /** Update status from core wallet tx.
      */
-    void updateStatus(const CWalletTx &wtx);
+    void updateStatus(const interfaces::WalletTxStatus &wtx, int numBlocks,
+                      int64_t adjustedTime);
 
     /** Return whether a status update is needed.
      */
-    bool statusUpdateNeeded() const;
+    bool statusUpdateNeeded(int numBlocks) const;
 };
 
 #endif // BITCOIN_QT_TRANSACTIONRECORD_H
diff --git a/src/qt/transactionrecord.cpp b/src/qt/transactionrecord.cpp
--- a/src/qt/transactionrecord.cpp
+++ b/src/qt/transactionrecord.cpp
@@ -2,22 +2,22 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "transactionrecord.h"
+#include <qt/transactionrecord.h>
 
-#include "chain.h"
-#include "consensus/consensus.h"
-#include "dstencode.h"
-#include "timedata.h"
-#include "validation.h"
-#include "wallet/finaltx.h"
-#include "wallet/wallet.h"
+#include <chain.h>
+#include <consensus/consensus.h>
+#include <dstencode.h>
+#include <interfaces/wallet.h>
+#include <timedata.h>
+#include <validation.h>
+#include <wallet/finaltx.h>
 
 #include <cstdint>
 
 /**
  * Return positive answer if transaction should be shown in list.
  */
-bool TransactionRecord::showTransaction(const CWalletTx &wtx) {
+bool TransactionRecord::showTransaction() {
     // There are currently no cases where we hide transactions, but we may want
     // to use this in the future for things like RBF.
     return true;
@@ -27,41 +27,39 @@
  * Decompose CWallet transaction to model transaction records.
  */
 QList<TransactionRecord>
-TransactionRecord::decomposeTransaction(const CWallet *wallet,
-                                        const CWalletTx &wtx) {
+TransactionRecord::decomposeTransaction(const interfaces::WalletTx &wtx) {
     QList<TransactionRecord> parts;
-    int64_t nTime = wtx.GetTxTime();
-    Amount nCredit = wtx.GetCredit(ISMINE_ALL);
-    Amount nDebit = wtx.GetDebit(ISMINE_ALL);
+    int64_t nTime = wtx.time;
+    Amount nCredit = wtx.credit;
+    Amount nDebit = wtx.debit;
     Amount nNet = nCredit - nDebit;
-    const TxId &txid = wtx.GetId();
-    std::map<std::string, std::string> mapValue = wtx.mapValue;
+    const TxId &txid = wtx.tx->GetId();
+    std::map<std::string, std::string> mapValue = wtx.value_map;
 
-    if (nNet > Amount::zero() || wtx.IsCoinBase()) {
+    if (nNet > Amount::zero() || wtx.is_coinbase) {
         //
         // Credit
         //
         for (size_t i = 0; i < wtx.tx->vout.size(); i++) {
             const CTxOut &txout = wtx.tx->vout[i];
-            isminetype mine = wallet->IsMine(txout);
+            isminetype mine = wtx.txout_is_mine[i];
             if (mine) {
                 TransactionRecord sub(txid, nTime);
                 CTxDestination address;
                 sub.idx = i; // vout index
                 sub.credit = txout.nValue;
                 sub.involvesWatchAddress = mine & ISMINE_WATCH_ONLY;
-                if (ExtractDestination(txout.scriptPubKey, address) &&
-                    IsMine(*wallet, address)) {
+                if (wtx.txout_address_is_mine[i]) {
                     // Received by Bitcoin Address
                     sub.type = TransactionRecord::RecvWithAddress;
-                    sub.address = EncodeDestination(address);
+                    sub.address = EncodeDestination(wtx.txout_address[i]);
                 } else {
                     // Received by IP connection (deprecated features), or a
                     // multisignature or other non-simple transaction
                     sub.type = TransactionRecord::RecvFromOther;
                     sub.address = mapValue["from"];
                 }
-                if (wtx.IsCoinBase()) {
+                if (wtx.is_coinbase) {
                     // Generated
                     sub.type = TransactionRecord::Generated;
                 }
@@ -72,8 +70,7 @@
     } else {
         bool involvesWatchAddress = false;
         isminetype fAllFromMe = ISMINE_SPENDABLE;
-        for (const CTxIn &txin : wtx.tx->vin) {
-            isminetype mine = wallet->IsMine(txin);
+        for (isminetype mine : wtx.txin_is_mine) {
             if (mine & ISMINE_WATCH_ONLY) {
                 involvesWatchAddress = true;
             }
@@ -83,8 +80,7 @@
         }
 
         isminetype fAllToMe = ISMINE_SPENDABLE;
-        for (const CTxOut &txout : wtx.tx->vout) {
-            isminetype mine = wallet->IsMine(txout);
+        for (isminetype mine : wtx.txout_is_mine) {
             if (mine & ISMINE_WATCH_ONLY) {
                 involvesWatchAddress = true;
             }
@@ -95,7 +91,7 @@
 
         if (fAllFromMe && fAllToMe) {
             // Payment to self
-            Amount nChange = wtx.GetChange();
+            Amount nChange = wtx.change;
 
             parts.append(TransactionRecord(
                 txid, nTime, TransactionRecord::SendToSelf, "",
@@ -114,17 +110,16 @@
                 sub.idx = nOut;
                 sub.involvesWatchAddress = involvesWatchAddress;
 
-                if (wallet->IsMine(txout)) {
+                if (wtx.txout_is_mine[nOut]) {
                     // Ignore parts sent to self, as this is usually the change
                     // from a transaction sent back to our own address.
                     continue;
                 }
 
-                CTxDestination address;
-                if (ExtractDestination(txout.scriptPubKey, address)) {
+                if (!boost::get<CNoDestination>(&wtx.txout_address[nOut])) {
                     // Sent to Bitcoin Address
                     sub.type = TransactionRecord::SendToAddress;
-                    sub.address = EncodeDestination(address);
+                    sub.address = EncodeDestination(wtx.txout_address[nOut]);
                 } else {
                     // Sent to IP, or other non-address transaction like OP_EVAL
                     sub.type = TransactionRecord::SendToOther;
@@ -155,42 +150,36 @@
     return parts;
 }
 
-void TransactionRecord::updateStatus(const CWalletTx &wtx) {
-    AssertLockHeld(cs_main);
+void TransactionRecord::updateStatus(const interfaces::WalletTxStatus &wtx,
+                                     int numBlocks, int64_t adjustedTime) {
     // Determine transaction status
 
-    // Find the block the tx is in
-    const CBlockIndex *pindex = LookupBlockIndex(wtx.hashBlock);
-
     // Sort order, unrecorded transactions sort to the top
-    status.sortKey =
-        strprintf("%010d-%01d-%010u-%03d",
-                  (pindex ? pindex->nHeight : std::numeric_limits<int>::max()),
-                  (wtx.IsCoinBase() ? 1 : 0), wtx.nTimeReceived, idx);
-    status.countsForBalance =
-        wtx.IsTrusted() && !(wtx.GetBlocksToMaturity() > 0);
-    status.depth = wtx.GetDepthInMainChain();
-    status.cur_num_blocks = chainActive.Height();
-
-    if (!CheckFinalTx(*wtx.tx)) {
-        if (wtx.tx->nLockTime < LOCKTIME_THRESHOLD) {
+    status.sortKey = strprintf("%010d-%01d-%010u-%03d", wtx.block_height,
+                               wtx.is_coinbase ? 1 : 0, wtx.time_received, idx);
+    status.countsForBalance = wtx.is_trusted && !(wtx.blocks_to_maturity > 0);
+    status.depth = wtx.depth_in_main_chain;
+    status.cur_num_blocks = numBlocks;
+
+    if (!wtx.is_final) {
+        if (wtx.lock_time < LOCKTIME_THRESHOLD) {
             status.status = TransactionStatus::OpenUntilBlock;
-            status.open_for = wtx.tx->nLockTime - chainActive.Height();
+            status.open_for = wtx.lock_time - numBlocks;
         } else {
             status.status = TransactionStatus::OpenUntilDate;
-            status.open_for = wtx.tx->nLockTime;
+            status.open_for = wtx.lock_time;
         }
     } else if (type == TransactionRecord::Generated) {
         // For generated transactions, determine maturity
-        if (wtx.GetBlocksToMaturity() > 0) {
+        if (wtx.blocks_to_maturity > 0) {
             status.status = TransactionStatus::Immature;
 
-            if (wtx.IsInMainChain()) {
-                status.matures_in = wtx.GetBlocksToMaturity();
+            if (wtx.is_in_main_chain) {
+                status.matures_in = wtx.blocks_to_maturity;
 
                 // Check if the block was requested by anyone
-                if (GetAdjustedTime() - wtx.nTimeReceived > 2 * 60 &&
-                    wtx.GetRequestCount() == 0) {
+                if (adjustedTime - wtx.time_received > 2 * 60 &&
+                    wtx.request_count == 0) {
                     status.status = TransactionStatus::MaturesWarning;
                 }
             } else {
@@ -202,12 +191,12 @@
     } else {
         if (status.depth < 0) {
             status.status = TransactionStatus::Conflicted;
-        } else if (GetAdjustedTime() - wtx.nTimeReceived > 2 * 60 &&
-                   wtx.GetRequestCount() == 0) {
+        } else if (adjustedTime - wtx.time_received > 2 * 60 &&
+                   wtx.request_count == 0) {
             status.status = TransactionStatus::Offline;
         } else if (status.depth == 0) {
             status.status = TransactionStatus::Unconfirmed;
-            if (wtx.isAbandoned()) {
+            if (wtx.is_abandoned) {
                 status.status = TransactionStatus::Abandoned;
             }
         } else if (status.depth < RecommendedNumConfirmations) {
@@ -218,9 +207,8 @@
     }
 }
 
-bool TransactionRecord::statusUpdateNeeded() const {
-    AssertLockHeld(cs_main);
-    return status.cur_num_blocks != chainActive.Height();
+bool TransactionRecord::statusUpdateNeeded(int numBlocks) const {
+    return status.cur_num_blocks != numBlocks;
 }
 
 QString TransactionRecord::getTxID() const {
diff --git a/src/qt/transactiontablemodel.h b/src/qt/transactiontablemodel.h
--- a/src/qt/transactiontablemodel.h
+++ b/src/qt/transactiontablemodel.h
@@ -5,18 +5,22 @@
 #ifndef BITCOIN_QT_TRANSACTIONTABLEMODEL_H
 #define BITCOIN_QT_TRANSACTIONTABLEMODEL_H
 
-#include "bitcoinunits.h"
+#include <qt/bitcoinunits.h>
 
 #include <QAbstractTableModel>
 #include <QStringList>
 
+#include <memory>
+
+namespace interfaces {
+class Handler;
+}
+
 class PlatformStyle;
 class TransactionRecord;
 class TransactionTablePriv;
 class WalletModel;
 
-class CWallet;
-
 /**
  * UI model for the transaction table of a wallet.
  */
@@ -25,7 +29,7 @@
 
 public:
     explicit TransactionTableModel(const PlatformStyle *platformStyle,
-                                   CWallet *wallet, WalletModel *parent = 0);
+                                   WalletModel *parent = 0);
     ~TransactionTableModel();
 
     enum ColumnIndex {
@@ -88,8 +92,9 @@
     }
 
 private:
-    CWallet *wallet;
     WalletModel *walletModel;
+    std::unique_ptr<interfaces::Handler> m_handler_transaction_changed;
+    std::unique_ptr<interfaces::Handler> m_handler_show_progress;
     QStringList columns;
     TransactionTablePriv *priv;
     bool fProcessingQueuedTransactions;
diff --git a/src/qt/transactiontablemodel.cpp b/src/qt/transactiontablemodel.cpp
--- a/src/qt/transactiontablemodel.cpp
+++ b/src/qt/transactiontablemodel.cpp
@@ -2,23 +2,23 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "transactiontablemodel.h"
-
-#include "addresstablemodel.h"
-#include "guiconstants.h"
-#include "guiutil.h"
-#include "optionsmodel.h"
-#include "platformstyle.h"
-#include "transactiondesc.h"
-#include "transactionrecord.h"
-#include "walletmodel.h"
-
-#include "core_io.h"
-#include "sync.h"
-#include "uint256.h"
-#include "util.h"
-#include "validation.h"
-#include "wallet/wallet.h"
+#include <qt/transactiontablemodel.h>
+
+#include <core_io.h>
+#include <interfaces/handler.h>
+#include <interfaces/node.h>
+#include <qt/addresstablemodel.h>
+#include <qt/guiconstants.h>
+#include <qt/guiutil.h>
+#include <qt/optionsmodel.h>
+#include <qt/platformstyle.h>
+#include <qt/transactiondesc.h>
+#include <qt/transactionrecord.h>
+#include <qt/walletmodel.h>
+#include <sync.h>
+#include <uint256.h>
+#include <util.h>
+#include <validation.h>
 
 #include <QColor>
 #include <QDateTime>
@@ -53,10 +53,8 @@
 // Private implementation
 class TransactionTablePriv {
 public:
-    TransactionTablePriv(CWallet *_wallet, TransactionTableModel *_parent)
-        : wallet(_wallet), parent(_parent) {}
+    TransactionTablePriv(TransactionTableModel *_parent) : parent(_parent) {}
 
-    CWallet *wallet;
     TransactionTableModel *parent;
 
     /* Local cache of wallet.
@@ -68,15 +66,13 @@
     /**
      * Query entire wallet anew from core.
      */
-    void refreshWallet() {
+    void refreshWallet(interfaces::Wallet &wallet) {
         qDebug() << "TransactionTablePriv::refreshWallet";
         cachedWallet.clear();
-
-        LOCK2(cs_main, wallet->cs_wallet);
-        for (const auto &entry : wallet->mapWallet) {
-            if (TransactionRecord::showTransaction(entry.second)) {
-                cachedWallet.append(TransactionRecord::decomposeTransaction(
-                    wallet, entry.second));
+        for (const auto &wtx : wallet.getWalletTxs()) {
+            if (TransactionRecord::showTransaction()) {
+                cachedWallet.append(
+                    TransactionRecord::decomposeTransaction(wtx));
             }
         }
     }
@@ -86,7 +82,8 @@
      * the wallet with that of the core.
      * Call with transaction that was added, removed or changed.
      */
-    void updateWallet(const TxId &txid, int status, bool showTransaction) {
+    void updateWallet(interfaces::Wallet &wallet, const TxId &txid, int status,
+                      bool showTransaction) {
         qDebug() << "TransactionTablePriv::updateWallet: " +
                         QString::fromStdString(txid.ToString()) + " " +
                         QString::number(status);
@@ -126,11 +123,9 @@
                     break;
                 }
                 if (showTransaction) {
-                    LOCK2(cs_main, wallet->cs_wallet);
                     // Find transaction in wallet
-                    std::map<TxId, CWalletTx>::iterator mi =
-                        wallet->mapWallet.find(txid);
-                    if (mi == wallet->mapWallet.end()) {
+                    interfaces::WalletTx wtx = wallet.getWalletTx(txid);
+                    if (!wtx.tx) {
                         qWarning() << "TransactionTablePriv::updateWallet: "
                                       "Warning: Got CT_NEW, but transaction is "
                                       "not in wallet";
@@ -138,8 +133,7 @@
                     }
                     // Added -- insert at the right position
                     QList<TransactionRecord> toInsert =
-                        TransactionRecord::decomposeTransaction(wallet,
-                                                                mi->second);
+                        TransactionRecord::decomposeTransaction(wtx);
                     /* only if something to insert */
                     if (!toInsert.isEmpty()) {
                         parent->beginInsertRows(QModelIndex(), lowerIndex,
@@ -177,7 +171,7 @@
 
     int size() { return cachedWallet.size(); }
 
-    TransactionRecord *index(int idx) {
+    TransactionRecord *index(interfaces::Wallet &wallet, int idx) {
         if (idx >= 0 && idx < cachedWallet.size()) {
             TransactionRecord *rec = &cachedWallet[idx];
 
@@ -188,40 +182,28 @@
             // If a status update is needed (blocks came in since last check),
             // update the status of this transaction from the wallet. Otherwise,
             // simply re-use the cached status.
-            TRY_LOCK(cs_main, lockMain);
-            if (lockMain) {
-                TRY_LOCK(wallet->cs_wallet, lockWallet);
-                if (lockWallet && rec->statusUpdateNeeded()) {
-                    std::map<TxId, CWalletTx>::iterator mi =
-                        wallet->mapWallet.find(rec->txid);
-
-                    if (mi != wallet->mapWallet.end()) {
-                        rec->updateStatus(mi->second);
-                    }
-                }
+            interfaces::WalletTxStatus wtx;
+            int numBlocks;
+            int64_t adjustedTime;
+            if (wallet.tryGetTxStatus(rec->txid, wtx, numBlocks,
+                                      adjustedTime) &&
+                rec->statusUpdateNeeded(numBlocks)) {
+                rec->updateStatus(wtx, numBlocks, adjustedTime);
             }
             return rec;
         }
         return 0;
     }
 
-    QString describe(TransactionRecord *rec, int unit) {
-        LOCK2(cs_main, wallet->cs_wallet);
-        std::map<TxId, CWalletTx>::iterator mi =
-            wallet->mapWallet.find(rec->txid);
-        if (mi != wallet->mapWallet.end()) {
-            return TransactionDesc::toHTML(wallet, mi->second, rec, unit);
-        }
-
-        return QString();
+    QString describe(interfaces::Node &node, interfaces::Wallet &wallet,
+                     TransactionRecord *rec, int unit) {
+        return TransactionDesc::toHTML(node, wallet, rec, unit);
     }
 
-    QString getTxHex(TransactionRecord *rec) {
-        LOCK2(cs_main, wallet->cs_wallet);
-        std::map<TxId, CWalletTx>::iterator mi =
-            wallet->mapWallet.find(rec->txid);
-        if (mi != wallet->mapWallet.end()) {
-            std::string strHex = EncodeHexTx(*mi->second.tx);
+    QString getTxHex(interfaces::Wallet &wallet, TransactionRecord *rec) {
+        auto tx = wallet.getTx(rec->txid);
+        if (tx) {
+            std::string strHex = EncodeHexTx(*tx);
             return QString::fromStdString(strHex);
         }
         return QString();
@@ -229,14 +211,14 @@
 };
 
 TransactionTableModel::TransactionTableModel(
-    const PlatformStyle *_platformStyle, CWallet *_wallet, WalletModel *parent)
-    : QAbstractTableModel(parent), wallet(_wallet), walletModel(parent),
-      priv(new TransactionTablePriv(_wallet, this)),
+    const PlatformStyle *_platformStyle, WalletModel *parent)
+    : QAbstractTableModel(parent), walletModel(parent),
+      priv(new TransactionTablePriv(this)),
       fProcessingQueuedTransactions(false), platformStyle(_platformStyle) {
     columns << QString() << QString() << tr("Date") << tr("Type") << tr("Label")
             << BitcoinUnits::getAmountColumnTitle(
                    walletModel->getOptionsModel()->getDisplayUnit());
-    priv->refreshWallet();
+    priv->refreshWallet(walletModel->wallet());
 
     connect(walletModel->getOptionsModel(), SIGNAL(displayUnitChanged(int)),
             this, SLOT(updateDisplayUnit()));
@@ -262,7 +244,7 @@
     TxId updated;
     updated.SetHex(hash.toStdString());
 
-    priv->updateWallet(updated, status, showTransaction);
+    priv->updateWallet(walletModel->wallet(), updated, status, showTransaction);
 }
 
 void TransactionTableModel::updateConfirmations() {
@@ -604,7 +586,8 @@
             return txWatchonlyDecoration(rec);
         case LongDescriptionRole:
             return priv->describe(
-                rec, walletModel->getOptionsModel()->getDisplayUnit());
+                walletModel->node(), walletModel->wallet(), rec,
+                walletModel->getOptionsModel()->getDisplayUnit());
         case AddressRole:
             return QString::fromStdString(rec->address);
         case LabelRole:
@@ -617,7 +600,7 @@
         case TxHashRole:
             return QString::fromStdString(rec->txid.ToString());
         case TxHexRole:
-            return priv->getTxHex(rec);
+            return priv->getTxHex(walletModel->wallet(), rec);
         case TxPlainTextRole: {
             QString details;
             QDateTime date =
@@ -695,9 +678,10 @@
 QModelIndex TransactionTableModel::index(int row, int column,
                                          const QModelIndex &parent) const {
     Q_UNUSED(parent);
-    TransactionRecord *data = priv->index(row);
+    TransactionRecord *data = priv->index(walletModel->wallet(), row);
     if (data) {
-        return createIndex(row, column, priv->index(row));
+        return createIndex(row, column,
+                           priv->index(walletModel->wallet(), row));
     }
     return QModelIndex();
 }
@@ -736,15 +720,11 @@
 static std::vector<TransactionNotification> vQueueNotifications;
 
 static void NotifyTransactionChanged(TransactionTableModel *ttm,
-                                     CWallet *wallet, const TxId &txid,
-                                     ChangeType status) {
+                                     const TxId &txid, ChangeType status) {
     // Find transaction in wallet
-    std::map<TxId, CWalletTx>::iterator mi = wallet->mapWallet.find(txid);
     // Determine whether to show transaction or not (determine this here so that
     // no relocking is needed in GUI thread)
-    bool inWallet = mi != wallet->mapWallet.end();
-    bool showTransaction =
-        (inWallet && TransactionRecord::showTransaction(mi->second));
+    bool showTransaction = TransactionRecord::showTransaction();
 
     TransactionNotification notification(txid, status, showTransaction);
 
@@ -786,14 +766,15 @@
 
 void TransactionTableModel::subscribeToCoreSignals() {
     // Connect signals to wallet
-    wallet->NotifyTransactionChanged.connect(
-        boost::bind(NotifyTransactionChanged, this, _1, _2, _3));
-    wallet->ShowProgress.connect(boost::bind(ShowProgress, this, _1, _2));
+    m_handler_transaction_changed =
+        walletModel->wallet().handleTransactionChanged(
+            boost::bind(NotifyTransactionChanged, this, _1, _2));
+    m_handler_show_progress = walletModel->wallet().handleShowProgress(
+        boost::bind(ShowProgress, this, _1, _2));
 }
 
 void TransactionTableModel::unsubscribeFromCoreSignals() {
     // Disconnect signals from wallet
-    wallet->NotifyTransactionChanged.disconnect(
-        boost::bind(NotifyTransactionChanged, this, _1, _2, _3));
-    wallet->ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
+    m_handler_transaction_changed->disconnect();
+    m_handler_show_progress->disconnect();
 }
diff --git a/src/qt/walletmodel.h b/src/qt/walletmodel.h
--- a/src/qt/walletmodel.h
+++ b/src/qt/walletmodel.h
@@ -115,7 +115,7 @@
 public:
     explicit WalletModel(std::unique_ptr<interfaces::Wallet> wallet,
                          interfaces::Node &node,
-                         const PlatformStyle *platformStyle, CWallet *cwallet,
+                         const PlatformStyle *platformStyle,
                          OptionsModel *optionsModel, QObject *parent = nullptr);
     ~WalletModel();
 
@@ -227,7 +227,6 @@
     std::unique_ptr<interfaces::Handler> m_handler_watch_only_changed;
     interfaces::Node &m_node;
 
-    CWallet *cwallet;
     bool fHaveWatchOnly;
     bool fForceCheckBalanceChanged;
 
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
--- a/src/qt/walletmodel.cpp
+++ b/src/qt/walletmodel.cpp
@@ -4,27 +4,19 @@
 
 #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>
@@ -34,19 +26,18 @@
 
 WalletModel::WalletModel(std::unique_ptr<interfaces::Wallet> wallet,
                          interfaces::Node &node,
-                         const PlatformStyle *platformStyle, CWallet *_wallet,
+                         const PlatformStyle *platformStyle,
                          OptionsModel *_optionsModel, QObject *parent)
     : QObject(parent), m_wallet(std::move(wallet)), m_node(node),
-      cwallet(_wallet), optionsModel(_optionsModel), addressTableModel(0),
+      optionsModel(_optionsModel), addressTableModel(0),
       transactionTableModel(0), recentRequestsTableModel(0),
       cachedEncryptionStatus(Unencrypted), cachedNumBlocks(0) {
     fHaveWatchOnly = m_wallet->haveWatchOnly();
     fForceCheckBalanceChanged = false;
 
     addressTableModel = new AddressTableModel(this);
-    transactionTableModel =
-        new TransactionTableModel(platformStyle, cwallet, this);
-    recentRequestsTableModel = new RecentRequestsTableModel(cwallet, this);
+    transactionTableModel = new TransactionTableModel(platformStyle, this);
+    recentRequestsTableModel = new RecentRequestsTableModel(this);
 
     // This timer will be fired repeatedly to update the balance
     pollTimer = new QTimer(this);