diff --git a/src/interfaces/node.cpp b/src/interfaces/node.cpp
index 51663dc09..d95f3b7ba 100644
--- a/src/interfaces/node.cpp
+++ b/src/interfaces/node.cpp
@@ -1,238 +1,246 @@
 // 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 <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 <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;
+        }
         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();
         }
         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 402e7af6d..ca1b21403 100644
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -1,202 +1,206 @@
 // 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;
 
 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;
+
     //! 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;
 
     //! 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/bantablemodel.cpp b/src/qt/bantablemodel.cpp
index 4838682f4..7b82f348d 100644
--- a/src/qt/bantablemodel.cpp
+++ b/src/qt/bantablemodel.cpp
@@ -1,159 +1,160 @@
 // 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.
 
-#include "bantablemodel.h"
+#include <qt/bantablemodel.h>
 
-#include "clientmodel.h"
-#include "guiconstants.h"
-#include "guiutil.h"
+#include <qt/clientmodel.h>
+#include <qt/guiconstants.h>
+#include <qt/guiutil.h>
 
-#include "sync.h"
-#include "utiltime.h"
+#include <interfaces/node.h>
+#include <sync.h>
+#include <utiltime.h>
 
 #include <QDebug>
 #include <QList>
 
 bool BannedNodeLessThan::operator()(const CCombinedBan &left,
                                     const CCombinedBan &right) const {
     const CCombinedBan *pLeft = &left;
     const CCombinedBan *pRight = &right;
 
     if (order == Qt::DescendingOrder) std::swap(pLeft, pRight);
 
     switch (column) {
         case BanTableModel::Address:
             return pLeft->subnet.ToString().compare(pRight->subnet.ToString()) <
                    0;
         case BanTableModel::Bantime:
             return pLeft->banEntry.nBanUntil < pRight->banEntry.nBanUntil;
     }
 
     return false;
 }
 
 // private implementation
 class BanTablePriv {
 public:
     /** Local cache of peer information */
     QList<CCombinedBan> cachedBanlist;
     /** Column to sort nodes by */
     int sortColumn;
     /** Order (ascending or descending) to sort nodes by */
     Qt::SortOrder sortOrder;
 
     /** Pull a full list of banned nodes from CNode into our cache */
-    void refreshBanlist() {
+    void refreshBanlist(interfaces::Node &node) {
         banmap_t banMap;
-        if (g_connman) g_connman->GetBanned(banMap);
+        node.getBanned(banMap);
 
         cachedBanlist.clear();
         cachedBanlist.reserve(banMap.size());
         for (const auto &entry : banMap) {
             CCombinedBan banEntry;
             banEntry.subnet = entry.first;
             banEntry.banEntry = entry.second;
             cachedBanlist.append(banEntry);
         }
 
         if (sortColumn >= 0)
             // sort cachedBanlist (use stable sort to prevent rows jumping
             // around unnecessarily)
             qStableSort(cachedBanlist.begin(), cachedBanlist.end(),
                         BannedNodeLessThan(sortColumn, sortOrder));
     }
 
     int size() const { return cachedBanlist.size(); }
 
     CCombinedBan *index(int idx) {
         if (idx >= 0 && idx < cachedBanlist.size()) return &cachedBanlist[idx];
 
         return 0;
     }
 };
 
-BanTableModel::BanTableModel(ClientModel *parent)
-    : QAbstractTableModel(parent), clientModel(parent) {
+BanTableModel::BanTableModel(interfaces::Node &node, ClientModel *parent)
+    : QAbstractTableModel(parent), m_node(node), clientModel(parent) {
     columns << tr("IP/Netmask") << tr("Banned Until");
     priv.reset(new BanTablePriv());
     // default to unsorted
     priv->sortColumn = -1;
 
     // load initial data
     refresh();
 }
 
 BanTableModel::~BanTableModel() {
     // Intentionally left empty
 }
 
 int BanTableModel::rowCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return priv->size();
 }
 
 int BanTableModel::columnCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return columns.length();
 }
 
 QVariant BanTableModel::data(const QModelIndex &index, int role) const {
     if (!index.isValid()) return QVariant();
 
     CCombinedBan *rec = static_cast<CCombinedBan *>(index.internalPointer());
 
     if (role == Qt::DisplayRole) {
         switch (index.column()) {
             case Address:
                 return QString::fromStdString(rec->subnet.ToString());
             case Bantime:
                 QDateTime date = QDateTime::fromMSecsSinceEpoch(0);
                 date = date.addSecs(rec->banEntry.nBanUntil);
                 return date.toString(Qt::SystemLocaleLongDate);
         }
     }
 
     return QVariant();
 }
 
 QVariant BanTableModel::headerData(int section, Qt::Orientation orientation,
                                    int role) const {
     if (orientation == Qt::Horizontal) {
         if (role == Qt::DisplayRole && section < columns.size()) {
             return columns[section];
         }
     }
     return QVariant();
 }
 
 Qt::ItemFlags BanTableModel::flags(const QModelIndex &index) const {
     if (!index.isValid()) return 0;
 
     Qt::ItemFlags retval = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
     return retval;
 }
 
 QModelIndex BanTableModel::index(int row, int column,
                                  const QModelIndex &parent) const {
     Q_UNUSED(parent);
     CCombinedBan *data = priv->index(row);
 
     if (data) return createIndex(row, column, data);
     return QModelIndex();
 }
 
 void BanTableModel::refresh() {
     Q_EMIT layoutAboutToBeChanged();
-    priv->refreshBanlist();
+    priv->refreshBanlist(m_node);
     Q_EMIT layoutChanged();
 }
 
 void BanTableModel::sort(int column, Qt::SortOrder order) {
     priv->sortColumn = column;
     priv->sortOrder = order;
     refresh();
 }
 
 bool BanTableModel::shouldShow() {
     return priv->size() > 0;
 }
diff --git a/src/qt/bantablemodel.h b/src/qt/bantablemodel.h
index 1762bc979..e2d90790b 100644
--- a/src/qt/bantablemodel.h
+++ b/src/qt/bantablemodel.h
@@ -1,70 +1,75 @@
 // 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_BANTABLEMODEL_H
 #define BITCOIN_QT_BANTABLEMODEL_H
 
-#include "net.h"
+#include <net.h>
 
 #include <QAbstractTableModel>
 #include <QStringList>
 
 class ClientModel;
 class BanTablePriv;
 
+namespace interfaces {
+class Node;
+}
+
 struct CCombinedBan {
     CSubNet subnet;
     CBanEntry banEntry;
 };
 
 class BannedNodeLessThan {
 public:
     BannedNodeLessThan(int nColumn, Qt::SortOrder fOrder)
         : column(nColumn), order(fOrder) {}
     bool operator()(const CCombinedBan &left, const CCombinedBan &right) const;
 
 private:
     int column;
     Qt::SortOrder order;
 };
 
 /**
    Qt model providing information about connected peers, similar to the
    "getpeerinfo" RPC call. Used by the rpc console UI.
  */
 class BanTableModel : public QAbstractTableModel {
     Q_OBJECT
 
 public:
-    explicit BanTableModel(ClientModel *parent = 0);
+    explicit BanTableModel(interfaces::Node &node, ClientModel *parent = 0);
     ~BanTableModel();
     void startAutoRefresh();
     void stopAutoRefresh();
 
     enum ColumnIndex { Address = 0, Bantime = 1 };
 
     /** @name Methods overridden from QAbstractTableModel
         @{*/
     int rowCount(const QModelIndex &parent) const override;
     int columnCount(const QModelIndex &parent) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     QVariant headerData(int section, Qt::Orientation orientation,
                         int role) const override;
     QModelIndex index(int row, int column,
                       const QModelIndex &parent) const override;
     Qt::ItemFlags flags(const QModelIndex &index) const override;
     void sort(int column, Qt::SortOrder order) override;
     bool shouldShow();
     /*@}*/
 
 public Q_SLOTS:
     void refresh();
 
 private:
+    interfaces::Node &m_node;
     ClientModel *clientModel;
     QStringList columns;
     std::unique_ptr<BanTablePriv> priv;
 };
 
 #endif // BITCOIN_QT_BANTABLEMODEL_H
diff --git a/src/qt/clientmodel.cpp b/src/qt/clientmodel.cpp
index 8c11e8dd9..d1cf04712 100644
--- a/src/qt/clientmodel.cpp
+++ b/src/qt/clientmodel.cpp
@@ -1,263 +1,263 @@
 // 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.
 
 #include "clientmodel.h"
 
 #include "bantablemodel.h"
 #include "guiconstants.h"
 #include "guiutil.h"
 #include "peertablemodel.h"
 
 #include "chain.h"
 #include "chainparams.h"
 #include "checkpoints.h"
 #include "clientversion.h"
 #include "config.h"
 #include "interfaces/handler.h"
 #include "interfaces/node.h"
 #include "net.h"
 #include "txmempool.h"
 #include "ui_interface.h"
 #include "util.h"
 #include "validation.h"
 #include "warnings.h"
 
 #include <cstdint>
 
 #include <QDebug>
 #include <QTimer>
 
 class CBlockIndex;
 
 static int64_t nLastHeaderTipUpdateNotification = 0;
 static int64_t nLastBlockTipUpdateNotification = 0;
 
 ClientModel::ClientModel(interfaces::Node &node, OptionsModel *_optionsModel,
                          QObject *parent)
     : QObject(parent), m_node(node), optionsModel(_optionsModel),
       peerTableModel(0), banTableModel(0), pollTimer(0) {
     cachedBestHeaderHeight = -1;
     cachedBestHeaderTime = -1;
     peerTableModel = new PeerTableModel(m_node, this);
-    banTableModel = new BanTableModel(this);
+    banTableModel = new BanTableModel(m_node, this);
     pollTimer = new QTimer(this);
     connect(pollTimer, SIGNAL(timeout()), this, SLOT(updateTimer()));
     pollTimer->start(MODEL_UPDATE_DELAY);
 
     subscribeToCoreSignals();
 }
 
 ClientModel::~ClientModel() {
     unsubscribeFromCoreSignals();
 }
 
 int ClientModel::getNumConnections(unsigned int flags) const {
     CConnman::NumConnections connections = CConnman::CONNECTIONS_NONE;
 
     if (flags == CONNECTIONS_IN) {
         connections = CConnman::CONNECTIONS_IN;
     } else if (flags == CONNECTIONS_OUT) {
         connections = CConnman::CONNECTIONS_OUT;
     } else if (flags == CONNECTIONS_ALL) {
         connections = CConnman::CONNECTIONS_ALL;
     }
 
     return m_node.getNodeCount(connections);
 }
 
 int ClientModel::getHeaderTipHeight() const {
     if (cachedBestHeaderHeight == -1) {
         // make sure we initially populate the cache via a cs_main lock
         // otherwise we need to wait for a tip update
         int height;
         int64_t blockTime;
         if (m_node.getHeaderTip(height, blockTime)) {
             cachedBestHeaderHeight = height;
             cachedBestHeaderTime = blockTime;
         }
     }
     return cachedBestHeaderHeight;
 }
 
 int64_t ClientModel::getHeaderTipTime() const {
     if (cachedBestHeaderTime == -1) {
         int height;
         int64_t blockTime;
         if (m_node.getHeaderTip(height, blockTime)) {
             cachedBestHeaderHeight = height;
             cachedBestHeaderTime = blockTime;
         }
     }
     return cachedBestHeaderTime;
 }
 
 void ClientModel::updateTimer() {
     // no locking required at this point
     // the following calls will acquire the required lock
     Q_EMIT mempoolSizeChanged(m_node.getMempoolSize(),
                               m_node.getMempoolDynamicUsage());
     Q_EMIT bytesChanged(m_node.getTotalBytesRecv(), m_node.getTotalBytesSent());
 }
 
 void ClientModel::updateNumConnections(int numConnections) {
     Q_EMIT numConnectionsChanged(numConnections);
 }
 
 void ClientModel::updateNetworkActive(bool networkActive) {
     Q_EMIT networkActiveChanged(networkActive);
 }
 
 void ClientModel::updateAlert() {
     Q_EMIT alertsChanged(getStatusBarWarnings());
 }
 
 enum BlockSource ClientModel::getBlockSource() const {
     if (m_node.getReindex()) {
         return BlockSource::REINDEX;
     } else if (m_node.getImporting()) {
         return BlockSource::DISK;
     } else if (getNumConnections() > 0) {
         return BlockSource::NETWORK;
     }
 
     return BlockSource::NONE;
 }
 
 QString ClientModel::getStatusBarWarnings() const {
     return QString::fromStdString(m_node.getWarnings("gui"));
 }
 
 OptionsModel *ClientModel::getOptionsModel() {
     return optionsModel;
 }
 
 PeerTableModel *ClientModel::getPeerTableModel() {
     return peerTableModel;
 }
 
 BanTableModel *ClientModel::getBanTableModel() {
     return banTableModel;
 }
 
 QString ClientModel::formatFullVersion() const {
     return QString::fromStdString(FormatFullVersion());
 }
 
 QString ClientModel::formatSubVersion() const {
     return QString::fromStdString(userAgent(GetConfig()));
 }
 
 bool ClientModel::isReleaseVersion() const {
     return CLIENT_VERSION_IS_RELEASE;
 }
 
 QString ClientModel::formatClientStartupTime() const {
     return QDateTime::fromTime_t(GetStartupTime()).toString();
 }
 
 QString ClientModel::dataDir() const {
     return GUIUtil::boostPathToQString(GetDataDir());
 }
 
 void ClientModel::updateBanlist() {
     banTableModel->refresh();
 }
 
 // Handlers for core signals
 static void ShowProgress(ClientModel *clientmodel, const std::string &title,
                          int nProgress) {
     // emits signal "showProgress"
     QMetaObject::invokeMethod(clientmodel, "showProgress", Qt::QueuedConnection,
                               Q_ARG(QString, QString::fromStdString(title)),
                               Q_ARG(int, nProgress));
 }
 
 static void NotifyNumConnectionsChanged(ClientModel *clientmodel,
                                         int newNumConnections) {
     // Too noisy: qDebug() << "NotifyNumConnectionsChanged: " +
     // QString::number(newNumConnections);
     QMetaObject::invokeMethod(clientmodel, "updateNumConnections",
                               Qt::QueuedConnection,
                               Q_ARG(int, newNumConnections));
 }
 
 static void NotifyNetworkActiveChanged(ClientModel *clientmodel,
                                        bool networkActive) {
     QMetaObject::invokeMethod(clientmodel, "updateNetworkActive",
                               Qt::QueuedConnection, Q_ARG(bool, networkActive));
 }
 
 static void NotifyAlertChanged(ClientModel *clientmodel) {
     qDebug() << "NotifyAlertChanged";
     QMetaObject::invokeMethod(clientmodel, "updateAlert", Qt::QueuedConnection);
 }
 
 static void BannedListChanged(ClientModel *clientmodel) {
     qDebug() << QString("%1: Requesting update for peer banlist").arg(__func__);
     QMetaObject::invokeMethod(clientmodel, "updateBanlist",
                               Qt::QueuedConnection);
 }
 
 static void BlockTipChanged(ClientModel *clientmodel, bool initialSync,
                             int height, int64_t blockTime,
                             double verificationProgress, bool fHeader) {
     // lock free async UI updates in case we have a new block tip
     // during initial sync, only update the UI if the last update
     // was > 250ms (MODEL_UPDATE_DELAY) ago
     int64_t now = 0;
     if (initialSync) {
         now = GetTimeMillis();
     }
 
     int64_t &nLastUpdateNotification = fHeader
                                            ? nLastHeaderTipUpdateNotification
                                            : nLastBlockTipUpdateNotification;
 
     if (fHeader) {
         // cache best headers time and height to reduce future cs_main locks
         clientmodel->cachedBestHeaderHeight = height;
         clientmodel->cachedBestHeaderTime = blockTime;
     }
     // if we are in-sync, update the UI regardless of last update time
     if (!initialSync || now - nLastUpdateNotification > MODEL_UPDATE_DELAY) {
         // pass a async signal to the UI thread
         QMetaObject::invokeMethod(
             clientmodel, "numBlocksChanged", Qt::QueuedConnection,
             Q_ARG(int, height),
             Q_ARG(QDateTime, QDateTime::fromTime_t(blockTime)),
             Q_ARG(double, verificationProgress), Q_ARG(bool, fHeader));
         nLastUpdateNotification = now;
     }
 }
 
 void ClientModel::subscribeToCoreSignals() {
     // Connect signals to client
     m_handler_show_progress =
         m_node.handleShowProgress(boost::bind(ShowProgress, this, _1, _2));
     m_handler_notify_num_connections_changed =
         m_node.handleNotifyNumConnectionsChanged(
             boost::bind(NotifyNumConnectionsChanged, this, _1));
     m_handler_notify_network_active_changed =
         m_node.handleNotifyNetworkActiveChanged(
             boost::bind(NotifyNetworkActiveChanged, this, _1));
     m_handler_notify_alert_changed =
         m_node.handleNotifyAlertChanged(boost::bind(NotifyAlertChanged, this));
     m_handler_banned_list_changed =
         m_node.handleBannedListChanged(boost::bind(BannedListChanged, this));
     m_handler_notify_block_tip = m_node.handleNotifyBlockTip(
         boost::bind(BlockTipChanged, this, _1, _2, _3, _4, false));
     m_handler_notify_header_tip = m_node.handleNotifyHeaderTip(
         boost::bind(BlockTipChanged, this, _1, _2, _3, _4, true));
 }
 
 void ClientModel::unsubscribeFromCoreSignals() {
     // Disconnect signals from client
     m_handler_show_progress->disconnect();
     m_handler_notify_num_connections_changed->disconnect();
     m_handler_notify_network_active_changed->disconnect();
     m_handler_notify_alert_changed->disconnect();
     m_handler_banned_list_changed->disconnect();
     m_handler_notify_block_tip->disconnect();
     m_handler_notify_header_tip->disconnect();
 }