diff --git a/src/interfaces/node.cpp b/src/interfaces/node.cpp
index d95f3b7ba..59df99d88 100644
--- a/src/interfaces/node.cpp
+++ b/src/interfaces/node.cpp
@@ -1,246 +1,287 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <interfaces/node.h>
 
 #include <addrdb.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <init.h>
 #include <interfaces/handler.h>
 #include <interfaces/wallet.h>
 #include <net.h>
 #include <net_processing.h>
 #include <netaddress.h>
 #include <netbase.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
 #define CHECK_WALLET(x) x
 #else
 #define CHECK_WALLET(x)                                                        \
     throw std::logic_error("Wallet function called in non-wallet build.")
 #endif
 
 #include <boost/thread/thread.hpp>
+#include <univalue.h>
 
 #include <atomic>
 
 class CWallet;
 class HTTPRPCRequestProcessor;
 
 namespace interfaces {
 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);
         }
         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();
             }
             // Genesis block's time of current network
             return Params().GenesisBlock().GetBlockTime();
         }
         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();
         }
+        UniValue executeRpc(Config &config, const std::string &command,
+                            const UniValue &params,
+                            const std::string &uri) override {
+            JSONRPCRequest req;
+            req.params = params;
+            req.strMethod = command;
+            req.URI = uri;
+            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);
+        }
         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 interfaces
diff --git a/src/interfaces/node.h b/src/interfaces/node.h
index ca1b21403..a2ef8493d 100644
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -1,206 +1,232 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_INTERFACES_NODE_H
 #define BITCOIN_INTERFACES_NODE_H
 
 #include <addrdb.h>     // For banmap_t
 #include <init.h>       // For HelpMessageMode
 #include <net.h>        // For CConnman::NumConnections
 #include <netaddress.h> // For Network
 
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <string>
 #include <tuple>
 #include <vector>
 
 struct CNodeStateStats;
 struct CNodeStats;
 class Config;
 class HTTPRPCRequestProcessor;
 class proxyType;
 class RPCServer;
+class RPCTimerInterface;
+class UniValue;
 
 namespace interfaces {
 
 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;
 
     //! 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;
 
+    //! Execute rpc command.
+    virtual UniValue executeRpc(Config &config, 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;
+
     //! 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 interfaces
 
 #endif // BITCOIN_INTERFACES_NODE_H
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index 09c5c0a00..9acace2f7 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -1,1333 +1,1333 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include "config/bitcoin-config.h"
 #endif
 
 #include "bitcoingui.h"
 
 #include "bitcoinunits.h"
 #include "clientmodel.h"
 #include "guiconstants.h"
 #include "guiutil.h"
 #include "modaloverlay.h"
 #include "networkstyle.h"
 #include "notificator.h"
 #include "openuridialog.h"
 #include "optionsdialog.h"
 #include "optionsmodel.h"
 #include "platformstyle.h"
 #include "rpcconsole.h"
 #include "utilitydialog.h"
 
 #ifdef ENABLE_WALLET
 #include "walletframe.h"
 #include "walletmodel.h"
 #include "walletview.h"
 #endif // ENABLE_WALLET
 
 #ifdef Q_OS_MAC
 #include "macdockiconhandler.h"
 #endif
 
 #include "chainparams.h"
 #include "init.h"
 #include "interfaces/handler.h"
 #include "interfaces/node.h"
 #include "ui_interface.h"
 #include "util.h"
 
 #include <iostream>
 
 #include <QAction>
 #include <QApplication>
 #include <QComboBox>
 #include <QDateTime>
 #include <QDesktopWidget>
 #include <QDragEnterEvent>
 #include <QListWidget>
 #include <QMenuBar>
 #include <QMessageBox>
 #include <QMimeData>
 #include <QProgressDialog>
 #include <QSettings>
 #include <QShortcut>
 #include <QStackedWidget>
 #include <QStatusBar>
 #include <QStyle>
 #include <QTimer>
 #include <QToolBar>
 #include <QUrlQuery>
 #include <QVBoxLayout>
 
 const std::string BitcoinGUI::DEFAULT_UIPLATFORM =
 #if defined(Q_OS_MAC)
     "macosx"
 #elif defined(Q_OS_WIN)
     "windows"
 #else
     "other"
 #endif
     ;
 
 BitcoinGUI::BitcoinGUI(interfaces::Node &node, const Config *configIn,
                        const PlatformStyle *_platformStyle,
                        const NetworkStyle *networkStyle, QWidget *parent)
     : 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
         move(QApplication::desktop()->availableGeometry().center() -
              frameGeometry().center());
     }
 
     QString windowTitle = tr(PACKAGE_NAME) + " - ";
 #ifdef ENABLE_WALLET
     enableWallet = WalletModel::isWalletEnabled();
 #endif // ENABLE_WALLET
     if (enableWallet) {
         windowTitle += tr("Wallet");
     } else {
         windowTitle += tr("Node");
     }
     windowTitle += " " + networkStyle->getTitleAddText();
 #ifndef Q_OS_MAC
     QApplication::setWindowIcon(networkStyle->getTrayAndWindowIcon());
     setWindowIcon(networkStyle->getTrayAndWindowIcon());
 #else
     MacDockIconHandler::instance()->setIcon(networkStyle->getAppIcon());
 #endif
     setWindowTitle(windowTitle);
 
-    rpcConsole = new RPCConsole(_platformStyle, 0);
+    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 */
         walletFrame = new WalletFrame(_platformStyle, config, this);
         setCentralWidget(walletFrame);
     } else
 #endif // ENABLE_WALLET
     {
         /**
          * When compiled without wallet or -disablewallet is provided,  the
          * central widget is the rpc console.
          */
         setCentralWidget(rpcConsole);
     }
 
     // Accept D&D of URIs
     setAcceptDrops(true);
 
     // Create actions for the toolbar, menu bar and tray/dock icon
     // Needs walletFrame to be initialized
     createActions();
 
     // Create application menu bar
     createMenuBar();
 
     // Create the toolbars
     createToolBars();
 
     // Create system tray icon and notification
     createTrayIcon(networkStyle);
 
     // Create status bar
     statusBar();
 
     // Disable size grip because it looks ugly and nobody needs it
     statusBar()->setSizeGripEnabled(false);
 
     // Status bar notification icons
     QFrame *frameBlocks = new QFrame();
     frameBlocks->setContentsMargins(0, 0, 0, 0);
     frameBlocks->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
     QHBoxLayout *frameBlocksLayout = new QHBoxLayout(frameBlocks);
     frameBlocksLayout->setContentsMargins(3, 0, 3, 0);
     frameBlocksLayout->setSpacing(3);
     unitDisplayControl = new UnitDisplayStatusBarControl(platformStyle);
     labelWalletEncryptionIcon = new QLabel();
     labelWalletHDStatusIcon = new QLabel();
     connectionsControl = new GUIUtil::ClickableLabel();
     labelBlocksIcon = new GUIUtil::ClickableLabel();
     if (enableWallet) {
         frameBlocksLayout->addStretch();
         frameBlocksLayout->addWidget(unitDisplayControl);
         frameBlocksLayout->addStretch();
         frameBlocksLayout->addWidget(labelWalletEncryptionIcon);
         frameBlocksLayout->addWidget(labelWalletHDStatusIcon);
     }
     frameBlocksLayout->addStretch();
     frameBlocksLayout->addWidget(connectionsControl);
     frameBlocksLayout->addStretch();
     frameBlocksLayout->addWidget(labelBlocksIcon);
     frameBlocksLayout->addStretch();
 
     // Progress bar and label for blocks download
     progressBarLabel = new QLabel();
     progressBarLabel->setVisible(false);
     progressBar = new GUIUtil::ProgressBar();
     progressBar->setAlignment(Qt::AlignCenter);
     progressBar->setVisible(false);
 
     // Override style sheet for progress bar for styles that have a segmented
     // progress bar, as they make the text unreadable (workaround for issue
     // #1071)
     // See https://doc.qt.io/qt-5/gallery.html
     QString curStyle = QApplication::style()->metaObject()->className();
     if (curStyle == "QWindowsStyle" || curStyle == "QWindowsXPStyle") {
         progressBar->setStyleSheet(
             "QProgressBar { background-color: #e8e8e8; border: 1px solid grey; "
             "border-radius: 7px; padding: 1px; text-align: center; } "
             "QProgressBar::chunk { background: QLinearGradient(x1: 0, y1: 0, "
             "x2: 1, y2: 0, stop: 0 #FF8000, stop: 1 orange); border-radius: "
             "7px; margin: 0px; }");
     }
 
     statusBar()->addWidget(progressBarLabel);
     statusBar()->addWidget(progressBar);
     statusBar()->addPermanentWidget(frameBlocks);
 
     // Install event filter to be able to catch status tip events
     // (QEvent::StatusTip)
     this->installEventFilter(this);
 
     // Initially wallet actions should be disabled
     setWalletActionsEnabled(false);
 
     // Subscribe to notifications from core
     subscribeToCoreSignals();
 
     connect(connectionsControl, SIGNAL(clicked(QPoint)), this,
             SLOT(toggleNetworkActive()));
 
     modalOverlay = new ModalOverlay(this->centralWidget());
 #ifdef ENABLE_WALLET
     if (enableWallet) {
         connect(walletFrame, SIGNAL(requestedSyncWarningInfo()), this,
                 SLOT(showModalOverlay()));
         connect(labelBlocksIcon, SIGNAL(clicked(QPoint)), this,
                 SLOT(showModalOverlay()));
         connect(progressBar, SIGNAL(clicked(QPoint)), this,
                 SLOT(showModalOverlay()));
     }
 #endif
 }
 
 BitcoinGUI::~BitcoinGUI() {
     // Unsubscribe from notifications from core
     unsubscribeFromCoreSignals();
 
     QSettings settings;
     settings.setValue("MainWindowGeometry", saveGeometry());
     // Hide tray icon, as deleting will let it linger until quit (on Ubuntu)
     if (trayIcon) {
         trayIcon->hide();
     }
 #ifdef Q_OS_MAC
     delete appMenuBar;
     MacDockIconHandler::cleanup();
 #endif
 
     delete rpcConsole;
 }
 
 void BitcoinGUI::createActions() {
     QActionGroup *tabGroup = new QActionGroup(this);
 
     overviewAction =
         new QAction(platformStyle->SingleColorIcon(":/icons/overview"),
                     tr("&Overview"), this);
     overviewAction->setStatusTip(tr("Show general overview of wallet"));
     overviewAction->setToolTip(overviewAction->statusTip());
     overviewAction->setCheckable(true);
     overviewAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_1));
     tabGroup->addAction(overviewAction);
 
     sendCoinsAction = new QAction(
         platformStyle->SingleColorIcon(":/icons/send"), tr("&Send"), this);
     sendCoinsAction->setStatusTip(tr("Send coins to a Bitcoin address"));
     sendCoinsAction->setToolTip(sendCoinsAction->statusTip());
     sendCoinsAction->setCheckable(true);
     sendCoinsAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_2));
     tabGroup->addAction(sendCoinsAction);
 
     sendCoinsMenuAction =
         new QAction(platformStyle->TextColorIcon(":/icons/send"),
                     sendCoinsAction->text(), this);
     sendCoinsMenuAction->setStatusTip(sendCoinsAction->statusTip());
     sendCoinsMenuAction->setToolTip(sendCoinsMenuAction->statusTip());
 
     receiveCoinsAction = new QAction(
         platformStyle->SingleColorIcon(":/icons/receiving_addresses"),
         tr("&Receive"), this);
     receiveCoinsAction->setStatusTip(
         tr("Request payments (generates QR codes and %1: URIs)")
             .arg(GUIUtil::bitcoinURIScheme(*config)));
     receiveCoinsAction->setToolTip(receiveCoinsAction->statusTip());
     receiveCoinsAction->setCheckable(true);
     receiveCoinsAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_3));
     tabGroup->addAction(receiveCoinsAction);
 
     receiveCoinsMenuAction =
         new QAction(platformStyle->TextColorIcon(":/icons/receiving_addresses"),
                     receiveCoinsAction->text(), this);
     receiveCoinsMenuAction->setStatusTip(receiveCoinsAction->statusTip());
     receiveCoinsMenuAction->setToolTip(receiveCoinsMenuAction->statusTip());
 
     historyAction =
         new QAction(platformStyle->SingleColorIcon(":/icons/history"),
                     tr("&Transactions"), this);
     historyAction->setStatusTip(tr("Browse transaction history"));
     historyAction->setToolTip(historyAction->statusTip());
     historyAction->setCheckable(true);
     historyAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_4));
     tabGroup->addAction(historyAction);
 
 #ifdef ENABLE_WALLET
     // These showNormalIfMinimized are needed because Send Coins and Receive
     // Coins can be triggered from the tray menu, and need to show the GUI to be
     // useful.
     connect(overviewAction, SIGNAL(triggered()), this,
             SLOT(showNormalIfMinimized()));
     connect(overviewAction, SIGNAL(triggered()), this,
             SLOT(gotoOverviewPage()));
     connect(sendCoinsAction, SIGNAL(triggered()), this,
             SLOT(showNormalIfMinimized()));
     connect(sendCoinsAction, SIGNAL(triggered()), this,
             SLOT(gotoSendCoinsPage()));
     connect(sendCoinsMenuAction, SIGNAL(triggered()), this,
             SLOT(showNormalIfMinimized()));
     connect(sendCoinsMenuAction, SIGNAL(triggered()), this,
             SLOT(gotoSendCoinsPage()));
     connect(receiveCoinsAction, SIGNAL(triggered()), this,
             SLOT(showNormalIfMinimized()));
     connect(receiveCoinsAction, SIGNAL(triggered()), this,
             SLOT(gotoReceiveCoinsPage()));
     connect(receiveCoinsMenuAction, SIGNAL(triggered()), this,
             SLOT(showNormalIfMinimized()));
     connect(receiveCoinsMenuAction, SIGNAL(triggered()), this,
             SLOT(gotoReceiveCoinsPage()));
     connect(historyAction, SIGNAL(triggered()), this,
             SLOT(showNormalIfMinimized()));
     connect(historyAction, SIGNAL(triggered()), this, SLOT(gotoHistoryPage()));
 #endif // ENABLE_WALLET
 
     quitAction = new QAction(platformStyle->TextColorIcon(":/icons/quit"),
                              tr("E&xit"), this);
     quitAction->setStatusTip(tr("Quit application"));
     quitAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q));
     quitAction->setMenuRole(QAction::QuitRole);
     aboutAction = new QAction(platformStyle->TextColorIcon(":/icons/about"),
                               tr("&About %1").arg(tr(PACKAGE_NAME)), this);
     aboutAction->setStatusTip(
         tr("Show information about %1").arg(tr(PACKAGE_NAME)));
     aboutAction->setMenuRole(QAction::AboutRole);
     aboutAction->setEnabled(false);
     aboutQtAction =
         new QAction(platformStyle->TextColorIcon(":/icons/about_qt"),
                     tr("About &Qt"), this);
     aboutQtAction->setStatusTip(tr("Show information about Qt"));
     aboutQtAction->setMenuRole(QAction::AboutQtRole);
     optionsAction = new QAction(platformStyle->TextColorIcon(":/icons/options"),
                                 tr("&Options..."), this);
     optionsAction->setStatusTip(
         tr("Modify configuration options for %1").arg(tr(PACKAGE_NAME)));
     optionsAction->setMenuRole(QAction::PreferencesRole);
     optionsAction->setEnabled(false);
     toggleHideAction =
         new QAction(platformStyle->TextColorIcon(":/icons/about"),
                     tr("&Show / Hide"), this);
     toggleHideAction->setStatusTip(tr("Show or hide the main Window"));
 
     encryptWalletAction =
         new QAction(platformStyle->TextColorIcon(":/icons/lock_closed"),
                     tr("&Encrypt Wallet..."), this);
     encryptWalletAction->setStatusTip(
         tr("Encrypt the private keys that belong to your wallet"));
     encryptWalletAction->setCheckable(true);
     backupWalletAction =
         new QAction(platformStyle->TextColorIcon(":/icons/filesave"),
                     tr("&Backup Wallet..."), this);
     backupWalletAction->setStatusTip(tr("Backup wallet to another location"));
     changePassphraseAction =
         new QAction(platformStyle->TextColorIcon(":/icons/key"),
                     tr("&Change Passphrase..."), this);
     changePassphraseAction->setStatusTip(
         tr("Change the passphrase used for wallet encryption"));
     signMessageAction =
         new QAction(platformStyle->TextColorIcon(":/icons/edit"),
                     tr("Sign &message..."), this);
     signMessageAction->setStatusTip(
         tr("Sign messages with your Bitcoin addresses to prove you own them"));
     verifyMessageAction =
         new QAction(platformStyle->TextColorIcon(":/icons/verify"),
                     tr("&Verify message..."), this);
     verifyMessageAction->setStatusTip(
         tr("Verify messages to ensure they were signed with specified Bitcoin "
            "addresses"));
 
     openRPCConsoleAction =
         new QAction(platformStyle->TextColorIcon(":/icons/debugwindow"),
                     tr("&Debug window"), this);
     openRPCConsoleAction->setStatusTip(
         tr("Open debugging and diagnostic console"));
     // initially disable the debug window menu item
     openRPCConsoleAction->setEnabled(false);
 
     usedSendingAddressesAction =
         new QAction(platformStyle->TextColorIcon(":/icons/address-book"),
                     tr("&Sending addresses..."), this);
     usedSendingAddressesAction->setStatusTip(
         tr("Show the list of used sending addresses and labels"));
     usedReceivingAddressesAction =
         new QAction(platformStyle->TextColorIcon(":/icons/address-book"),
                     tr("&Receiving addresses..."), this);
     usedReceivingAddressesAction->setStatusTip(
         tr("Show the list of used receiving addresses and labels"));
 
     openAction = new QAction(platformStyle->TextColorIcon(":/icons/open"),
                              tr("Open &URI..."), this);
     openAction->setStatusTip(tr("Open a %1: URI or payment request")
                                  .arg(GUIUtil::bitcoinURIScheme(*config)));
 
     showHelpMessageAction =
         new QAction(platformStyle->TextColorIcon(":/icons/info"),
                     tr("&Command-line options"), this);
     showHelpMessageAction->setMenuRole(QAction::NoRole);
     showHelpMessageAction->setStatusTip(
         tr("Show the %1 help message to get a list with possible Bitcoin "
            "command-line options")
             .arg(tr(PACKAGE_NAME)));
 
     connect(quitAction, SIGNAL(triggered()), qApp, SLOT(quit()));
     connect(aboutAction, SIGNAL(triggered()), this, SLOT(aboutClicked()));
     connect(aboutQtAction, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
     connect(optionsAction, SIGNAL(triggered()), this, SLOT(optionsClicked()));
     connect(toggleHideAction, SIGNAL(triggered()), this, SLOT(toggleHidden()));
     connect(showHelpMessageAction, SIGNAL(triggered()), this,
             SLOT(showHelpMessageClicked()));
     connect(openRPCConsoleAction, SIGNAL(triggered()), this,
             SLOT(showDebugWindow()));
     // prevents an open debug window from becoming stuck/unusable on client
     // shutdown
     connect(quitAction, SIGNAL(triggered()), rpcConsole, SLOT(hide()));
 
 #ifdef ENABLE_WALLET
     if (walletFrame) {
         connect(encryptWalletAction, SIGNAL(triggered(bool)), walletFrame,
                 SLOT(encryptWallet(bool)));
         connect(backupWalletAction, SIGNAL(triggered()), walletFrame,
                 SLOT(backupWallet()));
         connect(changePassphraseAction, SIGNAL(triggered()), walletFrame,
                 SLOT(changePassphrase()));
         connect(signMessageAction, SIGNAL(triggered()), this,
                 SLOT(gotoSignMessageTab()));
         connect(verifyMessageAction, SIGNAL(triggered()), this,
                 SLOT(gotoVerifyMessageTab()));
         connect(usedSendingAddressesAction, SIGNAL(triggered()), walletFrame,
                 SLOT(usedSendingAddresses()));
         connect(usedReceivingAddressesAction, SIGNAL(triggered()), walletFrame,
                 SLOT(usedReceivingAddresses()));
         connect(openAction, SIGNAL(triggered()), this, SLOT(openClicked()));
     }
 #endif // ENABLE_WALLET
 
     new QShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_C), this,
                   SLOT(showDebugWindowActivateConsole()));
     new QShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_D), this,
                   SLOT(showDebugWindow()));
 }
 
 void BitcoinGUI::createMenuBar() {
 #ifdef Q_OS_MAC
     // Create a decoupled menu bar on Mac which stays even if the window is
     // closed
     appMenuBar = new QMenuBar();
 #else
     // Get the main window's menu bar on other platforms
     appMenuBar = menuBar();
 #endif
 
     // Configure the menus
     QMenu *file = appMenuBar->addMenu(tr("&File"));
     if (walletFrame) {
         file->addAction(openAction);
         file->addAction(backupWalletAction);
         file->addAction(signMessageAction);
         file->addAction(verifyMessageAction);
         file->addSeparator();
         file->addAction(usedSendingAddressesAction);
         file->addAction(usedReceivingAddressesAction);
         file->addSeparator();
     }
     file->addAction(quitAction);
 
     QMenu *settings = appMenuBar->addMenu(tr("&Settings"));
     if (walletFrame) {
         settings->addAction(encryptWalletAction);
         settings->addAction(changePassphraseAction);
         settings->addSeparator();
     }
     settings->addAction(optionsAction);
 
     QMenu *help = appMenuBar->addMenu(tr("&Help"));
     if (walletFrame) {
         help->addAction(openRPCConsoleAction);
     }
     help->addAction(showHelpMessageAction);
     help->addSeparator();
     help->addAction(aboutAction);
     help->addAction(aboutQtAction);
 }
 
 void BitcoinGUI::createToolBars() {
     if (walletFrame) {
         QToolBar *toolbar = addToolBar(tr("Tabs toolbar"));
         appToolBar = toolbar;
         toolbar->setContextMenuPolicy(Qt::PreventContextMenu);
         toolbar->setMovable(false);
         toolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
         toolbar->addAction(overviewAction);
         toolbar->addAction(sendCoinsAction);
         toolbar->addAction(receiveCoinsAction);
         toolbar->addAction(historyAction);
         overviewAction->setChecked(true);
 
 #ifdef ENABLE_WALLET
         QWidget *spacer = new QWidget();
         spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
         toolbar->addWidget(spacer);
 
         m_wallet_selector = new QComboBox();
         connect(m_wallet_selector, SIGNAL(currentIndexChanged(const QString &)),
                 this, SLOT(setCurrentWallet(const QString &)));
 #endif
     }
 }
 
 void BitcoinGUI::setClientModel(ClientModel *_clientModel) {
     this->clientModel = _clientModel;
     if (_clientModel) {
         // Create system tray menu (or setup the dock menu) that late to prevent
         // users from calling actions, while the client has not yet fully loaded
         createTrayIconMenu();
 
         // Keep up to date with client
         updateNetworkState();
         connect(_clientModel, SIGNAL(numConnectionsChanged(int)), this,
                 SLOT(setNumConnections(int)));
         connect(_clientModel, SIGNAL(networkActiveChanged(bool)), this,
                 SLOT(setNetworkActive(bool)));
 
         modalOverlay->setKnownBestHeight(
             _clientModel->getHeaderTipHeight(),
             QDateTime::fromTime_t(_clientModel->getHeaderTipTime()));
         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)));
 
         // Receive and report messages from client model
         connect(_clientModel, SIGNAL(message(QString, QString, unsigned int)),
                 this, SLOT(message(QString, QString, unsigned int)));
 
         // Show progress dialog
         connect(_clientModel, SIGNAL(showProgress(QString, int)), this,
                 SLOT(showProgress(QString, int)));
 
         rpcConsole->setClientModel(_clientModel);
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->setClientModel(_clientModel);
         }
 #endif // ENABLE_WALLET
         unitDisplayControl->setOptionsModel(_clientModel->getOptionsModel());
 
         OptionsModel *optionsModel = _clientModel->getOptionsModel();
         if (optionsModel) {
             // be aware of the tray icon disable state change reported by the
             // OptionsModel object.
             connect(optionsModel, SIGNAL(hideTrayIconChanged(bool)), this,
                     SLOT(setTrayIconVisible(bool)));
 
             // initialize the disable state of the tray icon with the current
             // value in the model.
             setTrayIconVisible(optionsModel->getHideTrayIcon());
         }
     } else {
         // Disable possibility to show main window via action
         toggleHideAction->setEnabled(false);
         if (trayIconMenu) {
             // Disable context menu on tray icon
             trayIconMenu->clear();
         }
         // Propagate cleared model to child objects
         rpcConsole->setClientModel(nullptr);
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->setClientModel(nullptr);
         }
 #endif // ENABLE_WALLET
         unitDisplayControl->setOptionsModel(nullptr);
     }
 }
 
 #ifdef ENABLE_WALLET
 bool BitcoinGUI::addWallet(WalletModel *walletModel) {
     if (!walletFrame) return false;
     const QString name = walletModel->getWalletName();
     setWalletActionsEnabled(true);
     m_wallet_selector->addItem(name);
     if (m_wallet_selector->count() == 2) {
         m_wallet_selector_label = new QLabel();
         m_wallet_selector_label->setText(tr("Wallet:") + " ");
         m_wallet_selector_label->setBuddy(m_wallet_selector);
         appToolBar->addWidget(m_wallet_selector_label);
         appToolBar->addWidget(m_wallet_selector);
     }
     rpcConsole->addWallet(walletModel);
     return walletFrame->addWallet(walletModel);
 }
 
 bool BitcoinGUI::setCurrentWallet(const QString &name) {
     if (!walletFrame) return false;
     return walletFrame->setCurrentWallet(name);
 }
 
 void BitcoinGUI::removeAllWallets() {
     if (!walletFrame) return;
     setWalletActionsEnabled(false);
     walletFrame->removeAllWallets();
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::setWalletActionsEnabled(bool enabled) {
     overviewAction->setEnabled(enabled);
     sendCoinsAction->setEnabled(enabled);
     sendCoinsMenuAction->setEnabled(enabled);
     receiveCoinsAction->setEnabled(enabled);
     receiveCoinsMenuAction->setEnabled(enabled);
     historyAction->setEnabled(enabled);
     encryptWalletAction->setEnabled(enabled);
     backupWalletAction->setEnabled(enabled);
     changePassphraseAction->setEnabled(enabled);
     signMessageAction->setEnabled(enabled);
     verifyMessageAction->setEnabled(enabled);
     usedSendingAddressesAction->setEnabled(enabled);
     usedReceivingAddressesAction->setEnabled(enabled);
     openAction->setEnabled(enabled);
 }
 
 void BitcoinGUI::createTrayIcon(const NetworkStyle *networkStyle) {
 #ifndef Q_OS_MAC
     trayIcon = new QSystemTrayIcon(this);
     QString toolTip = tr("%1 client").arg(tr(PACKAGE_NAME)) + " " +
                       networkStyle->getTitleAddText();
     trayIcon->setToolTip(toolTip);
     trayIcon->setIcon(networkStyle->getTrayAndWindowIcon());
     trayIcon->hide();
 #endif
 
     notificator =
         new Notificator(QApplication::applicationName(), trayIcon, this);
 }
 
 void BitcoinGUI::createTrayIconMenu() {
 #ifndef Q_OS_MAC
     // return if trayIcon is unset (only on non-Mac OSes)
     if (!trayIcon) return;
 
     trayIconMenu = new QMenu(this);
     trayIcon->setContextMenu(trayIconMenu);
 
     connect(trayIcon, SIGNAL(activated(QSystemTrayIcon::ActivationReason)),
             this, SLOT(trayIconActivated(QSystemTrayIcon::ActivationReason)));
 #else
     // Note: On Mac, the dock icon is used to provide the tray's functionality.
     MacDockIconHandler *dockIconHandler = MacDockIconHandler::instance();
     dockIconHandler->setMainWindow(static_cast<QMainWindow *>(this));
     trayIconMenu = dockIconHandler->dockMenu();
 #endif
 
     // Configuration of the tray icon (or dock icon) icon menu
     trayIconMenu->addAction(toggleHideAction);
     trayIconMenu->addSeparator();
     trayIconMenu->addAction(sendCoinsMenuAction);
     trayIconMenu->addAction(receiveCoinsMenuAction);
     trayIconMenu->addSeparator();
     trayIconMenu->addAction(signMessageAction);
     trayIconMenu->addAction(verifyMessageAction);
     trayIconMenu->addSeparator();
     trayIconMenu->addAction(optionsAction);
     trayIconMenu->addAction(openRPCConsoleAction);
 #ifndef Q_OS_MAC // This is built-in on Mac
     trayIconMenu->addSeparator();
     trayIconMenu->addAction(quitAction);
 #endif
 }
 
 #ifndef Q_OS_MAC
 void BitcoinGUI::trayIconActivated(QSystemTrayIcon::ActivationReason reason) {
     if (reason == QSystemTrayIcon::Trigger) {
         // Click on system tray icon triggers show/hide of the main window
         toggleHidden();
     }
 }
 #endif
 
 void BitcoinGUI::optionsClicked() {
     if (!clientModel || !clientModel->getOptionsModel()) return;
 
     OptionsDialog dlg(this, enableWallet);
     dlg.setModel(clientModel->getOptionsModel());
     dlg.exec();
 }
 
 void BitcoinGUI::aboutClicked() {
     if (!clientModel) return;
 
     HelpMessageDialog dlg(m_node, this, true);
     dlg.exec();
 }
 
 void BitcoinGUI::showDebugWindow() {
     rpcConsole->showNormal();
     rpcConsole->show();
     rpcConsole->raise();
     rpcConsole->activateWindow();
 }
 
 void BitcoinGUI::showDebugWindowActivateConsole() {
     rpcConsole->setTabFocus(RPCConsole::TAB_CONSOLE);
     showDebugWindow();
 }
 
 void BitcoinGUI::showHelpMessageClicked() {
     helpMessageDialog->show();
 }
 
 #ifdef ENABLE_WALLET
 void BitcoinGUI::openClicked() {
     OpenURIDialog dlg(config, this);
     if (dlg.exec()) {
         Q_EMIT receivedURI(dlg.getURI());
     }
 }
 
 void BitcoinGUI::gotoOverviewPage() {
     overviewAction->setChecked(true);
     if (walletFrame) walletFrame->gotoOverviewPage();
 }
 
 void BitcoinGUI::gotoHistoryPage() {
     historyAction->setChecked(true);
     if (walletFrame) walletFrame->gotoHistoryPage();
 }
 
 void BitcoinGUI::gotoReceiveCoinsPage() {
     receiveCoinsAction->setChecked(true);
     if (walletFrame) walletFrame->gotoReceiveCoinsPage();
 }
 
 void BitcoinGUI::gotoSendCoinsPage(QString addr) {
     sendCoinsAction->setChecked(true);
     if (walletFrame) walletFrame->gotoSendCoinsPage(addr);
 }
 
 void BitcoinGUI::gotoSignMessageTab(QString addr) {
     if (walletFrame) walletFrame->gotoSignMessageTab(addr);
 }
 
 void BitcoinGUI::gotoVerifyMessageTab(QString addr) {
     if (walletFrame) walletFrame->gotoVerifyMessageTab(addr);
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::updateNetworkState() {
     int count = clientModel->getNumConnections();
     QString icon;
     switch (count) {
         case 0:
             icon = ":/icons/connect_0";
             break;
         case 1:
         case 2:
         case 3:
             icon = ":/icons/connect_1";
             break;
         case 4:
         case 5:
         case 6:
             icon = ":/icons/connect_2";
             break;
         case 7:
         case 8:
         case 9:
             icon = ":/icons/connect_3";
             break;
         default:
             icon = ":/icons/connect_4";
             break;
     }
 
     QString tooltip;
 
     if (m_node.getNetworkActive()) {
         tooltip = tr("%n active connection(s) to Bitcoin network", "", count) +
                   QString(".<br>") + tr("Click to disable network activity.");
     } else {
         tooltip = tr("Network activity disabled.") + QString("<br>") +
                   tr("Click to enable network activity again.");
         icon = ":/icons/network_disabled";
     }
 
     // Don't word-wrap this (fixed-width) tooltip
     tooltip = QString("<nobr>") + tooltip + QString("</nobr>");
     connectionsControl->setToolTip(tooltip);
 
     connectionsControl->setPixmap(platformStyle->SingleColorIcon(icon).pixmap(
         STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
 }
 
 void BitcoinGUI::setNumConnections(int count) {
     updateNetworkState();
 }
 
 void BitcoinGUI::setNetworkActive(bool networkActive) {
     updateNetworkState();
 }
 
 void BitcoinGUI::updateHeadersSyncProgressLabel() {
     int64_t headersTipTime = clientModel->getHeaderTipTime();
     int headersTipHeight = clientModel->getHeaderTipHeight();
     int estHeadersLeft = (GetTime() - headersTipTime) /
                          Params().GetConsensus().nPowTargetSpacing;
     if (estHeadersLeft > HEADER_HEIGHT_DELTA_SYNC) {
         progressBarLabel->setText(
             tr("Syncing Headers (%1%)...")
                 .arg(QString::number(100.0 /
                                          (headersTipHeight + estHeadersLeft) *
                                          headersTipHeight,
                                      'f', 1)));
     }
 }
 
 void BitcoinGUI::setNumBlocks(int count, const QDateTime &blockDate,
                               double nVerificationProgress, bool header) {
     if (modalOverlay) {
         if (header) {
             modalOverlay->setKnownBestHeight(count, blockDate);
         } else {
             modalOverlay->tipUpdate(count, blockDate, nVerificationProgress);
         }
     }
     if (!clientModel) {
         return;
     }
 
     // Prevent orphan statusbar messages (e.g. hover Quit in main menu, wait
     // until chain-sync starts -> garbled text)
     statusBar()->clearMessage();
 
     // Acquire current block source
     enum BlockSource blockSource = clientModel->getBlockSource();
     switch (blockSource) {
         case BlockSource::NETWORK:
             if (header) {
                 updateHeadersSyncProgressLabel();
                 return;
             }
             progressBarLabel->setText(tr("Synchronizing with network..."));
             updateHeadersSyncProgressLabel();
             break;
         case BlockSource::DISK:
             if (header) {
                 progressBarLabel->setText(tr("Indexing blocks on disk..."));
             } else {
                 progressBarLabel->setText(tr("Processing blocks on disk..."));
             }
             break;
         case BlockSource::REINDEX:
             progressBarLabel->setText(tr("Reindexing blocks on disk..."));
             break;
         case BlockSource::NONE:
             if (header) {
                 return;
             }
             progressBarLabel->setText(tr("Connecting to peers..."));
             break;
     }
 
     QString tooltip;
 
     QDateTime currentDate = QDateTime::currentDateTime();
     qint64 secs = blockDate.secsTo(currentDate);
 
     tooltip = tr("Processed %n block(s) of transaction history.", "", count);
 
     // Set icon state: spinning if catching up, tick otherwise
     if (secs < 90 * 60) {
         tooltip = tr("Up to date") + QString(".<br>") + tooltip;
         labelBlocksIcon->setPixmap(
             platformStyle->SingleColorIcon(":/icons/synced")
                 .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
 
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->showOutOfSyncWarning(false);
             modalOverlay->showHide(true, true);
         }
 #endif // ENABLE_WALLET
 
         progressBarLabel->setVisible(false);
         progressBar->setVisible(false);
     } else {
         QString timeBehindText = GUIUtil::formatNiceTimeOffset(secs);
 
         progressBarLabel->setVisible(true);
         progressBar->setFormat(tr("%1 behind").arg(timeBehindText));
         progressBar->setMaximum(1000000000);
         progressBar->setValue(nVerificationProgress * 1000000000.0 + 0.5);
         progressBar->setVisible(true);
 
         tooltip = tr("Catching up...") + QString("<br>") + tooltip;
         if (count != prevBlocks) {
             labelBlocksIcon->setPixmap(
                 platformStyle
                     ->SingleColorIcon(QString(":/movies/spinner-%1")
                                           .arg(spinnerFrame, 3, 10, QChar('0')))
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES;
         }
         prevBlocks = count;
 
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->showOutOfSyncWarning(true);
             modalOverlay->showHide();
         }
 #endif // ENABLE_WALLET
 
         tooltip += QString("<br>");
         tooltip +=
             tr("Last received block was generated %1 ago.").arg(timeBehindText);
         tooltip += QString("<br>");
         tooltip += tr("Transactions after this will not yet be visible.");
     }
 
     // Don't word-wrap this (fixed-width) tooltip
     tooltip = QString("<nobr>") + tooltip + QString("</nobr>");
 
     labelBlocksIcon->setToolTip(tooltip);
     progressBarLabel->setToolTip(tooltip);
     progressBar->setToolTip(tooltip);
 }
 
 void BitcoinGUI::message(const QString &title, const QString &message,
                          unsigned int style, bool *ret) {
     // default title
     QString strTitle = tr("Bitcoin");
     // Default to information icon
     int nMBoxIcon = QMessageBox::Information;
     int nNotifyIcon = Notificator::Information;
 
     QString msgType;
 
     // Prefer supplied title over style based title
     if (!title.isEmpty()) {
         msgType = title;
     } else {
         switch (style) {
             case CClientUIInterface::MSG_ERROR:
                 msgType = tr("Error");
                 break;
             case CClientUIInterface::MSG_WARNING:
                 msgType = tr("Warning");
                 break;
             case CClientUIInterface::MSG_INFORMATION:
                 msgType = tr("Information");
                 break;
             default:
                 break;
         }
     }
     // Append title to "Bitcoin - "
     if (!msgType.isEmpty()) {
         strTitle += " - " + msgType;
     }
 
     // Check for error/warning icon
     if (style & CClientUIInterface::ICON_ERROR) {
         nMBoxIcon = QMessageBox::Critical;
         nNotifyIcon = Notificator::Critical;
     } else if (style & CClientUIInterface::ICON_WARNING) {
         nMBoxIcon = QMessageBox::Warning;
         nNotifyIcon = Notificator::Warning;
     }
 
     // Display message
     if (style & CClientUIInterface::MODAL) {
         // Check for buttons, use OK as default, if none was supplied
         QMessageBox::StandardButton buttons;
         if (!(buttons = (QMessageBox::StandardButton)(
                   style & CClientUIInterface::BTN_MASK)))
             buttons = QMessageBox::Ok;
 
         showNormalIfMinimized();
         QMessageBox mBox(static_cast<QMessageBox::Icon>(nMBoxIcon), strTitle,
                          message, buttons, this);
         int r = mBox.exec();
         if (ret != nullptr) {
             *ret = r == QMessageBox::Ok;
         }
     } else
         notificator->notify(static_cast<Notificator::Class>(nNotifyIcon),
                             strTitle, message);
 }
 
 void BitcoinGUI::changeEvent(QEvent *e) {
     QMainWindow::changeEvent(e);
 #ifndef Q_OS_MAC // Ignored on Mac
     if (e->type() == QEvent::WindowStateChange) {
         if (clientModel && clientModel->getOptionsModel() &&
             clientModel->getOptionsModel()->getMinimizeToTray()) {
             QWindowStateChangeEvent *wsevt =
                 static_cast<QWindowStateChangeEvent *>(e);
             if (!(wsevt->oldState() & Qt::WindowMinimized) && isMinimized()) {
                 QTimer::singleShot(0, this, SLOT(hide()));
                 e->ignore();
             }
         }
     }
 #endif
 }
 
 void BitcoinGUI::closeEvent(QCloseEvent *event) {
 #ifndef Q_OS_MAC // Ignored on Mac
     if (clientModel && clientModel->getOptionsModel()) {
         if (!clientModel->getOptionsModel()->getMinimizeOnClose()) {
             // close rpcConsole in case it was open to make some space for the
             // shutdown window
             rpcConsole->close();
 
             QApplication::quit();
         } else {
             QMainWindow::showMinimized();
             event->ignore();
         }
     }
 #else
     QMainWindow::closeEvent(event);
 #endif
 }
 
 void BitcoinGUI::showEvent(QShowEvent *event) {
     // enable the debug window when the main window shows up
     openRPCConsoleAction->setEnabled(true);
     aboutAction->setEnabled(true);
     optionsAction->setEnabled(true);
 }
 
 #ifdef ENABLE_WALLET
 void BitcoinGUI::incomingTransaction(const QString &date, int unit,
                                      const Amount amount, const QString &type,
                                      const QString &address,
                                      const QString &label,
                                      const QString &walletName) {
     // On new transaction, make an info balloon
     QString msg = tr("Date: %1\n").arg(date) +
                   tr("Amount: %1\n")
                       .arg(BitcoinUnits::formatWithUnit(unit, amount, true));
     if (WalletModel::isMultiwallet() && !walletName.isEmpty()) {
         msg += tr("Wallet: %1\n").arg(walletName);
     }
     msg += tr("Type: %1\n").arg(type);
     if (!label.isEmpty()) {
         msg += tr("Label: %1\n").arg(label);
     } else if (!address.isEmpty()) {
         msg += tr("Address: %1\n").arg(address);
     }
     message(amount < Amount::zero() ? tr("Sent transaction")
                                     : tr("Incoming transaction"),
             msg, CClientUIInterface::MSG_INFORMATION);
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::dragEnterEvent(QDragEnterEvent *event) {
     // Accept only URIs
     if (event->mimeData()->hasUrls()) {
         event->acceptProposedAction();
     }
 }
 
 void BitcoinGUI::dropEvent(QDropEvent *event) {
     if (event->mimeData()->hasUrls()) {
         for (const QUrl &uri : event->mimeData()->urls()) {
             Q_EMIT receivedURI(uri.toString());
         }
     }
     event->acceptProposedAction();
 }
 
 bool BitcoinGUI::eventFilter(QObject *object, QEvent *event) {
     // Catch status tip events
     if (event->type() == QEvent::StatusTip) {
         // Prevent adding text from setStatusTip(), if we currently use the
         // status bar for displaying other stuff
         if (progressBarLabel->isVisible() || progressBar->isVisible()) {
             return true;
         }
     }
     return QMainWindow::eventFilter(object, event);
 }
 
 #ifdef ENABLE_WALLET
 bool BitcoinGUI::handlePaymentRequest(const SendCoinsRecipient &recipient) {
     // URI has to be valid
     if (walletFrame && walletFrame->handlePaymentRequest(recipient)) {
         showNormalIfMinimized();
         gotoSendCoinsPage();
         return true;
     }
     return false;
 }
 
 void BitcoinGUI::setHDStatus(int hdEnabled) {
     labelWalletHDStatusIcon->setPixmap(
         platformStyle
             ->SingleColorIcon(hdEnabled ? ":/icons/hd_enabled"
                                         : ":/icons/hd_disabled")
             .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
     labelWalletHDStatusIcon->setToolTip(
         hdEnabled ? tr("HD key generation is <b>enabled</b>")
                   : tr("HD key generation is <b>disabled</b>"));
 
     // eventually disable the QLabel to set its opacity to 50%
     labelWalletHDStatusIcon->setEnabled(hdEnabled);
 }
 
 void BitcoinGUI::setEncryptionStatus(int status) {
     switch (status) {
         case WalletModel::Unencrypted:
             labelWalletEncryptionIcon->hide();
             encryptWalletAction->setChecked(false);
             changePassphraseAction->setEnabled(false);
             encryptWalletAction->setEnabled(true);
             break;
         case WalletModel::Unlocked:
             labelWalletEncryptionIcon->show();
             labelWalletEncryptionIcon->setPixmap(
                 platformStyle->SingleColorIcon(":/icons/lock_open")
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             labelWalletEncryptionIcon->setToolTip(
                 tr("Wallet is <b>encrypted</b> and currently <b>unlocked</b>"));
             encryptWalletAction->setChecked(true);
             changePassphraseAction->setEnabled(true);
             encryptWalletAction->setEnabled(
                 false); // TODO: decrypt currently not supported
             break;
         case WalletModel::Locked:
             labelWalletEncryptionIcon->show();
             labelWalletEncryptionIcon->setPixmap(
                 platformStyle->SingleColorIcon(":/icons/lock_closed")
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             labelWalletEncryptionIcon->setToolTip(
                 tr("Wallet is <b>encrypted</b> and currently <b>locked</b>"));
             encryptWalletAction->setChecked(true);
             changePassphraseAction->setEnabled(true);
             encryptWalletAction->setEnabled(
                 false); // TODO: decrypt currently not supported
             break;
     }
 }
 
 void BitcoinGUI::updateWalletStatus() {
     if (!walletFrame) {
         return;
     }
     WalletView *const walletView = walletFrame->currentWalletView();
     if (!walletView) {
         return;
     }
     WalletModel *const walletModel = walletView->getWalletModel();
     setEncryptionStatus(walletModel->getEncryptionStatus());
     setHDStatus(walletModel->hdEnabled());
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::showNormalIfMinimized(bool fToggleHidden) {
     if (!clientModel) {
         return;
     }
 
     // activateWindow() (sometimes) helps with keyboard focus on Windows
     if (isHidden()) {
         show();
         activateWindow();
     } else if (isMinimized()) {
         showNormal();
         activateWindow();
     } else if (GUIUtil::isObscured(this)) {
         raise();
         activateWindow();
     } else if (fToggleHidden) {
         hide();
     }
 }
 
 void BitcoinGUI::toggleHidden() {
     showNormalIfMinimized(true);
 }
 
 void BitcoinGUI::detectShutdown() {
     if (m_node.shutdownRequested()) {
         if (rpcConsole) {
             rpcConsole->hide();
         }
         qApp->quit();
     }
 }
 
 void BitcoinGUI::showProgress(const QString &title, int nProgress) {
     if (nProgress == 0) {
         progressDialog = new QProgressDialog(title, "", 0, 100);
         progressDialog->setWindowModality(Qt::ApplicationModal);
         progressDialog->setMinimumDuration(0);
         progressDialog->setCancelButton(0);
         progressDialog->setAutoClose(false);
         progressDialog->setValue(0);
     } else if (progressDialog) {
         if (nProgress == 100) {
             progressDialog->close();
             progressDialog->deleteLater();
         } else {
             progressDialog->setValue(nProgress);
         }
     }
 }
 
 void BitcoinGUI::setTrayIconVisible(bool fHideTrayIcon) {
     if (trayIcon) {
         trayIcon->setVisible(!fHideTrayIcon);
     }
 }
 
 void BitcoinGUI::showModalOverlay() {
     if (modalOverlay &&
         (progressBar->isVisible() || modalOverlay->isLayerVisible())) {
         modalOverlay->toggleVisibility();
     }
 }
 
 static bool ThreadSafeMessageBox(BitcoinGUI *gui, const std::string &message,
                                  const std::string &caption,
                                  unsigned int style) {
     bool modal = (style & CClientUIInterface::MODAL);
     // The SECURE flag has no effect in the Qt GUI.
     // bool secure = (style & CClientUIInterface::SECURE);
     style &= ~CClientUIInterface::SECURE;
     bool ret = false;
     // In case of modal message, use blocking connection to wait for user to
     // click a button
     QMetaObject::invokeMethod(gui, "message",
                               modal ? GUIUtil::blockingGUIThreadConnection()
                                     : Qt::QueuedConnection,
                               Q_ARG(QString, QString::fromStdString(caption)),
                               Q_ARG(QString, QString::fromStdString(message)),
                               Q_ARG(unsigned int, style), Q_ARG(bool *, &ret));
     return ret;
 }
 
 void BitcoinGUI::subscribeToCoreSignals() {
     // Connect signals to client
     m_handler_message_box = m_node.handleMessageBox(
         boost::bind(ThreadSafeMessageBox, this, _1, _2, _3));
     m_handler_question = m_node.handleQuestion(
         boost::bind(ThreadSafeMessageBox, this, _1, _3, _4));
 }
 
 void BitcoinGUI::unsubscribeFromCoreSignals() {
     // Disconnect signals from client
     m_handler_message_box->disconnect();
     m_handler_question->disconnect();
 }
 
 void BitcoinGUI::toggleNetworkActive() {
     m_node.setNetworkActive(!m_node.getNetworkActive());
 }
 
 UnitDisplayStatusBarControl::UnitDisplayStatusBarControl(
     const PlatformStyle *platformStyle)
     : optionsModel(0), menu(0) {
     createContextMenu();
     setToolTip(tr("Unit to show amounts in. Click to select another unit."));
     QList<BitcoinUnits::Unit> units = BitcoinUnits::availableUnits();
     int max_width = 0;
     const QFontMetrics fm(font());
     for (const BitcoinUnits::Unit unit : units) {
         max_width = qMax(max_width, fm.width(BitcoinUnits::name(unit)));
     }
     setMinimumSize(max_width, 0);
     setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     setStyleSheet(QString("QLabel { color : %1 }")
                       .arg(platformStyle->SingleColor().name()));
 }
 
 /** So that it responds to button clicks */
 void UnitDisplayStatusBarControl::mousePressEvent(QMouseEvent *event) {
     onDisplayUnitsClicked(event->pos());
 }
 
 /** Creates context menu, its actions, and wires up all the relevant signals for
  * mouse events. */
 void UnitDisplayStatusBarControl::createContextMenu() {
     menu = new QMenu(this);
     for (BitcoinUnits::Unit u : BitcoinUnits::availableUnits()) {
         QAction *menuAction = new QAction(QString(BitcoinUnits::name(u)), this);
         menuAction->setData(QVariant(u));
         menu->addAction(menuAction);
     }
     connect(menu, SIGNAL(triggered(QAction *)), this,
             SLOT(onMenuSelection(QAction *)));
 }
 
 /** Lets the control know about the Options Model (and its signals) */
 void UnitDisplayStatusBarControl::setOptionsModel(OptionsModel *_optionsModel) {
     if (_optionsModel) {
         this->optionsModel = _optionsModel;
 
         // be aware of a display unit change reported by the OptionsModel
         // object.
         connect(_optionsModel, SIGNAL(displayUnitChanged(int)), this,
                 SLOT(updateDisplayUnit(int)));
 
         // initialize the display units label with the current value in the
         // model.
         updateDisplayUnit(_optionsModel->getDisplayUnit());
     }
 }
 
 /** When Display Units are changed on OptionsModel it will refresh the display
  * text of the control on the status bar */
 void UnitDisplayStatusBarControl::updateDisplayUnit(int newUnits) {
     setText(BitcoinUnits::name(newUnits));
 }
 
 /** Shows context menu with Display Unit options by the mouse coordinates */
 void UnitDisplayStatusBarControl::onDisplayUnitsClicked(const QPoint &point) {
     QPoint globalPos = mapToGlobal(point);
     menu->exec(globalPos);
 }
 
 /** Tells underlying optionsModel to update its current display unit. */
 void UnitDisplayStatusBarControl::onMenuSelection(QAction *action) {
     if (action) {
         optionsModel->setDisplayUnit(action->data());
     }
 }
diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
index 4e2021b5a..a0828d476 100644
--- a/src/qt/rpcconsole.cpp
+++ b/src/qt/rpcconsole.cpp
@@ -1,1431 +1,1436 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include "config/bitcoin-config.h"
 #endif
 
 #include "rpcconsole.h"
 #include "ui_debugwindow.h"
 
 #include "qt/bantablemodel.h"
 #include "qt/clientmodel.h"
 #include "qt/guiutil.h"
 #include "qt/platformstyle.h"
 #include "qt/walletmodel.h"
 
 #include "chainparams.h"
 #include "config.h"
 #include "interfaces/node.h"
 #include "netbase.h"
 #include "rpc/client.h"
 #include "rpc/server.h"
 #include "util.h"
 
 #include <univalue.h>
 
 #ifdef ENABLE_WALLET
 #include "wallet/wallet.h"
 
 #include <db_cxx.h>
 #endif
 
 #include <QDesktopWidget>
 #include <QKeyEvent>
 #include <QMenu>
 #include <QMessageBox>
 #include <QScrollBar>
 #include <QSettings>
 #include <QSignalMapper>
 #include <QStringList>
 #include <QThread>
 #include <QTime>
 #include <QTimer>
 
 // TODO: add a scrollback limit, as there is currently none
 // TODO: make it possible to filter out categories (esp debug messages when
 // implemented)
 // TODO: receive errors and debug messages through ClientModel
 
 const int CONSOLE_HISTORY = 50;
 const int INITIAL_TRAFFIC_GRAPH_MINS = 30;
 const QSize FONT_RANGE(4, 40);
 const char fontSizeSettingsKey[] = "consoleFontSize";
 
 const struct {
     const char *url;
     const char *source;
 } ICON_MAPPING[] = {{"cmd-request", ":/icons/tx_input"},
                     {"cmd-reply", ":/icons/tx_output"},
                     {"cmd-error", ":/icons/tx_output"},
                     {"misc", ":/icons/tx_inout"},
                     {nullptr, nullptr}};
 
 namespace {
 
 // don't add private key handling cmd's to the history
 const QStringList historyFilter = QStringList() << "importprivkey"
                                                 << "importmulti"
                                                 << "signmessagewithprivkey"
                                                 << "signrawtransaction"
                                                 << "signrawtransactionwithkey"
                                                 << "walletpassphrase"
                                                 << "walletpassphrasechange"
                                                 << "encryptwallet";
 } // namespace
 
 /* Object for executing console RPC commands in a separate thread.
  */
 class RPCExecutor : public QObject {
     Q_OBJECT
+public:
+    RPCExecutor(interfaces::Node &node) : m_node(node) {}
 
 public Q_SLOTS:
     void request(const QString &command, const QString &walletID);
 
 Q_SIGNALS:
     void reply(int category, const QString &command);
+
+private:
+    interfaces::Node &m_node;
 };
 
 /** Class for handling RPC timers
  * (used for e.g. re-locking the wallet after a timeout)
  */
 class QtRPCTimerBase : public QObject, public RPCTimerBase {
     Q_OBJECT
 public:
     QtRPCTimerBase(std::function<void(void)> &_func, int64_t millis)
         : func(_func) {
         timer.setSingleShot(true);
         connect(&timer, SIGNAL(timeout()), this, SLOT(timeout()));
         timer.start(millis);
     }
     ~QtRPCTimerBase() {}
 private Q_SLOTS:
     void timeout() { func(); }
 
 private:
     QTimer timer;
     std::function<void(void)> func;
 };
 
 class QtRPCTimerInterface : public RPCTimerInterface {
 public:
     ~QtRPCTimerInterface() {}
     const char *Name() override { return "Qt"; }
     RPCTimerBase *NewTimer(std::function<void(void)> &func,
                            int64_t millis) override {
         return new QtRPCTimerBase(func, millis);
     }
 };
 
 #include "rpcconsole.moc"
 
 /**
  * Split shell command line into a list of arguments and optionally execute the
  * command(s).
  * Aims to emulate \c bash and friends.
  *
  * - Command nesting is possible with parenthesis; for example:
  * validateaddress(getnewaddress())
  * - Arguments are delimited with whitespace or comma
  * - Extra whitespace at the beginning and end and between arguments will be
  * ignored
  * - Text can be "double" or 'single' quoted
  * - The backslash \c \ is used as escape character
  *   - Outside quotes, any character can be escaped
  *   - Within double quotes, only escape \c " and backslashes before a \c " or
  * another backslash
  *   - Within single quotes, no escaping is possible and no special
  * interpretation takes place
  *
+ * @param[in]    node    optional node to execute command on
  * @param[out]   result      stringified Result from the executed command(chain)
  * @param[in]    strCommand  Command line to split
  * @param[in]    fExecute    set true if you want the command to be executed
  * @param[out]   pstrFilteredOut  Command line, filtered to remove any sensitive
  * data
  */
 
-bool RPCConsole::RPCParseCommandLine(std::string &strResult,
+bool RPCConsole::RPCParseCommandLine(interfaces::Node *node,
+                                     std::string &strResult,
                                      const std::string &strCommand,
                                      const bool fExecute,
                                      std::string *const pstrFilteredOut,
                                      const std::string *walletID) {
     std::vector<std::vector<std::string>> stack;
     stack.push_back(std::vector<std::string>());
 
     enum CmdParseState {
         STATE_EATING_SPACES,
         STATE_EATING_SPACES_IN_ARG,
         STATE_EATING_SPACES_IN_BRACKETS,
         STATE_ARGUMENT,
         STATE_SINGLEQUOTED,
         STATE_DOUBLEQUOTED,
         STATE_ESCAPE_OUTER,
         STATE_ESCAPE_DOUBLEQUOTED,
         STATE_COMMAND_EXECUTED,
         STATE_COMMAND_EXECUTED_INNER
     } state = STATE_EATING_SPACES;
     std::string curarg;
     UniValue lastResult;
     unsigned nDepthInsideSensitive = 0;
     size_t filter_begin_pos = 0, chpos;
     std::vector<std::pair<size_t, size_t>> filter_ranges;
 
     auto add_to_current_stack = [&](const std::string &strArg) {
         if (stack.back().empty() && (!nDepthInsideSensitive) &&
             historyFilter.contains(QString::fromStdString(strArg),
                                    Qt::CaseInsensitive)) {
             nDepthInsideSensitive = 1;
             filter_begin_pos = chpos;
         }
         // Make sure stack is not empty before adding something
         if (stack.empty()) {
             stack.push_back(std::vector<std::string>());
         }
         stack.back().push_back(strArg);
     };
 
     auto close_out_params = [&]() {
         if (nDepthInsideSensitive) {
             if (!--nDepthInsideSensitive) {
                 assert(filter_begin_pos);
                 filter_ranges.push_back(
                     std::make_pair(filter_begin_pos, chpos));
                 filter_begin_pos = 0;
             }
         }
         stack.pop_back();
     };
 
     std::string strCommandTerminated = strCommand;
     if (strCommandTerminated.back() != '\n') strCommandTerminated += "\n";
     for (chpos = 0; chpos < strCommandTerminated.size(); ++chpos) {
         char ch = strCommandTerminated[chpos];
         switch (state) {
             case STATE_COMMAND_EXECUTED_INNER:
             case STATE_COMMAND_EXECUTED: {
                 bool breakParsing = true;
                 switch (ch) {
                     case '[':
                         curarg.clear();
                         state = STATE_COMMAND_EXECUTED_INNER;
                         break;
                     default:
                         if (state == STATE_COMMAND_EXECUTED_INNER) {
                             if (ch != ']') {
                                 // append char to the current argument (which is
                                 // also used for the query command)
                                 curarg += ch;
                                 break;
                             }
                             if (curarg.size() && fExecute) {
                                 // if we have a value query, query arrays with
                                 // index and objects with a string key
                                 UniValue subelement;
                                 if (lastResult.isArray()) {
                                     for (char argch : curarg) {
                                         if (!std::isdigit(argch)) {
                                             throw std::runtime_error(
                                                 "Invalid result query");
                                         }
                                     }
                                     subelement =
                                         lastResult[atoi(curarg.c_str())];
                                 } else if (lastResult.isObject()) {
                                     subelement = find_value(lastResult, curarg);
                                 } else {
                                     // no array or object: abort
                                     throw std::runtime_error(
                                         "Invalid result query");
                                 }
                                 lastResult = subelement;
                             }
 
                             state = STATE_COMMAND_EXECUTED;
                             break;
                         }
                         // don't break parsing when the char is required for the
                         // next argument
                         breakParsing = false;
 
                         // pop the stack and return the result to the current
                         // command arguments
                         close_out_params();
 
                         // don't stringify the json in case of a string to avoid
                         // doublequotes
                         if (lastResult.isStr()) {
                             curarg = lastResult.get_str();
                         } else {
                             curarg = lastResult.write(2);
                         }
 
                         // if we have a non empty result, use it as stack
                         // argument otherwise as general result
                         if (curarg.size()) {
                             if (stack.size()) {
                                 add_to_current_stack(curarg);
                             } else {
                                 strResult = curarg;
                             }
                         }
                         curarg.clear();
                         // assume eating space state
                         state = STATE_EATING_SPACES;
                 }
 
                 if (breakParsing) {
                     break;
                 }
             }
             // FALLTHROUGH
             case STATE_ARGUMENT: // In or after argument
             case STATE_EATING_SPACES_IN_ARG:
             case STATE_EATING_SPACES_IN_BRACKETS:
             case STATE_EATING_SPACES: // Handle runs of whitespace
                 switch (ch) {
                     case '"':
                         state = STATE_DOUBLEQUOTED;
                         break;
                     case '\'':
                         state = STATE_SINGLEQUOTED;
                         break;
                     case '\\':
                         state = STATE_ESCAPE_OUTER;
                         break;
                     case '(':
                     case ')':
                     case '\n':
                         if (state == STATE_EATING_SPACES_IN_ARG) {
                             throw std::runtime_error("Invalid Syntax");
                         }
                         if (state == STATE_ARGUMENT) {
                             if (ch == '(' && stack.size() &&
                                 stack.back().size() > 0) {
                                 if (nDepthInsideSensitive) {
                                     ++nDepthInsideSensitive;
                                 }
                                 stack.push_back(std::vector<std::string>());
                             }
 
                             // don't allow commands after executed commands on
                             // baselevel
                             if (!stack.size()) {
                                 throw std::runtime_error("Invalid Syntax");
                             }
 
                             add_to_current_stack(curarg);
                             curarg.clear();
                             state = STATE_EATING_SPACES_IN_BRACKETS;
                         }
                         if ((ch == ')' || ch == '\n') && stack.size() > 0) {
                             if (fExecute) {
                                 // Convert argument list to JSON objects in
                                 // method-dependent way, and pass it along with
                                 // the method name to the dispatcher.
-                                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(config, method,
+                                                              params, uri);
                             }
 
                             state = STATE_COMMAND_EXECUTED;
                             curarg.clear();
                         }
                         break;
                     case ' ':
                     case ',':
                     case '\t':
                         if (state == STATE_EATING_SPACES_IN_ARG &&
                             curarg.empty() && ch == ',') {
                             throw std::runtime_error("Invalid Syntax");
                         } else if (state == STATE_ARGUMENT) {
                             // Space ends argument
                             add_to_current_stack(curarg);
                             curarg.clear();
                         }
                         if ((state == STATE_EATING_SPACES_IN_BRACKETS ||
                              state == STATE_ARGUMENT) &&
                             ch == ',') {
                             state = STATE_EATING_SPACES_IN_ARG;
                             break;
                         }
                         state = STATE_EATING_SPACES;
                         break;
                     default:
                         curarg += ch;
                         state = STATE_ARGUMENT;
                 }
                 break;
             case STATE_SINGLEQUOTED: // Single-quoted string
                 switch (ch) {
                     case '\'':
                         state = STATE_ARGUMENT;
                         break;
                     default:
                         curarg += ch;
                 }
                 break;
             case STATE_DOUBLEQUOTED: // Double-quoted string
                 switch (ch) {
                     case '"':
                         state = STATE_ARGUMENT;
                         break;
                     case '\\':
                         state = STATE_ESCAPE_DOUBLEQUOTED;
                         break;
                     default:
                         curarg += ch;
                 }
                 break;
             case STATE_ESCAPE_OUTER: // '\' outside quotes
                 curarg += ch;
                 state = STATE_ARGUMENT;
                 break;
             case STATE_ESCAPE_DOUBLEQUOTED: // '\' in double-quoted text
                 if (ch != '"' && ch != '\\') {
                     // keep '\' for everything but the quote and '\' itself
                     curarg += '\\';
                 }
                 curarg += ch;
                 state = STATE_DOUBLEQUOTED;
                 break;
         }
     }
     if (pstrFilteredOut) {
         if (STATE_COMMAND_EXECUTED == state) {
             assert(!stack.empty());
             close_out_params();
         }
         *pstrFilteredOut = strCommand;
         for (auto i = filter_ranges.rbegin(); i != filter_ranges.rend(); ++i) {
             pstrFilteredOut->replace(i->first, i->second - i->first, "(…)");
         }
     }
 
     // final state
     switch (state) {
         case STATE_COMMAND_EXECUTED:
             if (lastResult.isStr()) {
                 strResult = lastResult.get_str();
             } else {
                 strResult = lastResult.write(2);
             }
         // FALLTHROUGH
         case STATE_ARGUMENT:
         case STATE_EATING_SPACES:
             return true;
         default: // ERROR to end in one of the other states
             return false;
     }
 }
 
 void RPCExecutor::request(const QString &command, const QString &walletID) {
     try {
         std::string result;
         std::string executableCommand = command.toStdString() + "\n";
 
         // Catch the console-only-help command before RPC call is executed and
         // reply with help text as-if a RPC reply.
         if (executableCommand == "help-console\n") {
             Q_EMIT reply(
                 RPCConsole::CMD_REPLY,
                 QString(("\n"
                          "This console accepts RPC commands using the standard "
                          "syntax.\n"
                          "   example:    getblockhash 0\n\n"
 
                          "This console can also accept RPC commands using "
                          "parenthesized syntax.\n"
                          "   example:    getblockhash(0)\n\n"
 
                          "Commands may be nested when specified with the "
                          "parenthesized syntax.\n"
                          "   example:    getblock(getblockhash(0) 1)\n\n"
 
                          "A space or a comma can be used to delimit arguments "
                          "for either syntax.\n"
                          "   example:    getblockhash 0\n"
                          "               getblockhash,0\n\n"
 
                          "Named results can be queried with a non-quoted key "
                          "string in brackets.\n"
                          "   example:    getblock(getblockhash(0) true)[tx]\n\n"
 
                          "Results without keys can be queried using an integer "
                          "in brackets.\n"
                          "   example:    "
                          "getblock(getblockhash(0),true)[tx][0]\n\n")));
             return;
         }
         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;
         }
 
         Q_EMIT reply(RPCConsole::CMD_REPLY, QString::fromStdString(result));
     } catch (UniValue &objError) {
         // Nice formatting for standard-format error
         try {
             int code = find_value(objError, "code").get_int();
             std::string message = find_value(objError, "message").get_str();
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString::fromStdString(message) + " (code " +
                              QString::number(code) + ")");
         } catch (const std::runtime_error &) {
             // raised when converting to invalid type, i.e. missing code or
             // message. Show raw JSON object.
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString::fromStdString(objError.write()));
         }
     } catch (const std::exception &e) {
         Q_EMIT reply(RPCConsole::CMD_ERROR,
                      QString("Error: ") + QString::fromStdString(e.what()));
     }
 }
 
-RPCConsole::RPCConsole(const PlatformStyle *_platformStyle, QWidget *parent)
-    : QWidget(parent), ui(new Ui::RPCConsole), clientModel(0), historyPtr(0),
-      platformStyle(_platformStyle), peersTableContextMenu(0),
+RPCConsole::RPCConsole(interfaces::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;
     if (!restoreGeometry(
             settings.value("RPCConsoleWindowGeometry").toByteArray())) {
         // Restore failed (perhaps missing setting), center the window
         move(QApplication::desktop()->availableGeometry().center() -
              frameGeometry().center());
     }
 
     ui->openDebugLogfileButton->setToolTip(
         ui->openDebugLogfileButton->toolTip().arg(tr(PACKAGE_NAME)));
 
     if (platformStyle->getImagesOnButtons()) {
         ui->openDebugLogfileButton->setIcon(
             platformStyle->SingleColorIcon(":/icons/export"));
     }
     ui->clearButton->setIcon(platformStyle->SingleColorIcon(":/icons/remove"));
     ui->fontBiggerButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/fontbigger"));
     ui->fontSmallerButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/fontsmaller"));
 
     // Install event filter for up and down arrow
     ui->lineEdit->installEventFilter(this);
     ui->messagesWidget->installEventFilter(this);
 
     connect(ui->clearButton, SIGNAL(clicked()), this, SLOT(clear()));
     connect(ui->fontBiggerButton, SIGNAL(clicked()), this, SLOT(fontBigger()));
     connect(ui->fontSmallerButton, SIGNAL(clicked()), this,
             SLOT(fontSmaller()));
     connect(ui->btnClearTrafficGraph, SIGNAL(clicked()), ui->trafficGraph,
             SLOT(clear()));
 
     // disable the wallet selector by default
     ui->WalletSelector->setVisible(false);
     ui->WalletSelectorLabel->setVisible(false);
 
 // set library version labels
 #ifdef ENABLE_WALLET
     ui->berkeleyDBVersion->setText(DbEnv::version(0, 0, 0));
 #else
     ui->label_berkeleyDBVersion->hide();
     ui->berkeleyDBVersion->hide();
 #endif
     // Register RPC timer interface
     rpcTimerInterface = new QtRPCTimerInterface();
     // avoid accidentally overwriting an existing, non QTThread
     // based timer interface
-    RPCSetTimerInterfaceIfUnset(rpcTimerInterface);
+    m_node.rpcSetTimerInterfaceIfUnset(rpcTimerInterface);
 
     setTrafficGraphRange(INITIAL_TRAFFIC_GRAPH_MINS);
 
     ui->detailWidget->hide();
     ui->peerHeading->setText(tr("Select a peer to view detailed information."));
 
     consoleFontSize =
         settings.value(fontSizeSettingsKey, QFontInfo(QFont()).pointSize())
             .toInt();
     clear();
 }
 
 RPCConsole::~RPCConsole() {
     QSettings settings;
     settings.setValue("RPCConsoleWindowGeometry", saveGeometry());
-    RPCUnsetTimerInterface(rpcTimerInterface);
+    m_node.rpcUnsetTimerInterface(rpcTimerInterface);
     delete rpcTimerInterface;
     delete ui;
 }
 
 bool RPCConsole::eventFilter(QObject *obj, QEvent *event) {
     // Special key handling
     if (event->type() == QEvent::KeyPress) {
         QKeyEvent *keyevt = static_cast<QKeyEvent *>(event);
         int key = keyevt->key();
         Qt::KeyboardModifiers mod = keyevt->modifiers();
         switch (key) {
             case Qt::Key_Up:
                 if (obj == ui->lineEdit) {
                     browseHistory(-1);
                     return true;
                 }
                 break;
             case Qt::Key_Down:
                 if (obj == ui->lineEdit) {
                     browseHistory(1);
                     return true;
                 }
                 break;
             case Qt::Key_PageUp: /* pass paging keys to messages widget */
             case Qt::Key_PageDown:
                 if (obj == ui->lineEdit) {
                     QApplication::postEvent(ui->messagesWidget,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
                 break;
             case Qt::Key_Return:
             case Qt::Key_Enter:
                 // forward these events to lineEdit
                 if (obj == autoCompleter->popup()) {
                     QApplication::postEvent(ui->lineEdit,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
                 break;
             default:
                 // Typing in messages widget brings focus to line edit, and
                 // redirects key there. Exclude most combinations and keys that
                 // emit no text, except paste shortcuts.
                 if (obj == ui->messagesWidget &&
                     ((!mod && !keyevt->text().isEmpty() &&
                       key != Qt::Key_Tab) ||
                      ((mod & Qt::ControlModifier) && key == Qt::Key_V) ||
                      ((mod & Qt::ShiftModifier) && key == Qt::Key_Insert))) {
                     ui->lineEdit->setFocus();
                     QApplication::postEvent(ui->lineEdit,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
         }
     }
     return QWidget::eventFilter(obj, event);
 }
 
 void RPCConsole::setClientModel(ClientModel *model) {
     clientModel = model;
     ui->trafficGraph->setClientModel(model);
     if (model && clientModel->getPeerTableModel() &&
         clientModel->getBanTableModel()) {
         // Keep up to date with client
         setNumConnections(model->getNumConnections());
         connect(model, SIGNAL(numConnectionsChanged(int)), this,
                 SLOT(setNumConnections(int)));
 
         interfaces::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)));
 
         updateNetworkState();
         connect(model, SIGNAL(networkActiveChanged(bool)), this,
                 SLOT(setNetworkActive(bool)));
 
         updateTrafficStats(node.getTotalBytesRecv(), node.getTotalBytesSent());
         connect(model, SIGNAL(bytesChanged(quint64, quint64)), this,
                 SLOT(updateTrafficStats(quint64, quint64)));
 
         connect(model, SIGNAL(mempoolSizeChanged(long, size_t)), this,
                 SLOT(setMempoolSize(long, size_t)));
 
         // set up peer table
         ui->peerWidget->setModel(model->getPeerTableModel());
         ui->peerWidget->verticalHeader()->hide();
         ui->peerWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
         ui->peerWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
         ui->peerWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
         ui->peerWidget->setContextMenuPolicy(Qt::CustomContextMenu);
         ui->peerWidget->setColumnWidth(PeerTableModel::Address,
                                        ADDRESS_COLUMN_WIDTH);
         ui->peerWidget->setColumnWidth(PeerTableModel::Subversion,
                                        SUBVERSION_COLUMN_WIDTH);
         ui->peerWidget->setColumnWidth(PeerTableModel::Ping, PING_COLUMN_WIDTH);
         ui->peerWidget->horizontalHeader()->setStretchLastSection(true);
 
         // create peer table context menu actions
         QAction *disconnectAction = new QAction(tr("&Disconnect"), this);
         QAction *banAction1h =
             new QAction(tr("Ban for") + " " + tr("1 &hour"), this);
         QAction *banAction24h =
             new QAction(tr("Ban for") + " " + tr("1 &day"), this);
         QAction *banAction7d =
             new QAction(tr("Ban for") + " " + tr("1 &week"), this);
         QAction *banAction365d =
             new QAction(tr("Ban for") + " " + tr("1 &year"), this);
 
         // create peer table context menu
         peersTableContextMenu = new QMenu(this);
         peersTableContextMenu->addAction(disconnectAction);
         peersTableContextMenu->addAction(banAction1h);
         peersTableContextMenu->addAction(banAction24h);
         peersTableContextMenu->addAction(banAction7d);
         peersTableContextMenu->addAction(banAction365d);
 
         // Add a signal mapping to allow dynamic context menu arguments. We need
         // to use int (instead of int64_t), because signal mapper only supports
         // int or objects, which is okay because max bantime (1 year) is <
         // int_max.
         QSignalMapper *signalMapper = new QSignalMapper(this);
         signalMapper->setMapping(banAction1h, 60 * 60);
         signalMapper->setMapping(banAction24h, 60 * 60 * 24);
         signalMapper->setMapping(banAction7d, 60 * 60 * 24 * 7);
         signalMapper->setMapping(banAction365d, 60 * 60 * 24 * 365);
         connect(banAction1h, SIGNAL(triggered()), signalMapper, SLOT(map()));
         connect(banAction24h, SIGNAL(triggered()), signalMapper, SLOT(map()));
         connect(banAction7d, SIGNAL(triggered()), signalMapper, SLOT(map()));
         connect(banAction365d, SIGNAL(triggered()), signalMapper, SLOT(map()));
         connect(signalMapper, SIGNAL(mapped(int)), this,
                 SLOT(banSelectedNode(int)));
 
         // peer table context menu signals
         connect(ui->peerWidget,
                 SIGNAL(customContextMenuRequested(const QPoint &)), this,
                 SLOT(showPeersTableContextMenu(const QPoint &)));
         connect(disconnectAction, SIGNAL(triggered()), this,
                 SLOT(disconnectSelectedNode()));
 
         // peer table signal handling - update peer details when selecting new
         // node
         connect(
             ui->peerWidget->selectionModel(),
             SIGNAL(selectionChanged(const QItemSelection &,
                                     const QItemSelection &)),
             this,
             SLOT(peerSelected(const QItemSelection &, const QItemSelection &)));
         // peer table signal handling - update peer details when new nodes are
         // added to the model
         connect(model->getPeerTableModel(), SIGNAL(layoutChanged()), this,
                 SLOT(peerLayoutChanged()));
         // peer table signal handling - cache selected node ids
         connect(model->getPeerTableModel(), SIGNAL(layoutAboutToBeChanged()),
                 this, SLOT(peerLayoutAboutToChange()));
 
         // set up ban table
         ui->banlistWidget->setModel(model->getBanTableModel());
         ui->banlistWidget->verticalHeader()->hide();
         ui->banlistWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
         ui->banlistWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
         ui->banlistWidget->setSelectionMode(QAbstractItemView::SingleSelection);
         ui->banlistWidget->setContextMenuPolicy(Qt::CustomContextMenu);
         ui->banlistWidget->setColumnWidth(BanTableModel::Address,
                                           BANSUBNET_COLUMN_WIDTH);
         ui->banlistWidget->setColumnWidth(BanTableModel::Bantime,
                                           BANTIME_COLUMN_WIDTH);
         ui->banlistWidget->horizontalHeader()->setStretchLastSection(true);
 
         // create ban table context menu action
         QAction *unbanAction = new QAction(tr("&Unban"), this);
 
         // create ban table context menu
         banTableContextMenu = new QMenu(this);
         banTableContextMenu->addAction(unbanAction);
 
         // ban table context menu signals
         connect(ui->banlistWidget,
                 SIGNAL(customContextMenuRequested(const QPoint &)), this,
                 SLOT(showBanTableContextMenu(const QPoint &)));
         connect(unbanAction, SIGNAL(triggered()), this,
                 SLOT(unbanSelectedNode()));
 
         // ban table signal handling - clear peer details when clicking a peer
         // in the ban table
         connect(ui->banlistWidget, SIGNAL(clicked(const QModelIndex &)), this,
                 SLOT(clearSelectedNode()));
         // ban table signal handling - ensure ban table is shown or hidden (if
         // empty)
         connect(model->getBanTableModel(), SIGNAL(layoutChanged()), this,
                 SLOT(showOrHideBanTableIfRequired()));
         showOrHideBanTableIfRequired();
 
         // Provide initial values
         ui->clientVersion->setText(model->formatFullVersion());
         ui->clientUserAgent->setText(model->formatSubVersion());
         ui->dataDir->setText(model->dataDir());
         ui->startupTime->setText(model->formatClientStartupTime());
         ui->networkName->setText(
             QString::fromStdString(Params().NetworkIDString()));
 
         // 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();
         }
 
         wordList << "help-console";
         wordList.sort();
         autoCompleter = new QCompleter(wordList, this);
         autoCompleter->setModelSorting(QCompleter::CaseSensitivelySortedModel);
         ui->lineEdit->setCompleter(autoCompleter);
         autoCompleter->popup()->installEventFilter(this);
         // Start thread to execute RPC commands.
         startExecutor();
     }
     if (!model) {
         // Client model is being set to 0, this means shutdown() is about to be
         // called. Make sure we clean up the executor thread
         Q_EMIT stopExecutor();
         thread.wait();
     }
 }
 
 #ifdef ENABLE_WALLET
 void RPCConsole::addWallet(WalletModel *const walletModel) {
     const QString name = walletModel->getWalletName();
     // use name for text and internal data object (to allow to move to a wallet
     // id later)
     ui->WalletSelector->addItem(name, name);
     if (ui->WalletSelector->count() == 2 && !isVisible()) {
         // First wallet added, set to default so long as the window isn't
         // presently visible (and potentially in use)
         ui->WalletSelector->setCurrentIndex(1);
     }
     if (ui->WalletSelector->count() > 2) {
         ui->WalletSelector->setVisible(true);
         ui->WalletSelectorLabel->setVisible(true);
     }
 }
 #endif
 
 static QString categoryClass(int category) {
     switch (category) {
         case RPCConsole::CMD_REQUEST:
             return "cmd-request";
             break;
         case RPCConsole::CMD_REPLY:
             return "cmd-reply";
             break;
         case RPCConsole::CMD_ERROR:
             return "cmd-error";
             break;
         default:
             return "misc";
     }
 }
 
 void RPCConsole::fontBigger() {
     setFontSize(consoleFontSize + 1);
 }
 
 void RPCConsole::fontSmaller() {
     setFontSize(consoleFontSize - 1);
 }
 
 void RPCConsole::setFontSize(int newSize) {
     QSettings settings;
 
     // don't allow a insane font size
     if (newSize < FONT_RANGE.width() || newSize > FONT_RANGE.height()) return;
 
     // temp. store the console content
     QString str = ui->messagesWidget->toHtml();
 
     // replace font tags size in current content
     str.replace(QString("font-size:%1pt").arg(consoleFontSize),
                 QString("font-size:%1pt").arg(newSize));
 
     // store the new font size
     consoleFontSize = newSize;
     settings.setValue(fontSizeSettingsKey, consoleFontSize);
 
     // clear console (reset icon sizes, default stylesheet) and re-add the
     // content
     float oldPosFactor = 1.0 /
                          ui->messagesWidget->verticalScrollBar()->maximum() *
                          ui->messagesWidget->verticalScrollBar()->value();
     clear(false);
     ui->messagesWidget->setHtml(str);
     ui->messagesWidget->verticalScrollBar()->setValue(
         oldPosFactor * ui->messagesWidget->verticalScrollBar()->maximum());
 }
 
 void RPCConsole::clear(bool clearHistory) {
     ui->messagesWidget->clear();
     if (clearHistory) {
         history.clear();
         historyPtr = 0;
     }
     ui->lineEdit->clear();
     ui->lineEdit->setFocus();
 
     // Add smoothly scaled icon images.
     // (when using width/height on an img, Qt uses nearest instead of linear
     // interpolation)
     for (int i = 0; ICON_MAPPING[i].url; ++i) {
         ui->messagesWidget->document()->addResource(
             QTextDocument::ImageResource, QUrl(ICON_MAPPING[i].url),
             platformStyle->SingleColorImage(ICON_MAPPING[i].source)
                 .scaled(QSize(consoleFontSize * 2, consoleFontSize * 2),
                         Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
     }
 
     // Set default style sheet
     QFontInfo fixedFontInfo(GUIUtil::fixedPitchFont());
     ui->messagesWidget->document()->setDefaultStyleSheet(
         QString("table { }"
                 "td.time { color: #808080; font-size: %2; padding-top: 3px; } "
                 "td.message { font-family: %1; font-size: %2; "
                 "white-space:pre-wrap; } "
                 "td.cmd-request { color: #006060; } "
                 "td.cmd-error { color: red; } "
                 ".secwarning { color: red; }"
                 "b { color: #006060; } ")
             .arg(fixedFontInfo.family(), QString("%1pt").arg(consoleFontSize)));
 
 #ifdef Q_OS_MAC
     QString clsKey = "(⌘)-L";
 #else
     QString clsKey = "Ctrl-L";
 #endif
 
     message(CMD_REPLY,
             (tr("Welcome to the %1 RPC console.").arg(tr(PACKAGE_NAME)) +
              "<br>" +
              tr("Use up and down arrows to navigate history, and "
                 "%1 to clear screen.")
                  .arg("<b>" + clsKey + "</b>") +
              "<br>" +
              tr("Type %1 for an overview of available commands.")
                  .arg("<b>help</b>") +
              "<br>" +
              tr("For more information on using this console type %1.")
                  .arg("<b>help-console</b>") +
              "<br><span class=\"secwarning\"><br>" +
              tr("WARNING: Scammers have been active, telling users to type "
                 "commands here, stealing their wallet contents. Do not use "
                 "this console without fully understanding the ramification "
                 "of a command.") +
              "</span>"),
             true);
 }
 
 void RPCConsole::keyPressEvent(QKeyEvent *event) {
     if (windowType() != Qt::Widget && event->key() == Qt::Key_Escape) {
         close();
     }
 }
 
 void RPCConsole::message(int category, const QString &message, bool html) {
     QTime time = QTime::currentTime();
     QString timeString = time.toString();
     QString out;
     out += "<table><tr><td class=\"time\" width=\"65\">" + timeString + "</td>";
     out += "<td class=\"icon\" width=\"32\"><img src=\"" +
            categoryClass(category) + "\"></td>";
     out += "<td class=\"message " + categoryClass(category) +
            "\" valign=\"middle\">";
     if (html) {
         out += message;
     } else {
         out += GUIUtil::HtmlEscape(message, false);
     }
     out += "</td></tr></table>";
     ui->messagesWidget->append(out);
 }
 
 void RPCConsole::updateNetworkState() {
     QString connections =
         QString::number(clientModel->getNumConnections()) + " (";
     connections +=
         tr("In:") + " " +
         QString::number(clientModel->getNumConnections(CONNECTIONS_IN)) + " / ";
     connections +=
         tr("Out:") + " " +
         QString::number(clientModel->getNumConnections(CONNECTIONS_OUT)) + ")";
 
     if (!clientModel->node().getNetworkActive()) {
         connections += " (" + tr("Network activity disabled") + ")";
     }
 
     ui->numberOfConnections->setText(connections);
 }
 
 void RPCConsole::setNumConnections(int count) {
     if (!clientModel) {
         return;
     }
 
     updateNetworkState();
 }
 
 void RPCConsole::setNetworkActive(bool networkActive) {
     updateNetworkState();
 }
 
 void RPCConsole::setNumBlocks(int count, const QDateTime &blockDate,
                               double nVerificationProgress, bool headers) {
     if (!headers) {
         ui->numberOfBlocks->setText(QString::number(count));
         ui->lastBlockTime->setText(blockDate.toString());
     }
 }
 
 void RPCConsole::setMempoolSize(long numberOfTxs, size_t dynUsage) {
     ui->mempoolNumberTxs->setText(QString::number(numberOfTxs));
 
     if (dynUsage < 1000000) {
         ui->mempoolSize->setText(QString::number(dynUsage / 1000.0, 'f', 2) +
                                  " KB");
     } else {
         ui->mempoolSize->setText(QString::number(dynUsage / 1000000.0, 'f', 2) +
                                  " MB");
     }
 }
 
 void RPCConsole::on_lineEdit_returnPressed() {
     QString cmd = ui->lineEdit->text();
 
     if (!cmd.isEmpty()) {
         std::string strFilteredCmd;
         try {
             std::string dummy;
-            if (!RPCParseCommandLine(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
                 throw std::runtime_error("Invalid command line");
             }
         } catch (const std::exception &e) {
             QMessageBox::critical(this, "Error",
                                   QString("Error: ") +
                                       QString::fromStdString(e.what()));
             return;
         }
 
         ui->lineEdit->clear();
 
         cmdBeforeBrowsing = QString();
 
         QString walletID;
 #ifdef ENABLE_WALLET
         const int wallet_index = ui->WalletSelector->currentIndex();
         if (wallet_index > 0) {
             walletID = (QString)ui->WalletSelector->itemData(wallet_index)
                            .value<QString>();
         }
 
         if (m_last_wallet_id != walletID) {
             if (walletID.isEmpty()) {
                 message(CMD_REQUEST,
                         tr("Executing command without any wallet"));
             } else {
                 message(
                     CMD_REQUEST,
                     tr("Executing command using \"%1\" wallet").arg(walletID));
             }
             m_last_wallet_id = walletID;
         }
 #endif
 
         message(CMD_REQUEST, QString::fromStdString(strFilteredCmd));
         Q_EMIT cmdRequest(cmd, walletID);
 
         cmd = QString::fromStdString(strFilteredCmd);
 
         // Remove command, if already in history
         history.removeOne(cmd);
         // Append command to history
         history.append(cmd);
         // Enforce maximum history size
         while (history.size() > CONSOLE_HISTORY)
             history.removeFirst();
         // Set pointer to end of history
         historyPtr = history.size();
 
         // Scroll console view to end
         scrollToEnd();
     }
 }
 
 void RPCConsole::browseHistory(int offset) {
     // store current text when start browsing through the history
     if (historyPtr == history.size()) {
         cmdBeforeBrowsing = ui->lineEdit->text();
     }
 
     historyPtr += offset;
     if (historyPtr < 0) {
         historyPtr = 0;
     }
     if (historyPtr > history.size()) {
         historyPtr = history.size();
     }
     QString cmd;
     if (historyPtr < history.size()) {
         cmd = history.at(historyPtr);
     } else if (!cmdBeforeBrowsing.isNull()) {
         cmd = cmdBeforeBrowsing;
     }
     ui->lineEdit->setText(cmd);
 }
 
 void RPCConsole::startExecutor() {
-    RPCExecutor *executor = new RPCExecutor();
+    RPCExecutor *executor = new RPCExecutor(m_node);
     executor->moveToThread(&thread);
 
     // Replies from executor object must go to this object
     connect(executor, SIGNAL(reply(int, QString)), this,
             SLOT(message(int, QString)));
     // Requests from this object must go to executor
     connect(this, SIGNAL(cmdRequest(QString, QString)), executor,
             SLOT(request(QString, QString)));
 
     // On stopExecutor signal
     // - quit the Qt event loop in the execution thread
     connect(this, SIGNAL(stopExecutor()), &thread, SLOT(quit()));
     // - queue executor for deletion (in execution thread)
     connect(&thread, SIGNAL(finished()), executor, SLOT(deleteLater()),
             Qt::DirectConnection);
 
     // Default implementation of QThread::run() simply spins up an event loop in
     // the thread, which is what we want.
     thread.start();
 }
 
 void RPCConsole::on_tabWidget_currentChanged(int index) {
     if (ui->tabWidget->widget(index) == ui->tab_console) {
         ui->lineEdit->setFocus();
     } else if (ui->tabWidget->widget(index) != ui->tab_peers) {
         clearSelectedNode();
     }
 }
 
 void RPCConsole::on_openDebugLogfileButton_clicked() {
     GUIUtil::openDebugLogfile();
 }
 
 void RPCConsole::scrollToEnd() {
     QScrollBar *scrollbar = ui->messagesWidget->verticalScrollBar();
     scrollbar->setValue(scrollbar->maximum());
 }
 
 void RPCConsole::on_sldGraphRange_valueChanged(int value) {
     const int multiplier = 5; // each position on the slider represents 5 min
     int mins = value * multiplier;
     setTrafficGraphRange(mins);
 }
 
 void RPCConsole::setTrafficGraphRange(int mins) {
     ui->trafficGraph->setGraphRangeMins(mins);
     ui->lblGraphRange->setText(GUIUtil::formatDurationStr(mins * 60));
 }
 
 void RPCConsole::updateTrafficStats(quint64 totalBytesIn,
                                     quint64 totalBytesOut) {
     ui->lblBytesIn->setText(GUIUtil::formatBytes(totalBytesIn));
     ui->lblBytesOut->setText(GUIUtil::formatBytes(totalBytesOut));
 }
 
 void RPCConsole::peerSelected(const QItemSelection &selected,
                               const QItemSelection &deselected) {
     Q_UNUSED(deselected);
 
     if (!clientModel || !clientModel->getPeerTableModel() ||
         selected.indexes().isEmpty())
         return;
 
     const CNodeCombinedStats *stats =
         clientModel->getPeerTableModel()->getNodeStats(
             selected.indexes().first().row());
     if (stats) updateNodeDetail(stats);
 }
 
 void RPCConsole::peerLayoutAboutToChange() {
     QModelIndexList selected =
         ui->peerWidget->selectionModel()->selectedIndexes();
     cachedNodeids.clear();
     for (int i = 0; i < selected.size(); i++) {
         const CNodeCombinedStats *stats =
             clientModel->getPeerTableModel()->getNodeStats(
                 selected.at(i).row());
         cachedNodeids.append(stats->nodeStats.nodeid);
     }
 }
 
 void RPCConsole::peerLayoutChanged() {
     if (!clientModel || !clientModel->getPeerTableModel()) {
         return;
     }
 
     const CNodeCombinedStats *stats = nullptr;
     bool fUnselect = false;
     bool fReselect = false;
 
     if (cachedNodeids.empty()) // no node selected yet
         return;
 
     // find the currently selected row
     int selectedRow = -1;
     QModelIndexList selectedModelIndex =
         ui->peerWidget->selectionModel()->selectedIndexes();
     if (!selectedModelIndex.isEmpty()) {
         selectedRow = selectedModelIndex.first().row();
     }
 
     // check if our detail node has a row in the table (it may not necessarily
     // be at selectedRow since its position can change after a layout change)
     int detailNodeRow =
         clientModel->getPeerTableModel()->getRowByNodeId(cachedNodeids.first());
 
     if (detailNodeRow < 0) {
         // detail node disappeared from table (node disconnected)
         fUnselect = true;
     } else {
         if (detailNodeRow != selectedRow) {
             // detail node moved position
             fUnselect = true;
             fReselect = true;
         }
 
         // get fresh stats on the detail node.
         stats = clientModel->getPeerTableModel()->getNodeStats(detailNodeRow);
     }
 
     if (fUnselect && selectedRow >= 0) {
         clearSelectedNode();
     }
 
     if (fReselect) {
         for (int i = 0; i < cachedNodeids.size(); i++) {
             ui->peerWidget->selectRow(
                 clientModel->getPeerTableModel()->getRowByNodeId(
                     cachedNodeids.at(i)));
         }
     }
 
     if (stats) updateNodeDetail(stats);
 }
 
 void RPCConsole::updateNodeDetail(const CNodeCombinedStats *stats) {
     // update the detail ui with latest node information
     QString peerAddrDetails(QString::fromStdString(stats->nodeStats.addrName) +
                             " ");
     peerAddrDetails +=
         tr("(node id: %1)").arg(QString::number(stats->nodeStats.nodeid));
     if (!stats->nodeStats.addrLocal.empty()) {
         peerAddrDetails += "<br />" + tr("via %1").arg(QString::fromStdString(
                                           stats->nodeStats.addrLocal));
     }
     ui->peerHeading->setText(peerAddrDetails);
     ui->peerServices->setText(
         GUIUtil::formatServicesStr(stats->nodeStats.nServices));
     ui->peerLastSend->setText(
         stats->nodeStats.nLastSend
             ? GUIUtil::formatDurationStr(GetSystemTimeInSeconds() -
                                          stats->nodeStats.nLastSend)
             : tr("never"));
     ui->peerLastRecv->setText(
         stats->nodeStats.nLastRecv
             ? GUIUtil::formatDurationStr(GetSystemTimeInSeconds() -
                                          stats->nodeStats.nLastRecv)
             : tr("never"));
     ui->peerBytesSent->setText(
         GUIUtil::formatBytes(stats->nodeStats.nSendBytes));
     ui->peerBytesRecv->setText(
         GUIUtil::formatBytes(stats->nodeStats.nRecvBytes));
     ui->peerConnTime->setText(GUIUtil::formatDurationStr(
         GetSystemTimeInSeconds() - stats->nodeStats.nTimeConnected));
     ui->peerPingTime->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dPingTime));
     ui->peerPingWait->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dPingWait));
     ui->peerMinPing->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dMinPing));
     ui->timeoffset->setText(
         GUIUtil::formatTimeOffset(stats->nodeStats.nTimeOffset));
     ui->peerVersion->setText(
         QString("%1").arg(QString::number(stats->nodeStats.nVersion)));
     ui->peerSubversion->setText(
         QString::fromStdString(stats->nodeStats.cleanSubVer));
     ui->peerDirection->setText(stats->nodeStats.fInbound ? tr("Inbound")
                                                          : tr("Outbound"));
     ui->peerHeight->setText(
         QString("%1").arg(QString::number(stats->nodeStats.nStartingHeight)));
     ui->peerWhitelisted->setText(stats->nodeStats.fWhitelisted ? tr("Yes")
                                                                : tr("No"));
 
     // This check fails for example if the lock was busy and
     // nodeStateStats couldn't be fetched.
     if (stats->fNodeStateStatsAvailable) {
         // Ban score is init to 0
         ui->peerBanScore->setText(
             QString("%1").arg(stats->nodeStateStats.nMisbehavior));
 
         // Sync height is init to -1
         if (stats->nodeStateStats.nSyncHeight > -1) {
             ui->peerSyncHeight->setText(
                 QString("%1").arg(stats->nodeStateStats.nSyncHeight));
         } else {
             ui->peerSyncHeight->setText(tr("Unknown"));
         }
 
         // Common height is init to -1
         if (stats->nodeStateStats.nCommonHeight > -1) {
             ui->peerCommonHeight->setText(
                 QString("%1").arg(stats->nodeStateStats.nCommonHeight));
         } else {
             ui->peerCommonHeight->setText(tr("Unknown"));
         }
     }
 
     ui->detailWidget->show();
 }
 
 void RPCConsole::resizeEvent(QResizeEvent *event) {
     QWidget::resizeEvent(event);
 }
 
 void RPCConsole::showEvent(QShowEvent *event) {
     QWidget::showEvent(event);
 
     if (!clientModel || !clientModel->getPeerTableModel()) {
         return;
     }
 
     // start PeerTableModel auto refresh
     clientModel->getPeerTableModel()->startAutoRefresh();
 }
 
 void RPCConsole::hideEvent(QHideEvent *event) {
     QWidget::hideEvent(event);
 
     if (!clientModel || !clientModel->getPeerTableModel()) {
         return;
     }
 
     // stop PeerTableModel auto refresh
     clientModel->getPeerTableModel()->stopAutoRefresh();
 }
 
 void RPCConsole::showPeersTableContextMenu(const QPoint &point) {
     QModelIndex index = ui->peerWidget->indexAt(point);
     if (index.isValid()) peersTableContextMenu->exec(QCursor::pos());
 }
 
 void RPCConsole::showBanTableContextMenu(const QPoint &point) {
     QModelIndex index = ui->banlistWidget->indexAt(point);
     if (index.isValid()) banTableContextMenu->exec(QCursor::pos());
 }
 
 void RPCConsole::disconnectSelectedNode() {
-    if (!g_connman) {
-        return;
-    }
-
     // Get selected peer addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected peer address
         NodeId id = nodes.at(i).data().toLongLong();
         // 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;
     }
 
     // Get selected peer addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected peer address
         NodeId id = nodes.at(i).data().toLongLong();
 
         // Get currently selected peer address
         int detailNodeRow =
             clientModel->getPeerTableModel()->getRowByNodeId(id);
         if (detailNodeRow < 0) {
             return;
         }
 
         // Find possible nodes, ban it and clear the selected node
         const CNodeCombinedStats *stats =
             clientModel->getPeerTableModel()->getNodeStats(detailNodeRow);
         if (stats) {
-            g_connman->Ban(stats->nodeStats.addr, BanReasonManuallyAdded,
-                           bantime);
+            m_node.ban(stats->nodeStats.addr, BanReasonManuallyAdded, bantime);
         }
     }
     clearSelectedNode();
     clientModel->getBanTableModel()->refresh();
 }
 
 void RPCConsole::unbanSelectedNode() {
     if (!clientModel) {
         return;
     }
 
     // Get selected ban addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->banlistWidget, BanTableModel::Address);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected ban address
         QString strNode = nodes.at(i).data().toString();
         CSubNet possibleSubnet;
 
         LookupSubNet(strNode.toStdString().c_str(), possibleSubnet);
-        if (possibleSubnet.IsValid() && g_connman) {
-            g_connman->Unban(possibleSubnet);
+        if (possibleSubnet.IsValid() && m_node.unban(possibleSubnet)) {
             clientModel->getBanTableModel()->refresh();
         }
     }
 }
 
 void RPCConsole::clearSelectedNode() {
     ui->peerWidget->selectionModel()->clearSelection();
     cachedNodeids.clear();
     ui->detailWidget->hide();
     ui->peerHeading->setText(tr("Select a peer to view detailed information."));
 }
 
 void RPCConsole::showOrHideBanTableIfRequired() {
     if (!clientModel) {
         return;
     }
 
     bool visible = clientModel->getBanTableModel()->shouldShow();
     ui->banlistWidget->setVisible(visible);
     ui->banHeading->setVisible(visible);
 }
 
 void RPCConsole::setTabFocus(enum TabTypes tabType) {
     ui->tabWidget->setCurrentIndex(tabType);
 }
diff --git a/src/qt/rpcconsole.h b/src/qt/rpcconsole.h
index ed76e426e..c83a2887e 100644
--- a/src/qt/rpcconsole.h
+++ b/src/qt/rpcconsole.h
@@ -1,165 +1,172 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_QT_RPCCONSOLE_H
 #define BITCOIN_QT_RPCCONSOLE_H
 
-#include "guiutil.h"
-#include "peertablemodel.h"
+#include <qt/guiutil.h>
+#include <qt/peertablemodel.h>
 
-#include "net.h"
+#include <net.h>
 
 #include <QCompleter>
 #include <QThread>
 #include <QWidget>
 
 class ClientModel;
 class PlatformStyle;
 class RPCTimerInterface;
 class WalletModel;
 
+namespace interfaces {
+class Node;
+}
+
 namespace Ui {
 class RPCConsole;
 }
 
 QT_BEGIN_NAMESPACE
 class QMenu;
 class QItemSelection;
 QT_END_NAMESPACE
 
 /** Local Bitcoin RPC console. */
 class RPCConsole : public QWidget {
     Q_OBJECT
 
 public:
-    explicit RPCConsole(const PlatformStyle *platformStyle, QWidget *parent);
+    explicit RPCConsole(interfaces::Node &node,
+                        const PlatformStyle *platformStyle, QWidget *parent);
     ~RPCConsole();
 
     static bool
-    RPCParseCommandLine(std::string &strResult, const std::string &strCommand,
-                        bool fExecute,
+    RPCParseCommandLine(interfaces::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(interfaces::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);
     void addWallet(WalletModel *const walletModel);
 
     enum MessageClass { MC_ERROR, MC_DEBUG, CMD_REQUEST, CMD_REPLY, CMD_ERROR };
 
     enum TabTypes {
         TAB_INFO = 0,
         TAB_CONSOLE = 1,
         TAB_GRAPH = 2,
         TAB_PEERS = 3
     };
 
 protected:
     virtual bool eventFilter(QObject *obj, QEvent *event) override;
     void keyPressEvent(QKeyEvent *) override;
 
 private Q_SLOTS:
     void on_lineEdit_returnPressed();
     void on_tabWidget_currentChanged(int index);
     /** open the debug.log from the current datadir */
     void on_openDebugLogfileButton_clicked();
     /** change the time range of the network traffic graph */
     void on_sldGraphRange_valueChanged(int value);
     /** update traffic statistics */
     void updateTrafficStats(quint64 totalBytesIn, quint64 totalBytesOut);
     void resizeEvent(QResizeEvent *event) override;
     void showEvent(QShowEvent *event) override;
     void hideEvent(QHideEvent *event) override;
     /** Show custom context menu on Peers tab */
     void showPeersTableContextMenu(const QPoint &point);
     /** Show custom context menu on Bans tab */
     void showBanTableContextMenu(const QPoint &point);
     /** Hides ban table if no bans are present */
     void showOrHideBanTableIfRequired();
     /** clear the selected node */
     void clearSelectedNode();
 
 public Q_SLOTS:
     void clear(bool clearHistory = true);
     void fontBigger();
     void fontSmaller();
     void setFontSize(int newSize);
     /** Append the message to the message widget */
     void message(int category, const QString &message, bool html = false);
     /** Set number of connections shown in the UI */
     void setNumConnections(int count);
     /** Set network state shown in the UI */
     void setNetworkActive(bool networkActive);
     /** Set number of blocks and last block date shown in the UI */
     void setNumBlocks(int count, const QDateTime &blockDate,
                       double nVerificationProgress, bool headers);
     /** Set size (number of transactions and memory usage) of the mempool in the
      * UI */
     void setMempoolSize(long numberOfTxs, size_t dynUsage);
     /** Go forward or back in history */
     void browseHistory(int offset);
     /** Scroll console view to end */
     void scrollToEnd();
     /** Handle selection of peer in peers list */
     void peerSelected(const QItemSelection &selected,
                       const QItemSelection &deselected);
     /** Handle selection caching before update */
     void peerLayoutAboutToChange();
     /** Handle updated peer information */
     void peerLayoutChanged();
     /** Disconnect a selected node on the Peers tab */
     void disconnectSelectedNode();
     /** Ban a selected node on the Peers tab */
     void banSelectedNode(int bantime);
     /** Unban a selected node on the Bans tab */
     void unbanSelectedNode();
     /** set which tab has the focus (is visible) */
     void setTabFocus(enum TabTypes tabType);
 
 Q_SIGNALS:
     // For RPC command executor
     void stopExecutor();
     void cmdRequest(const QString &command, const QString &walletID);
 
 private:
     void startExecutor();
     void setTrafficGraphRange(int mins);
     /** show detailed information on ui about selected node */
     void updateNodeDetail(const CNodeCombinedStats *stats);
 
     enum ColumnWidths {
         ADDRESS_COLUMN_WIDTH = 200,
         SUBVERSION_COLUMN_WIDTH = 150,
         PING_COLUMN_WIDTH = 80,
         BANSUBNET_COLUMN_WIDTH = 200,
         BANTIME_COLUMN_WIDTH = 250
 
     };
 
+    interfaces::Node &m_node;
     Ui::RPCConsole *ui;
     ClientModel *clientModel;
     QStringList history;
     int historyPtr;
     QString cmdBeforeBrowsing;
     QList<NodeId> cachedNodeids;
     const PlatformStyle *platformStyle;
     RPCTimerInterface *rpcTimerInterface;
     QMenu *peersTableContextMenu;
     QMenu *banTableContextMenu;
     int consoleFontSize;
     QCompleter *autoCompleter;
     QThread thread;
     QString m_last_wallet_id;
 
     /** Update UI with latest network info from model. */
     void updateNetworkState();
 };
 
 #endif // BITCOIN_QT_RPCCONSOLE_H
diff --git a/src/qt/test/rpcnestedtests.cpp b/src/qt/test/rpcnestedtests.cpp
index 8a17f1794..4a73f54bf 100644
--- a/src/qt/test/rpcnestedtests.cpp
+++ b/src/qt/test/rpcnestedtests.cpp
@@ -1,200 +1,210 @@
 // Copyright (c) 2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "rpcnestedtests.h"
-
-#include "chainparams.h"
-#include "config.h"
-#include "consensus/validation.h"
-#include "fs.h"
-#include "rpc/register.h"
-#include "rpc/server.h"
-#include "rpcconsole.h"
-#include "test/test_bitcoin.h"
-#include "univalue.h"
-#include "util.h"
-#include "validation.h"
+#include <test/rpcnestedtests.h>
+
+#include <chainparams.h>
+#include <config.h>
+#include <consensus/validation.h>
+#include <fs.h>
+#include <interfaces/node.h>
+#include <qt/rpcconsole.h>
+#include <rpc/register.h>
+#include <rpc/server.h>
+#include <test/test_bitcoin.h>
+#include <univalue.h>
+#include <util.h>
+#include <validation.h>
 
 #include <QDir>
 #include <QtGlobal>
 
 static UniValue rpcNestedTest_rpc(const Config &config,
                                   const JSONRPCRequest &request) {
     if (request.fHelp) {
         return "help message";
     }
     return request.params.write(0, 0);
 }
 
 static const ContextFreeRPCCommand vRPCCommands[] = {
     {"test", "rpcNestedTest", &rpcNestedTest_rpc, {}},
 };
 
 void RPCNestedTests::rpcNestedTests() {
     // do some test setup
     // could be moved to a more generic place when we add more tests on QT level
     tableRPC.appendCommand("rpcNestedTest", &vRPCCommands[0]);
     ClearDatadirCache();
     std::string path =
         QDir::tempPath().toStdString() + "/" +
         strprintf("test_bitcoin_qt_%lu_%i", (unsigned long)GetTime(),
                   (int)(GetRand(100000)));
     QDir dir(QString::fromStdString(path));
     dir.mkpath(".");
     gArgs.ForceSetArg("-datadir", path);
     // mempool.setSanityCheck(1.0);
 
     TestingSetup test;
 
     std::string result;
     std::string result2;
     std::string filtered;
+    auto node = interfaces::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\"]");
 
 #if QT_VERSION >= 0x050300
     // do the QVERIFY_EXCEPTION_THROWN checks only with Qt5.3 and higher
     // (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));
 }