diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -132,6 +132,9 @@
 	compat/glibcxx_sanity.cpp
 	compat/strnlen.cpp
 	fs.cpp
+	interface/handler.cpp
+	interface/node.cpp
+	interface/wallet.cpp
 	logging.cpp
 	random.cpp
 	rcu.cpp
diff --git a/src/Makefile.am b/src/Makefile.am
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -7,6 +7,7 @@
 AM_LDFLAGS = $(PTHREAD_CFLAGS) $(LIBTOOL_LDFLAGS) $(HARDENED_LDFLAGS) $(SANITIZER_LDFLAGS)
 AM_CXXFLAGS = $(DEBUG_CXXFLAGS) $(HARDENED_CXXFLAGS) $(ERROR_CXXFLAGS) $(SANITIZER_CXXFLAGS)
 AM_CPPFLAGS = $(DEBUG_CPPFLAGS) $(HARDENED_CPPFLAGS)
+AM_LIBTOOLFLAGS = --preserve-dup-deps
 EXTRA_LIBRARIES =
 
 if EMBEDDED_UNIVALUE
@@ -140,6 +141,9 @@
   httpserver.h \
   indirectmap.h \
   init.h \
+  interface/handler.h \
+  interface/node.h \
+  interface/wallet.h \
   key.h \
   keystore.h \
   dbwrapper.h \
@@ -292,6 +296,7 @@
 libbitcoin_wallet_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
 libbitcoin_wallet_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_wallet_a_SOURCES = \
+  interface/wallet.cpp \
   wallet/crypter.cpp \
   wallet/db.cpp \
   wallet/finaltx.cpp \
@@ -430,6 +435,8 @@
   compat/glibcxx_sanity.cpp \
   compat/strnlen.cpp \
   fs.cpp \
+  interface/handler.cpp \
+  interface/node.cpp \
   logging.cpp \
   random.cpp \
   rcu.cpp \
diff --git a/src/Makefile.qt.include b/src/Makefile.qt.include
--- a/src/Makefile.qt.include
+++ b/src/Makefile.qt.include
@@ -399,7 +399,7 @@
 endif
 qt_bitcoin_qt_LDADD = qt/libbitcoinqt.a $(LIBBITCOIN_SERVER)
 if ENABLE_WALLET
-qt_bitcoin_qt_LDADD += $(LIBBITCOIN_WALLET)
+qt_bitcoin_qt_LDADD += $(LIBBITCOIN_UTIL) $(LIBBITCOIN_WALLET)
 endif
 if ENABLE_ZMQ
 qt_bitcoin_qt_LDADD += $(LIBBITCOIN_ZMQ) $(ZMQ_LIBS)
@@ -408,7 +408,7 @@
   $(BOOST_LIBS) $(QT_LIBS) $(QT_DBUS_LIBS) $(QR_LIBS) $(PROTOBUF_LIBS) $(BDB_LIBS) $(SSL_LIBS) $(CRYPTO_LIBS) $(MINIUPNPC_LIBS) $(LIBSECP256K1) \
   $(EVENT_PTHREADS_LIBS) $(EVENT_LIBS)
 qt_bitcoin_qt_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(QT_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
-qt_bitcoin_qt_LIBTOOLFLAGS = --tag CXX
+qt_bitcoin_qt_LIBTOOLFLAGS = $(AM_LIBTOOLFLAGS) --tag CXX
 
 #locale/foo.ts -> locale/foo.qm
 QT_QM=$(QT_TS:.ts=.qm)
diff --git a/src/Makefile.qttest.include b/src/Makefile.qttest.include
--- a/src/Makefile.qttest.include
+++ b/src/Makefile.qttest.include
@@ -58,7 +58,7 @@
 
 qt_test_test_bitcoin_qt_LDADD = $(LIBBITCOINQT) $(LIBBITCOIN_SERVER)
 if ENABLE_WALLET
-qt_test_test_bitcoin_qt_LDADD += $(LIBBITCOIN_WALLET)
+qt_test_test_bitcoin_qt_LDADD += $(LIBBITCOIN_UTIL) $(LIBBITCOIN_WALLET)
 endif
 if ENABLE_ZMQ
 qt_test_test_bitcoin_qt_LDADD += $(LIBBITCOIN_ZMQ) $(ZMQ_LIBS)
diff --git a/src/interface/handler.h b/src/interface/handler.h
new file mode 100644
--- /dev/null
+++ b/src/interface/handler.h
@@ -0,0 +1,34 @@
+// Copyright (c) 2018 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_INTERFACE_HANDLER_H
+#define BITCOIN_INTERFACE_HANDLER_H
+
+#include <memory>
+
+namespace boost {
+namespace signals2 {
+    class connection;
+} // namespace signals2
+} // namespace boost
+
+namespace interface {
+
+//! Generic interface for managing an event handler or callback function
+//! registered with another interface. Has a single disconnect method to cancel
+//! the registration and prevent any future notifications.
+class Handler {
+public:
+    virtual ~Handler() {}
+
+    //! Disconnect the handler.
+    virtual void disconnect() = 0;
+};
+
+//! Return handler wrapping a boost signal connection.
+std::unique_ptr<Handler> MakeHandler(boost::signals2::connection connection);
+
+} // namespace interface
+
+#endif // BITCOIN_INTERFACE_HANDLER_H
diff --git a/src/interface/handler.cpp b/src/interface/handler.cpp
new file mode 100644
--- /dev/null
+++ b/src/interface/handler.cpp
@@ -0,0 +1,32 @@
+// Copyright (c) 2018 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <interface/handler.h>
+
+#include <util.h>
+
+#include <boost/signals2/connection.hpp>
+#include <memory>
+#include <utility>
+
+namespace interface {
+namespace {
+
+    class HandlerImpl : public Handler {
+    public:
+        HandlerImpl(boost::signals2::connection connection)
+            : m_connection(std::move(connection)) {}
+
+        void disconnect() override { m_connection.disconnect(); }
+
+        boost::signals2::scoped_connection m_connection;
+    };
+
+} // namespace
+
+std::unique_ptr<Handler> MakeHandler(boost::signals2::connection connection) {
+    return std::make_unique<HandlerImpl>(std::move(connection));
+}
+
+} // namespace interface
diff --git a/src/interface/node.h b/src/interface/node.h
new file mode 100644
--- /dev/null
+++ b/src/interface/node.h
@@ -0,0 +1,258 @@
+// Copyright (c) 2018 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_INTERFACE_NODE_H
+#define BITCOIN_INTERFACE_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
+
+#include <functional>
+#include <memory>
+#include <stddef.h>
+#include <stdint.h>
+#include <string>
+#include <tuple>
+#include <vector>
+
+class CCoinControl;
+class Coin;
+class Config;
+class CFeeRate;
+struct CNodeStateStats;
+struct CNodeStats;
+class HTTPRPCRequestProcessor;
+class proxyType;
+class RPCServer;
+class RPCTimerInterface;
+class UniValue;
+
+namespace interface {
+
+class Handler;
+class Wallet;
+
+//! Top-level interface for a bitcoin node (bitcoind process).
+class Node {
+public:
+    virtual ~Node() {}
+
+    //! Set command line arguments.
+    virtual void parseParameters(int argc, const char *const argv[]) = 0;
+
+    //! Set a command line argument if it doesn't already have a value
+    virtual bool softSetArg(const std::string &arg,
+                            const std::string &value) = 0;
+
+    //! Set a command line boolean argument if it doesn't already have a value
+    virtual bool softSetBoolArg(const std::string &arg, bool value) = 0;
+
+    //! Load settings from configuration file.
+    virtual void readConfigFile(const std::string &conf_path) = 0;
+
+    //! Choose network parameters.
+    virtual void selectParams(const std::string &network) = 0;
+
+    //! Get network name.
+    virtual std::string getNetwork() = 0;
+
+    //! Init logging.
+    virtual void initLogging() = 0;
+
+    //! Init parameter interaction.
+    virtual void initParameterInteraction() = 0;
+
+    //! Get warnings.
+    virtual std::string getWarnings(const std::string &type) = 0;
+
+    //! Initialize app dependencies.
+    virtual bool baseInitialize(Config &config, RPCServer &rpcServer) = 0;
+
+    //! Start node.
+    virtual bool
+    appInitMain(Config &config,
+                HTTPRPCRequestProcessor &httpRPCRequestProcessor) = 0;
+
+    //! Stop node.
+    virtual void appShutdown() = 0;
+
+    //! Start shutdown.
+    virtual void startShutdown() = 0;
+
+    //! Return whether shutdown was requested.
+    virtual bool shutdownRequested() = 0;
+
+    //! Get help message string.
+    virtual std::string helpMessage(HelpMessageMode mode) = 0;
+
+    //! Map port.
+    virtual void mapPort(bool use_upnp) = 0;
+
+    //! Get proxy.
+    virtual bool getProxy(Network net, proxyType &proxy_info) = 0;
+
+    //! Get number of connections.
+    virtual size_t getNodeCount(CConnman::NumConnections flags) = 0;
+
+    //! Get stats for connected nodes.
+    using NodesStats =
+        std::vector<std::tuple<CNodeStats, bool, CNodeStateStats>>;
+    virtual bool getNodesStats(NodesStats &stats) = 0;
+
+    //! Get ban map entries.
+    virtual bool getBanned(banmap_t &banmap) = 0;
+
+    //! Ban node.
+    virtual bool ban(const CNetAddr &net_addr, BanReason reason,
+                     int64_t ban_time_offset) = 0;
+
+    //! Unban node.
+    virtual bool unban(const CSubNet &ip) = 0;
+
+    //! Disconnect node.
+    virtual bool disconnect(NodeId id) = 0;
+
+    //! Get total bytes recv.
+    virtual int64_t getTotalBytesRecv() = 0;
+
+    //! Get total bytes sent.
+    virtual int64_t getTotalBytesSent() = 0;
+
+    //! Get mempool size.
+    virtual size_t getMempoolSize() = 0;
+
+    //! Get mempool dynamic usage.
+    virtual size_t getMempoolDynamicUsage() = 0;
+
+    //! Get header tip height and time.
+    virtual bool getHeaderTip(int &height, int64_t &block_time) = 0;
+
+    //! Get num blocks.
+    virtual int getNumBlocks() = 0;
+
+    //! Get last block time.
+    virtual int64_t getLastBlockTime() = 0;
+
+    //! Get verification progress.
+    virtual double getVerificationProgress() = 0;
+
+    //! Is initial block download.
+    virtual bool isInitialBlockDownload() = 0;
+
+    //! Get reindex.
+    virtual bool getReindex() = 0;
+
+    //! Get importing.
+    virtual bool getImporting() = 0;
+
+    //! Set network active.
+    virtual void setNetworkActive(bool active) = 0;
+
+    //! Get network active.
+    virtual bool getNetworkActive() = 0;
+
+    //! Get minimum fee.
+    virtual Amount getMinimumFee(unsigned int tx_bytes,
+                                 const CCoinControl &coin_control) = 0;
+
+    //! Get max tx fee.
+    virtual Amount getMaxTxFee() = 0;
+
+    //! Get dust relay fee.
+    virtual CFeeRate getDustRelayFee() = 0;
+
+    //! Get pay tx fee.
+    virtual CFeeRate getPayTxFee() = 0;
+
+    //! Execute rpc command.
+    virtual UniValue executeRpc(const std::string &command,
+                                const UniValue &params,
+                                const std::string &uri) = 0;
+
+    //! List rpc commands.
+    virtual std::vector<std::string> listRpcCommands() = 0;
+
+    //! Set RPC timer interface if unset.
+    virtual void rpcSetTimerInterfaceIfUnset(RPCTimerInterface *iface) = 0;
+
+    //! 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;
+
+    //! Register handler for init messages.
+    using InitMessageFn = std::function<void(const std::string &message)>;
+    virtual std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) = 0;
+
+    //! Register handler for message box messages.
+    using MessageBoxFn =
+        std::function<bool(const std::string &message,
+                           const std::string &caption, unsigned int style)>;
+    virtual std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) = 0;
+
+    //! Register handler for question messages.
+    using QuestionFn = std::function<bool(
+        const std::string &message, const std::string &non_interactive_message,
+        const std::string &caption, unsigned int style)>;
+    virtual std::unique_ptr<Handler> handleQuestion(QuestionFn fn) = 0;
+
+    //! Register handler for progress messages.
+    using ShowProgressFn = std::function<void(
+        const std::string &title, int progress, bool resume_possible)>;
+    virtual std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) = 0;
+
+    //! Register handler for load wallet messages.
+    using LoadWalletFn = std::function<void(std::unique_ptr<Wallet> wallet)>;
+    virtual std::unique_ptr<Handler> handleLoadWallet(LoadWalletFn fn) = 0;
+
+    //! Register handler for number of connections changed messages.
+    using NotifyNumConnectionsChangedFn =
+        std::function<void(int new_num_connections)>;
+    virtual std::unique_ptr<Handler>
+    handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn) = 0;
+
+    //! Register handler for network active messages.
+    using NotifyNetworkActiveChangedFn =
+        std::function<void(bool network_active)>;
+    virtual std::unique_ptr<Handler>
+    handleNotifyNetworkActiveChanged(NotifyNetworkActiveChangedFn fn) = 0;
+
+    //! Register handler for notify alert messages.
+    using NotifyAlertChangedFn = std::function<void()>;
+    virtual std::unique_ptr<Handler>
+    handleNotifyAlertChanged(NotifyAlertChangedFn fn) = 0;
+
+    //! Register handler for ban list messages.
+    using BannedListChangedFn = std::function<void()>;
+    virtual std::unique_ptr<Handler>
+    handleBannedListChanged(BannedListChangedFn fn) = 0;
+
+    //! Register handler for block tip messages.
+    using NotifyBlockTipFn =
+        std::function<void(bool initial_download, int height,
+                           int64_t block_time, double verification_progress)>;
+    virtual std::unique_ptr<Handler>
+    handleNotifyBlockTip(NotifyBlockTipFn fn) = 0;
+
+    //! Register handler for header tip messages.
+    using NotifyHeaderTipFn =
+        std::function<void(bool initial_download, int height,
+                           int64_t block_time, double verification_progress)>;
+    virtual std::unique_ptr<Handler>
+    handleNotifyHeaderTip(NotifyHeaderTipFn fn) = 0;
+};
+
+//! Return implementation of Node interface.
+std::unique_ptr<Node> MakeNode();
+
+} // namespace interface
+
+#endif // BITCOIN_INTERFACE_NODE_H
diff --git a/src/interface/node.cpp b/src/interface/node.cpp
new file mode 100644
--- /dev/null
+++ b/src/interface/node.cpp
@@ -0,0 +1,320 @@
+// Copyright (c) 2018 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <interface/node.h>
+
+#include <addrdb.h>
+#include <amount.h>
+#include <chain.h>
+#include <chainparams.h>
+#include <config.h>
+#include <feerate.h>
+#include <init.h>
+#include <interface/handler.h>
+#include <interface/wallet.h>
+#include <net.h>
+#include <net_processing.h>
+#include <netaddress.h>
+#include <netbase.h>
+#include <policy/fees.h>
+#include <policy/policy.h>
+#include <primitives/block.h>
+#include <rpc/server.h>
+#include <scheduler.h>
+#include <sync.h>
+#include <txmempool.h>
+#include <ui_interface.h>
+#include <util.h>
+#include <validation.h>
+#include <warnings.h>
+
+#if defined(HAVE_CONFIG_H)
+#include <config/bitcoin-config.h>
+#endif
+#ifdef ENABLE_WALLET
+#include <wallet/fees.h>
+#include <wallet/wallet.h>
+#define CHECK_WALLET(x) x
+#else
+#define CHECK_WALLET(x)                                                        \
+    throw std::logic_error("Wallet function called in non-wallet build.")
+#endif
+
+#include <atomic>
+#include <boost/thread/thread.hpp>
+#include <univalue.h>
+
+class CWallet;
+class HTTPRPCRequestProcessor;
+
+namespace interface {
+namespace {
+
+    class NodeImpl : public Node {
+        void parseParameters(int argc, const char *const argv[]) override {
+            gArgs.ParseParameters(argc, argv);
+        }
+        void readConfigFile(const std::string &conf_path) override {
+            gArgs.ReadConfigFile(conf_path);
+        }
+        bool softSetArg(const std::string &arg,
+                        const std::string &value) override {
+            return gArgs.SoftSetArg(arg, value);
+        }
+        bool softSetBoolArg(const std::string &arg, bool value) override {
+            return gArgs.SoftSetBoolArg(arg, value);
+        }
+        void selectParams(const std::string &network) override {
+            SelectParams(network);
+        }
+        std::string getNetwork() override { return Params().NetworkIDString(); }
+        void initLogging() override { InitLogging(); }
+        void initParameterInteraction() override { InitParameterInteraction(); }
+        std::string getWarnings(const std::string &type) override {
+            return GetWarnings(type);
+        }
+        bool baseInitialize(Config &config, RPCServer &rpcServer) override {
+            return AppInitBasicSetup() &&
+                   AppInitParameterInteraction(config, rpcServer) &&
+                   AppInitSanityChecks() && AppInitLockDataDirectory();
+        }
+        bool
+        appInitMain(Config &config,
+                    HTTPRPCRequestProcessor &httpRPCRequestProcessor) override {
+            return AppInitMain(config, httpRPCRequestProcessor);
+        }
+        void appShutdown() override {
+            Interrupt();
+            Shutdown();
+        }
+        void startShutdown() override { StartShutdown(); }
+        bool shutdownRequested() override { return ShutdownRequested(); }
+        void mapPort(bool use_upnp) override {
+            if (use_upnp) {
+                StartMapPort();
+            } else {
+                InterruptMapPort();
+                StopMapPort();
+            }
+        }
+        std::string helpMessage(HelpMessageMode mode) override {
+            return HelpMessage(mode);
+        }
+        bool getProxy(Network net, proxyType &proxy_info) override {
+            return GetProxy(net, proxy_info);
+        }
+        size_t getNodeCount(CConnman::NumConnections flags) override {
+            return g_connman ? g_connman->GetNodeCount(flags) : 0;
+        }
+        bool getNodesStats(NodesStats &stats) override {
+            stats.clear();
+
+            if (g_connman) {
+                std::vector<CNodeStats> stats_temp;
+                g_connman->GetNodeStats(stats_temp);
+
+                stats.reserve(stats_temp.size());
+                for (auto &node_stats_temp : stats_temp) {
+                    stats.emplace_back(std::move(node_stats_temp), false,
+                                       CNodeStateStats());
+                }
+
+                // Try to retrieve the CNodeStateStats for each node.
+                TRY_LOCK(::cs_main, lockMain);
+                if (lockMain) {
+                    for (auto &node_stats : stats) {
+                        std::get<1>(node_stats) =
+                            GetNodeStateStats(std::get<0>(node_stats).nodeid,
+                                              std::get<2>(node_stats));
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+        bool getBanned(banmap_t &banmap) override {
+            if (g_connman) {
+                g_connman->GetBanned(banmap);
+                return true;
+            }
+            return false;
+        }
+        bool ban(const CNetAddr &net_addr, BanReason reason,
+                 int64_t ban_time_offset) override {
+            if (g_connman) {
+                g_connman->Ban(net_addr, reason, ban_time_offset);
+                return true;
+            }
+            return false;
+        }
+        bool unban(const CSubNet &ip) override {
+            if (g_connman) {
+                g_connman->Unban(ip);
+                return true;
+            }
+            return false;
+        }
+        bool disconnect(NodeId id) override {
+            if (g_connman) {
+                return g_connman->DisconnectNode(id);
+            }
+            return false;
+        }
+        int64_t getTotalBytesRecv() override {
+            return g_connman ? g_connman->GetTotalBytesRecv() : 0;
+        }
+        int64_t getTotalBytesSent() override {
+            return g_connman ? g_connman->GetTotalBytesSent() : 0;
+        }
+        size_t getMempoolSize() override { return g_mempool.size(); }
+        size_t getMempoolDynamicUsage() override {
+            return g_mempool.DynamicMemoryUsage();
+        }
+        bool getHeaderTip(int &height, int64_t &block_time) override {
+            LOCK(::cs_main);
+            if (::pindexBestHeader) {
+                height = ::pindexBestHeader->nHeight;
+                block_time = ::pindexBestHeader->GetBlockTime();
+                return true;
+            }
+            return false;
+        }
+        int getNumBlocks() override {
+            LOCK(::cs_main);
+            return ::chainActive.Height();
+        }
+        int64_t getLastBlockTime() override {
+            LOCK(::cs_main);
+            if (::chainActive.Tip()) {
+                return ::chainActive.Tip()->GetBlockTime();
+            }
+            return Params()
+                .GenesisBlock()
+                .GetBlockTime(); // Genesis block's time of current network
+        }
+        double getVerificationProgress() override {
+            const CBlockIndex *tip;
+            {
+                LOCK(::cs_main);
+                tip = ::chainActive.Tip();
+            }
+            return GuessVerificationProgress(Params().TxData(), tip);
+        }
+        bool isInitialBlockDownload() override {
+            return IsInitialBlockDownload();
+        }
+        bool getReindex() override { return ::fReindex; }
+        bool getImporting() override { return ::fImporting; }
+        void setNetworkActive(bool active) override {
+            if (g_connman) {
+                g_connman->SetNetworkActive(active);
+            }
+        }
+        bool getNetworkActive() override {
+            return g_connman && g_connman->GetNetworkActive();
+        }
+        Amount getMinimumFee(unsigned int tx_bytes,
+                             const CCoinControl &coin_control) override {
+            Amount result;
+            CHECK_WALLET(result =
+                             GetMinimumFee(tx_bytes, g_mempool, coin_control));
+            return result;
+        }
+        Amount getMaxTxFee() override { return ::maxTxFee; }
+        CFeeRate getDustRelayFee() override { return ::dustRelayFee; }
+        CFeeRate getPayTxFee() override { CHECK_WALLET(return ::payTxFee); }
+        UniValue executeRpc(const std::string &command, const UniValue &params,
+                            const std::string &uri) override {
+            JSONRPCRequest req;
+            req.params = params;
+            req.strMethod = command;
+            req.URI = uri;
+            GlobalConfig config;
+            return ::tableRPC.execute(config, req);
+        }
+        std::vector<std::string> listRpcCommands() override {
+            return ::tableRPC.listCommands();
+        }
+        void rpcSetTimerInterfaceIfUnset(RPCTimerInterface *iface) override {
+            RPCSetTimerInterfaceIfUnset(iface);
+        }
+        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;
+            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));
+        }
+        std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) override {
+            return MakeHandler(::uiInterface.ThreadSafeMessageBox.connect(fn));
+        }
+        std::unique_ptr<Handler> handleQuestion(QuestionFn fn) override {
+            return MakeHandler(::uiInterface.ThreadSafeQuestion.connect(fn));
+        }
+        std::unique_ptr<Handler>
+        handleShowProgress(ShowProgressFn fn) override {
+            return MakeHandler(::uiInterface.ShowProgress.connect(fn));
+        }
+        std::unique_ptr<Handler> handleLoadWallet(LoadWalletFn fn) override {
+            CHECK_WALLET(return MakeHandler(::uiInterface.LoadWallet.connect(
+                [fn](CWallet *wallet) { fn(MakeWallet(*wallet)); })));
+        }
+        std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(
+            NotifyNumConnectionsChangedFn fn) override {
+            return MakeHandler(
+                ::uiInterface.NotifyNumConnectionsChanged.connect(fn));
+        }
+        std::unique_ptr<Handler> handleNotifyNetworkActiveChanged(
+            NotifyNetworkActiveChangedFn fn) override {
+            return MakeHandler(
+                ::uiInterface.NotifyNetworkActiveChanged.connect(fn));
+        }
+        std::unique_ptr<Handler>
+        handleNotifyAlertChanged(NotifyAlertChangedFn fn) override {
+            return MakeHandler(::uiInterface.NotifyAlertChanged.connect(fn));
+        }
+        std::unique_ptr<Handler>
+        handleBannedListChanged(BannedListChangedFn fn) override {
+            return MakeHandler(::uiInterface.BannedListChanged.connect(fn));
+        }
+        std::unique_ptr<Handler>
+        handleNotifyBlockTip(NotifyBlockTipFn fn) override {
+            return MakeHandler(::uiInterface.NotifyBlockTip.connect(
+                [fn](bool initial_download, const CBlockIndex *block) {
+                    fn(initial_download, block->nHeight, block->GetBlockTime(),
+                       GuessVerificationProgress(Params().TxData(), block));
+                }));
+        }
+        std::unique_ptr<Handler>
+        handleNotifyHeaderTip(NotifyHeaderTipFn fn) override {
+            return MakeHandler(::uiInterface.NotifyHeaderTip.connect(
+                [fn](bool initial_download, const CBlockIndex *block) {
+                    fn(initial_download, block->nHeight, block->GetBlockTime(),
+                       GuessVerificationProgress(Params().TxData(), block));
+                }));
+        }
+    };
+
+} // namespace
+
+std::unique_ptr<Node> MakeNode() {
+    return std::make_unique<NodeImpl>();
+}
+
+} // namespace interface
diff --git a/src/interface/wallet.h b/src/interface/wallet.h
new file mode 100644
--- /dev/null
+++ b/src/interface/wallet.h
@@ -0,0 +1,337 @@
+// Copyright (c) 2018 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_INTERFACE_WALLET_H
+#define BITCOIN_INTERFACE_WALLET_H
+
+#include <amount.h>                 // For Amount
+#include <primitives/transaction.h> // For CTxOut
+#include <pubkey.h>                 // For CTxDestination (CKeyID and CScriptID)
+#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 <functional>
+#include <map>
+#include <memory>
+#include <stdint.h>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+class CChainParams;
+class CCoinControl;
+class CKey;
+class CMutableTransaction;
+class COutPoint;
+struct CRecipient;
+class CTransaction;
+class CWallet;
+struct TxId;
+
+namespace interface {
+
+class Handler;
+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>;
+
+//! 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 set of addresses corresponding to a given label.
+    virtual std::set<CTxDestination>
+    getLabelAddresses(const std::string &label) = 0;
+
+    // Get key from pool.
+    virtual bool getKeyFromPool(bool internal, CPubKey &pub_key) = 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;
+
+    // Remove address.
+    virtual bool delAddressBook(const CTxDestination &dest) = 0;
+
+    //! Look up address in wallet, return whether exists.
+    virtual bool getAddress(const CTxDestination &dest,
+                            std::string *name = nullptr,
+                            isminetype *is_mine = nullptr) = 0;
+
+    //! Get wallet address list.
+    virtual std::vector<WalletAddress> getAddresses() = 0;
+
+    //! Add dest data.
+    virtual bool addDestData(const CTxDestination &dest, const std::string &key,
+                             const std::string &value) = 0;
+
+    //! Erase dest data.
+    virtual bool eraseDestData(const CTxDestination &dest,
+                               const std::string &key) = 0;
+
+    //! Get dest values with prefix.
+    virtual std::vector<std::string>
+    getDestValues(const std::string &prefix) = 0;
+
+    //! Lock coin.
+    virtual void lockCoin(const COutPoint &output) = 0;
+
+    //! Unlock coin.
+    virtual void unlockCoin(const COutPoint &output) = 0;
+
+    //! Return whether coin is locked.
+    virtual bool isLockedCoin(const COutPoint &output) = 0;
+
+    //! List locked coins.
+    virtual void listLockedCoins(std::vector<COutPoint> &outputs) = 0;
+
+    //! Create transaction.
+    virtual 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 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;
+
+    //! Get balances if possible without blocking.
+    virtual bool tryGetBalances(WalletBalances &balances, int &num_blocks) = 0;
+
+    //! Get balance.
+    virtual Amount getBalance() = 0;
+
+    //! Get available balance.
+    virtual Amount getAvailableBalance(const CCoinControl &coin_control) = 0;
+
+    //! Return whether transaction input belongs to wallet.
+    virtual isminetype txinIsMine(const CTxIn &txin) = 0;
+
+    //! Return whether transaction output belongs to wallet.
+    virtual isminetype txoutIsMine(const CTxOut &txout) = 0;
+
+    //! Return debit amount if transaction input belongs to wallet.
+    virtual Amount getDebit(const CTxIn &txin, isminefilter filter) = 0;
+
+    //! Return credit amount if transaction input belongs to wallet.
+    virtual Amount getCredit(const CTxOut &txout, isminefilter filter) = 0;
+
+    //! Return AvailableCoins + LockedCoins grouped by wallet address.
+    //! (put change in one group with wallet address)
+    using CoinsList = std::map<CTxDestination,
+                               std::vector<std::tuple<COutPoint, WalletTxOut>>>;
+    virtual CoinsList listCoins() = 0;
+
+    //! Return wallet transaction output information.
+    virtual std::vector<WalletTxOut>
+    getCoins(const std::vector<COutPoint> &outputs) = 0;
+
+    // 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;
+
+    //! Get virtual transaction size.
+    virtual int64_t getVirtualSize() = 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;
+};
+
+//! Information about one wallet address.
+struct WalletAddress {
+    CTxDestination dest;
+    isminetype is_mine;
+    std::string name;
+    std::string purpose;
+
+    WalletAddress(CTxDestination dest, isminetype is_mine, std::string name,
+                  std::string purpose)
+        : dest(std::move(dest)), is_mine(is_mine), name(std::move(name)),
+          purpose(std::move(purpose)) {}
+};
+
+//! Collection of wallet balances.
+struct WalletBalances {
+    Amount balance = Amount::zero();
+    Amount unconfirmed_balance = Amount::zero();
+    Amount immature_balance = Amount::zero();
+    bool have_watch_only = false;
+    Amount watch_only_balance = Amount::zero();
+    Amount unconfirmed_watch_only_balance = Amount::zero();
+    Amount immature_watch_only_balance = Amount::zero();
+
+    bool balanceChanged(const WalletBalances &prev) const {
+        return balance != prev.balance ||
+               unconfirmed_balance != prev.unconfirmed_balance ||
+               immature_balance != prev.immature_balance ||
+               watch_only_balance != prev.watch_only_balance ||
+               unconfirmed_watch_only_balance !=
+                   prev.unconfirmed_watch_only_balance ||
+               immature_watch_only_balance != prev.immature_watch_only_balance;
+    }
+};
+
+// Wallet transaction information.
+struct WalletTx {
+    CTransactionRef tx;
+    std::vector<isminetype> txin_is_mine;
+    std::vector<isminetype> txout_is_mine;
+    std::vector<CTxDestination> txout_address;
+    std::vector<isminetype> txout_address_is_mine;
+    Amount credit;
+    Amount debit;
+    Amount change;
+    int64_t time;
+    std::map<std::string, std::string> value_map;
+    bool is_coinbase;
+};
+
+//! Updated transaction status.
+struct WalletTxStatus {
+    int block_height;
+    int blocks_to_maturity;
+    int depth_in_main_chain;
+    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;
+    int64_t time;
+    int depth_in_main_chain = -1;
+    bool is_spent = false;
+};
+
+//! Return implementation of Wallet interface. This function will be undefined
+//! in builds where ENABLE_WALLET is false.
+std::unique_ptr<Wallet> MakeWallet(CWallet &wallet);
+
+} // namespace interface
+
+#endif // BITCOIN_INTERFACE_WALLET_H
diff --git a/src/interface/wallet.cpp b/src/interface/wallet.cpp
new file mode 100644
--- /dev/null
+++ b/src/interface/wallet.cpp
@@ -0,0 +1,421 @@
+// Copyright (c) 2018 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <interface/wallet.h>
+
+#include <amount.h>
+#include <chain.h>
+#include <consensus/validation.h>
+#include <interface/handler.h>
+#include <net.h>
+#include <policy/policy.h>
+#include <primitives/transaction.h>
+#include <script/standard.h>
+#include <support/allocators/secure.h>
+#include <sync.h>
+#include <timedata.h>
+#include <ui_interface.h>
+#include <util.h>
+#include <validation.h>
+#include <wallet/finaltx.h>
+#include <wallet/wallet.h>
+
+#include <memory>
+
+namespace interface {
+namespace {
+
+    class PendingWalletTxImpl : public PendingWalletTx {
+    public:
+        PendingWalletTxImpl(CWallet &wallet)
+            : m_wallet(wallet), m_key(&wallet) {}
+
+        const CTransaction &get() override { return *m_tx; }
+
+        int64_t getVirtualSize() override { return m_tx->GetTotalSize(); }
+
+        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;
+    };
+
+    //! 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;
+        auto mi = ::mapBlockIndex.find(wtx.hashBlock);
+        CBlockIndex *block = mi != ::mapBlockIndex.end() ? mi->second : nullptr;
+        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) {
+        WalletTxOut result;
+        result.txout = wtx.tx->vout[n];
+        result.time = wtx.GetTxTime();
+        result.depth_in_main_chain = depth;
+        result.is_spent = wallet.IsSpent(wtx.GetId(), n);
+        return result;
+    }
+
+    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;
+        }
+        std::set<CTxDestination>
+        getLabelAddresses(const std::string &label) override {
+            return m_wallet.GetLabelAddresses(label);
+        }
+        bool getKeyFromPool(bool internal, CPubKey &pub_key) override {
+            return m_wallet.GetKeyFromPool(pub_key, internal);
+        }
+        bool getPubKey(const CKeyID &address, CPubKey &pub_key) override {
+            return m_wallet.GetPubKey(address, pub_key);
+        }
+        bool getPrivKey(const CKeyID &address, CKey &key) override {
+            return m_wallet.GetKey(address, key);
+        }
+        bool isSpendable(const CTxDestination &dest) override {
+            return IsMine(m_wallet, dest) & ISMINE_SPENDABLE;
+        }
+        bool haveWatchOnly() override { return m_wallet.HaveWatchOnly(); };
+        bool setAddressBook(const CTxDestination &dest, const std::string &name,
+                            const std::string &purpose) override {
+            return m_wallet.SetAddressBook(dest, name, purpose);
+        }
+        bool delAddressBook(const CTxDestination &dest) override {
+            return m_wallet.DelAddressBook(dest);
+        }
+        bool getAddress(const CTxDestination &dest, std::string *name,
+                        isminetype *is_mine) 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;
+        }
+        std::vector<WalletAddress> getAddresses() override {
+            LOCK(m_wallet.cs_wallet);
+            std::vector<WalletAddress> result;
+            for (const auto &item : m_wallet.mapAddressBook) {
+                result.emplace_back(item.first, IsMine(m_wallet, item.first),
+                                    item.second.name, item.second.purpose);
+            }
+            return result;
+        }
+        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);
+        }
+        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,
+                            interface::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();
+            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);
+        }
+        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;
+            for (const auto &entry : m_wallet.ListCoins()) {
+                auto &group = result[entry.first];
+                for (const auto &coin : entry.second) {
+                    group.emplace_back(COutPoint(coin.tx->GetId(), coin.i),
+                                       MakeWalletTxOut(m_wallet, *coin.tx,
+                                                       coin.i, coin.nDepth));
+                }
+            }
+            return result;
+        }
+        std::vector<WalletTxOut>
+        getCoins(const std::vector<COutPoint> &outputs) override {
+            LOCK2(::cs_main, m_wallet.cs_wallet);
+            std::vector<WalletTxOut> result;
+            result.reserve(outputs.size());
+            for (const auto &output : outputs) {
+                result.emplace_back();
+                auto it = m_wallet.mapWallet.find(output.GetTxId());
+                if (it != m_wallet.mapWallet.end()) {
+                    int depth = it->second.GetDepthInMainChain();
+                    if (depth >= 0) {
+                        result.back() = MakeWalletTxOut(m_wallet, it->second,
+                                                        output.GetN(), depth);
+                    }
+                }
+            }
+            return result;
+        }
+        bool hdEnabled() override { return m_wallet.IsHDEnabled(); }
+        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;
+    };
+
+} // namespace
+
+std::unique_ptr<Wallet> MakeWallet(CWallet &wallet) {
+    return std::make_unique<WalletImpl>(wallet);
+}
+
+} // namespace interface
diff --git a/src/net_processing.h b/src/net_processing.h
--- a/src/net_processing.h
+++ b/src/net_processing.h
@@ -107,9 +107,9 @@
 };
 
 struct CNodeStateStats {
-    int nMisbehavior;
-    int nSyncHeight;
-    int nCommonHeight;
+    int nMisbehavior = 0;
+    int nSyncHeight = -1;
+    int nCommonHeight = -1;
     std::vector<int> vHeightInFlight;
 };
 
diff --git a/src/qt/addresstablemodel.h b/src/qt/addresstablemodel.h
--- a/src/qt/addresstablemodel.h
+++ b/src/qt/addresstablemodel.h
@@ -11,7 +11,9 @@
 class AddressTablePriv;
 class WalletModel;
 
-class CWallet;
+namespace interface {
+class Wallet;
+}
 
 /**
  * Qt model of the address book in the core. This allows views to access and
@@ -21,7 +23,7 @@
     Q_OBJECT
 
 public:
-    explicit AddressTableModel(CWallet *wallet, WalletModel *parent = 0);
+    explicit AddressTableModel(WalletModel *parent = 0);
     ~AddressTableModel();
 
     enum ColumnIndex {
@@ -93,7 +95,6 @@
 
 private:
     WalletModel *walletModel;
-    CWallet *wallet;
     AddressTablePriv *priv;
     QStringList columns;
     EditStatus editStatus;
diff --git a/src/qt/addresstablemodel.cpp b/src/qt/addresstablemodel.cpp
--- a/src/qt/addresstablemodel.cpp
+++ b/src/qt/addresstablemodel.cpp
@@ -8,6 +8,7 @@
 #include "walletmodel.h"
 
 #include "dstencode.h"
+#include "interface/node.h"
 #include "wallet/wallet.h"
 
 #include <QDebug>
@@ -68,27 +69,20 @@
 // Private implementation
 class AddressTablePriv {
 public:
-    CWallet *wallet;
     QList<AddressTableEntry> cachedAddressTable;
     AddressTableModel *parent;
 
-    AddressTablePriv(CWallet *_wallet, AddressTableModel *_parent)
-        : wallet(_wallet), parent(_parent) {}
+    AddressTablePriv(AddressTableModel *_parent) : parent(_parent) {}
 
-    void refreshAddressTable() {
+    void refreshAddressTable(interface::Wallet &wallet) {
         cachedAddressTable.clear();
         {
-            LOCK(wallet->cs_wallet);
-            for (const std::pair<CTxDestination, CAddressBookData> &item :
-                 wallet->mapAddressBook) {
-                const CTxDestination &address = item.first;
-                bool fMine = IsMine(*wallet, address);
+            for (const auto &address : wallet.getAddresses()) {
                 AddressTableEntry::Type addressType = translateTransactionType(
-                    QString::fromStdString(item.second.purpose), fMine);
-                const std::string &strName = item.second.name;
+                    QString::fromStdString(address.purpose), address.is_mine);
                 cachedAddressTable.append(AddressTableEntry(
-                    addressType, QString::fromStdString(strName),
-                    QString::fromStdString(EncodeDestination(address))));
+                    addressType, QString::fromStdString(address.name),
+                    QString::fromStdString(EncodeDestination(address.dest))));
             }
         }
         // qLowerBound() and qUpperBound() require our cachedAddressTable list
@@ -162,12 +156,11 @@
     }
 };
 
-AddressTableModel::AddressTableModel(CWallet *_wallet, WalletModel *parent)
-    : QAbstractTableModel(parent), walletModel(parent), wallet(_wallet),
-      priv(0) {
+AddressTableModel::AddressTableModel(WalletModel *parent)
+    : QAbstractTableModel(parent), walletModel(parent), priv(0) {
     columns << tr("Label") << tr("Address");
-    priv = new AddressTablePriv(wallet, this);
-    priv->refreshAddressTable();
+    priv = new AddressTablePriv(this);
+    priv->refreshAddressTable(parent->wallet());
 }
 
 AddressTableModel::~AddressTableModel() {
@@ -230,20 +223,19 @@
     editStatus = OK;
 
     if (role == Qt::EditRole) {
-        LOCK(wallet->cs_wallet); /* For SetAddressBook / DelAddressBook */
-        CTxDestination curAddress =
-            DecodeDestination(rec->address.toStdString(), wallet->chainParams);
+        CTxDestination curAddress = DecodeDestination(
+            rec->address.toStdString(), walletModel->getChainParams());
         if (index.column() == Label) {
             // Do nothing, if old label == new label
             if (rec->label == value.toString()) {
                 editStatus = NO_CHANGES;
                 return false;
             }
-            wallet->SetAddressBook(curAddress, value.toString().toStdString(),
-                                   strPurpose);
+            walletModel->wallet().setAddressBook(
+                curAddress, value.toString().toStdString(), strPurpose);
         } else if (index.column() == Address) {
             CTxDestination newAddress = DecodeDestination(
-                value.toString().toStdString(), wallet->chainParams);
+                value.toString().toStdString(), walletModel->getChainParams());
             // Refuse to set invalid address, set error status and return false
             if (boost::get<CNoDestination>(&newAddress)) {
                 editStatus = INVALID_ADDRESS;
@@ -257,17 +249,17 @@
             // Check for duplicate addresses to prevent accidental deletion of
             // addresses, if you try to paste an existing address over another
             // address (with a different label)
-            else if (wallet->mapAddressBook.count(newAddress)) {
+            if (walletModel->wallet().getAddress(newAddress)) {
                 editStatus = DUPLICATE_ADDRESS;
                 return false;
             }
             // Double-check that we're not overwriting a receiving address
             else if (rec->type == AddressTableEntry::Sending) {
                 // Remove old entry
-                wallet->DelAddressBook(curAddress);
+                walletModel->wallet().delAddressBook(curAddress);
                 // Add new entry with new address
-                wallet->SetAddressBook(newAddress, rec->label.toStdString(),
-                                       strPurpose);
+                walletModel->wallet().setAddressBook(
+                    newAddress, value.toString().toStdString(), strPurpose);
             }
         }
         return true;
@@ -333,9 +325,8 @@
         }
         // Check for duplicate addresses
         {
-            LOCK(wallet->cs_wallet);
-            if (wallet->mapAddressBook.count(
-                    DecodeDestination(strAddress, wallet->chainParams))) {
+            if (walletModel->wallet().getAddress(DecodeDestination(
+                    strAddress, walletModel->getChainParams()))) {
                 editStatus = DUPLICATE_ADDRESS;
                 return QString();
             }
@@ -343,14 +334,16 @@
     } else if (type == Receive) {
         // Generate a new address to associate with given label
         CPubKey newKey;
-        if (!wallet->GetKeyFromPool(newKey)) {
+        if (!walletModel->wallet().getKeyFromPool(false /* internal */,
+                                                  newKey)) {
             WalletModel::UnlockContext ctx(walletModel->requestUnlock());
             if (!ctx.isValid()) {
                 // Unlock wallet failed or was cancelled
                 editStatus = WALLET_UNLOCK_FAILURE;
                 return QString();
             }
-            if (!wallet->GetKeyFromPool(newKey)) {
+            if (!walletModel->wallet().getKeyFromPool(false /* internal */,
+                                                      newKey)) {
                 editStatus = KEY_GENERATION_FAILURE;
                 return QString();
             }
@@ -361,8 +354,9 @@
     }
 
     // Add entry
-    wallet->SetAddressBook(DecodeDestination(strAddress, wallet->chainParams),
-                           strLabel, (type == Send ? "send" : "receive"));
+    walletModel->wallet().setAddressBook(
+        DecodeDestination(strAddress, walletModel->getChainParams()), strLabel,
+        (type == Send ? "send" : "receive"));
     return QString::fromStdString(strAddress);
 }
 
@@ -376,8 +370,8 @@
         // Also refuse to remove receiving addresses.
         return false;
     }
-    wallet->DelAddressBook(
-        DecodeDestination(rec->address.toStdString(), wallet->chainParams));
+    walletModel->wallet().delAddressBook(DecodeDestination(
+        rec->address.toStdString(), walletModel->getChainParams()));
     return true;
 }
 
@@ -385,13 +379,11 @@
  */
 QString AddressTableModel::labelForAddress(const QString &address) const {
     {
-        LOCK(wallet->cs_wallet);
-        CTxDestination destination =
-            DecodeDestination(address.toStdString(), wallet->chainParams);
-        std::map<CTxDestination, CAddressBookData>::iterator mi =
-            wallet->mapAddressBook.find(destination);
-        if (mi != wallet->mapAddressBook.end()) {
-            return QString::fromStdString(mi->second.name);
+        CTxDestination destination = DecodeDestination(
+            address.toStdString(), walletModel->getChainParams());
+        std::string name;
+        if (walletModel->wallet().getAddress(destination, &name)) {
+            return QString::fromStdString(name);
         }
     }
     return QString();
diff --git a/src/qt/bantablemodel.h b/src/qt/bantablemodel.h
--- a/src/qt/bantablemodel.h
+++ b/src/qt/bantablemodel.h
@@ -13,6 +13,10 @@
 class ClientModel;
 class BanTablePriv;
 
+namespace interface {
+class Node;
+}
+
 struct CCombinedBan {
     CSubNet subnet;
     CBanEntry banEntry;
@@ -37,7 +41,7 @@
     Q_OBJECT
 
 public:
-    explicit BanTableModel(ClientModel *parent = 0);
+    explicit BanTableModel(interface::Node &node, ClientModel *parent = 0);
     ~BanTableModel();
     void startAutoRefresh();
     void stopAutoRefresh();
@@ -62,6 +66,7 @@
     void refresh();
 
 private:
+    interface::Node &m_node;
     ClientModel *clientModel;
     QStringList columns;
     std::unique_ptr<BanTablePriv> priv;
diff --git a/src/qt/bantablemodel.cpp b/src/qt/bantablemodel.cpp
--- a/src/qt/bantablemodel.cpp
+++ b/src/qt/bantablemodel.cpp
@@ -8,6 +8,7 @@
 #include "guiconstants.h"
 #include "guiutil.h"
 
+#include "interface/node.h"
 #include "sync.h"
 #include "utiltime.h"
 
@@ -43,9 +44,9 @@
     Qt::SortOrder sortOrder;
 
     /** Pull a full list of banned nodes from CNode into our cache */
-    void refreshBanlist() {
+    void refreshBanlist(interface::Node &node) {
         banmap_t banMap;
-        if (g_connman) g_connman->GetBanned(banMap);
+        node.getBanned(banMap);
 
         cachedBanlist.clear();
         cachedBanlist.reserve(banMap.size());
@@ -72,8 +73,8 @@
     }
 };
 
-BanTableModel::BanTableModel(ClientModel *parent)
-    : QAbstractTableModel(parent), clientModel(parent) {
+BanTableModel::BanTableModel(interface::Node &node, ClientModel *parent)
+    : QAbstractTableModel(parent), m_node(node), clientModel(parent) {
     columns << tr("IP/Netmask") << tr("Banned Until");
     priv.reset(new BanTablePriv());
     // default to unsorted
@@ -144,7 +145,7 @@
 
 void BanTableModel::refresh() {
     Q_EMIT layoutAboutToBeChanged();
-    priv->refreshBanlist();
+    priv->refreshBanlist(m_node);
     Q_EMIT layoutChanged();
 }
 
diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp
--- a/src/qt/bitcoin.cpp
+++ b/src/qt/bitcoin.cpp
@@ -28,6 +28,8 @@
 #endif
 
 #include "init.h"
+#include "interface/handler.h"
+#include "interface/node.h"
 #include "rpc/server.h"
 #include "ui_interface.h"
 #include "uint256.h"
@@ -35,7 +37,7 @@
 #include "warnings.h"
 
 #ifdef ENABLE_WALLET
-#include "wallet/wallet.h"
+// TODO: Remove this sections?
 #endif
 #include "walletinitinterface.h"
 
@@ -173,13 +175,7 @@
 class BitcoinABC : public QObject {
     Q_OBJECT
 public:
-    explicit BitcoinABC();
-
-    /**
-     * Basic initialization, before starting initialization/shutdown thread.
-     * Return true on success.
-     */
-    static bool baseInitialize(Config &config, RPCServer &rpcServer);
+    explicit BitcoinABC(interface::Node &node);
 
 public Q_SLOTS:
     void initialize(Config *config,
@@ -194,13 +190,15 @@
 private:
     /// Pass fatal exception message to UI thread
     void handleRunawayException(const std::exception *e);
+
+    interface::Node &m_node;
 };
 
 /** Main Bitcoin application object */
 class BitcoinApplication : public QApplication {
     Q_OBJECT
 public:
-    explicit BitcoinApplication(int &argc, char **argv);
+    explicit BitcoinApplication(interface::Node &node, int &argc, char **argv);
     ~BitcoinApplication();
 
 #ifdef ENABLE_WALLET
@@ -244,6 +242,7 @@
 
 private:
     QThread *coreThread;
+    interface::Node &m_node;
     OptionsModel *optionsModel;
     ClientModel *clientModel;
     BitcoinGUI *window;
@@ -261,27 +260,11 @@
 
 #include "bitcoin.moc"
 
-BitcoinABC::BitcoinABC() : QObject() {}
+BitcoinABC::BitcoinABC(interface::Node &node) : QObject(), m_node(node) {}
 
 void BitcoinABC::handleRunawayException(const std::exception *e) {
     PrintExceptionContinue(e, "Runaway exception");
-    Q_EMIT runawayException(QString::fromStdString(GetWarnings("gui")));
-}
-
-bool BitcoinABC::baseInitialize(Config &config, RPCServer &rpcServer) {
-    if (!AppInitBasicSetup()) {
-        return false;
-    }
-    if (!AppInitParameterInteraction(config, rpcServer)) {
-        return false;
-    }
-    if (!AppInitSanityChecks()) {
-        return false;
-    }
-    if (!AppInitLockDataDirectory()) {
-        return false;
-    }
-    return true;
+    Q_EMIT runawayException(QString::fromStdString(m_node.getWarnings("gui")));
 }
 
 void BitcoinABC::initialize(Config *cfg,
@@ -289,7 +272,7 @@
     Config &config(*cfg);
     try {
         qDebug() << __func__ << ": Running initialization in thread";
-        bool rv = AppInitMain(config, *httpRPCRequestProcessor);
+        bool rv = m_node.appInitMain(config, *httpRPCRequestProcessor);
         Q_EMIT initializeResult(rv);
     } catch (const std::exception &e) {
         handleRunawayException(&e);
@@ -301,8 +284,7 @@
 void BitcoinABC::shutdown() {
     try {
         qDebug() << __func__ << ": Running Shutdown in thread";
-        Interrupt();
-        Shutdown();
+        m_node.appShutdown();
         qDebug() << __func__ << ": Shutdown finished";
         Q_EMIT shutdownResult();
     } catch (const std::exception &e) {
@@ -312,9 +294,10 @@
     }
 }
 
-BitcoinApplication::BitcoinApplication(int &argc, char **argv)
-    : QApplication(argc, argv), coreThread(0), optionsModel(0), clientModel(0),
-      window(0), pollShutdownTimer(0),
+BitcoinApplication::BitcoinApplication(interface::Node &node, int &argc,
+                                       char **argv)
+    : QApplication(argc, argv), coreThread(0), m_node(node), optionsModel(0),
+      clientModel(0), window(0), pollShutdownTimer(0),
 #ifdef ENABLE_WALLET
       paymentServer(0), m_wallet_models(),
 #endif
@@ -362,12 +345,12 @@
 #endif
 
 void BitcoinApplication::createOptionsModel(bool resetSettings) {
-    optionsModel = new OptionsModel(nullptr, resetSettings);
+    optionsModel = new OptionsModel(m_node, nullptr, resetSettings);
 }
 
 void BitcoinApplication::createWindow(const Config *config,
                                       const NetworkStyle *networkStyle) {
-    window = new BitcoinGUI(config, platformStyle, networkStyle, 0);
+    window = new BitcoinGUI(m_node, config, platformStyle, networkStyle, 0);
 
     pollShutdownTimer = new QTimer(window);
     connect(pollShutdownTimer, SIGNAL(timeout()), window,
@@ -375,7 +358,7 @@
 }
 
 void BitcoinApplication::createSplashScreen(const NetworkStyle *networkStyle) {
-    SplashScreen *splash = new SplashScreen(0, networkStyle);
+    SplashScreen *splash = new SplashScreen(m_node, 0, networkStyle);
     // We don't hold a direct pointer to the splash screen after creation, but
     // the splash screen will take care of deleting itself when slotFinish
     // happens.
@@ -390,7 +373,7 @@
         return;
     }
     coreThread = new QThread(this);
-    BitcoinABC *executor = new BitcoinABC();
+    BitcoinABC *executor = new BitcoinABC(m_node);
     executor->moveToThread(coreThread);
 
     /*  communication to and from thread */
@@ -426,8 +409,8 @@
 }
 
 void BitcoinApplication::parameterSetup() {
-    InitLogging();
-    InitParameterInteraction();
+    m_node.initLogging();
+    m_node.initParameterInteraction();
 }
 
 void BitcoinApplication::requestInitialize(
@@ -462,7 +445,7 @@
     delete clientModel;
     clientModel = 0;
 
-    StartShutdown();
+    m_node.startShutdown();
 
     // Request shutdown from core thread
     Q_EMIT requestedShutdown();
@@ -486,14 +469,15 @@
     paymentServer->setOptionsModel(optionsModel);
 #endif
 
-    clientModel = new ClientModel(optionsModel);
+    clientModel = new ClientModel(m_node, optionsModel);
     window->setClientModel(clientModel);
 
 #ifdef ENABLE_WALLET
     bool fFirstWallet = true;
-    for (CWalletRef pwallet : vpwallets) {
-        WalletModel *const walletModel =
-            new WalletModel(platformStyle, pwallet, optionsModel);
+    auto wallets = m_node.getWallets();
+    for (auto &wallet : wallets) {
+        WalletModel *const walletModel = new WalletModel(
+            std::move(wallet), m_node, platformStyle, optionsModel);
 
         window->addWallet(walletModel);
         if (fFirstWallet) {
@@ -501,11 +485,12 @@
             fFirstWallet = false;
         }
 
-        connect(walletModel,
-                SIGNAL(coinsSent(CWallet *, SendCoinsRecipient, QByteArray)),
-                paymentServer,
-                SLOT(fetchPaymentACK(CWallet *, const SendCoinsRecipient &,
-                                     QByteArray)));
+        connect(
+            walletModel,
+            SIGNAL(coinsSent(WalletModel *, SendCoinsRecipient, QByteArray)),
+            paymentServer,
+            SLOT(fetchPaymentACK(WalletModel *, const SendCoinsRecipient &,
+                                 QByteArray)));
 
         m_wallet_models.push_back(walletModel);
     }
@@ -598,9 +583,11 @@
 int main(int argc, char *argv[]) {
     SetupEnvironment();
 
+    std::unique_ptr<interface::Node> node = interface::MakeNode();
+
     /// 1. Parse command-line options. These take precedence over anything else.
     // Command-line options take precedence:
-    gArgs.ParseParameters(argc, argv);
+    node->parseParameters(argc, argv);
 
     // Do not refer to data directory yet, this can be overridden by
     // Intro::pickDataDirectory
@@ -610,7 +597,7 @@
     Q_INIT_RESOURCE(bitcoin);
     Q_INIT_RESOURCE(bitcoin_locale);
 
-    BitcoinApplication app(argc, argv);
+    BitcoinApplication app(*node, argc, argv);
 #if QT_VERSION > 0x050100
     // Generate high-dpi pixmaps
     QApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
@@ -664,14 +651,14 @@
     // Show help message immediately after parsing command-line options (for
     // "-lang") and setting locale, but before showing splash screen.
     if (HelpRequested(gArgs) || gArgs.IsArgSet("-version")) {
-        HelpMessageDialog help(nullptr, gArgs.IsArgSet("-version"));
+        HelpMessageDialog help(*node, nullptr, gArgs.IsArgSet("-version"));
         help.showOrPrint();
         return EXIT_SUCCESS;
     }
 
     /// 5. Now that settings and translations are available, ask user for data
     /// directory. User language is set up: pick a data directory.
-    if (!Intro::pickDataDirectory()) {
+    if (!Intro::pickDataDirectory(*node)) {
         return EXIT_SUCCESS;
     }
 
@@ -686,7 +673,7 @@
         return EXIT_FAILURE;
     }
     try {
-        gArgs.ReadConfigFile(gArgs.GetArg("-conf", BITCOIN_CONF_FILENAME));
+        node->readConfigFile(gArgs.GetArg("-conf", BITCOIN_CONF_FILENAME));
     } catch (const std::exception &e) {
         QMessageBox::critical(
             0, QObject::tr(PACKAGE_NAME),
@@ -707,7 +694,7 @@
     // Check for -testnet or -regtest parameter (Params() calls are only valid
     // after this clause)
     try {
-        SelectParams(gArgs.GetChainName());
+        node->selectParams(gArgs.GetChainName());
     } catch (std::exception &e) {
         QMessageBox::critical(0, QObject::tr(PACKAGE_NAME),
                               QObject::tr("Error: %1").arg(e.what()));
@@ -715,7 +702,7 @@
     }
 #ifdef ENABLE_WALLET
     // Parse URIs on command line -- this can affect Params()
-    PaymentServer::ipcParseCommandLine(argc, argv);
+    PaymentServer::ipcParseCommandLine(*node, argc, argv);
 #endif
 
     QScopedPointer<const NetworkStyle> networkStyle(NetworkStyle::instantiate(
@@ -765,7 +752,8 @@
     app.createOptionsModel(gArgs.GetBoolArg("-resetguisettings", false));
 
     // Subscribe to global signals from core
-    uiInterface.InitMessage.connect(InitMessage);
+    std::unique_ptr<interface::Handler> handler =
+        node->handleInitMessage(InitMessage);
 
     // Get global config
     Config &config = const_cast<Config &>(GetConfig());
@@ -784,7 +772,7 @@
         // initialization/shutdown thread. This is acceptable because this
         // function only contains steps that are quick to execute, so the GUI
         // thread won't be held up.
-        if (!BitcoinABC::baseInitialize(config, rpcServer)) {
+        if (!node->baseInitialize(config, rpcServer)) {
             // A dialog with detailed error will have been shown by InitError()
             return EXIT_FAILURE;
         }
@@ -801,10 +789,12 @@
         return app.getReturnValue();
     } catch (const std::exception &e) {
         PrintExceptionContinue(&e, "Runaway exception");
-        app.handleRunawayException(QString::fromStdString(GetWarnings("gui")));
+        app.handleRunawayException(
+            QString::fromStdString(node->getWarnings("gui")));
     } catch (...) {
         PrintExceptionContinue(nullptr, "Runaway exception");
-        app.handleRunawayException(QString::fromStdString(GetWarnings("gui")));
+        app.handleRunawayException(
+            QString::fromStdString(node->getWarnings("gui")));
     }
     return EXIT_FAILURE;
 }
diff --git a/src/qt/bitcoingui.h b/src/qt/bitcoingui.h
--- a/src/qt/bitcoingui.h
+++ b/src/qt/bitcoingui.h
@@ -18,6 +18,8 @@
 #include <QPoint>
 #include <QSystemTrayIcon>
 
+#include <memory>
+
 class ClientModel;
 class NetworkStyle;
 class Notificator;
@@ -34,6 +36,11 @@
 class Config;
 class CWallet;
 
+namespace interface {
+class Handler;
+class Node;
+}
+
 QT_BEGIN_NAMESPACE
 class QAction;
 class QComboBox;
@@ -52,7 +59,8 @@
 public:
     static const std::string DEFAULT_UIPLATFORM;
 
-    explicit BitcoinGUI(const Config *, const PlatformStyle *platformStyle,
+    explicit BitcoinGUI(interface::Node &node, const Config *,
+                        const PlatformStyle *platformStyle,
                         const NetworkStyle *networkStyle, QWidget *parent = 0);
     ~BitcoinGUI();
 
@@ -83,6 +91,9 @@
     bool eventFilter(QObject *object, QEvent *event) override;
 
 private:
+    interface::Node &m_node;
+    std::unique_ptr<interface::Handler> m_handler_message_box;
+    std::unique_ptr<interface::Handler> m_handler_question;
     ClientModel *clientModel = nullptr;
     WalletFrame *walletFrame = nullptr;
 
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -34,6 +34,8 @@
 
 #include "chainparams.h"
 #include "init.h"
+#include "interface/handler.h"
+#include "interface/node.h"
 #include "ui_interface.h"
 #include "util.h"
 
@@ -70,11 +72,11 @@
 #endif
     ;
 
-BitcoinGUI::BitcoinGUI(const Config *configIn,
+BitcoinGUI::BitcoinGUI(interface::Node &node, const Config *configIn,
                        const PlatformStyle *_platformStyle,
                        const NetworkStyle *networkStyle, QWidget *parent)
-    : QMainWindow(parent), enableWallet(false), platformStyle(_platformStyle),
-      config(configIn) {
+    : QMainWindow(parent), enableWallet(false), m_node(node),
+      platformStyle(_platformStyle), config(configIn) {
     QSettings settings;
     if (!restoreGeometry(settings.value("MainWindowGeometry").toByteArray())) {
         // Restore failed (perhaps missing setting), center the window
@@ -100,8 +102,8 @@
 #endif
     setWindowTitle(windowTitle);
 
-    rpcConsole = new RPCConsole(_platformStyle, 0);
-    helpMessageDialog = new HelpMessageDialog(this, false);
+    rpcConsole = new RPCConsole(node, _platformStyle, 0);
+    helpMessageDialog = new HelpMessageDialog(node, this, false);
 #ifdef ENABLE_WALLET
     if (enableWallet) {
         /** Create wallet frame and make it the central widget */
@@ -524,9 +526,9 @@
         modalOverlay->setKnownBestHeight(
             _clientModel->getHeaderTipHeight(),
             QDateTime::fromTime_t(_clientModel->getHeaderTipTime()));
-        setNumBlocks(_clientModel->getNumBlocks(),
-                     _clientModel->getLastBlockDate(),
-                     _clientModel->getVerificationProgress(nullptr), false);
+        setNumBlocks(m_node.getNumBlocks(),
+                     QDateTime::fromTime_t(m_node.getLastBlockTime()),
+                     m_node.getVerificationProgress(), false);
         connect(_clientModel,
                 SIGNAL(numBlocksChanged(int, QDateTime, double, bool)), this,
                 SLOT(setNumBlocks(int, QDateTime, double, bool)));
@@ -690,7 +692,7 @@
 void BitcoinGUI::aboutClicked() {
     if (!clientModel) return;
 
-    HelpMessageDialog dlg(this, true);
+    HelpMessageDialog dlg(m_node, this, true);
     dlg.exec();
 }
 
@@ -776,7 +778,7 @@
 
     QString tooltip;
 
-    if (clientModel->getNetworkActive()) {
+    if (m_node.getNetworkActive()) {
         tooltip = tr("%n active connection(s) to Bitcoin network", "", count) +
                   QString(".<br>") + tr("Click to disable network activity.");
     } else {
@@ -1042,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);
@@ -1155,7 +1157,7 @@
     }
     WalletModel *const walletModel = walletView->getWalletModel();
     setEncryptionStatus(walletModel->getEncryptionStatus());
-    setHDStatus(walletModel->hdEnabled());
+    setHDStatus(walletModel->wallet().hdEnabled());
 }
 #endif // ENABLE_WALLET
 
@@ -1184,7 +1186,7 @@
 }
 
 void BitcoinGUI::detectShutdown() {
-    if (ShutdownRequested()) {
+    if (m_node.shutdownRequested()) {
         if (rpcConsole) {
             rpcConsole->hide();
         }
@@ -1244,24 +1246,20 @@
 
 void BitcoinGUI::subscribeToCoreSignals() {
     // Connect signals to client
-    uiInterface.ThreadSafeMessageBox.connect(
+    m_handler_message_box = m_node.handleMessageBox(
         boost::bind(ThreadSafeMessageBox, this, _1, _2, _3));
-    uiInterface.ThreadSafeQuestion.connect(
+    m_handler_question = m_node.handleQuestion(
         boost::bind(ThreadSafeMessageBox, this, _1, _3, _4));
 }
 
 void BitcoinGUI::unsubscribeFromCoreSignals() {
     // Disconnect signals from client
-    uiInterface.ThreadSafeMessageBox.disconnect(
-        boost::bind(ThreadSafeMessageBox, this, _1, _2, _3));
-    uiInterface.ThreadSafeQuestion.disconnect(
-        boost::bind(ThreadSafeMessageBox, this, _1, _3, _4));
+    m_handler_message_box->disconnect();
+    m_handler_question->disconnect();
 }
 
 void BitcoinGUI::toggleNetworkActive() {
-    if (clientModel) {
-        clientModel->setNetworkActive(!clientModel->getNetworkActive());
-    }
+    m_node.setNetworkActive(!m_node.getNetworkActive());
 }
 
 UnitDisplayStatusBarControl::UnitDisplayStatusBarControl(
diff --git a/src/qt/clientmodel.h b/src/qt/clientmodel.h
--- a/src/qt/clientmodel.h
+++ b/src/qt/clientmodel.h
@@ -9,6 +9,7 @@
 #include <QObject>
 
 #include <atomic>
+#include <memory>
 
 class AddressTableModel;
 class BanTableModel;
@@ -19,6 +20,11 @@
 class CWallet;
 class CBlockIndex;
 
+namespace interface {
+class Handler;
+class Node;
+}
+
 QT_BEGIN_NAMESPACE
 class QTimer;
 QT_END_NAMESPACE
@@ -37,37 +43,24 @@
     Q_OBJECT
 
 public:
-    explicit ClientModel(OptionsModel *optionsModel, QObject *parent = 0);
+    explicit ClientModel(interface::Node &node, OptionsModel *optionsModel,
+                         QObject *parent = 0);
     ~ClientModel();
 
+    interface::Node &node() const {
+        return m_node;
+    }
     OptionsModel *getOptionsModel();
     PeerTableModel *getPeerTableModel();
     BanTableModel *getBanTableModel();
 
     //! Return number of connections, default is in- and outbound (total)
     int getNumConnections(unsigned int flags = CONNECTIONS_ALL) const;
-    int getNumBlocks() const;
     int getHeaderTipHeight() const;
     int64_t getHeaderTipTime() const;
-    //! Return number of transactions in the mempool
-    long getMempoolSize() const;
-    //! Return the dynamic memory usage of the mempool
-    size_t getMempoolDynamicUsage() const;
-
-    quint64 getTotalBytesRecv() const;
-    quint64 getTotalBytesSent() const;
-
-    double getVerificationProgress(const CBlockIndex *tip) const;
-    QDateTime getLastBlockDate() const;
 
-    //! Return true if core is doing initial block download
-    bool inInitialBlockDownload() const;
     //! Returns enum BlockSource of the current importing/syncing state
     enum BlockSource getBlockSource() const;
-    //! Return true if network activity in core is enabled
-    bool getNetworkActive() const;
-    //! Toggle network activity state in core
-    void setNetworkActive(bool active);
     //! Return warnings to be displayed in status bar
     QString getStatusBarWarnings() const;
 
@@ -82,6 +75,15 @@
     mutable std::atomic<int64_t> cachedBestHeaderTime;
 
 private:
+    interface::Node &m_node;
+    std::unique_ptr<interface::Handler> m_handler_show_progress;
+    std::unique_ptr<interface::Handler>
+        m_handler_notify_num_connections_changed;
+    std::unique_ptr<interface::Handler> m_handler_notify_network_active_changed;
+    std::unique_ptr<interface::Handler> m_handler_notify_alert_changed;
+    std::unique_ptr<interface::Handler> m_handler_banned_list_changed;
+    std::unique_ptr<interface::Handler> m_handler_notify_block_tip;
+    std::unique_ptr<interface::Handler> m_handler_notify_header_tip;
     OptionsModel *optionsModel;
     PeerTableModel *peerTableModel;
     BanTableModel *banTableModel;
diff --git a/src/qt/clientmodel.cpp b/src/qt/clientmodel.cpp
--- a/src/qt/clientmodel.cpp
+++ b/src/qt/clientmodel.cpp
@@ -14,6 +14,8 @@
 #include "checkpoints.h"
 #include "clientversion.h"
 #include "config.h"
+#include "interface/handler.h"
+#include "interface/node.h"
 #include "net.h"
 #include "txmempool.h"
 #include "ui_interface.h"
@@ -31,13 +33,14 @@
 static int64_t nLastHeaderTipUpdateNotification = 0;
 static int64_t nLastBlockTipUpdateNotification = 0;
 
-ClientModel::ClientModel(OptionsModel *_optionsModel, QObject *parent)
-    : QObject(parent), optionsModel(_optionsModel), peerTableModel(0),
-      banTableModel(0), pollTimer(0) {
+ClientModel::ClientModel(interface::Node &node, OptionsModel *_optionsModel,
+                         QObject *parent)
+    : QObject(parent), m_node(node), optionsModel(_optionsModel),
+      peerTableModel(0), banTableModel(0), pollTimer(0) {
     cachedBestHeaderHeight = -1;
     cachedBestHeaderTime = -1;
-    peerTableModel = new PeerTableModel(this);
-    banTableModel = new BanTableModel(this);
+    peerTableModel = new PeerTableModel(m_node, this);
+    banTableModel = new BanTableModel(m_node, this);
     pollTimer = new QTimer(this);
     connect(pollTimer, SIGNAL(timeout()), this, SLOT(updateTimer()));
     pollTimer->start(MODEL_UPDATE_DELAY);
@@ -60,25 +63,18 @@
         connections = CConnman::CONNECTIONS_ALL;
     }
 
-    if (g_connman) {
-        return g_connman->GetNodeCount(connections);
-    }
-    return 0;
-}
-
-int ClientModel::getNumBlocks() const {
-    LOCK(cs_main);
-    return chainActive.Height();
+    return m_node.getNodeCount(connections);
 }
 
 int ClientModel::getHeaderTipHeight() const {
     if (cachedBestHeaderHeight == -1) {
         // make sure we initially populate the cache via a cs_main lock
         // otherwise we need to wait for a tip update
-        LOCK(cs_main);
-        if (pindexBestHeader) {
-            cachedBestHeaderHeight = pindexBestHeader->nHeight;
-            cachedBestHeaderTime = pindexBestHeader->GetBlockTime();
+        int height;
+        int64_t blockTime;
+        if (m_node.getHeaderTip(height, blockTime)) {
+            cachedBestHeaderHeight = height;
+            cachedBestHeaderTime = blockTime;
         }
     }
     return cachedBestHeaderHeight;
@@ -86,62 +82,22 @@
 
 int64_t ClientModel::getHeaderTipTime() const {
     if (cachedBestHeaderTime == -1) {
-        LOCK(cs_main);
-        if (pindexBestHeader) {
-            cachedBestHeaderHeight = pindexBestHeader->nHeight;
-            cachedBestHeaderTime = pindexBestHeader->GetBlockTime();
+        int height;
+        int64_t blockTime;
+        if (m_node.getHeaderTip(height, blockTime)) {
+            cachedBestHeaderHeight = height;
+            cachedBestHeaderTime = blockTime;
         }
     }
     return cachedBestHeaderTime;
 }
 
-quint64 ClientModel::getTotalBytesRecv() const {
-    if (!g_connman) {
-        return 0;
-    }
-    return g_connman->GetTotalBytesRecv();
-}
-
-quint64 ClientModel::getTotalBytesSent() const {
-    if (!g_connman) {
-        return 0;
-    }
-    return g_connman->GetTotalBytesSent();
-}
-
-QDateTime ClientModel::getLastBlockDate() const {
-    LOCK(cs_main);
-
-    if (chainActive.Tip()) {
-        return QDateTime::fromTime_t(chainActive.Tip()->GetBlockTime());
-    }
-
-    // Genesis block's time of current network
-    return QDateTime::fromTime_t(Params().GenesisBlock().GetBlockTime());
-}
-
-long ClientModel::getMempoolSize() const {
-    return g_mempool.size();
-}
-
-size_t ClientModel::getMempoolDynamicUsage() const {
-    return g_mempool.DynamicMemoryUsage();
-}
-
-double ClientModel::getVerificationProgress(const CBlockIndex *tipIn) const {
-    CBlockIndex *tip = const_cast<CBlockIndex *>(tipIn);
-    if (!tip) {
-        LOCK(cs_main);
-        tip = chainActive.Tip();
-    }
-    return GuessVerificationProgress(Params().TxData(), tip);
-}
-
 void ClientModel::updateTimer() {
     // no locking required at this point
     // the following calls will acquire the required lock
-    Q_EMIT mempoolSizeChanged(getMempoolSize(), getMempoolDynamicUsage());
-    Q_EMIT bytesChanged(getTotalBytesRecv(), getTotalBytesSent());
+    Q_EMIT mempoolSizeChanged(m_node.getMempoolSize(),
+                              m_node.getMempoolDynamicUsage());
+    Q_EMIT bytesChanged(m_node.getTotalBytesRecv(), m_node.getTotalBytesSent());
 }
 
 void ClientModel::updateNumConnections(int numConnections) {
@@ -156,14 +112,10 @@
     Q_EMIT alertsChanged(getStatusBarWarnings());
 }
 
-bool ClientModel::inInitialBlockDownload() const {
-    return IsInitialBlockDownload();
-}
-
 enum BlockSource ClientModel::getBlockSource() const {
-    if (fReindex) {
+    if (m_node.getReindex()) {
         return BlockSource::REINDEX;
-    } else if (fImporting) {
+    } else if (m_node.getImporting()) {
         return BlockSource::DISK;
     } else if (getNumConnections() > 0) {
         return BlockSource::NETWORK;
@@ -172,21 +124,8 @@
     return BlockSource::NONE;
 }
 
-void ClientModel::setNetworkActive(bool active) {
-    if (g_connman) {
-        g_connman->SetNetworkActive(active);
-    }
-}
-
-bool ClientModel::getNetworkActive() const {
-    if (g_connman) {
-        return g_connman->GetNetworkActive();
-    }
-    return false;
-}
-
 QString ClientModel::getStatusBarWarnings() const {
-    return QString::fromStdString(GetWarnings("gui"));
+    return QString::fromStdString(m_node.getWarnings("gui"));
 }
 
 OptionsModel *ClientModel::getOptionsModel() {
@@ -261,7 +200,8 @@
 }
 
 static void BlockTipChanged(ClientModel *clientmodel, bool initialSync,
-                            const CBlockIndex *pIndex, bool fHeader) {
+                            int height, int64_t blockTime,
+                            double verificationProgress, bool fHeader) {
     // lock free async UI updates in case we have a new block tip
     // during initial sync, only update the UI if the last update
     // was > 250ms (MODEL_UPDATE_DELAY) ago
@@ -276,52 +216,48 @@
 
     if (fHeader) {
         // cache best headers time and height to reduce future cs_main locks
-        clientmodel->cachedBestHeaderHeight = pIndex->nHeight;
-        clientmodel->cachedBestHeaderTime = pIndex->GetBlockTime();
+        clientmodel->cachedBestHeaderHeight = height;
+        clientmodel->cachedBestHeaderTime = blockTime;
     }
     // if we are in-sync, update the UI regardless of last update time
     if (!initialSync || now - nLastUpdateNotification > MODEL_UPDATE_DELAY) {
         // pass a async signal to the UI thread
         QMetaObject::invokeMethod(
             clientmodel, "numBlocksChanged", Qt::QueuedConnection,
-            Q_ARG(int, pIndex->nHeight),
-            Q_ARG(QDateTime, QDateTime::fromTime_t(pIndex->GetBlockTime())),
-            Q_ARG(double, clientmodel->getVerificationProgress(pIndex)),
-            Q_ARG(bool, fHeader));
+            Q_ARG(int, height),
+            Q_ARG(QDateTime, QDateTime::fromTime_t(blockTime)),
+            Q_ARG(double, verificationProgress), Q_ARG(bool, fHeader));
         nLastUpdateNotification = now;
     }
 }
 
 void ClientModel::subscribeToCoreSignals() {
     // Connect signals to client
-    uiInterface.ShowProgress.connect(boost::bind(ShowProgress, this, _1, _2));
-    uiInterface.NotifyNumConnectionsChanged.connect(
-        boost::bind(NotifyNumConnectionsChanged, this, _1));
-    uiInterface.NotifyNetworkActiveChanged.connect(
-        boost::bind(NotifyNetworkActiveChanged, this, _1));
-    uiInterface.NotifyAlertChanged.connect(
-        boost::bind(NotifyAlertChanged, this));
-    uiInterface.BannedListChanged.connect(boost::bind(BannedListChanged, this));
-    uiInterface.NotifyBlockTip.connect(
-        boost::bind(BlockTipChanged, this, _1, _2, false));
-    uiInterface.NotifyHeaderTip.connect(
-        boost::bind(BlockTipChanged, this, _1, _2, true));
+    m_handler_show_progress =
+        m_node.handleShowProgress(boost::bind(ShowProgress, this, _1, _2));
+    m_handler_notify_num_connections_changed =
+        m_node.handleNotifyNumConnectionsChanged(
+            boost::bind(NotifyNumConnectionsChanged, this, _1));
+    m_handler_notify_network_active_changed =
+        m_node.handleNotifyNetworkActiveChanged(
+            boost::bind(NotifyNetworkActiveChanged, this, _1));
+    m_handler_notify_alert_changed =
+        m_node.handleNotifyAlertChanged(boost::bind(NotifyAlertChanged, this));
+    m_handler_banned_list_changed =
+        m_node.handleBannedListChanged(boost::bind(BannedListChanged, this));
+    m_handler_notify_block_tip = m_node.handleNotifyBlockTip(
+        boost::bind(BlockTipChanged, this, _1, _2, _3, _4, false));
+    m_handler_notify_header_tip = m_node.handleNotifyHeaderTip(
+        boost::bind(BlockTipChanged, this, _1, _2, _3, _4, true));
 }
 
 void ClientModel::unsubscribeFromCoreSignals() {
     // Disconnect signals from client
-    uiInterface.ShowProgress.disconnect(
-        boost::bind(ShowProgress, this, _1, _2));
-    uiInterface.NotifyNumConnectionsChanged.disconnect(
-        boost::bind(NotifyNumConnectionsChanged, this, _1));
-    uiInterface.NotifyNetworkActiveChanged.disconnect(
-        boost::bind(NotifyNetworkActiveChanged, this, _1));
-    uiInterface.NotifyAlertChanged.disconnect(
-        boost::bind(NotifyAlertChanged, this));
-    uiInterface.BannedListChanged.disconnect(
-        boost::bind(BannedListChanged, this));
-    uiInterface.NotifyBlockTip.disconnect(
-        boost::bind(BlockTipChanged, this, _1, _2, false));
-    uiInterface.NotifyHeaderTip.disconnect(
-        boost::bind(BlockTipChanged, this, _1, _2, true));
+    m_handler_show_progress->disconnect();
+    m_handler_notify_num_connections_changed->disconnect();
+    m_handler_notify_network_active_changed->disconnect();
+    m_handler_notify_alert_changed->disconnect();
+    m_handler_banned_list_changed->disconnect();
+    m_handler_notify_block_tip->disconnect();
+    m_handler_notify_header_tip->disconnect();
 }
diff --git a/src/qt/coincontroldialog.cpp b/src/qt/coincontroldialog.cpp
--- a/src/qt/coincontroldialog.cpp
+++ b/src/qt/coincontroldialog.cpp
@@ -14,7 +14,7 @@
 #include "walletmodel.h"
 
 #include "dstencode.h"
-#include "init.h"
+#include "interface/node.h"
 #include "policy/policy.h"
 #include "validation.h" // For mempool
 #include "wallet/coincontrol.h"
@@ -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);
@@ -470,7 +470,7 @@
             CTxOut txout(amount,
                          static_cast<CScript>(std::vector<uint8_t>(24, 0)));
             txDummy.vout.push_back(txout);
-            if (txout.IsDust(dustRelayFee)) {
+            if (txout.IsDust(model->node().getDustRelayFee())) {
                 fDust = true;
             }
         }
@@ -486,16 +486,16 @@
     int nQuantityUncompressed = 0;
 
     std::vector<COutPoint> vCoinControl;
-    std::vector<COutput> vOutputs;
     coinControl()->ListSelected(vCoinControl);
-    model->getOutputs(vCoinControl, vOutputs);
 
-    for (const COutput &out : vOutputs) {
+    size_t i = 0;
+    for (const auto &out : model->wallet().getCoins(vCoinControl)) {
+        if (out.depth_in_main_chain < 0) continue;
+
         // unselect already spent, very unlikely scenario, this could happen
         // when selected are spent elsewhere, like rpc or another computer
-        uint256 txhash = out.tx->GetId();
-        COutPoint outpt(txhash, out.i);
-        if (model->isSpent(outpt)) {
+        const COutPoint &outpt = vCoinControl[i++];
+        if (out.is_spent) {
             coinControl()->UnSelect(outpt);
             continue;
         }
@@ -504,14 +504,14 @@
         nQuantity++;
 
         // Amount
-        nAmount += out.tx->tx->vout[out.i].nValue;
+        nAmount += out.txout.nValue;
 
         // Bytes
         CTxDestination address;
-        if (ExtractDestination(out.tx->tx->vout[out.i].scriptPubKey, address)) {
+        if (ExtractDestination(out.txout.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++;
@@ -546,7 +546,7 @@
         }
 
         // Fee
-        nPayFee = GetMinimumFee(nBytes, g_mempool, *coinControl());
+        nPayFee = model->node().getMinimumFee(nBytes, *coinControl());
 
         if (nPayAmount > Amount::zero()) {
             nChange = nAmount - nPayAmount;
@@ -559,7 +559,7 @@
             if (nChange > Amount::zero() && nChange < MIN_CHANGE) {
                 CTxOut txout(nChange,
                              static_cast<CScript>(std::vector<uint8_t>(24, 0)));
-                if (txout.IsDust(dustRelayFee)) {
+                if (txout.IsDust(model->node().getDustRelayFee())) {
                     // dust-change will be raised until no dust
                     if (CoinControlDialog::fSubtractFeeFromAmount) {
                         nChange = txout.GetDustThreshold(dustRelayFee);
@@ -689,14 +689,12 @@
 
     int nDisplayUnit = model->getOptionsModel()->getDisplayUnit();
 
-    std::map<QString, std::vector<COutput>> mapCoins;
-    model->listCoins(mapCoins);
-
-    for (const std::pair<QString, std::vector<COutput>> &coins : mapCoins) {
+    for (const auto &coins : model->wallet().listCoins()) {
         CCoinControlWidgetItem *itemWalletAddress =
             new CCoinControlWidgetItem();
         itemWalletAddress->setCheckState(COLUMN_CHECKBOX, Qt::Unchecked);
-        QString sWalletAddress = coins.first;
+        QString sWalletAddress =
+            QString::fromStdString(EncodeDestination(coins.first));
         QString sWalletLabel =
             model->getAddressTableModel()->labelForAddress(sWalletAddress);
         if (sWalletLabel.isEmpty()) {
@@ -719,8 +717,10 @@
 
         Amount nSum = Amount::zero();
         int nChildren = 0;
-        for (const COutput &out : coins.second) {
-            nSum += out.tx->tx->vout[out.i].nValue;
+        for (const auto &outpair : coins.second) {
+            const COutPoint &output = std::get<0>(outpair);
+            const interface::WalletTxOut &out = std::get<1>(outpair);
+            nSum += out.txout.nValue;
             nChildren++;
 
             CCoinControlWidgetItem *itemOutput;
@@ -735,8 +735,7 @@
             // address
             CTxDestination outputAddress;
             QString sAddress = "";
-            if (ExtractDestination(out.tx->tx->vout[out.i].scriptPubKey,
-                                   outputAddress)) {
+            if (ExtractDestination(out.txout.scriptPubKey, outputAddress)) {
                 sAddress =
                     QString::fromStdString(EncodeDestination(outputAddress));
 
@@ -766,38 +765,35 @@
             // amount
             itemOutput->setText(
                 COLUMN_AMOUNT,
-                BitcoinUnits::format(nDisplayUnit,
-                                     out.tx->tx->vout[out.i].nValue));
+                BitcoinUnits::format(nDisplayUnit, out.txout.nValue));
             // padding so that sorting works correctly
             itemOutput->setData(
                 COLUMN_AMOUNT, Qt::UserRole,
-                QVariant(qlonglong(out.tx->tx->vout[out.i].nValue / SATOSHI)));
+                QVariant(qlonglong(out.txout.nValue / SATOSHI)));
 
             // date
-            itemOutput->setText(COLUMN_DATE,
-                                GUIUtil::dateTimeStr(out.tx->GetTxTime()));
+            itemOutput->setText(COLUMN_DATE, GUIUtil::dateTimeStr(out.time));
             itemOutput->setData(COLUMN_DATE, Qt::UserRole,
-                                QVariant((qlonglong)out.tx->GetTxTime()));
+                                QVariant(qlonglong(out.time)));
 
             // confirmations
             itemOutput->setText(COLUMN_CONFIRMATIONS,
-                                QString::number(out.nDepth));
+                                QString::number(out.depth_in_main_chain));
             itemOutput->setData(COLUMN_CONFIRMATIONS, Qt::UserRole,
-                                QVariant((qlonglong)out.nDepth));
+                                QVariant(qlonglong(out.depth_in_main_chain)));
 
-            // transaction id
-            const TxId txid = out.tx->GetId();
-            itemOutput->setText(COLUMN_TXHASH,
-                                QString::fromStdString(txid.GetHex()));
+            // transaction hash
+            itemOutput->setText(COLUMN_TXHASH, QString::fromStdString(
+                                                   output.GetTxId().GetHex()));
 
             // vout index
-            itemOutput->setText(COLUMN_VOUT_INDEX, QString::number(out.i));
+            itemOutput->setText(COLUMN_VOUT_INDEX,
+                                QString::number(output.GetN()));
 
             // disable locked coins
-            if (model->isLockedCoin(txid, out.i)) {
-                COutPoint outpt(txid, out.i);
+            if (model->wallet().isLockedCoin(output)) {
                 // just to be sure
-                coinControl()->UnSelect(outpt);
+                coinControl()->UnSelect(output);
                 itemOutput->setDisabled(true);
                 itemOutput->setIcon(
                     COLUMN_CHECKBOX,
@@ -805,7 +801,7 @@
             }
 
             // set checkbox
-            if (coinControl()->IsSelected(COutPoint(txid, out.i))) {
+            if (coinControl()->IsSelected(output)) {
                 itemOutput->setCheckState(COLUMN_CHECKBOX, Qt::Checked);
             }
         }
diff --git a/src/qt/intro.h b/src/qt/intro.h
--- a/src/qt/intro.h
+++ b/src/qt/intro.h
@@ -13,6 +13,10 @@
 
 class FreespaceChecker;
 
+namespace interface {
+class Node;
+}
+
 namespace Ui {
 class Intro;
 }
@@ -42,7 +46,7 @@
      * @note do NOT call global GetDataDir() before calling this function, this
      * will cause the wrong path to be cached.
      */
-    static bool pickDataDirectory();
+    static bool pickDataDirectory(interface::Node &node);
 
     /**
      * Determine default data directory for operating system.
diff --git a/src/qt/intro.cpp b/src/qt/intro.cpp
--- a/src/qt/intro.cpp
+++ b/src/qt/intro.cpp
@@ -8,6 +8,7 @@
 
 #include "fs.h"
 #include "guiutil.h"
+#include "interface/node.h"
 #include "intro.h"
 #include "ui_intro.h"
 #include "util.h"
@@ -161,7 +162,7 @@
     return GUIUtil::boostPathToQString(GetDefaultDataDir());
 }
 
-bool Intro::pickDataDirectory() {
+bool Intro::pickDataDirectory(interface::Node &node) {
     QSettings settings;
     /* If data directory provided on command line, no need to look at settings
        or show a picking dialog */
@@ -215,8 +216,8 @@
      */
     if (dataDir != getDefaultDataDirectory()) {
         // use OS locale for path setting
-        gArgs.SoftSetArg("-datadir",
-                         GUIUtil::qstringToBoostPath(dataDir).string());
+        node.softSetArg("-datadir",
+                        GUIUtil::qstringToBoostPath(dataDir).string());
     }
     return true;
 }
diff --git a/src/qt/optionsdialog.cpp b/src/qt/optionsdialog.cpp
--- a/src/qt/optionsdialog.cpp
+++ b/src/qt/optionsdialog.cpp
@@ -13,6 +13,7 @@
 #include "guiutil.h"
 #include "optionsmodel.h"
 
+#include "interface/node.h"
 #include "netbase.h"
 #include "txdb.h"       // for -dbcache defaults
 #include "validation.h" // for DEFAULT_SCRIPTCHECK_THREADS and MAX_SCRIPTCHECK_THREADS
@@ -294,21 +295,21 @@
     std::string strProxy;
     QString strDefaultProxyGUI;
 
-    GetProxy(NET_IPV4, proxy);
+    model->node().getProxy(NET_IPV4, proxy);
     strProxy = proxy.proxy.ToStringIP() + ":" + proxy.proxy.ToStringPort();
     strDefaultProxyGUI = ui->proxyIp->text() + ":" + ui->proxyPort->text();
     (strProxy == strDefaultProxyGUI.toStdString())
         ? ui->proxyReachIPv4->setChecked(true)
         : ui->proxyReachIPv4->setChecked(false);
 
-    GetProxy(NET_IPV6, proxy);
+    model->node().getProxy(NET_IPV6, proxy);
     strProxy = proxy.proxy.ToStringIP() + ":" + proxy.proxy.ToStringPort();
     strDefaultProxyGUI = ui->proxyIp->text() + ":" + ui->proxyPort->text();
     (strProxy == strDefaultProxyGUI.toStdString())
         ? ui->proxyReachIPv6->setChecked(true)
         : ui->proxyReachIPv6->setChecked(false);
 
-    GetProxy(NET_TOR, proxy);
+    model->node().getProxy(NET_TOR, proxy);
     strProxy = proxy.proxy.ToStringIP() + ":" + proxy.proxy.ToStringPort();
     strDefaultProxyGUI = ui->proxyIp->text() + ":" + ui->proxyPort->text();
     (strProxy == strDefaultProxyGUI.toStdString())
diff --git a/src/qt/optionsmodel.h b/src/qt/optionsmodel.h
--- a/src/qt/optionsmodel.h
+++ b/src/qt/optionsmodel.h
@@ -9,6 +9,10 @@
 
 #include <QAbstractListModel>
 
+namespace interface {
+class Node;
+}
+
 QT_BEGIN_NAMESPACE
 class QNetworkProxy;
 QT_END_NAMESPACE
@@ -26,7 +30,8 @@
     Q_OBJECT
 
 public:
-    explicit OptionsModel(QObject *parent = 0, bool resetSettings = false);
+    explicit OptionsModel(interface::Node &node, QObject *parent = 0,
+                          bool resetSettings = false);
 
     enum OptionID {
         StartAtStartup,      // bool
@@ -79,7 +84,12 @@
     void setRestartRequired(bool fRequired);
     bool isRestartRequired() const;
 
+    interface::Node &node() const {
+        return m_node;
+    }
+
 private:
+    interface::Node &m_node;
     /* Qt-only settings */
     bool fHideTrayIcon;
     bool fMinimizeToTray;
diff --git a/src/qt/optionsmodel.cpp b/src/qt/optionsmodel.cpp
--- a/src/qt/optionsmodel.cpp
+++ b/src/qt/optionsmodel.cpp
@@ -12,26 +12,22 @@
 #include "guiutil.h"
 
 #include "amount.h"
-#include "init.h"
+#include "interface/node.h"
 #include "intro.h"
 #include "net.h"
 #include "netbase.h"
 #include "txdb.h"       // for -dbcache defaults
 #include "validation.h" // For DEFAULT_SCRIPTCHECK_THREADS
 
-#ifdef ENABLE_WALLET
-#include "wallet/wallet.h"
-#include "wallet/walletdb.h"
-#endif
-
 #include <QNetworkProxy>
 #include <QSettings>
 #include <QStringList>
 
 const char *DEFAULT_GUI_PROXY_HOST = "127.0.0.1";
 
-OptionsModel::OptionsModel(QObject *parent, bool resetSettings)
-    : QAbstractListModel(parent) {
+OptionsModel::OptionsModel(interface::Node &node, QObject *parent,
+                           bool resetSettings)
+    : QAbstractListModel(parent), m_node(node) {
     Init(resetSettings);
 }
 
@@ -104,7 +100,7 @@
     if (!settings.contains("nDatabaseCache")) {
         settings.setValue("nDatabaseCache", (qint64)nDefaultDbCache);
     }
-    if (!gArgs.SoftSetArg(
+    if (!m_node.softSetArg(
             "-dbcache",
             settings.value("nDatabaseCache").toString().toStdString())) {
         addOverriddenOption("-dbcache");
@@ -113,7 +109,7 @@
     if (!settings.contains("nThreadsScriptVerif")) {
         settings.setValue("nThreadsScriptVerif", DEFAULT_SCRIPTCHECK_THREADS);
     }
-    if (!gArgs.SoftSetArg(
+    if (!m_node.softSetArg(
             "-par",
             settings.value("nThreadsScriptVerif").toString().toStdString())) {
         addOverriddenOption("-par");
@@ -128,7 +124,7 @@
     if (!settings.contains("bSpendZeroConfChange")) {
         settings.setValue("bSpendZeroConfChange", true);
     }
-    if (!gArgs.SoftSetBoolArg(
+    if (!m_node.softSetBoolArg(
             "-spendzeroconfchange",
             settings.value("bSpendZeroConfChange").toBool())) {
         addOverriddenOption("-spendzeroconfchange");
@@ -139,14 +135,14 @@
     if (!settings.contains("fUseUPnP")) {
         settings.setValue("fUseUPnP", DEFAULT_UPNP);
     }
-    if (!gArgs.SoftSetBoolArg("-upnp", settings.value("fUseUPnP").toBool())) {
+    if (!m_node.softSetBoolArg("-upnp", settings.value("fUseUPnP").toBool())) {
         addOverriddenOption("-upnp");
     }
 
     if (!settings.contains("fListen")) {
         settings.setValue("fListen", DEFAULT_LISTEN);
     }
-    if (!gArgs.SoftSetBoolArg("-listen", settings.value("fListen").toBool())) {
+    if (!m_node.softSetBoolArg("-listen", settings.value("fListen").toBool())) {
         addOverriddenOption("-listen");
     }
 
@@ -160,7 +156,7 @@
     }
     // Only try to set -proxy, if user has enabled fUseProxy
     if (settings.value("fUseProxy").toBool() &&
-        !gArgs.SoftSetArg(
+        !m_node.softSetArg(
             "-proxy", settings.value("addrProxy").toString().toStdString())) {
         addOverriddenOption("-proxy");
     } else if (!settings.value("fUseProxy").toBool() &&
@@ -178,7 +174,7 @@
     }
     // Only try to set -onion, if user has enabled fUseSeparateProxyTor
     if (settings.value("fUseSeparateProxyTor").toBool() &&
-        !gArgs.SoftSetArg(
+        !m_node.softSetArg(
             "-onion",
             settings.value("addrSeparateProxyTor").toString().toStdString())) {
         addOverriddenOption("-onion");
@@ -191,7 +187,7 @@
     if (!settings.contains("language")) {
         settings.setValue("language", "");
     }
-    if (!gArgs.SoftSetArg(
+    if (!m_node.softSetArg(
             "-lang", settings.value("language").toString().toStdString())) {
         addOverriddenOption("-lang");
     }
@@ -336,12 +332,7 @@
                 break;
             case MapPortUPnP: // core option - can be changed on-the-fly
                 settings.setValue("fUseUPnP", value.toBool());
-                if (value.toBool()) {
-                    StartMapPort();
-                } else {
-                    InterruptMapPort();
-                    StopMapPort();
-                }
+                m_node.mapPort(value.toBool());
                 break;
             case MinimizeOnClose:
                 fMinimizeOnClose = value.toBool();
@@ -471,7 +462,7 @@
     // Directly query current base proxy, because
     // GUI settings can be overridden with -proxy.
     proxyType curProxy;
-    if (GetProxy(NET_IPV4, curProxy)) {
+    if (m_node.getProxy(NET_IPV4, curProxy)) {
         proxy.setType(QNetworkProxy::Socks5Proxy);
         proxy.setHostName(QString::fromStdString(curProxy.proxy.ToStringIP()));
         proxy.setPort(curProxy.proxy.GetPort());
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());
+        interface::Wallet &wallet = model->wallet();
+        interface::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/paymentserver.h b/src/qt/paymentserver.h
--- a/src/qt/paymentserver.h
+++ b/src/qt/paymentserver.h
@@ -36,8 +36,6 @@
 
 class OptionsModel;
 
-class CWallet;
-
 QT_BEGIN_NAMESPACE
 class QApplication;
 class QByteArray;
@@ -57,7 +55,8 @@
 public:
     // Parse URIs on command line
     // Returns false on error
-    static void ipcParseCommandLine(int argc, char *argv[]);
+    static void ipcParseCommandLine(interface::Node &node, int argc,
+                                    char *argv[]);
 
     // Returns true if there were URIs on the command line which were
     // successfully sent to an already-running process.
@@ -83,7 +82,8 @@
     void setOptionsModel(OptionsModel *optionsModel);
 
     // Verify that the payment request network matches the client network
-    static bool verifyNetwork(const payments::PaymentDetails &requestDetails);
+    static bool verifyNetwork(interface::Node &node,
+                              const payments::PaymentDetails &requestDetails);
     // Verify if the payment request is expired
     static bool verifyExpired(const payments::PaymentDetails &requestDetails);
     // Verify the payment request size is valid as per BIP70
@@ -108,7 +108,8 @@
     void uiReady();
 
     // Submit Payment message to a merchant, get back PaymentACK:
-    void fetchPaymentACK(CWallet *wallet, const SendCoinsRecipient &recipient,
+    void fetchPaymentACK(WalletModel *walletModel,
+                         const SendCoinsRecipient &recipient,
                          QByteArray transaction);
 
     // Handle an incoming URI, URI with local file scheme or file
diff --git a/src/qt/paymentserver.cpp b/src/qt/paymentserver.cpp
--- a/src/qt/paymentserver.cpp
+++ b/src/qt/paymentserver.cpp
@@ -11,6 +11,7 @@
 #include "chainparams.h"
 #include "config.h"
 #include "dstencode.h"
+#include "interface/node.h"
 #include "policy/policy.h"
 #include "ui_interface.h"
 #include "util.h"
@@ -223,7 +224,8 @@
 // Warning: ipcSendCommandLine() is called early in init, so don't use "Q_EMIT
 // message()", but "QMessageBox::"!
 //
-void PaymentServer::ipcParseCommandLine(int argc, char *argv[]) {
+void PaymentServer::ipcParseCommandLine(interface::Node &node, int argc,
+                                        char *argv[]) {
     std::array<const std::string *, 3> networks = {
         {&CBaseChainParams::MAIN, &CBaseChainParams::TESTNET,
          &CBaseChainParams::REGTEST}};
@@ -286,7 +288,7 @@
     }
 
     if (chosenNetwork) {
-        SelectParams(*chosenNetwork);
+        node.selectParams(*chosenNetwork);
     }
 }
 
@@ -566,7 +568,7 @@
 
     if (request.IsInitialized()) {
         // Payment request network matches client network?
-        if (!verifyNetwork(request.getDetails())) {
+        if (!verifyNetwork(optionsModel->node(), request.getDetails())) {
             Q_EMIT message(
                 tr("Payment request rejected"),
                 tr("Payment request network doesn't match client network."),
@@ -633,7 +635,7 @@
 
         // Extract and check amounts
         CTxOut txOut(Amount(sendingTo.second), sendingTo.first);
-        if (txOut.IsDust(dustRelayFee)) {
+        if (txOut.IsDust(optionsModel->node().getDustRelayFee())) {
             Q_EMIT message(
                 tr("Payment request error"),
                 tr("Requested payment amount of %1 is too small (considered "
@@ -681,7 +683,7 @@
     netManager->get(netRequest);
 }
 
-void PaymentServer::fetchPaymentACK(CWallet *wallet,
+void PaymentServer::fetchPaymentACK(WalletModel *walletModel,
                                     const SendCoinsRecipient &recipient,
                                     QByteArray transaction) {
     const payments::PaymentDetails &details =
@@ -705,16 +707,18 @@
     // Create a new refund address, or re-use:
     std::string label =
         tr("Refund from %1").arg(recipient.authenticatedMerchant).toStdString();
-    std::set<CTxDestination> refundAddresses = wallet->GetLabelAddresses(label);
+    std::set<CTxDestination> refundAddresses =
+        walletModel->wallet().getLabelAddresses(label);
     if (!refundAddresses.empty()) {
         CScript s = GetScriptForDestination(*refundAddresses.begin());
         payments::Output *refund_to = payment.add_refund_to();
         refund_to->set_script(&s[0], s.size());
     } else {
         CPubKey newKey;
-        if (wallet->GetKeyFromPool(newKey)) {
+        if (walletModel->wallet().getKeyFromPool(false /* internal */,
+                                                 newKey)) {
             CKeyID keyID = newKey.GetID();
-            wallet->SetAddressBook(keyID, label, "refund");
+            walletModel->wallet().setAddressBook(keyID, label, "refund");
 
             CScript s = GetScriptForDestination(keyID);
             payments::Output *refund_to = payment.add_refund_to();
@@ -823,15 +827,14 @@
 }
 
 bool PaymentServer::verifyNetwork(
-    const payments::PaymentDetails &requestDetails) {
-    bool fVerified = requestDetails.network() == Params().NetworkIDString();
+    interface::Node &node, const payments::PaymentDetails &requestDetails) {
+    bool fVerified = requestDetails.network() == node.getNetwork();
     if (!fVerified) {
         qWarning() << QString("PaymentServer::%1: Payment request network "
                               "\"%2\" doesn't match client network \"%3\".")
                           .arg(__func__)
                           .arg(QString::fromStdString(requestDetails.network()))
-                          .arg(QString::fromStdString(
-                              Params().NetworkIDString()));
+                          .arg(QString::fromStdString(node.getNetwork()));
     }
     return fVerified;
 }
diff --git a/src/qt/peertablemodel.h b/src/qt/peertablemodel.h
--- a/src/qt/peertablemodel.h
+++ b/src/qt/peertablemodel.h
@@ -14,6 +14,10 @@
 class ClientModel;
 class PeerTablePriv;
 
+namespace interface {
+class Node;
+}
+
 QT_BEGIN_NAMESPACE
 class QTimer;
 QT_END_NAMESPACE
@@ -44,7 +48,7 @@
     Q_OBJECT
 
 public:
-    explicit PeerTableModel(ClientModel *parent = 0);
+    explicit PeerTableModel(interface::Node &node, ClientModel *parent = 0);
     ~PeerTableModel();
     const CNodeCombinedStats *getNodeStats(int idx);
     int getRowByNodeId(NodeId nodeid);
@@ -70,6 +74,7 @@
     void refresh();
 
 private:
+    interface::Node &m_node;
     ClientModel *clientModel;
     QStringList columns;
     std::unique_ptr<PeerTablePriv> priv;
diff --git a/src/qt/peertablemodel.cpp b/src/qt/peertablemodel.cpp
--- a/src/qt/peertablemodel.cpp
+++ b/src/qt/peertablemodel.cpp
@@ -8,6 +8,7 @@
 #include "guiconstants.h"
 #include "guiutil.h"
 
+#include "interface/node.h"
 #include "sync.h"
 #include "validation.h" // for cs_main
 
@@ -49,34 +50,24 @@
     std::map<NodeId, int> mapNodeRows;
 
     /** Pull a full list of peers from vNodes into our cache */
-    void refreshPeers() {
+    void refreshPeers(interface::Node &node) {
         {
             cachedNodeStats.clear();
-            std::vector<CNodeStats> vstats;
-            if (g_connman) g_connman->GetNodeStats(vstats);
-            cachedNodeStats.reserve(vstats.size());
-            for (const CNodeStats &nodestats : vstats) {
+
+            interface::Node::NodesStats nodes_stats;
+            node.getNodesStats(nodes_stats);
+#if QT_VERSION >= 0x040700
+            cachedNodeStats.reserve(nodes_stats.size());
+#endif
+            for (auto &node_stats : nodes_stats) {
                 CNodeCombinedStats stats;
-                stats.nodeStateStats.nMisbehavior = 0;
-                stats.nodeStateStats.nSyncHeight = -1;
-                stats.nodeStateStats.nCommonHeight = -1;
-                stats.fNodeStateStatsAvailable = false;
-                stats.nodeStats = nodestats;
+                stats.nodeStats = std::get<0>(node_stats);
+                stats.fNodeStateStatsAvailable = std::get<1>(node_stats);
+                stats.nodeStateStats = std::get<2>(node_stats);
                 cachedNodeStats.append(stats);
             }
         }
 
-        // Try to retrieve the CNodeStateStats for each node.
-        {
-            TRY_LOCK(cs_main, lockMain);
-            if (lockMain) {
-                for (CNodeCombinedStats &stats : cachedNodeStats) {
-                    stats.fNodeStateStatsAvailable = GetNodeStateStats(
-                        stats.nodeStats.nodeid, stats.nodeStateStats);
-                }
-            }
-        }
-
         if (sortColumn >= 0)
             // sort cacheNodeStats (use stable sort to prevent rows jumping
             // around unnecessarily)
@@ -102,10 +93,10 @@
     }
 };
 
-PeerTableModel::PeerTableModel(ClientModel *parent)
-    : QAbstractTableModel(parent), clientModel(parent), timer(0) {
-    columns << tr("NodeId") << tr("Node/Service") << tr("User Agent")
-            << tr("Ping");
+PeerTableModel::PeerTableModel(interface::Node &node, ClientModel *parent)
+    : QAbstractTableModel(parent), m_node(node), clientModel(parent), timer(0) {
+    columns << tr("NodeId") << tr("Node/Service") << tr("Ping") << tr("Sent")
+            << tr("Received") << tr("User Agent");
     priv.reset(new PeerTablePriv());
     // default to unsorted
     priv->sortColumn = -1;
@@ -198,7 +189,7 @@
 
 void PeerTableModel::refresh() {
     Q_EMIT layoutAboutToBeChanged();
-    priv->refreshPeers();
+    priv->refreshPeers(m_node);
     Q_EMIT layoutChanged();
 }
 
diff --git a/src/qt/recentrequeststablemodel.h b/src/qt/recentrequeststablemodel.h
--- a/src/qt/recentrequeststablemodel.h
+++ b/src/qt/recentrequeststablemodel.h
@@ -11,8 +11,6 @@
 #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
@@ -11,10 +11,8 @@
 #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/rpcconsole.h b/src/qt/rpcconsole.h
--- a/src/qt/rpcconsole.h
+++ b/src/qt/rpcconsole.h
@@ -19,6 +19,10 @@
 class RPCTimerInterface;
 class WalletModel;
 
+namespace interface {
+class Node;
+}
+
 namespace Ui {
 class RPCConsole;
 }
@@ -33,20 +37,22 @@
     Q_OBJECT
 
 public:
-    explicit RPCConsole(const PlatformStyle *platformStyle, QWidget *parent);
+    explicit RPCConsole(interface::Node &node,
+                        const PlatformStyle *platformStyle, QWidget *parent);
     ~RPCConsole();
 
     static bool
-    RPCParseCommandLine(std::string &strResult, const std::string &strCommand,
-                        bool fExecute,
+    RPCParseCommandLine(interface::Node *node, std::string &strResult,
+                        const std::string &strCommand, bool fExecute,
                         std::string *const pstrFilteredOut = nullptr,
                         const std::string *walletID = nullptr);
     static bool
-    RPCExecuteCommandLine(std::string &strResult, const std::string &strCommand,
+    RPCExecuteCommandLine(interface::Node &node, std::string &strResult,
+                          const std::string &strCommand,
                           std::string *const pstrFilteredOut = nullptr,
                           const std::string *walletID = nullptr) {
-        return RPCParseCommandLine(strResult, strCommand, true, pstrFilteredOut,
-                                   walletID);
+        return RPCParseCommandLine(&node, strResult, strCommand, true,
+                                   pstrFilteredOut, walletID);
     }
 
     void setClientModel(ClientModel *model);
@@ -144,6 +150,7 @@
 
     };
 
+    interface::Node &m_node;
     Ui::RPCConsole *ui;
     ClientModel *clientModel;
     QStringList history;
diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
--- a/src/qt/rpcconsole.cpp
+++ b/src/qt/rpcconsole.cpp
@@ -17,6 +17,7 @@
 
 #include "chainparams.h"
 #include "config.h"
+#include "interface/node.h"
 #include "netbase.h"
 #include "rpc/client.h"
 #include "rpc/server.h"
@@ -78,12 +79,17 @@
  */
 class RPCExecutor : public QObject {
     Q_OBJECT
+public:
+    RPCExecutor(interface::Node &node) : m_node(node) {}
 
 public Q_SLOTS:
     void request(const QString &command, const QString &walletID);
 
 Q_SIGNALS:
     void reply(int category, const QString &command);
+
+private:
+    interface::Node &m_node;
 };
 
 /** Class for handling RPC timers
@@ -137,6 +143,7 @@
  *   - Within single quotes, no escaping is possible and no special
  * interpretation takes place
  *
+ * @param[in]    node    optional node to execute command on
  * @param[out]   result      stringified Result from the executed command(chain)
  * @param[in]    strCommand  Command line to split
  * @param[in]    fExecute    set true if you want the command to be executed
@@ -144,7 +151,8 @@
  * data
  */
 
-bool RPCConsole::RPCParseCommandLine(std::string &strResult,
+bool RPCConsole::RPCParseCommandLine(interface::Node *node,
+                                     std::string &strResult,
                                      const std::string &strCommand,
                                      const bool fExecute,
                                      std::string *const pstrFilteredOut,
@@ -322,28 +330,28 @@
                                 // Convert argument list to JSON objects in
                                 // method-dependent way, and pass it along with
                                 // the method name to the dispatcher.
-                                JSONRPCRequest req;
-                                req.params = RPCConvertValues(
+                                UniValue params = RPCConvertValues(
                                     stack.back()[0],
                                     std::vector<std::string>(
                                         stack.back().begin() + 1,
                                         stack.back().end()));
-                                req.strMethod = stack.back()[0];
+                                std::string method = stack.back()[0];
+                                std::string uri;
 
 #ifdef ENABLE_WALLET
                                 if (walletID && !walletID->empty()) {
                                     QByteArray encodedName =
                                         QUrl::toPercentEncoding(
                                             QString::fromStdString(*walletID));
-                                    req.URI =
-                                        "/wallet/" +
-                                        std::string(encodedName.constData(),
-                                                    encodedName.length());
+                                    uri = "/wallet/" +
+                                          std::string(encodedName.constData(),
+                                                      encodedName.length());
                                 }
 #endif
 
-                                GlobalConfig config;
-                                lastResult = tableRPC.execute(config, req);
+                                assert(node);
+                                lastResult =
+                                    node->executeRpc(method, params, uri);
                             }
 
                             state = STATE_COMMAND_EXECUTED;
@@ -476,8 +484,8 @@
             return;
         }
         std::string wallet_id = walletID.toStdString();
-        if (!RPCConsole::RPCExecuteCommandLine(result, executableCommand,
-                                               nullptr, &wallet_id)) {
+        if (!RPCConsole::RPCExecuteCommandLine(
+                m_node, result, executableCommand, nullptr, &wallet_id)) {
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString("Parse error: unbalanced ' or \""));
             return;
@@ -504,9 +512,10 @@
     }
 }
 
-RPCConsole::RPCConsole(const PlatformStyle *_platformStyle, QWidget *parent)
-    : QWidget(parent), ui(new Ui::RPCConsole), clientModel(0), historyPtr(0),
-      platformStyle(_platformStyle), peersTableContextMenu(0),
+RPCConsole::RPCConsole(interface::Node &node,
+                       const PlatformStyle *_platformStyle, QWidget *parent)
+    : QWidget(parent), m_node(node), ui(new Ui::RPCConsole), clientModel(0),
+      historyPtr(0), platformStyle(_platformStyle), peersTableContextMenu(0),
       banTableContextMenu(0), consoleFontSize(0) {
     ui->setupUi(this);
     QSettings settings;
@@ -556,7 +565,7 @@
     rpcTimerInterface = new QtRPCTimerInterface();
     // avoid accidentally overwriting an existing, non QTThread
     // based timer interface
-    RPCSetTimerInterfaceIfUnset(rpcTimerInterface);
+    m_node.rpcSetTimerInterfaceIfUnset(rpcTimerInterface);
 
     setTrafficGraphRange(INITIAL_TRAFFIC_GRAPH_MINS);
 
@@ -572,7 +581,7 @@
 RPCConsole::~RPCConsole() {
     QSettings settings;
     settings.setValue("RPCConsoleWindowGeometry", saveGeometry());
-    RPCUnsetTimerInterface(rpcTimerInterface);
+    m_node.rpcUnsetTimerInterface(rpcTimerInterface);
     delete rpcTimerInterface;
     delete ui;
 }
@@ -642,8 +651,10 @@
         connect(model, SIGNAL(numConnectionsChanged(int)), this,
                 SLOT(setNumConnections(int)));
 
-        setNumBlocks(model->getNumBlocks(), model->getLastBlockDate(),
-                     model->getVerificationProgress(nullptr), false);
+        interface::Node &node = clientModel->node();
+        setNumBlocks(node.getNumBlocks(),
+                     QDateTime::fromTime_t(node.getLastBlockTime()),
+                     node.getVerificationProgress(), false);
         connect(model, SIGNAL(numBlocksChanged(int, QDateTime, double, bool)),
                 this, SLOT(setNumBlocks(int, QDateTime, double, bool)));
 
@@ -651,8 +662,7 @@
         connect(model, SIGNAL(networkActiveChanged(bool)), this,
                 SLOT(setNetworkActive(bool)));
 
-        updateTrafficStats(model->getTotalBytesRecv(),
-                           model->getTotalBytesSent());
+        updateTrafficStats(node.getTotalBytesRecv(), node.getTotalBytesSent());
         connect(model, SIGNAL(bytesChanged(quint64, quint64)), this,
                 SLOT(updateTrafficStats(quint64, quint64)));
 
@@ -778,7 +788,7 @@
 
         // Setup autocomplete and attach it
         QStringList wordList;
-        std::vector<std::string> commandList = tableRPC.listCommands();
+        std::vector<std::string> commandList = m_node.listRpcCommands();
         for (size_t i = 0; i < commandList.size(); ++i) {
             wordList << commandList[i].c_str();
             wordList << ("help " + commandList[i]).c_str();
@@ -965,7 +975,7 @@
         tr("Out:") + " " +
         QString::number(clientModel->getNumConnections(CONNECTIONS_OUT)) + ")";
 
-    if (!clientModel->getNetworkActive()) {
+    if (!clientModel->node().getNetworkActive()) {
         connections += " (" + tr("Network activity disabled") + ")";
     }
 
@@ -1011,7 +1021,7 @@
         std::string strFilteredCmd;
         try {
             std::string dummy;
-            if (!RPCParseCommandLine(dummy, cmd.toStdString(), false,
+            if (!RPCParseCommandLine(nullptr, dummy, cmd.toStdString(), false,
                                      &strFilteredCmd)) {
                 // Failed to parse command, so we cannot even filter it for the
                 // history
@@ -1092,7 +1102,7 @@
 }
 
 void RPCConsole::startExecutor() {
-    RPCExecutor *executor = new RPCExecutor();
+    RPCExecutor *executor = new RPCExecutor(m_node);
     executor->moveToThread(&thread);
 
     // Replies from executor object must go to this object
@@ -1352,10 +1362,6 @@
 }
 
 void RPCConsole::disconnectSelectedNode() {
-    if (!g_connman) {
-        return;
-    }
-
     // Get selected peer addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);
@@ -1363,12 +1369,14 @@
         // Get currently selected peer address
         NodeId id = nodes.at(i).data().toLongLong();
         // Find the node, disconnect it and clear the selected node
-        if (g_connman->DisconnectNode(id)) clearSelectedNode();
+        if (m_node.disconnect(id)) {
+            clearSelectedNode();
+        }
     }
 }
 
 void RPCConsole::banSelectedNode(int bantime) {
-    if (!clientModel || !g_connman) {
+    if (!clientModel) {
         return;
     }
 
@@ -1390,8 +1398,7 @@
         const CNodeCombinedStats *stats =
             clientModel->getPeerTableModel()->getNodeStats(detailNodeRow);
         if (stats) {
-            g_connman->Ban(stats->nodeStats.addr, BanReasonManuallyAdded,
-                           bantime);
+            m_node.ban(stats->nodeStats.addr, BanReasonManuallyAdded, bantime);
         }
     }
     clearSelectedNode();
@@ -1412,8 +1419,7 @@
         CSubNet possibleSubnet;
 
         LookupSubNet(strNode.toStdString().c_str(), possibleSubnet);
-        if (possibleSubnet.IsValid() && g_connman) {
-            g_connman->Unban(possibleSubnet);
+        if (possibleSubnet.IsValid() && m_node.unban(possibleSubnet)) {
             clientModel->getBanTableModel()->refresh();
         }
     }
diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp
--- a/src/qt/sendcoinsdialog.cpp
+++ b/src/qt/sendcoinsdialog.cpp
@@ -17,6 +17,7 @@
 
 #include "chainparams.h"
 #include "dstencode.h"
+#include "interface/node.h"
 #include "txmempool.h"
 #include "ui_interface.h"
 #include "validation.h" // mempool and minRelayTxFee
@@ -165,10 +166,11 @@
             }
         }
 
-        setBalance(_model->getBalance(), _model->getUnconfirmedBalance(),
-                   _model->getImmatureBalance(), _model->getWatchBalance(),
-                   _model->getWatchUnconfirmedBalance(),
-                   _model->getWatchImmatureBalance());
+        interface::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 +403,7 @@
         accept();
         CoinControlDialog::coinControl()->UnSelectAll();
         coinControlUpdateLabels();
-        Q_EMIT coinsSent(currentTransaction.getTransaction()->GetId());
+        Q_EMIT coinsSent(currentTransaction.getWtx()->get().GetId());
     }
     fNewRecipientAllowed = true;
 }
@@ -548,7 +550,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 +645,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 +839,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/splashscreen.h b/src/qt/splashscreen.h
--- a/src/qt/splashscreen.h
+++ b/src/qt/splashscreen.h
@@ -8,9 +8,16 @@
 #include <QSplashScreen>
 #include <functional>
 
-class CWallet;
+#include <memory>
+
 class NetworkStyle;
 
+namespace interface {
+class Handler;
+class Node;
+class Wallet;
+};
+
 /** Class for the splashscreen with information of the running client.
  *
  * @note this is intentionally not a QSplashScreen. Bitcoin Core initialization
@@ -21,7 +28,8 @@
     Q_OBJECT
 
 public:
-    explicit SplashScreen(Qt::WindowFlags f, const NetworkStyle *networkStyle);
+    explicit SplashScreen(interface::Node &node, Qt::WindowFlags f,
+                          const NetworkStyle *networkStyle);
     ~SplashScreen();
 
 protected:
@@ -45,14 +53,19 @@
     /** Disconnect core signals to splash screen */
     void unsubscribeFromCoreSignals();
     /** Connect wallet signals to splash screen */
-    void ConnectWallet(CWallet *);
+    void ConnectWallet(std::unique_ptr<interface::Wallet> wallet);
 
     QPixmap pixmap;
     QString curMessage;
     QColor curColor;
     int curAlignment;
 
-    QList<CWallet *> connectedWallets;
+    interface::Node &m_node;
+    std::unique_ptr<interface::Handler> m_handler_init_message;
+    std::unique_ptr<interface::Handler> m_handler_show_progress;
+    std::unique_ptr<interface::Handler> m_handler_load_wallet;
+    std::list<std::unique_ptr<interface::Wallet>> m_connected_wallets;
+    std::list<std::unique_ptr<interface::Handler>> m_connected_wallet_handlers;
 };
 
 #endif // BITCOIN_QT_SPLASHSCREEN_H
diff --git a/src/qt/splashscreen.cpp b/src/qt/splashscreen.cpp
--- a/src/qt/splashscreen.cpp
+++ b/src/qt/splashscreen.cpp
@@ -12,6 +12,9 @@
 
 #include "clientversion.h"
 #include "init.h"
+#include "interface/handler.h"
+#include "interface/node.h"
+#include "interface/wallet.h"
 #include "ui_interface.h"
 #include "util.h"
 #include "version.h"
@@ -26,8 +29,9 @@
 #include <QPainter>
 #include <QRadialGradient>
 
-SplashScreen::SplashScreen(Qt::WindowFlags f, const NetworkStyle *networkStyle)
-    : QWidget(0, f), curAlignment(0) {
+SplashScreen::SplashScreen(interface::Node &node, Qt::WindowFlags f,
+                           const NetworkStyle *networkStyle)
+    : QWidget(0, f), curAlignment(0), m_node(node) {
     // set reference point, paddings
     int paddingRight = 50;
     int paddingTop = 50;
@@ -158,7 +162,7 @@
     if (ev->type() == QEvent::KeyPress) {
         QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
         if (keyEvent->text()[0] == 'q') {
-            StartShutdown();
+            m_node.startShutdown();
         }
     }
     return QObject::eventFilter(obj, ev);
@@ -189,37 +193,37 @@
                                  : _("press q to shutdown")) +
                             strprintf("\n%d", nProgress) + "%");
 }
-
 #ifdef ENABLE_WALLET
-void SplashScreen::ConnectWallet(CWallet *wallet) {
-    wallet->ShowProgress.connect(
-        boost::bind(ShowProgress, this, _1, _2, false));
-    connectedWallets.push_back(wallet);
+void SplashScreen::ConnectWallet(std::unique_ptr<interface::Wallet> wallet) {
+    m_connected_wallet_handlers.emplace_back(wallet->handleShowProgress(
+        boost::bind(ShowProgress, this, _1, _2, false)));
+    m_connected_wallets.emplace_back(std::move(wallet));
 }
 #endif
 
 void SplashScreen::subscribeToCoreSignals() {
     // Connect signals to client
-    uiInterface.InitMessage.connect(boost::bind(InitMessage, this, _1));
-    uiInterface.ShowProgress.connect(
-        boost::bind(ShowProgress, this, _1, _2, _3));
+    m_handler_init_message =
+        m_node.handleInitMessage(boost::bind(InitMessage, this, _1));
+    m_handler_show_progress =
+        m_node.handleShowProgress(boost::bind(ShowProgress, this, _1, _2, _3));
 #ifdef ENABLE_WALLET
-    uiInterface.LoadWallet.connect(
-        boost::bind(&SplashScreen::ConnectWallet, this, _1));
+    m_handler_load_wallet = m_node.handleLoadWallet(
+        [this](std::unique_ptr<interface::Wallet> wallet) {
+            ConnectWallet(std::move(wallet));
+        });
 #endif
 }
 
 void SplashScreen::unsubscribeFromCoreSignals() {
     // Disconnect signals from client
-    uiInterface.InitMessage.disconnect(boost::bind(InitMessage, this, _1));
-    uiInterface.ShowProgress.disconnect(
-        boost::bind(ShowProgress, this, _1, _2, _3));
-#ifdef ENABLE_WALLET
-    for (CWallet *const &pwallet : connectedWallets) {
-        pwallet->ShowProgress.disconnect(
-            boost::bind(ShowProgress, this, _1, _2, false));
+    m_handler_init_message->disconnect();
+    m_handler_show_progress->disconnect();
+    for (auto &handler : m_connected_wallet_handlers) {
+        handler->disconnect();
     }
-#endif
+    m_connected_wallet_handlers.clear();
+    m_connected_wallets.clear();
 }
 
 void SplashScreen::showMessage(const QString &message, int alignment,
@@ -240,6 +244,6 @@
 
 void SplashScreen::closeEvent(QCloseEvent *event) {
     // allows an "emergency" shutdown during startup
-    StartShutdown();
+    m_node.startShutdown();
     event->ignore();
 }
diff --git a/src/qt/test/paymentservertests.cpp b/src/qt/test/paymentservertests.cpp
--- a/src/qt/test/paymentservertests.cpp
+++ b/src/qt/test/paymentservertests.cpp
@@ -8,6 +8,7 @@
 #include "paymentrequestdata.h"
 
 #include "amount.h"
+#include "interface/node.h"
 #include "random.h"
 #include "script/script.h"
 #include "script/standard.h"
@@ -64,7 +65,8 @@
 
 void PaymentServerTests::paymentServerTests() {
     SelectParams(CBaseChainParams::MAIN);
-    OptionsModel optionsModel;
+    auto node = interface::MakeNode();
+    OptionsModel optionsModel(*node);
     PaymentServer *server = new PaymentServer(nullptr, false);
     X509_STORE *caStore = X509_STORE_new();
     X509_STORE_add_cert(caStore, parse_b64der_cert(caCert1_BASE64));
@@ -145,7 +147,7 @@
     // Ensure the request is initialized, because network "main" is default,
     // even for uninizialized payment requests and that will fail our test here.
     QVERIFY(r.paymentRequest.IsInitialized());
-    QCOMPARE(PaymentServer::verifyNetwork(r.paymentRequest.getDetails()),
+    QCOMPARE(PaymentServer::verifyNetwork(*node, r.paymentRequest.getDetails()),
              false);
 
     // Expired payment request (expires is set to 1 = 1970-01-01 00:00:01):
diff --git a/src/qt/test/rpcnestedtests.cpp b/src/qt/test/rpcnestedtests.cpp
--- a/src/qt/test/rpcnestedtests.cpp
+++ b/src/qt/test/rpcnestedtests.cpp
@@ -8,6 +8,7 @@
 #include "config.h"
 #include "consensus/validation.h"
 #include "fs.h"
+#include "interface/node.h"
 #include "rpc/register.h"
 #include "rpc/server.h"
 #include "rpcconsole.h"
@@ -50,107 +51,115 @@
     std::string result;
     std::string result2;
     std::string filtered;
+    auto node = interface::MakeNode();
 
     // Simple result filtering with path.
-    RPCConsole::RPCExecuteCommandLine(result, "getblockchaininfo()[chain]",
-                                      &filtered);
+    RPCConsole::RPCExecuteCommandLine(*node, result,
+                                      "getblockchaininfo()[chain]", &filtered);
     QVERIFY(result == "main");
     QVERIFY(filtered == "getblockchaininfo()[chain]");
 
     // Simple 2 level nesting.
-    RPCConsole::RPCExecuteCommandLine(result, "getblock(getbestblockhash())");
+    RPCConsole::RPCExecuteCommandLine(*node, result,
+                                      "getblock(getbestblockhash())");
     RPCConsole::RPCExecuteCommandLine(
-        result, "getblock(getblock(getbestblockhash())[hash], true)");
+        *node, result, "getblock(getblock(getbestblockhash())[hash], true)");
 
     // 4 level nesting with whitespace, filtering path and boolean parameter.
     RPCConsole::RPCExecuteCommandLine(
-        result, "getblock( getblock( getblock(getbestblockhash())[hash] "
-                ")[hash], true)");
+        *node, result,
+        "getblock( getblock( getblock(getbestblockhash())[hash] "
+        ")[hash], true)");
 
-    RPCConsole::RPCExecuteCommandLine(result, "getblockchaininfo");
+    RPCConsole::RPCExecuteCommandLine(*node, result, "getblockchaininfo");
     QVERIFY(result.substr(0, 1) == "{");
 
-    RPCConsole::RPCExecuteCommandLine(result, "getblockchaininfo()");
+    RPCConsole::RPCExecuteCommandLine(*node, result, "getblockchaininfo()");
     QVERIFY(result.substr(0, 1) == "{");
 
     // Whitespace at the end will be tolerated.
-    RPCConsole::RPCExecuteCommandLine(result, "getblockchaininfo ");
+    RPCConsole::RPCExecuteCommandLine(*node, result, "getblockchaininfo ");
     QVERIFY(result.substr(0, 1) == "{");
 
     // Quote path identifier are allowed, but look after a child contaning the
     // quotes in the key.
-    (RPCConsole::RPCExecuteCommandLine(result,
+    (RPCConsole::RPCExecuteCommandLine(*node, result,
                                        "getblockchaininfo()[\"chain\"]"));
     QVERIFY(result == "null");
 
     // parameter not in brackets are allowed.
-    (RPCConsole::RPCExecuteCommandLine(result, "createrawtransaction [] {} 0"));
+    (RPCConsole::RPCExecuteCommandLine(*node, result,
+                                       "createrawtransaction [] {} 0"));
     // Parameter in brackets are allowed.
-    (RPCConsole::RPCExecuteCommandLine(result2,
+    (RPCConsole::RPCExecuteCommandLine(*node, result2,
                                        "createrawtransaction([],{},0)"));
     QVERIFY(result == result2);
     // Whitespace between parametres is allowed.
     (RPCConsole::RPCExecuteCommandLine(
-        result2, "createrawtransaction( [],  {} , 0   )"));
+        *node, result2, "createrawtransaction( [],  {} , 0   )"));
     QVERIFY(result == result2);
 
     RPCConsole::RPCExecuteCommandLine(
-        result, "getblock(getbestblockhash())[tx][0]", &filtered);
+        *node, result, "getblock(getbestblockhash())[tx][0]", &filtered);
     QVERIFY(result ==
             "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b");
     QVERIFY(filtered == "getblock(getbestblockhash())[tx][0]");
 
-    RPCConsole::RPCParseCommandLine(result, "importprivkey", false, &filtered);
-    QVERIFY(filtered == "importprivkey(…)");
-    RPCConsole::RPCParseCommandLine(result, "signmessagewithprivkey abc", false,
+    RPCConsole::RPCParseCommandLine(nullptr, result, "importprivkey", false,
                                     &filtered);
+    QVERIFY(filtered == "importprivkey(…)");
+    RPCConsole::RPCParseCommandLine(
+        nullptr, result, "signmessagewithprivkey abc", false, &filtered);
     QVERIFY(filtered == "signmessagewithprivkey(…)");
-    RPCConsole::RPCParseCommandLine(result, "signmessagewithprivkey abc,def",
-                                    false, &filtered);
+    RPCConsole::RPCParseCommandLine(
+        nullptr, result, "signmessagewithprivkey abc,def", false, &filtered);
     QVERIFY(filtered == "signmessagewithprivkey(…)");
-    RPCConsole::RPCParseCommandLine(result, "signrawtransactionwithkey(abc)",
-                                    false, &filtered);
+    RPCConsole::RPCParseCommandLine(
+        nullptr, result, "signrawtransactionwithkey(abc)", false, &filtered);
     QVERIFY(filtered == "signrawtransactionwithkey(…)");
-    RPCConsole::RPCParseCommandLine(result, "walletpassphrase(help())", false,
-                                    &filtered);
+    RPCConsole::RPCParseCommandLine(nullptr, result, "walletpassphrase(help())",
+                                    false, &filtered);
     QVERIFY(filtered == "walletpassphrase(…)");
     RPCConsole::RPCParseCommandLine(
-        result, "walletpassphrasechange(help(walletpassphrasechange(abc)))",
-        false, &filtered);
+        nullptr, result,
+        "walletpassphrasechange(help(walletpassphrasechange(abc)))", false,
+        &filtered);
     QVERIFY(filtered == "walletpassphrasechange(…)");
-    RPCConsole::RPCParseCommandLine(result, "help(encryptwallet(abc, def))",
-                                    false, &filtered);
+    RPCConsole::RPCParseCommandLine(
+        nullptr, result, "help(encryptwallet(abc, def))", false, &filtered);
     QVERIFY(filtered == "help(encryptwallet(…))");
-    RPCConsole::RPCParseCommandLine(result, "help(importprivkey())", false,
-                                    &filtered);
-    QVERIFY(filtered == "help(importprivkey(…))");
-    RPCConsole::RPCParseCommandLine(result, "help(importprivkey(help()))",
+    RPCConsole::RPCParseCommandLine(nullptr, result, "help(importprivkey())",
                                     false, &filtered);
     QVERIFY(filtered == "help(importprivkey(…))");
     RPCConsole::RPCParseCommandLine(
-        result, "help(importprivkey(abc), walletpassphrase(def))", false,
-        &filtered);
+        nullptr, result, "help(importprivkey(help()))", false, &filtered);
+    QVERIFY(filtered == "help(importprivkey(…))");
+    RPCConsole::RPCParseCommandLine(
+        nullptr, result, "help(importprivkey(abc), walletpassphrase(def))",
+        false, &filtered);
     QVERIFY(filtered == "help(importprivkey(…), walletpassphrase(…))");
 
-    RPCConsole::RPCExecuteCommandLine(result, "rpcNestedTest");
+    RPCConsole::RPCExecuteCommandLine(*node, result, "rpcNestedTest");
     QVERIFY(result == "[]");
-    RPCConsole::RPCExecuteCommandLine(result, "rpcNestedTest ''");
+    RPCConsole::RPCExecuteCommandLine(*node, result, "rpcNestedTest ''");
     QVERIFY(result == "[\"\"]");
-    RPCConsole::RPCExecuteCommandLine(result, "rpcNestedTest \"\"");
+    RPCConsole::RPCExecuteCommandLine(*node, result, "rpcNestedTest \"\"");
     QVERIFY(result == "[\"\"]");
-    RPCConsole::RPCExecuteCommandLine(result, "rpcNestedTest '' abc");
+    RPCConsole::RPCExecuteCommandLine(*node, result, "rpcNestedTest '' abc");
     QVERIFY(result == "[\"\",\"abc\"]");
-    RPCConsole::RPCExecuteCommandLine(result, "rpcNestedTest abc '' abc");
+    RPCConsole::RPCExecuteCommandLine(*node, result,
+                                      "rpcNestedTest abc '' abc");
     QVERIFY(result == "[\"abc\",\"\",\"abc\"]");
-    RPCConsole::RPCExecuteCommandLine(result, "rpcNestedTest abc  abc");
+    RPCConsole::RPCExecuteCommandLine(*node, result, "rpcNestedTest abc  abc");
     QVERIFY(result == "[\"abc\",\"abc\"]");
-    RPCConsole::RPCExecuteCommandLine(result, "rpcNestedTest abc\t\tabc");
+    RPCConsole::RPCExecuteCommandLine(*node, result,
+                                      "rpcNestedTest abc\t\tabc");
     QVERIFY(result == "[\"abc\",\"abc\"]");
-    RPCConsole::RPCExecuteCommandLine(result, "rpcNestedTest(abc )");
+    RPCConsole::RPCExecuteCommandLine(*node, result, "rpcNestedTest(abc )");
     QVERIFY(result == "[\"abc\"]");
-    RPCConsole::RPCExecuteCommandLine(result, "rpcNestedTest( abc )");
+    RPCConsole::RPCExecuteCommandLine(*node, result, "rpcNestedTest( abc )");
     QVERIFY(result == "[\"abc\"]");
-    RPCConsole::RPCExecuteCommandLine(result,
+    RPCConsole::RPCExecuteCommandLine(*node, result,
                                       "rpcNestedTest(   abc   ,   cba )");
     QVERIFY(result == "[\"abc\",\"cba\"]");
 
@@ -159,41 +168,42 @@
     // (QVERIFY_EXCEPTION_THROWN was introduced in Qt5.3)
 
     // invalid syntax
-    QVERIFY_EXCEPTION_THROWN(
-        RPCConsole::RPCExecuteCommandLine(result, "getblockchaininfo() .\n"),
-        std::runtime_error);
+    QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(
+                                 *node, result, "getblockchaininfo() .\n"),
+                             std::runtime_error);
 
     // invalid syntax
     QVERIFY_EXCEPTION_THROWN(
         RPCConsole::RPCExecuteCommandLine(
-            result, "getblockchaininfo() getblockchaininfo()"),
+            *node, result, "getblockchaininfo() getblockchaininfo()"),
         std::runtime_error);
     // tolerate non closing brackets if we have no arguments.
-    (RPCConsole::RPCExecuteCommandLine(result, "getblockchaininfo("));
+    (RPCConsole::RPCExecuteCommandLine(*node, result, "getblockchaininfo("));
 
     // tolerate non command brackts
-    (RPCConsole::RPCExecuteCommandLine(result, "getblockchaininfo()()()"));
+    (RPCConsole::RPCExecuteCommandLine(*node, result,
+                                       "getblockchaininfo()()()"));
 
     // invalid argument
-    QVERIFY_EXCEPTION_THROWN(
-        RPCConsole::RPCExecuteCommandLine(result, "getblockchaininfo(True)"),
-        UniValue);
+    QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(
+                                 *node, result, "getblockchaininfo(True)"),
+                             UniValue);
     // method not found
-    QVERIFY_EXCEPTION_THROWN(
-        RPCConsole::RPCExecuteCommandLine(result, "a(getblockchaininfo(True))"),
-        UniValue);
+    QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(
+                                 *node, result, "a(getblockchaininfo(True))"),
+                             UniValue);
     // don't tollerate empty arguments when using ,
-    QVERIFY_EXCEPTION_THROWN(
-        RPCConsole::RPCExecuteCommandLine(result, "rpcNestedTest abc,,abc"),
-        std::runtime_error);
+    QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(
+                                 *node, result, "rpcNestedTest abc,,abc"),
+                             std::runtime_error);
     // don't tollerate empty arguments when using ,
-    QVERIFY_EXCEPTION_THROWN(
-        RPCConsole::RPCExecuteCommandLine(result, "rpcNestedTest(abc,,abc)"),
-        std::runtime_error);
+    QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(
+                                 *node, result, "rpcNestedTest(abc,,abc)"),
+                             std::runtime_error);
     // don't tollerate empty arguments when using ,
-    QVERIFY_EXCEPTION_THROWN(
-        RPCConsole::RPCExecuteCommandLine(result, "rpcNestedTest(abc,,)"),
-        std::runtime_error);
+    QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(
+                                 *node, result, "rpcNestedTest(abc,,)"),
+                             std::runtime_error);
 #endif
 
     fs::remove_all(fs::path(path));
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
@@ -3,6 +3,7 @@
 #include "chainparams.h"
 #include "config.h"
 #include "dstencode.h"
+#include "interface/node.h"
 #include "qt/bitcoinamountfield.h"
 #include "qt/optionsmodel.h"
 #include "qt/overviewpage.h"
@@ -139,8 +140,12 @@
     std::unique_ptr<const PlatformStyle> platformStyle(
         PlatformStyle::instantiate("other"));
     SendCoinsDialog sendCoinsDialog(platformStyle.get());
-    OptionsModel optionsModel;
-    WalletModel walletModel(platformStyle.get(), &wallet, &optionsModel);
+    auto node = interface::MakeNode();
+    OptionsModel optionsModel(*node);
+    vpwallets.insert(vpwallets.begin(), &wallet);
+    WalletModel walletModel(std::move(node->getWallets()[0]), *node,
+                            platformStyle.get(), &optionsModel);
+    vpwallets.erase(vpwallets.begin());
     sendCoinsDialog.setModel(&walletModel);
 
     // Send two transactions, and verify they are added to transaction list.
@@ -161,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/trafficgraphwidget.cpp b/src/qt/trafficgraphwidget.cpp
--- a/src/qt/trafficgraphwidget.cpp
+++ b/src/qt/trafficgraphwidget.cpp
@@ -4,6 +4,7 @@
 
 #include "trafficgraphwidget.h"
 #include "clientmodel.h"
+#include "interface/node.h"
 
 #include <QColor>
 #include <QPainter>
@@ -26,8 +27,8 @@
 void TrafficGraphWidget::setClientModel(ClientModel *model) {
     clientModel = model;
     if (model) {
-        nLastBytesIn = model->getTotalBytesRecv();
-        nLastBytesOut = model->getTotalBytesSent();
+        nLastBytesIn = model->node().getTotalBytesRecv();
+        nLastBytesOut = model->node().getTotalBytesSent();
     }
 }
 
@@ -111,8 +112,8 @@
 void TrafficGraphWidget::updateRates() {
     if (!clientModel) return;
 
-    quint64 bytesIn = clientModel->getTotalBytesRecv(),
-            bytesOut = clientModel->getTotalBytesSent();
+    quint64 bytesIn = clientModel->node().getTotalBytesRecv(),
+            bytesOut = clientModel->node().getTotalBytesSent();
     float inRate =
         (bytesIn - nLastBytesIn) / 1024.0f * 1000 / timer->interval();
     float outRate =
@@ -157,8 +158,8 @@
     fMax = 0.0f;
 
     if (clientModel) {
-        nLastBytesIn = clientModel->getTotalBytesRecv();
-        nLastBytesOut = clientModel->getTotalBytesSent();
+        nLastBytesIn = clientModel->node().getTotalBytesRecv();
+        nLastBytesOut = clientModel->node().getTotalBytesSent();
     }
     timer->start();
 }
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 interface {
+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(interface::Node &node, interface::Wallet &wallet,
                           TransactionRecord *rec, int unit);
 
 private:
     TransactionDesc() {}
 
-    static QString FormatTxStatus(const CWalletTx &wtx);
+    static QString FormatTxStatus(const interface::WalletTx &wtx,
+                                  const interface::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
@@ -12,6 +12,7 @@
 #include "chain.h"
 #include "consensus/consensus.h"
 #include "dstencode.h"
+#include "interface/node.h"
 #include "script/script.h"
 #include "timedata.h"
 #include "util.h"
@@ -23,29 +24,31 @@
 #include <cstdint>
 #include <string>
 
-QString TransactionDesc::FormatTxStatus(const CWalletTx &wtx) {
-    AssertLockHeld(cs_main);
-    if (!CheckFinalTx(*wtx.tx)) {
+QString TransactionDesc::FormatTxStatus(const interface::WalletTx &wtx,
+                                        const interface::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 +57,30 @@
     }
 }
 
-QString TransactionDesc::toHTML(CWallet *wallet, CWalletTx &wtx,
+QString TransactionDesc::toHTML(interface::Node &node,
+                                interface::Wallet &wallet,
                                 TransactionRecord *rec, int unit) {
+    int numBlocks;
+    int64_t adjustedTime;
+    interface::WalletTxStatus status;
+    interface::WalletOrderForm orderForm;
+    bool inMempool;
+    interface::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 +96,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 +134,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 +150,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 +177,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 +199,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 +243,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 +262,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 +289,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 +306,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 +316,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 +329,7 @@
         }
     }
 
-    if (wtx.IsCoinBase()) {
+    if (wtx.is_coinbase) {
         quint32 numBlocksToMaturity = COINBASE_MATURITY + 1;
         strHTML +=
             "<br>" +
@@ -342,18 +349,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 +375,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
@@ -11,8 +11,12 @@
 #include <QList>
 #include <QString>
 
-class CWallet;
-class CWalletTx;
+namespace interface {
+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 interface::WalletTx &wtx);
 
     /** @name Immutable transaction attributes
       @{*/
@@ -145,11 +149,12 @@
 
     /** Update status from core wallet tx.
      */
-    void updateStatus(const CWalletTx &wtx);
+    void updateStatus(const interface::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
@@ -7,17 +7,17 @@
 #include "chain.h"
 #include "consensus/consensus.h"
 #include "dstencode.h"
+#include "interface/wallet.h"
 #include "timedata.h"
 #include "validation.h"
 #include "wallet/finaltx.h"
-#include "wallet/wallet.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 interface::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,30 +70,20 @@
     } else {
         bool involvesWatchAddress = false;
         isminetype fAllFromMe = ISMINE_SPENDABLE;
-        for (const CTxIn &txin : wtx.tx->vin) {
-            isminetype mine = wallet->IsMine(txin);
-            if (mine & ISMINE_WATCH_ONLY) {
-                involvesWatchAddress = true;
-            }
-            if (fAllFromMe > mine) {
-                fAllFromMe = mine;
-            }
+        for (isminetype mine : wtx.txin_is_mine) {
+            if (mine & ISMINE_WATCH_ONLY) involvesWatchAddress = true;
+            if (fAllFromMe > mine) fAllFromMe = mine;
         }
 
         isminetype fAllToMe = ISMINE_SPENDABLE;
-        for (const CTxOut &txout : wtx.tx->vout) {
-            isminetype mine = wallet->IsMine(txout);
-            if (mine & ISMINE_WATCH_ONLY) {
-                involvesWatchAddress = true;
-            }
-            if (fAllToMe > mine) {
-                fAllToMe = mine;
-            }
+        for (isminetype mine : wtx.txout_is_mine) {
+            if (mine & ISMINE_WATCH_ONLY) involvesWatchAddress = true;
+            if (fAllToMe > mine) fAllToMe = mine;
         }
 
         if (fAllFromMe && fAllToMe) {
             // Payment to self
-            Amount nChange = wtx.GetChange();
+            Amount nChange = wtx.change;
 
             parts.append(TransactionRecord(
                 txid, nTime, TransactionRecord::SendToSelf, "",
@@ -114,17 +102,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 +142,36 @@
     return parts;
 }
 
-void TransactionRecord::updateStatus(const CWalletTx &wtx) {
-    AssertLockHeld(cs_main);
+void TransactionRecord::updateStatus(const interface::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 +183,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 +199,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
@@ -10,13 +10,17 @@
 #include <QAbstractTableModel>
 #include <QStringList>
 
+#include <memory>
+
+namespace interface {
+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<interface::Handler> m_handler_transaction_changed;
+    std::unique_ptr<interface::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
@@ -14,11 +14,12 @@
 #include "walletmodel.h"
 
 #include "core_io.h"
+#include "interface/handler.h"
+#include "interface/node.h"
 #include "sync.h"
 #include "uint256.h"
 #include "util.h"
 #include "validation.h"
-#include "wallet/wallet.h"
 
 #include <QColor>
 #include <QDateTime>
@@ -53,10 +54,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 +67,13 @@
     /**
      * Query entire wallet anew from core.
      */
-    void refreshWallet() {
+    void refreshWallet(interface::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 +83,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(interface::Wallet &wallet, const TxId &txid, int status,
+                      bool showTransaction) {
         qDebug() << "TransactionTablePriv::updateWallet: " +
                         QString::fromStdString(txid.ToString()) + " " +
                         QString::number(status);
@@ -126,11 +124,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()) {
+                    interface::WalletTx wtx = wallet.getWalletTx(txid);
+                    if (!wtx.tx) {
                         qWarning() << "TransactionTablePriv::updateWallet: "
                                       "Warning: Got CT_NEW, but transaction is "
                                       "not in wallet";
@@ -138,8 +134,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 +172,7 @@
 
     int size() { return cachedWallet.size(); }
 
-    TransactionRecord *index(int idx) {
+    TransactionRecord *index(interface::Wallet &wallet, int idx) {
         if (idx >= 0 && idx < cachedWallet.size()) {
             TransactionRecord *rec = &cachedWallet[idx];
 
@@ -188,40 +183,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);
-                    }
-                }
+            interface::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(interface::Node &node, interface::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(interface::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 +212,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 +245,7 @@
     TxId updated;
     updated.SetHex(hash.toStdString());
 
-    priv->updateWallet(updated, status, showTransaction);
+    priv->updateWallet(walletModel->wallet(), updated, status, showTransaction);
 }
 
 void TransactionTableModel::updateConfirmations() {
@@ -604,7 +587,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 +601,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 +679,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 +721,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 +767,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/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,
@@ -370,7 +370,7 @@
     // name, column, role
     writer.setModel(transactionProxyModel);
     writer.addColumn(tr("Confirmed"), 0, TransactionTableModel::ConfirmedRole);
-    if (model && model->haveWatchOnly()) {
+    if (model->wallet().haveWatchOnly()) {
         writer.addColumn(tr("Watch-only"), TransactionTableModel::Watchonly);
     }
     writer.addColumn(tr("Date"), 0, TransactionTableModel::DateRole);
@@ -412,7 +412,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));
@@ -435,7 +435,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/utilitydialog.h b/src/qt/utilitydialog.h
--- a/src/qt/utilitydialog.h
+++ b/src/qt/utilitydialog.h
@@ -11,6 +11,10 @@
 class BitcoinGUI;
 class ClientModel;
 
+namespace interface {
+class Node;
+}
+
 namespace Ui {
 class HelpMessageDialog;
 }
@@ -20,7 +24,8 @@
     Q_OBJECT
 
 public:
-    explicit HelpMessageDialog(QWidget *parent, bool about);
+    explicit HelpMessageDialog(interface::Node &node, QWidget *parent,
+                               bool about);
     ~HelpMessageDialog();
 
     void printToConsole();
diff --git a/src/qt/utilitydialog.cpp b/src/qt/utilitydialog.cpp
--- a/src/qt/utilitydialog.cpp
+++ b/src/qt/utilitydialog.cpp
@@ -19,6 +19,7 @@
 
 #include "clientversion.h"
 #include "init.h"
+#include "interface/node.h"
 #include "util.h"
 
 #include <cstdio>
@@ -31,7 +32,8 @@
 #include <QVBoxLayout>
 
 /** "Help message" or "About" dialog box */
-HelpMessageDialog::HelpMessageDialog(QWidget *parent, bool about)
+HelpMessageDialog::HelpMessageDialog(interface::Node &node, QWidget *parent,
+                                     bool about)
     : QDialog(parent), ui(new Ui::HelpMessageDialog) {
     ui->setupUi(this);
 
@@ -78,7 +80,7 @@
         cursor.insertText(header);
         cursor.insertBlock();
 
-        std::string strUsage = HelpMessage(HelpMessageMode::BITCOIN_QT);
+        std::string strUsage = node.helpMessage(HelpMessageMode::BITCOIN_QT);
         const bool showDebug = gArgs.GetBoolArg("-help-debug", false);
         strUsage += HelpMessageGroup(tr("UI Options:").toStdString());
         if (showDebug) {
diff --git a/src/qt/walletmodel.h b/src/qt/walletmodel.h
--- a/src/qt/walletmodel.h
+++ b/src/qt/walletmodel.h
@@ -9,6 +9,7 @@
 #include "paymentrequestplus.h"
 #include "walletmodeltransaction.h"
 
+#include "interface/wallet.h"
 #include "support/allocators/secure.h"
 
 #include <map>
@@ -28,9 +29,12 @@
 class COutPoint;
 class COutput;
 class CPubKey;
-class CWallet;
 class uint256;
 
+namespace interface {
+class Node;
+} // namespace interface
+
 QT_BEGIN_NAMESPACE
 class QTimer;
 QT_END_NAMESPACE
@@ -111,7 +115,9 @@
     Q_OBJECT
 
 public:
-    explicit WalletModel(const PlatformStyle *platformStyle, CWallet *wallet,
+    explicit WalletModel(std::unique_ptr<interface::Wallet> wallet,
+                         interface::Node &node,
+                         const PlatformStyle *platformStyle,
                          OptionsModel *optionsModel, QObject *parent = nullptr);
     ~WalletModel();
 
@@ -144,15 +150,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 +178,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 +205,34 @@
 
     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;
+    interface::Node &node() const {
+        return m_node;
+    }
+    interface::Wallet &wallet() const {
+        return *m_wallet;
+    }
 
     const CChainParams &getChainParams() const;
 
     QString getWalletName() const;
 
-    static bool isMultiwallet();
+    bool isMultiwallet();
 
 private:
-    CWallet *wallet;
+    std::unique_ptr<interface::Wallet> m_wallet;
+    std::unique_ptr<interface::Handler> m_handler_status_changed;
+    std::unique_ptr<interface::Handler> m_handler_address_book_changed;
+    std::unique_ptr<interface::Handler> m_handler_transaction_changed;
+    std::unique_ptr<interface::Handler> m_handler_show_progress;
+    std::unique_ptr<interface::Handler> m_handler_watch_only_changed;
+    interface::Node &m_node;
+
     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;
+    interface::WalletBalances m_cached_balances;
     EncryptionStatus cachedEncryptionStatus;
     int cachedNumBlocks;
 
@@ -267,7 +253,7 @@
 
     void subscribeToCoreSignals();
     void unsubscribeFromCoreSignals();
-    void checkBalanceChanged();
+    void checkBalanceChanged(const interface::WalletBalances &new_balances);
 
 Q_SIGNALS:
     // Signal that balance in wallet changed
@@ -290,7 +276,7 @@
                  unsigned int style);
 
     // Coins sent: from wallet, to recipient, in (serialized) transaction:
-    void coinsSent(CWallet *wallet, SendCoinsRecipient recipient,
+    void coinsSent(WalletModel *wallet, SendCoinsRecipient recipient,
                    QByteArray transaction);
 
     // Show progress dialog e.g. for rescan
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
--- a/src/qt/walletmodel.cpp
+++ b/src/qt/walletmodel.cpp
@@ -5,9 +5,7 @@
 #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"
@@ -15,15 +13,12 @@
 #include "chain.h"
 #include "config.h"
 #include "dstencode.h"
-#include "keystore.h"
-#include "net.h" // for g_connman
-#include "sync.h"
+#include "interface/handler.h"
+#include "interface/node.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>
 
@@ -31,20 +26,20 @@
 #include <QSet>
 #include <QTimer>
 
-WalletModel::WalletModel(const PlatformStyle *platformStyle, CWallet *_wallet,
+WalletModel::WalletModel(std::unique_ptr<interface::Wallet> wallet,
+                         interface::Node &node,
+                         const PlatformStyle *platformStyle,
                          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),
+      optionsModel(_optionsModel), addressTableModel(0),
+      transactionTableModel(0), recentRequestsTableModel(0),
+      cachedEncryptionStatus(Unencrypted), cachedNumBlocks(0) {
+    fHaveWatchOnly = m_wallet->haveWatchOnly();
     fForceCheckBalanceChanged = false;
 
-    addressTableModel = new AddressTableModel(wallet, this);
-    transactionTableModel =
-        new TransactionTableModel(platformStyle, wallet, this);
-    recentRequestsTableModel = new RecentRequestsTableModel(wallet, this);
+    addressTableModel = new AddressTableModel(this);
+    transactionTableModel = new TransactionTableModel(platformStyle, this);
+    recentRequestsTableModel = new RecentRequestsTableModel(this);
 
     // This timer will be fired repeatedly to update the balance
     pollTimer = new QTimer(this);
@@ -58,38 +53,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 +62,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.
+    interface::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 interface::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 +116,7 @@
 }
 
 bool WalletModel::validateAddress(const QString &address) {
-    return IsValidDestinationString(address.toStdString(),
-                                    GetConfig().GetChainParams());
+    return IsValidDestinationString(address.toStdString(), getChainParams());
 }
 
 WalletModel::SendCoinsReturn
@@ -234,8 +175,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,32 +188,27 @@
         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);
+        auto &newTx = transaction.getWtx();
+        newTx = m_wallet->createTransaction(vecSend, coinControl,
+                                            true /* sign */, nChangePosRet,
+                                            nFeeRequired, strFailReason);
         transaction.setTransactionFee(nFeeRequired);
-        if (fSubtractFeeFromAmount && fCreated) {
+        if (fSubtractFeeFromAmount && newTx) {
             transaction.reassignAmounts(nChangePosRet);
         }
 
-        if (!fCreated) {
+        if (!newTx) {
             if (!fSubtractFeeFromAmount && (total + nFeeRequired) > nBalance) {
                 return SendCoinsReturn(AmountWithFeeExceedsBalance);
             }
@@ -282,10 +218,10 @@
             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)) {
+        // 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;
         }
     }
@@ -299,8 +235,6 @@
     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()) {
@@ -321,19 +255,16 @@
             }
         }
 
-        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()));
+        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;
+        ssTx << newTx->get();
         transaction_array.append(&(ssTx[0]), ssTx.size());
     }
 
@@ -344,29 +275,25 @@
         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) {
+                std::string name;
+                if (!m_wallet->getAddress(dest, &name)) {
+                    m_wallet->setAddressBook(dest, strLabel, "send");
+                } else if (name != strLabel) {
                     // "" means don't change purpose
-                    wallet->SetAddressBook(dest, strLabel, "");
+                    m_wallet->setAddressBook(dest, strLabel, "");
                 }
             }
         }
-        Q_EMIT coinsSent(wallet, rcp, transaction_array);
+        Q_EMIT coinsSent(this, 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 +315,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 +328,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 +338,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 +378,8 @@
                               Q_ARG(QString, strPurpose), Q_ARG(int, status));
 }
 
-static void NotifyTransactionChanged(WalletModel *walletmodel, CWallet *wallet,
+static void NotifyTransactionChanged(WalletModel *walletmodel,
                                      const uint256 &hash, ChangeType status) {
-    Q_UNUSED(wallet);
     Q_UNUSED(hash);
     Q_UNUSED(status);
     QMetaObject::invokeMethod(walletmodel, "updateTransaction",
@@ -483,28 +403,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,123 +454,38 @@
     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);
-    for (const COutPoint &outpoint : vOutpoints) {
-        auto it = wallet->mapWallet.find(outpoint.GetTxId());
-        if (it == wallet->mapWallet.end()) {
-            continue;
-        }
-        int nDepth = it->second.GetDepthInMainChain();
-        if (nDepth < 0) {
-            continue;
-        }
-        COutput out(&it->second, outpoint.GetN(), nDepth, true /* spendable */,
-                    true /* solvable */, true /* safe */);
-        vOutputs.push_back(out);
-    }
-}
-
-bool WalletModel::isSpent(const COutPoint &outpoint) const {
-    LOCK2(cs_main, wallet->cs_wallet);
-    return wallet->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()) {
-        auto &resultGroup =
-            mapCoins[QString::fromStdString(EncodeDestination(group.first))];
-        for (auto &coin : group.second) {
-            resultGroup.emplace_back(std::move(coin));
-        }
-    }
-}
-
-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
@@ -11,9 +11,10 @@
 
 class SendCoinsRecipient;
 
-class CReserveKey;
-class CWallet;
-class CWalletTx;
+namespace interface {
+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<interface::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<interface::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
@@ -4,24 +4,24 @@
 
 #include "walletmodeltransaction.h"
 
+#include "interface/node.h"
 #include "policy/policy.h"
-#include "wallet/wallet.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<interface::PendingWalletTx> &WalletModelTransaction::getWtx() {
+    return wtx;
 }
 
 unsigned int WalletModelTransaction::getTransactionSize() {
-    return !walletTransaction ? 0
-                              : CTransaction(*walletTransaction).GetTotalSize();
+    // TODO Fix "virtual" size
+    return wtx ? wtx->getVirtualSize() : 0;
 }
 
 Amount WalletModelTransaction::getTransactionFee() const {
@@ -33,6 +33,7 @@
 }
 
 void WalletModelTransaction::reassignAmounts(int nChangePosRet) {
+    const CTransaction *walletTransaction = &wtx->get();
     int i = 0;
     for (SendCoinsRecipient &rcp : recipients) {
         if (rcp.paymentRequest.IsInitialized()) {
@@ -72,11 +73,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
@@ -19,6 +19,7 @@
 #include "transactionview.h"
 #include "walletmodel.h"
 
+#include "interface/node.h"
 #include "ui_interface.h"
 
 #include <QAction>
@@ -181,7 +182,8 @@
 void WalletView::processNewTransaction(const QModelIndex &parent, int start,
                                        int end) {
     // Prevent balloon-spam when initial block download is in progress
-    if (!walletModel || !clientModel || clientModel->inInitialBlockDownload()) {
+    if (!walletModel || !clientModel ||
+        clientModel->node().isInitialBlockDownload()) {
         return;
     }
 
@@ -292,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.")
diff --git a/src/validation.h b/src/validation.h
--- a/src/validation.h
+++ b/src/validation.h
@@ -426,7 +426,8 @@
  * Guess verification progress (as a fraction between 0.0=genesis and
  * 1.0=current tip).
  */
-double GuessVerificationProgress(const ChainTxData &data, CBlockIndex *pindex);
+double GuessVerificationProgress(const ChainTxData &data,
+                                 const CBlockIndex *pindex);
 
 /**
  * Calculate the amount of disk space the block & undo files currently use.
diff --git a/src/validation.cpp b/src/validation.cpp
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -5688,7 +5688,8 @@
 }
 
 //! Guess how far we are in the verification process at the given block index
-double GuessVerificationProgress(const ChainTxData &data, CBlockIndex *pindex) {
+double GuessVerificationProgress(const ChainTxData &data,
+                                 const CBlockIndex *pindex) {
     if (pindex == nullptr) {
         return 0.0;
     }
diff --git a/src/wallet/CMakeLists.txt b/src/wallet/CMakeLists.txt
--- a/src/wallet/CMakeLists.txt
+++ b/src/wallet/CMakeLists.txt
@@ -10,6 +10,7 @@
 find_package(Event REQUIRED)
 
 add_library(wallet
+	../interface/wallet.cpp
 	crypter.cpp
 	db.cpp
 	fees.cpp