diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
index a36c9bebd7..e7f49ed6cd 100644
--- a/src/qt/guiutil.cpp
+++ b/src/qt/guiutil.cpp
@@ -1,1025 +1,1025 @@
 // 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 "guiutil.h"
-
-#include "bitcoinaddressvalidator.h"
-#include "bitcoinunits.h"
-#include "dstencode.h"
-#include "qvalidatedlineedit.h"
-#include "walletmodel.h"
-
-#include "cashaddr.h"
-#include "config.h"
-#include "dstencode.h"
-#include "fs.h"
-#include "init.h"
-#include "policy/policy.h"
-#include "primitives/transaction.h"
-#include "protocol.h"
-#include "script/script.h"
-#include "script/standard.h"
-#include "util.h"
-#include "utilstrencodings.h"
+#include <qt/guiutil.h>
+
+#include <base58.h>
+#include <cashaddr.h>
+#include <chainparams.h>
+#include <config.h>
+#include <dstencode.h>
+#include <fs.h>
+#include <interfaces/node.h>
+#include <policy/policy.h>
+#include <primitives/transaction.h>
+#include <protocol.h>
+#include <qt/bitcoinaddressvalidator.h>
+#include <qt/bitcoinunits.h>
+#include <qt/qvalidatedlineedit.h>
+#include <qt/walletmodel.h>
+#include <script/script.h>
+#include <script/standard.h>
+#include <util.h>
+#include <utilstrencodings.h>
 
 #ifdef WIN32
 #ifdef _WIN32_WINNT
 #undef _WIN32_WINNT
 #endif
 #define _WIN32_WINNT 0x0501
 #ifdef _WIN32_IE
 #undef _WIN32_IE
 #endif
 #define _WIN32_IE 0x0501
 #define WIN32_LEAN_AND_MEAN 1
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
-#include "shellapi.h"
-#include "shlobj.h"
-#include "shlwapi.h"
+#include <shellapi.h>
+#include <shlobj.h>
+#include <shlwapi.h>
 #endif
 
 #include <boost/filesystem/detail/utf8_codecvt_facet.hpp>
 #include <boost/filesystem/fstream.hpp>
 #include <boost/scoped_array.hpp>
 
 #include <QAbstractItemView>
 #include <QApplication>
 #include <QClipboard>
 #include <QDateTime>
 #include <QDesktopServices>
 #include <QDesktopWidget>
 #include <QDoubleValidator>
 #include <QFileDialog>
 #include <QFont>
 #include <QLineEdit>
 #include <QMouseEvent>
 #include <QSettings>
 #include <QTextDocument> // for Qt::mightBeRichText
 #include <QThread>
 #include <QUrlQuery>
 
 #if QT_VERSION >= 0x50200
 #include <QFontDatabase>
 #endif
 
 static fs::detail::utf8_codecvt_facet utf8;
 
 #if defined(Q_OS_MAC)
 // These Mac includes must be done in the global namespace
 #include <CoreFoundation/CoreFoundation.h>
 #include <CoreServices/CoreServices.h>
 
 extern double NSAppKitVersionNumber;
 #if !defined(NSAppKitVersionNumber10_8)
 #define NSAppKitVersionNumber10_8 1187
 #endif
 #if !defined(NSAppKitVersionNumber10_9)
 #define NSAppKitVersionNumber10_9 1265
 #endif
 #endif
 
 namespace GUIUtil {
 
 QString dateTimeStr(const QDateTime &date) {
     return date.date().toString(Qt::SystemLocaleShortDate) + QString(" ") +
            date.toString("hh:mm");
 }
 
 QString dateTimeStr(qint64 nTime) {
     return dateTimeStr(QDateTime::fromTime_t((qint32)nTime));
 }
 
 QFont fixedPitchFont() {
 #if QT_VERSION >= 0x50200
     return QFontDatabase::systemFont(QFontDatabase::FixedFont);
 #else
     QFont font("Monospace");
     font.setStyleHint(QFont::Monospace);
     return font;
 #endif
 }
 
 static std::string MakeAddrInvalid(std::string addr, const Config &config) {
     if (addr.size() < 2) {
         return "";
     }
 
     // Checksum is at the end of the address. Swapping chars to make it invalid.
     std::swap(addr[addr.size() - 1], addr[addr.size() - 2]);
     if (!IsValidDestinationString(addr, config.GetChainParams())) {
         return addr;
     }
 
     return "";
 }
 
 std::string DummyAddress(const Config &config) {
     // Just some dummy data to generate an convincing random-looking (but
     // consistent) address
     static const std::vector<uint8_t> dummydata = {
         0xeb, 0x15, 0x23, 0x1d, 0xfc, 0xeb, 0x60, 0x92, 0x58, 0x86,
         0xb6, 0x7d, 0x06, 0x52, 0x99, 0x92, 0x59, 0x15, 0xae, 0xb1};
 
     const CTxDestination dstKey = CKeyID(uint160(dummydata));
     return MakeAddrInvalid(EncodeDestination(dstKey, config), config);
 }
 
 // Addresses are stored in the database with the encoding that the client was
 // configured with at the time of creation.
 //
 // This converts to clients current configuration.
 QString convertToConfiguredAddressFormat(const Config &config,
                                          const QString &addr) {
     if (!IsValidDestinationString(addr.toStdString(),
                                   config.GetChainParams())) {
         // We have something sketchy as input. Do not try to convert.
         return addr;
     }
     CTxDestination dst =
         DecodeDestination(addr.toStdString(), config.GetChainParams());
     return QString::fromStdString(EncodeDestination(dst, config));
 }
 
 void setupAddressWidget(QValidatedLineEdit *widget, QWidget *parent) {
     parent->setFocusProxy(widget);
 
     widget->setFont(fixedPitchFont());
     // We don't want translators to use own addresses in translations
     // and this is the only place, where this address is supplied.
     widget->setPlaceholderText(
         QObject::tr("Enter a Bitcoin address (e.g. %1)")
             .arg(QString::fromStdString(DummyAddress(GetConfig()))));
     widget->setValidator(
         new BitcoinAddressEntryValidator(Params().CashAddrPrefix(), parent));
     widget->setCheckValidator(new BitcoinAddressCheckValidator(parent));
 }
 
 void setupAmountWidget(QLineEdit *widget, QWidget *parent) {
     QDoubleValidator *amountValidator = new QDoubleValidator(parent);
     amountValidator->setDecimals(8);
     amountValidator->setBottom(0.0);
     widget->setValidator(amountValidator);
     widget->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
 }
 
 QString bitcoinURIScheme(const CChainParams &params, bool useCashAddr) {
     if (!useCashAddr) {
         return "bitcoincash";
     }
     return QString::fromStdString(params.CashAddrPrefix());
 }
 
 QString bitcoinURIScheme(const Config &config) {
     return bitcoinURIScheme(config.GetChainParams(),
                             config.UseCashAddrEncoding());
 }
 
 static bool IsCashAddrEncoded(const QUrl &uri) {
     const std::string addr = (uri.scheme() + ":" + uri.path()).toStdString();
     auto decoded = cashaddr::Decode(addr, "");
     return !decoded.first.empty();
 }
 
 bool parseBitcoinURI(const QString &scheme, const QUrl &uri,
                      SendCoinsRecipient *out) {
     // return if URI has wrong scheme.
     if (!uri.isValid() || uri.scheme() != scheme) {
         return false;
     }
 
     SendCoinsRecipient rv;
     if (IsCashAddrEncoded(uri)) {
         rv.address = uri.scheme() + ":" + uri.path();
     } else {
         // strip out uri scheme for base58 encoded addresses
         rv.address = uri.path();
     }
     // Trim any following forward slash which may have been added by the OS
     if (rv.address.endsWith("/")) {
         rv.address.truncate(rv.address.length() - 1);
     }
     rv.amount = Amount::zero();
 
     QUrlQuery uriQuery(uri);
     QList<QPair<QString, QString>> items = uriQuery.queryItems();
     for (QList<QPair<QString, QString>>::iterator i = items.begin();
          i != items.end(); i++) {
         bool fShouldReturnFalse = false;
         if (i->first.startsWith("req-")) {
             i->first.remove(0, 4);
             fShouldReturnFalse = true;
         }
 
         if (i->first == "label") {
             rv.label = i->second;
             fShouldReturnFalse = false;
         }
         if (i->first == "message") {
             rv.message = i->second;
             fShouldReturnFalse = false;
         } else if (i->first == "amount") {
             if (!i->second.isEmpty()) {
                 if (!BitcoinUnits::parse(BitcoinUnits::BCH, i->second,
                                          &rv.amount)) {
                     return false;
                 }
             }
             fShouldReturnFalse = false;
         }
 
         if (fShouldReturnFalse) {
             return false;
         }
     }
     if (out) {
         *out = rv;
     }
     return true;
 }
 
 bool parseBitcoinURI(const QString &scheme, QString uri,
                      SendCoinsRecipient *out) {
     //
     //    Cannot handle this later, because bitcoincash://
     //    will cause Qt to see the part after // as host,
     //    which will lower-case it (and thus invalidate the address).
     if (uri.startsWith(scheme + "://", Qt::CaseInsensitive)) {
         uri.replace(0, scheme.length() + 3, scheme + ":");
     }
     QUrl uriInstance(uri);
     return parseBitcoinURI(scheme, uriInstance, out);
 }
 
 QString formatBitcoinURI(const Config &config, const SendCoinsRecipient &info) {
     QString ret = info.address;
     if (!config.UseCashAddrEncoding()) {
         // prefix address with uri scheme for base58 encoded addresses.
         ret = (bitcoinURIScheme(config) + ":%1").arg(ret);
     }
     int paramCount = 0;
 
     if (info.amount != Amount::zero()) {
         ret +=
             QString("?amount=%1")
                 .arg(BitcoinUnits::format(BitcoinUnits::BCH, info.amount, false,
                                           BitcoinUnits::separatorNever));
         paramCount++;
     }
 
     if (!info.label.isEmpty()) {
         QString lbl(QUrl::toPercentEncoding(info.label));
         ret += QString("%1label=%2").arg(paramCount == 0 ? "?" : "&").arg(lbl);
         paramCount++;
     }
 
     if (!info.message.isEmpty()) {
         QString msg(QUrl::toPercentEncoding(info.message));
         ret +=
             QString("%1message=%2").arg(paramCount == 0 ? "?" : "&").arg(msg);
         paramCount++;
     }
 
     return ret;
 }
 
-bool isDust(const QString &address, const Amount amount,
+bool isDust(interfaces::Node &node, const QString &address, const Amount amount,
             const CChainParams &chainParams) {
     CTxDestination dest = DecodeDestination(address.toStdString(), chainParams);
     CScript script = GetScriptForDestination(dest);
     CTxOut txOut(amount, script);
-    return txOut.IsDust(dustRelayFee);
+    return txOut.IsDust(node.getDustRelayFee());
 }
 
 QString HtmlEscape(const QString &str, bool fMultiLine) {
     QString escaped = str.toHtmlEscaped();
     if (fMultiLine) {
         escaped = escaped.replace("\n", "<br>\n");
     }
     return escaped;
 }
 
 QString HtmlEscape(const std::string &str, bool fMultiLine) {
     return HtmlEscape(QString::fromStdString(str), fMultiLine);
 }
 
 void copyEntryData(QAbstractItemView *view, int column, int role) {
     if (!view || !view->selectionModel()) {
         return;
     }
     QModelIndexList selection = view->selectionModel()->selectedRows(column);
 
     if (!selection.isEmpty()) {
         // Copy first item
         setClipboard(selection.at(0).data(role).toString());
     }
 }
 
 QList<QModelIndex> getEntryData(QAbstractItemView *view, int column) {
     if (!view || !view->selectionModel()) {
         return QList<QModelIndex>();
     }
     return view->selectionModel()->selectedRows(column);
 }
 
 QString getSaveFileName(QWidget *parent, const QString &caption,
                         const QString &dir, const QString &filter,
                         QString *selectedSuffixOut) {
     QString selectedFilter;
     QString myDir;
     // Default to user documents location
     if (dir.isEmpty()) {
         myDir =
             QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
     } else {
         myDir = dir;
     }
     /* Directly convert path to native OS path separators */
     QString result = QDir::toNativeSeparators(QFileDialog::getSaveFileName(
         parent, caption, myDir, filter, &selectedFilter));
 
     /* Extract first suffix from filter pattern "Description (*.foo)" or
      * "Description (*.foo *.bar ...) */
     QRegExp filter_re(".* \\(\\*\\.(.*)[ \\)]");
     QString selectedSuffix;
     if (filter_re.exactMatch(selectedFilter)) {
         selectedSuffix = filter_re.cap(1);
     }
 
     /* Add suffix if needed */
     QFileInfo info(result);
     if (!result.isEmpty()) {
         if (info.suffix().isEmpty() && !selectedSuffix.isEmpty()) {
             /* No suffix specified, add selected suffix */
             if (!result.endsWith(".")) {
                 result.append(".");
             }
             result.append(selectedSuffix);
         }
     }
 
     /* Return selected suffix if asked to */
     if (selectedSuffixOut) {
         *selectedSuffixOut = selectedSuffix;
     }
     return result;
 }
 
 QString getOpenFileName(QWidget *parent, const QString &caption,
                         const QString &dir, const QString &filter,
                         QString *selectedSuffixOut) {
     QString selectedFilter;
     QString myDir;
     // Default to user documents location
     if (dir.isEmpty()) {
         myDir =
             QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
     } else {
         myDir = dir;
     }
     /* Directly convert path to native OS path separators */
     QString result = QDir::toNativeSeparators(QFileDialog::getOpenFileName(
         parent, caption, myDir, filter, &selectedFilter));
 
     if (selectedSuffixOut) {
         /* Extract first suffix from filter pattern "Description (*.foo)" or
          * "Description (*.foo *.bar ...) */
         QRegExp filter_re(".* \\(\\*\\.(.*)[ \\)]");
         QString selectedSuffix;
         if (filter_re.exactMatch(selectedFilter)) {
             selectedSuffix = filter_re.cap(1);
         }
         *selectedSuffixOut = selectedSuffix;
     }
     return result;
 }
 
 Qt::ConnectionType blockingGUIThreadConnection() {
     if (QThread::currentThread() != qApp->thread()) {
         return Qt::BlockingQueuedConnection;
     } else {
         return Qt::DirectConnection;
     }
 }
 
 bool checkPoint(const QPoint &p, const QWidget *w) {
     QWidget *atW = QApplication::widgetAt(w->mapToGlobal(p));
     if (!atW) {
         return false;
     }
     return atW->topLevelWidget() == w;
 }
 
 bool isObscured(QWidget *w) {
     return !(checkPoint(QPoint(0, 0), w) &&
              checkPoint(QPoint(w->width() - 1, 0), w) &&
              checkPoint(QPoint(0, w->height() - 1), w) &&
              checkPoint(QPoint(w->width() - 1, w->height() - 1), w) &&
              checkPoint(QPoint(w->width() / 2, w->height() / 2), w));
 }
 
 void openDebugLogfile() {
     fs::path pathDebug = GetDataDir() / "debug.log";
 
     /* Open debug.log with the associated application */
     if (fs::exists(pathDebug)) {
         QDesktopServices::openUrl(
             QUrl::fromLocalFile(boostPathToQString(pathDebug)));
     }
 }
 
 void SubstituteFonts(const QString &language) {
 #if defined(Q_OS_MAC)
 // Background:
 // OSX's default font changed in 10.9 and Qt is unable to find it with its
 // usual fallback methods when building against the 10.7 sdk or lower.
 // The 10.8 SDK added a function to let it find the correct fallback font.
 // If this fallback is not properly loaded, some characters may fail to
 // render correctly.
 //
 // The same thing happened with 10.10. .Helvetica Neue DeskInterface is now
 // default.
 //
 // Solution: If building with the 10.7 SDK or lower and the user's platform
 // is 10.9 or higher at runtime, substitute the correct font. This needs to
 // happen before the QApplication is created.
 #if defined(MAC_OS_X_VERSION_MAX_ALLOWED) &&                                   \
     MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_8
     if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_8) {
         if (floor(NSAppKitVersionNumber) <= NSAppKitVersionNumber10_9) {
             /* On a 10.9 - 10.9.x system */
             QFont::insertSubstitution(".Lucida Grande UI", "Lucida Grande");
         } else {
             /* 10.10 or later system */
             if (language == "zh_CN" || language == "zh_TW" ||
                 language == "zh_HK") {
                 // traditional or simplified Chinese
                 QFont::insertSubstitution(".Helvetica Neue DeskInterface",
                                           "Heiti SC");
             } else if (language == "ja") {
                 // Japanesee
                 QFont::insertSubstitution(".Helvetica Neue DeskInterface",
                                           "Songti SC");
             } else {
                 QFont::insertSubstitution(".Helvetica Neue DeskInterface",
                                           "Lucida Grande");
             }
         }
     }
 #endif
 #endif
 }
 
 ToolTipToRichTextFilter::ToolTipToRichTextFilter(int _size_threshold,
                                                  QObject *parent)
     : QObject(parent), size_threshold(_size_threshold) {}
 
 bool ToolTipToRichTextFilter::eventFilter(QObject *obj, QEvent *evt) {
     if (evt->type() == QEvent::ToolTipChange) {
         QWidget *widget = static_cast<QWidget *>(obj);
         QString tooltip = widget->toolTip();
         if (tooltip.size() > size_threshold && !tooltip.startsWith("<qt") &&
             !Qt::mightBeRichText(tooltip)) {
             // Envelop with <qt></qt> to make sure Qt detects this as rich text
             // Escape the current message as HTML and replace \n by <br>
             tooltip = "<qt>" + HtmlEscape(tooltip, true) + "</qt>";
             widget->setToolTip(tooltip);
             return true;
         }
     }
     return QObject::eventFilter(obj, evt);
 }
 
 void TableViewLastColumnResizingFixer::connectViewHeadersSignals() {
     connect(tableView->horizontalHeader(),
             SIGNAL(sectionResized(int, int, int)), this,
             SLOT(on_sectionResized(int, int, int)));
     connect(tableView->horizontalHeader(), SIGNAL(geometriesChanged()), this,
             SLOT(on_geometriesChanged()));
 }
 
 // We need to disconnect these while handling the resize events, otherwise we
 // can enter infinite loops.
 void TableViewLastColumnResizingFixer::disconnectViewHeadersSignals() {
     disconnect(tableView->horizontalHeader(),
                SIGNAL(sectionResized(int, int, int)), this,
                SLOT(on_sectionResized(int, int, int)));
     disconnect(tableView->horizontalHeader(), SIGNAL(geometriesChanged()), this,
                SLOT(on_geometriesChanged()));
 }
 
 // Setup the resize mode, handles compatibility for Qt5 and below as the method
 // signatures changed.
 // Refactored here for readability.
 void TableViewLastColumnResizingFixer::setViewHeaderResizeMode(
     int logicalIndex, QHeaderView::ResizeMode resizeMode) {
     tableView->horizontalHeader()->setSectionResizeMode(logicalIndex,
                                                         resizeMode);
 }
 
 void TableViewLastColumnResizingFixer::resizeColumn(int nColumnIndex,
                                                     int width) {
     tableView->setColumnWidth(nColumnIndex, width);
     tableView->horizontalHeader()->resizeSection(nColumnIndex, width);
 }
 
 int TableViewLastColumnResizingFixer::getColumnsWidth() {
     int nColumnsWidthSum = 0;
     for (int i = 0; i < columnCount; i++) {
         nColumnsWidthSum += tableView->horizontalHeader()->sectionSize(i);
     }
     return nColumnsWidthSum;
 }
 
 int TableViewLastColumnResizingFixer::getAvailableWidthForColumn(int column) {
     int nResult = lastColumnMinimumWidth;
     int nTableWidth = tableView->horizontalHeader()->width();
 
     if (nTableWidth > 0) {
         int nOtherColsWidth =
             getColumnsWidth() -
             tableView->horizontalHeader()->sectionSize(column);
         nResult = std::max(nResult, nTableWidth - nOtherColsWidth);
     }
 
     return nResult;
 }
 
 // Make sure we don't make the columns wider than the table's viewport width.
 void TableViewLastColumnResizingFixer::adjustTableColumnsWidth() {
     disconnectViewHeadersSignals();
     resizeColumn(lastColumnIndex, getAvailableWidthForColumn(lastColumnIndex));
     connectViewHeadersSignals();
 
     int nTableWidth = tableView->horizontalHeader()->width();
     int nColsWidth = getColumnsWidth();
     if (nColsWidth > nTableWidth) {
         resizeColumn(secondToLastColumnIndex,
                      getAvailableWidthForColumn(secondToLastColumnIndex));
     }
 }
 
 // Make column use all the space available, useful during window resizing.
 void TableViewLastColumnResizingFixer::stretchColumnWidth(int column) {
     disconnectViewHeadersSignals();
     resizeColumn(column, getAvailableWidthForColumn(column));
     connectViewHeadersSignals();
 }
 
 // When a section is resized this is a slot-proxy for ajustAmountColumnWidth().
 void TableViewLastColumnResizingFixer::on_sectionResized(int logicalIndex,
                                                          int oldSize,
                                                          int newSize) {
     adjustTableColumnsWidth();
     int remainingWidth = getAvailableWidthForColumn(logicalIndex);
     if (newSize > remainingWidth) {
         resizeColumn(logicalIndex, remainingWidth);
     }
 }
 
 // When the table's geometry is ready, we manually perform the stretch of the
 // "Message" column,
 // as the "Stretch" resize mode does not allow for interactive resizing.
 void TableViewLastColumnResizingFixer::on_geometriesChanged() {
     if ((getColumnsWidth() - this->tableView->horizontalHeader()->width()) !=
         0) {
         disconnectViewHeadersSignals();
         resizeColumn(secondToLastColumnIndex,
                      getAvailableWidthForColumn(secondToLastColumnIndex));
         connectViewHeadersSignals();
     }
 }
 
 /**
  * Initializes all internal variables and prepares the
  * the resize modes of the last 2 columns of the table and
  */
 TableViewLastColumnResizingFixer::TableViewLastColumnResizingFixer(
     QTableView *table, int lastColMinimumWidth, int allColsMinimumWidth,
     QObject *parent)
     : QObject(parent), tableView(table),
       lastColumnMinimumWidth(lastColMinimumWidth),
       allColumnsMinimumWidth(allColsMinimumWidth) {
     columnCount = tableView->horizontalHeader()->count();
     lastColumnIndex = columnCount - 1;
     secondToLastColumnIndex = columnCount - 2;
     tableView->horizontalHeader()->setMinimumSectionSize(
         allColumnsMinimumWidth);
     setViewHeaderResizeMode(secondToLastColumnIndex, QHeaderView::Interactive);
     setViewHeaderResizeMode(lastColumnIndex, QHeaderView::Interactive);
 }
 
 #ifdef WIN32
 static fs::path StartupShortcutPath() {
     std::string chain = gArgs.GetChainName();
     if (chain == CBaseChainParams::MAIN) {
         return GetSpecialFolderPath(CSIDL_STARTUP) / "Bitcoin.lnk";
     }
     // Remove this special case when CBaseChainParams::TESTNET = "testnet4"
     if (chain == CBaseChainParams::TESTNET) {
         return GetSpecialFolderPath(CSIDL_STARTUP) / "Bitcoin (testnet).lnk";
     }
     return GetSpecialFolderPath(CSIDL_STARTUP) /
            strprintf("Bitcoin (%s).lnk", chain);
 }
 
 bool GetStartOnSystemStartup() {
     // check for Bitcoin*.lnk
     return fs::exists(StartupShortcutPath());
 }
 
 bool SetStartOnSystemStartup(bool fAutoStart) {
     // If the shortcut exists already, remove it for updating
     fs::remove(StartupShortcutPath());
 
     if (fAutoStart) {
         CoInitialize(nullptr);
 
         // Get a pointer to the IShellLink interface.
         IShellLink *psl = nullptr;
         HRESULT hres =
             CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_INPROC_SERVER,
                              IID_IShellLink, reinterpret_cast<void **>(&psl));
 
         if (SUCCEEDED(hres)) {
             // Get the current executable path
             TCHAR pszExePath[MAX_PATH];
             GetModuleFileName(nullptr, pszExePath, sizeof(pszExePath));
 
             // Start client minimized
             QString strArgs = "-min";
             // Set -testnet /-regtest options
             strArgs += QString::fromStdString(strprintf(
                 " -testnet=%d -regtest=%d", gArgs.GetBoolArg("-testnet", false),
                 gArgs.GetBoolArg("-regtest", false)));
 
 #ifdef UNICODE
             boost::scoped_array<TCHAR> args(new TCHAR[strArgs.length() + 1]);
             // Convert the QString to TCHAR*
             strArgs.toWCharArray(args.get());
             // Add missing '\0'-termination to string
             args[strArgs.length()] = '\0';
 #endif
 
             // Set the path to the shortcut target
             psl->SetPath(pszExePath);
             PathRemoveFileSpec(pszExePath);
             psl->SetWorkingDirectory(pszExePath);
             psl->SetShowCmd(SW_SHOWMINNOACTIVE);
 #ifndef UNICODE
             psl->SetArguments(strArgs.toStdString().c_str());
 #else
             psl->SetArguments(args.get());
 #endif
 
             // Query IShellLink for the IPersistFile interface for
             // saving the shortcut in persistent storage.
             IPersistFile *ppf = nullptr;
             hres = psl->QueryInterface(IID_IPersistFile,
                                        reinterpret_cast<void **>(&ppf));
             if (SUCCEEDED(hres)) {
                 WCHAR pwsz[MAX_PATH];
                 // Ensure that the string is ANSI.
                 MultiByteToWideChar(CP_ACP, 0,
                                     StartupShortcutPath().string().c_str(), -1,
                                     pwsz, MAX_PATH);
                 // Save the link by calling IPersistFile::Save.
                 hres = ppf->Save(pwsz, TRUE);
                 ppf->Release();
                 psl->Release();
                 CoUninitialize();
                 return true;
             }
             psl->Release();
         }
         CoUninitialize();
         return false;
     }
     return true;
 }
 #elif defined(Q_OS_LINUX)
 
 // Follow the Desktop Application Autostart Spec:
 // http://standards.freedesktop.org/autostart-spec/autostart-spec-latest.html
 
 static fs::path GetAutostartDir() {
     char *pszConfigHome = getenv("XDG_CONFIG_HOME");
     if (pszConfigHome) {
         return fs::path(pszConfigHome) / "autostart";
     }
     char *pszHome = getenv("HOME");
     if (pszHome) {
         return fs::path(pszHome) / ".config" / "autostart";
     }
     return fs::path();
 }
 
 static fs::path GetAutostartFilePath() {
     std::string chain = gArgs.GetChainName();
     if (chain == CBaseChainParams::MAIN) {
         return GetAutostartDir() / "bitcoin.desktop";
     }
     return GetAutostartDir() / strprintf("bitcoin-%s.lnk", chain);
 }
 
 bool GetStartOnSystemStartup() {
     fs::ifstream optionFile(GetAutostartFilePath());
     if (!optionFile.good()) {
         return false;
     }
     // Scan through file for "Hidden=true":
     std::string line;
     while (!optionFile.eof()) {
         getline(optionFile, line);
         if (line.find("Hidden") != std::string::npos &&
             line.find("true") != std::string::npos) {
             return false;
         }
     }
     optionFile.close();
 
     return true;
 }
 
 bool SetStartOnSystemStartup(bool fAutoStart) {
     if (!fAutoStart) {
         fs::remove(GetAutostartFilePath());
     } else {
         char pszExePath[MAX_PATH + 1];
         memset(pszExePath, 0, sizeof(pszExePath));
         if (readlink("/proc/self/exe", pszExePath, sizeof(pszExePath) - 1) ==
             -1) {
             return false;
         }
 
         fs::create_directories(GetAutostartDir());
 
         fs::ofstream optionFile(GetAutostartFilePath(),
                                 std::ios_base::out | std::ios_base::trunc);
         if (!optionFile.good()) {
             return false;
         }
         std::string chain = gArgs.GetChainName();
         // Write a bitcoin.desktop file to the autostart directory:
         optionFile << "[Desktop Entry]\n";
         optionFile << "Type=Application\n";
         if (chain == CBaseChainParams::MAIN) {
             optionFile << "Name=Bitcoin\n";
         } else {
             optionFile << strprintf("Name=Bitcoin (%s)\n", chain);
         }
         optionFile << "Exec=" << pszExePath
                    << strprintf(" -min -testnet=%d -regtest=%d\n",
                                 gArgs.GetBoolArg("-testnet", false),
                                 gArgs.GetBoolArg("-regtest", false));
         optionFile << "Terminal=false\n";
         optionFile << "Hidden=false\n";
         optionFile.close();
     }
     return true;
 }
 
 #elif defined(Q_OS_MAC)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 // based on:
 // https://github.com/Mozketo/LaunchAtLoginController/blob/master/LaunchAtLoginController.m
 
 // NB: caller must release returned ref if it's not NULL
 LSSharedFileListItemRef findStartupItemInList(LSSharedFileListRef list,
                                               CFURLRef findUrl);
 LSSharedFileListItemRef findStartupItemInList(LSSharedFileListRef list,
                                               CFURLRef findUrl) {
     LSSharedFileListItemRef foundItem = nullptr;
     // loop through the list of startup items and try to find the bitcoin app
     CFArrayRef listSnapshot = LSSharedFileListCopySnapshot(list, nullptr);
     for (int i = 0; !foundItem && i < CFArrayGetCount(listSnapshot); ++i) {
         LSSharedFileListItemRef item =
             (LSSharedFileListItemRef)CFArrayGetValueAtIndex(listSnapshot, i);
         UInt32 resolutionFlags = kLSSharedFileListNoUserInteraction |
                                  kLSSharedFileListDoNotMountVolumes;
         CFURLRef currentItemURL = nullptr;
 
 #if defined(MAC_OS_X_VERSION_MAX_ALLOWED) &&                                   \
     MAC_OS_X_VERSION_MAX_ALLOWED >= 10100
         if (&LSSharedFileListItemCopyResolvedURL) {
             currentItemURL = LSSharedFileListItemCopyResolvedURL(
                 item, resolutionFlags, nullptr);
         }
 #if defined(MAC_OS_X_VERSION_MIN_REQUIRED) &&                                  \
     MAC_OS_X_VERSION_MIN_REQUIRED < 10100
         else {
             LSSharedFileListItemResolve(item, resolutionFlags, &currentItemURL,
                                         nullptr);
         }
 #endif
 #else
         LSSharedFileListItemResolve(item, resolutionFlags, &currentItemURL,
                                     nullptr);
 #endif
 
         if (currentItemURL && CFEqual(currentItemURL, findUrl)) {
             // found
             CFRetain(foundItem = item);
         }
         if (currentItemURL) {
             CFRelease(currentItemURL);
         }
     }
     CFRelease(listSnapshot);
     return foundItem;
 }
 
 bool GetStartOnSystemStartup() {
     CFURLRef bitcoinAppUrl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
     LSSharedFileListRef loginItems = LSSharedFileListCreate(
         nullptr, kLSSharedFileListSessionLoginItems, nullptr);
     LSSharedFileListItemRef foundItem =
         findStartupItemInList(loginItems, bitcoinAppUrl);
     // findStartupItemInList retains the item it returned, need to release
     if (foundItem) {
         CFRelease(foundItem);
     }
     CFRelease(loginItems);
     CFRelease(bitcoinAppUrl);
     return foundItem;
 }
 
 bool SetStartOnSystemStartup(bool fAutoStart) {
     CFURLRef bitcoinAppUrl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
     LSSharedFileListRef loginItems = LSSharedFileListCreate(
         nullptr, kLSSharedFileListSessionLoginItems, nullptr);
     LSSharedFileListItemRef foundItem =
         findStartupItemInList(loginItems, bitcoinAppUrl);
 
     if (fAutoStart && !foundItem) {
         // add bitcoin app to startup item list
         LSSharedFileListInsertItemURL(loginItems,
                                       kLSSharedFileListItemBeforeFirst, nullptr,
                                       nullptr, bitcoinAppUrl, nullptr, nullptr);
     } else if (!fAutoStart && foundItem) {
         // remove item
         LSSharedFileListItemRemove(loginItems, foundItem);
     }
     // findStartupItemInList retains the item it returned, need to release
     if (foundItem) {
         CFRelease(foundItem);
     }
     CFRelease(loginItems);
     CFRelease(bitcoinAppUrl);
     return true;
 }
 #pragma GCC diagnostic pop
 #else
 
 bool GetStartOnSystemStartup() {
     return false;
 }
 bool SetStartOnSystemStartup(bool fAutoStart) {
     return false;
 }
 
 #endif
 
 void setClipboard(const QString &str) {
     QApplication::clipboard()->setText(str, QClipboard::Clipboard);
     QApplication::clipboard()->setText(str, QClipboard::Selection);
 }
 
 fs::path qstringToBoostPath(const QString &path) {
     return fs::path(path.toStdString(), utf8);
 }
 
 QString boostPathToQString(const fs::path &path) {
     return QString::fromStdString(path.string(utf8));
 }
 
 QString formatDurationStr(int secs) {
     QStringList strList;
     int days = secs / 86400;
     int hours = (secs % 86400) / 3600;
     int mins = (secs % 3600) / 60;
     int seconds = secs % 60;
 
     if (days) {
         strList.append(QString(QObject::tr("%1 d")).arg(days));
     }
     if (hours) {
         strList.append(QString(QObject::tr("%1 h")).arg(hours));
     }
     if (mins) {
         strList.append(QString(QObject::tr("%1 m")).arg(mins));
     }
     if (seconds || (!days && !hours && !mins)) {
         strList.append(QString(QObject::tr("%1 s")).arg(seconds));
     }
 
     return strList.join(" ");
 }
 
 QString formatServicesStr(quint64 mask) {
     QStringList strList;
 
     // Don't display experimental service bits
     for (uint64_t check = 1; check <= NODE_LAST_NON_EXPERIMENTAL_SERVICE_BIT;
          check <<= 1) {
         if (mask & check) {
             switch (check) {
                 case NODE_NETWORK:
                     strList.append("NETWORK");
                     break;
                 case NODE_GETUTXO:
                     strList.append("GETUTXO");
                     break;
                 case NODE_BLOOM:
                     strList.append("BLOOM");
                     break;
                 case NODE_XTHIN:
                     strList.append("XTHIN");
                     break;
                 case NODE_BITCOIN_CASH:
                     strList.append("CASH");
                     break;
                 case NODE_NETWORK_LIMITED:
                     strList.append("LIMITED");
                     break;
                 default:
                     strList.append(QString("%1[%2]").arg("UNKNOWN").arg(check));
             }
         }
     }
 
     if (strList.size()) {
         return strList.join(" & ");
     } else {
         return QObject::tr("None");
     }
 }
 
 QString formatPingTime(double dPingTime) {
     return (dPingTime == std::numeric_limits<int64_t>::max() / 1e6 ||
             dPingTime == 0)
                ? QObject::tr("N/A")
                : QString(QObject::tr("%1 ms"))
                      .arg(QString::number((int)(dPingTime * 1000), 10));
 }
 
 QString formatTimeOffset(int64_t nTimeOffset) {
     return QString(QObject::tr("%1 s"))
         .arg(QString::number((int)nTimeOffset, 10));
 }
 
 QString formatNiceTimeOffset(qint64 secs) {
     // Represent time from last generated block in human readable text
     QString timeBehindText;
     const int HOUR_IN_SECONDS = 60 * 60;
     const int DAY_IN_SECONDS = 24 * 60 * 60;
     const int WEEK_IN_SECONDS = 7 * 24 * 60 * 60;
     // Average length of year in Gregorian calendar
     const int YEAR_IN_SECONDS = 31556952;
     if (secs < 60) {
         timeBehindText = QObject::tr("%n second(s)", "", secs);
     } else if (secs < 2 * HOUR_IN_SECONDS) {
         timeBehindText = QObject::tr("%n minute(s)", "", secs / 60);
     } else if (secs < 2 * DAY_IN_SECONDS) {
         timeBehindText = QObject::tr("%n hour(s)", "", secs / HOUR_IN_SECONDS);
     } else if (secs < 2 * WEEK_IN_SECONDS) {
         timeBehindText = QObject::tr("%n day(s)", "", secs / DAY_IN_SECONDS);
     } else if (secs < YEAR_IN_SECONDS) {
         timeBehindText = QObject::tr("%n week(s)", "", secs / WEEK_IN_SECONDS);
     } else {
         qint64 years = secs / YEAR_IN_SECONDS;
         qint64 remainder = secs % YEAR_IN_SECONDS;
         timeBehindText = QObject::tr("%1 and %2")
                              .arg(QObject::tr("%n year(s)", "", years))
                              .arg(QObject::tr("%n week(s)", "",
                                               remainder / WEEK_IN_SECONDS));
     }
     return timeBehindText;
 }
 
 QString formatBytes(uint64_t bytes) {
     if (bytes < 1024) {
         return QString(QObject::tr("%1 B")).arg(bytes);
     }
     if (bytes < 1024 * 1024) {
         return QString(QObject::tr("%1 KB")).arg(bytes / 1024);
     }
     if (bytes < 1024 * 1024 * 1024) {
         return QString(QObject::tr("%1 MB")).arg(bytes / 1024 / 1024);
     }
 
     return QString(QObject::tr("%1 GB")).arg(bytes / 1024 / 1024 / 1024);
 }
 
 void ClickableLabel::mouseReleaseEvent(QMouseEvent *event) {
     Q_EMIT clicked(event->pos());
 }
 
 void ClickableProgressBar::mouseReleaseEvent(QMouseEvent *event) {
     Q_EMIT clicked(event->pos());
 }
 
 } // namespace GUIUtil
diff --git a/src/qt/guiutil.h b/src/qt/guiutil.h
index abb270b208..345587accd 100644
--- a/src/qt/guiutil.h
+++ b/src/qt/guiutil.h
@@ -1,277 +1,281 @@
 // 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_GUIUTIL_H
 #define BITCOIN_QT_GUIUTIL_H
 
-#include "amount.h"
-#include "fs.h"
+#include <amount.h>
+#include <fs.h>
 
 #include <QEvent>
 #include <QHeaderView>
 #include <QLabel>
 #include <QMessageBox>
 #include <QObject>
 #include <QProgressBar>
 #include <QString>
 #include <QTableView>
 
 class QValidatedLineEdit;
 class SendCoinsRecipient;
 class CChainParams;
 class Config;
 
+namespace interfaces {
+class Node;
+}
+
 QT_BEGIN_NAMESPACE
 class QAbstractItemView;
 class QDateTime;
 class QFont;
 class QLineEdit;
 class QUrl;
 class QWidget;
 QT_END_NAMESPACE
 
 /** Utility functions used by the Bitcoin Qt UI.
  */
 namespace GUIUtil {
 
 // Create human-readable string from date
 QString dateTimeStr(const QDateTime &datetime);
 QString dateTimeStr(qint64 nTime);
 
 // Return a monospace font
 QFont fixedPitchFont();
 
 // Generate an invalid, but convincing address.
 std::string DummyAddress(const Config &config);
 
 // Convert an address into the user chosen format
 QString convertToConfiguredAddressFormat(const Config &config,
                                          const QString &addr);
 
 // Set up widgets for address and amounts
 void setupAddressWidget(QValidatedLineEdit *widget, QWidget *parent);
 void setupAmountWidget(QLineEdit *widget, QWidget *parent);
 
 QString bitcoinURIScheme(const CChainParams &, bool useCashAddr);
 QString bitcoinURIScheme(const Config &);
 // Parse "bitcoincash:" URI into recipient object, return true on successful
 // parsing
 bool parseBitcoinURI(const QString &scheme, const QUrl &uri,
                      SendCoinsRecipient *out);
 bool parseBitcoinURI(const QString &scheme, QString uri,
                      SendCoinsRecipient *out);
 QString formatBitcoinURI(const Config &config, const SendCoinsRecipient &info);
 
 // Returns true if given address+amount meets "dust" definition
-bool isDust(const QString &address, const Amount amount,
+bool isDust(interfaces::Node &node, const QString &address, const Amount amount,
             const CChainParams &chainParams);
 
 // HTML escaping for rich text controls
 QString HtmlEscape(const QString &str, bool fMultiLine = false);
 QString HtmlEscape(const std::string &str, bool fMultiLine = false);
 
 /** Copy a field of the currently selected entry of a view to the clipboard.
    Does nothing if nothing
     is selected.
    @param[in] column  Data column to extract from the model
    @param[in] role    Data role to extract from the model
    @see  TransactionView::copyLabel, TransactionView::copyAmount,
    TransactionView::copyAddress
  */
 void copyEntryData(QAbstractItemView *view, int column,
                    int role = Qt::EditRole);
 
 /** Return a field of the currently selected entry as a QString. Does nothing if
    nothing
     is selected.
    @param[in] column  Data column to extract from the model
    @see  TransactionView::copyLabel, TransactionView::copyAmount,
    TransactionView::copyAddress
  */
 QList<QModelIndex> getEntryData(QAbstractItemView *view, int column);
 
 void setClipboard(const QString &str);
 
 /** Get save filename, mimics QFileDialog::getSaveFileName, except that it
   appends a default suffix
     when no suffix is provided by the user.
 
   @param[in] parent  Parent window (or 0)
   @param[in] caption Window caption (or empty, for default)
   @param[in] dir     Starting directory (or empty, to default to documents
   directory)
   @param[in] filter  Filter specification such as "Comma Separated Files
   (*.csv)"
   @param[out] selectedSuffixOut  Pointer to return the suffix (file type) that
   was selected (or 0).
               Can be useful when choosing the save file format based on suffix.
  */
 QString getSaveFileName(QWidget *parent, const QString &caption,
                         const QString &dir, const QString &filter,
                         QString *selectedSuffixOut);
 
 /** Get open filename, convenience wrapper for QFileDialog::getOpenFileName.
 
   @param[in] parent  Parent window (or 0)
   @param[in] caption Window caption (or empty, for default)
   @param[in] dir     Starting directory (or empty, to default to documents
   directory)
   @param[in] filter  Filter specification such as "Comma Separated Files
   (*.csv)"
   @param[out] selectedSuffixOut  Pointer to return the suffix (file type) that
   was selected (or 0).
               Can be useful when choosing the save file format based on suffix.
  */
 QString getOpenFileName(QWidget *parent, const QString &caption,
                         const QString &dir, const QString &filter,
                         QString *selectedSuffixOut);
 
 /** Get connection type to call object slot in GUI thread with invokeMethod. The
    call will be blocking.
 
    @returns If called from the GUI thread, return a Qt::DirectConnection.
             If called from another thread, return a
    Qt::BlockingQueuedConnection.
 */
 Qt::ConnectionType blockingGUIThreadConnection();
 
 // Determine whether a widget is hidden behind other windows
 bool isObscured(QWidget *w);
 
 // Open debug.log
 void openDebugLogfile();
 
 // Replace invalid default fonts with known good ones
 void SubstituteFonts(const QString &language);
 
 /** Qt event filter that intercepts ToolTipChange events, and replaces the
  * tooltip with a rich text representation if needed.  This assures that Qt can
  * word-wrap long tooltip messages. Tooltips longer than the provided size
  * threshold (in characters) are wrapped.
  */
 class ToolTipToRichTextFilter : public QObject {
     Q_OBJECT
 
 public:
     explicit ToolTipToRichTextFilter(int size_threshold, QObject *parent = 0);
 
 protected:
     bool eventFilter(QObject *obj, QEvent *evt) override;
 
 private:
     int size_threshold;
 };
 
 /**
  * Makes a QTableView last column feel as if it was being resized from its left
  * border.
  * Also makes sure the column widths are never larger than the table's viewport.
  * In Qt, all columns are resizable from the right, but it's not intuitive
  * resizing the last column from the right.
  * Usually our second to last columns behave as if stretched, and when on strech
  * mode, columns aren't resizable interactively or programmatically.
  *
  * This helper object takes care of this issue.
  *
  */
 class TableViewLastColumnResizingFixer : public QObject {
     Q_OBJECT
 
 public:
     TableViewLastColumnResizingFixer(QTableView *table, int lastColMinimumWidth,
                                      int allColsMinimumWidth, QObject *parent);
     void stretchColumnWidth(int column);
 
 private:
     QTableView *tableView;
     int lastColumnMinimumWidth;
     int allColumnsMinimumWidth;
     int lastColumnIndex;
     int columnCount;
     int secondToLastColumnIndex;
 
     void adjustTableColumnsWidth();
     int getAvailableWidthForColumn(int column);
     int getColumnsWidth();
     void connectViewHeadersSignals();
     void disconnectViewHeadersSignals();
     void setViewHeaderResizeMode(int logicalIndex,
                                  QHeaderView::ResizeMode resizeMode);
     void resizeColumn(int nColumnIndex, int width);
 
 private Q_SLOTS:
     void on_sectionResized(int logicalIndex, int oldSize, int newSize);
     void on_geometriesChanged();
 };
 
 bool GetStartOnSystemStartup();
 bool SetStartOnSystemStartup(bool fAutoStart);
 
 /* Convert QString to OS specific boost path through UTF-8 */
 fs::path qstringToBoostPath(const QString &path);
 
 /* Convert OS specific boost path to QString through UTF-8 */
 QString boostPathToQString(const fs::path &path);
 
 /* Convert seconds into a QString with days, hours, mins, secs */
 QString formatDurationStr(int secs);
 
 /* Format CNodeStats.nServices bitmask into a user-readable string */
 QString formatServicesStr(quint64 mask);
 
 /* Format a CNodeCombinedStats.dPingTime into a user-readable string or display
  * N/A, if 0*/
 QString formatPingTime(double dPingTime);
 
 /* Format a CNodeCombinedStats.nTimeOffset into a user-readable string. */
 QString formatTimeOffset(int64_t nTimeOffset);
 
 QString formatNiceTimeOffset(qint64 secs);
 
 QString formatBytes(uint64_t bytes);
 
 class ClickableLabel : public QLabel {
     Q_OBJECT
 
 Q_SIGNALS:
     /** Emitted when the label is clicked. The relative mouse coordinates of the
      * click are passed to the signal.
      */
     void clicked(const QPoint &point);
 
 protected:
     void mouseReleaseEvent(QMouseEvent *event) override;
 };
 
 class ClickableProgressBar : public QProgressBar {
     Q_OBJECT
 
 Q_SIGNALS:
     /** Emitted when the progressbar is clicked. The relative mouse coordinates
      * of the click are passed to the signal.
      */
     void clicked(const QPoint &point);
 
 protected:
     void mouseReleaseEvent(QMouseEvent *event) override;
 };
 
 #if defined(Q_OS_MAC)
 // workaround for Qt OSX Bug:
 // https://bugreports.qt-project.org/browse/QTBUG-15631
 // QProgressBar uses around 10% CPU even when app is in background
 class ProgressBar : public ClickableProgressBar {
     bool event(QEvent *e) override {
         return (e->type() != QEvent::StyleAnimationUpdate)
                    ? QProgressBar::event(e)
                    : false;
     }
 };
 #else
 typedef ClickableProgressBar ProgressBar;
 #endif
 
 } // namespace GUIUtil
 
 #endif // BITCOIN_QT_GUIUTIL_H
diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp
index ec43ab5af5..39aa59d847 100644
--- a/src/qt/sendcoinsdialog.cpp
+++ b/src/qt/sendcoinsdialog.cpp
@@ -1,955 +1,955 @@
 // 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 <qt/forms/ui_sendcoinsdialog.h>
 #include <qt/sendcoinsdialog.h>
 
 #include <chainparams.h>
 #include <dstencode.h>
 #include <interfaces/node.h>
 #include <qt/addresstablemodel.h>
 #include <qt/bitcoinunits.h>
 #include <qt/clientmodel.h>
 #include <qt/coincontroldialog.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/sendcoinsentry.h>
 #include <qt/walletmodel.h>
 #include <txmempool.h>
 #include <ui_interface.h>
 #include <validation.h> // mempool and minRelayTxFee
 #include <wallet/coincontrol.h>
 #include <wallet/fees.h>
 #include <wallet/wallet.h>
 
 #include <QMessageBox>
 #include <QScrollBar>
 #include <QSettings>
 #include <QTextDocument>
 #include <QTimer>
 
 SendCoinsDialog::SendCoinsDialog(const PlatformStyle *_platformStyle,
                                  QWidget *parent)
     : QDialog(parent), ui(new Ui::SendCoinsDialog), clientModel(0), model(0),
       fNewRecipientAllowed(true), fFeeMinimized(true),
       platformStyle(_platformStyle) {
     ui->setupUi(this);
 
     if (!_platformStyle->getImagesOnButtons()) {
         ui->addButton->setIcon(QIcon());
         ui->clearButton->setIcon(QIcon());
         ui->sendButton->setIcon(QIcon());
     } else {
         ui->addButton->setIcon(_platformStyle->SingleColorIcon(":/icons/add"));
         ui->clearButton->setIcon(
             _platformStyle->SingleColorIcon(":/icons/remove"));
         ui->sendButton->setIcon(
             _platformStyle->SingleColorIcon(":/icons/send"));
     }
 
     GUIUtil::setupAddressWidget(ui->lineEditCoinControlChange, this);
 
     addEntry();
 
     connect(ui->addButton, SIGNAL(clicked()), this, SLOT(addEntry()));
     connect(ui->clearButton, SIGNAL(clicked()), this, SLOT(clear()));
 
     // Coin Control
     connect(ui->pushButtonCoinControl, SIGNAL(clicked()), this,
             SLOT(coinControlButtonClicked()));
     connect(ui->checkBoxCoinControlChange, SIGNAL(stateChanged(int)), this,
             SLOT(coinControlChangeChecked(int)));
     connect(ui->lineEditCoinControlChange, SIGNAL(textEdited(const QString &)),
             this, SLOT(coinControlChangeEdited(const QString &)));
 
     // Coin Control: clipboard actions
     QAction *clipboardQuantityAction = new QAction(tr("Copy quantity"), this);
     QAction *clipboardAmountAction = new QAction(tr("Copy amount"), this);
     QAction *clipboardFeeAction = new QAction(tr("Copy fee"), this);
     QAction *clipboardAfterFeeAction = new QAction(tr("Copy after fee"), this);
     QAction *clipboardBytesAction = new QAction(tr("Copy bytes"), this);
     QAction *clipboardLowOutputAction = new QAction(tr("Copy dust"), this);
     QAction *clipboardChangeAction = new QAction(tr("Copy change"), this);
     connect(clipboardQuantityAction, SIGNAL(triggered()), this,
             SLOT(coinControlClipboardQuantity()));
     connect(clipboardAmountAction, SIGNAL(triggered()), this,
             SLOT(coinControlClipboardAmount()));
     connect(clipboardFeeAction, SIGNAL(triggered()), this,
             SLOT(coinControlClipboardFee()));
     connect(clipboardAfterFeeAction, SIGNAL(triggered()), this,
             SLOT(coinControlClipboardAfterFee()));
     connect(clipboardBytesAction, SIGNAL(triggered()), this,
             SLOT(coinControlClipboardBytes()));
     connect(clipboardLowOutputAction, SIGNAL(triggered()), this,
             SLOT(coinControlClipboardLowOutput()));
     connect(clipboardChangeAction, SIGNAL(triggered()), this,
             SLOT(coinControlClipboardChange()));
     ui->labelCoinControlQuantity->addAction(clipboardQuantityAction);
     ui->labelCoinControlAmount->addAction(clipboardAmountAction);
     ui->labelCoinControlFee->addAction(clipboardFeeAction);
     ui->labelCoinControlAfterFee->addAction(clipboardAfterFeeAction);
     ui->labelCoinControlBytes->addAction(clipboardBytesAction);
     ui->labelCoinControlLowOutput->addAction(clipboardLowOutputAction);
     ui->labelCoinControlChange->addAction(clipboardChangeAction);
 
     // init transaction fee section
     QSettings settings;
     if (!settings.contains("fFeeSectionMinimized")) {
         settings.setValue("fFeeSectionMinimized", true);
     }
     // compatibility
     if (!settings.contains("nFeeRadio") &&
         settings.contains("nTransactionFee") &&
         settings.value("nTransactionFee").toLongLong() > 0) {
         // custom
         settings.setValue("nFeeRadio", 1);
     }
     if (!settings.contains("nFeeRadio")) {
         // recommended
         settings.setValue("nFeeRadio", 0);
     }
     // compatibility
     if (!settings.contains("nCustomFeeRadio") &&
         settings.contains("nTransactionFee") &&
         settings.value("nTransactionFee").toLongLong() > 0) {
         // total at least
         settings.setValue("nCustomFeeRadio", 1);
     }
     if (!settings.contains("nCustomFeeRadio")) {
         // per kilobyte
         settings.setValue("nCustomFeeRadio", 0);
     }
     if (!settings.contains("nTransactionFee")) {
         settings.setValue("nTransactionFee",
                           qint64(DEFAULT_TRANSACTION_FEE / SATOSHI));
     }
     if (!settings.contains("fPayOnlyMinFee")) {
         settings.setValue("fPayOnlyMinFee", false);
     }
     ui->groupFee->setId(ui->radioSmartFee, 0);
     ui->groupFee->setId(ui->radioCustomFee, 1);
     ui->groupFee
         ->button(
             std::max<int>(0, std::min(1, settings.value("nFeeRadio").toInt())))
         ->setChecked(true);
     ui->groupCustomFee->setId(ui->radioCustomPerKilobyte, 0);
     ui->groupCustomFee->button(0)->setChecked(true);
     ui->customFee->setValue(
         int64_t(settings.value("nTransactionFee").toLongLong()) * SATOSHI);
     ui->checkBoxMinimumFee->setChecked(
         settings.value("fPayOnlyMinFee").toBool());
     minimizeFeeSection(settings.value("fFeeSectionMinimized").toBool());
 }
 
 void SendCoinsDialog::setClientModel(ClientModel *_clientModel) {
     this->clientModel = _clientModel;
 
     if (_clientModel) {
         connect(_clientModel,
                 SIGNAL(numBlocksChanged(int, QDateTime, double, bool)), this,
                 SLOT(updateSmartFeeLabel()));
     }
 }
 
 void SendCoinsDialog::setModel(WalletModel *_model) {
     this->model = _model;
 
     if (_model && _model->getOptionsModel()) {
         for (int i = 0; i < ui->entries->count(); ++i) {
             SendCoinsEntry *entry = qobject_cast<SendCoinsEntry *>(
                 ui->entries->itemAt(i)->widget());
             if (entry) {
                 entry->setModel(_model);
             }
         }
 
         interfaces::WalletBalances balances = _model->wallet().getBalances();
         setBalance(balances.balance, balances.unconfirmed_balance,
                    balances.immature_balance, balances.watch_only_balance,
                    balances.unconfirmed_watch_only_balance,
                    balances.immature_watch_only_balance);
         connect(
             _model,
             SIGNAL(
                 balanceChanged(Amount, Amount, Amount, Amount, Amount, Amount)),
             this,
             SLOT(setBalance(Amount, Amount, Amount, Amount, Amount, Amount)));
         connect(_model->getOptionsModel(), SIGNAL(displayUnitChanged(int)),
                 this, SLOT(updateDisplayUnit()));
         updateDisplayUnit();
 
         // Coin Control
         connect(_model->getOptionsModel(), SIGNAL(displayUnitChanged(int)),
                 this, SLOT(coinControlUpdateLabels()));
         connect(_model->getOptionsModel(),
                 SIGNAL(coinControlFeaturesChanged(bool)), this,
                 SLOT(coinControlFeatureChanged(bool)));
         ui->frameCoinControl->setVisible(
             _model->getOptionsModel()->getCoinControlFeatures());
         coinControlUpdateLabels();
 
         // fee section
         connect(ui->groupFee, SIGNAL(buttonClicked(int)), this,
                 SLOT(updateFeeSectionControls()));
         connect(ui->groupFee, SIGNAL(buttonClicked(int)), this,
                 SLOT(coinControlUpdateLabels()));
         connect(ui->groupCustomFee, SIGNAL(buttonClicked(int)), this,
                 SLOT(coinControlUpdateLabels()));
         connect(ui->customFee, SIGNAL(valueChanged()), this,
                 SLOT(coinControlUpdateLabels()));
         connect(ui->checkBoxMinimumFee, SIGNAL(stateChanged(int)), this,
                 SLOT(setMinimumFee()));
         connect(ui->checkBoxMinimumFee, SIGNAL(stateChanged(int)), this,
                 SLOT(updateFeeSectionControls()));
         connect(ui->checkBoxMinimumFee, SIGNAL(stateChanged(int)), this,
                 SLOT(coinControlUpdateLabels()));
 
         ui->customFee->setSingleStep(GetMinimumFee(1000, g_mempool));
         updateFeeSectionControls();
         updateMinFeeLabel();
         updateSmartFeeLabel();
 
         // Cleanup old confirmation target related settings
         // TODO: Remove these in 0.20
         QSettings settings;
         if (settings.value("nSmartFeeSliderPosition").toInt() != 0) {
             settings.remove("nSmartFeeSliderPosition");
         }
         if (settings.value("nConfTarget").toInt() != 0) {
             settings.remove("nConfTarget");
         }
     }
 }
 
 SendCoinsDialog::~SendCoinsDialog() {
     QSettings settings;
     settings.setValue("fFeeSectionMinimized", fFeeMinimized);
     settings.setValue("nFeeRadio", ui->groupFee->checkedId());
     settings.setValue("nCustomFeeRadio", ui->groupCustomFee->checkedId());
     settings.setValue("nTransactionFee",
                       qint64(ui->customFee->value() / SATOSHI));
     settings.setValue("fPayOnlyMinFee", ui->checkBoxMinimumFee->isChecked());
 
     delete ui;
 }
 
 void SendCoinsDialog::on_sendButton_clicked() {
     if (!model || !model->getOptionsModel()) {
         return;
     }
 
     QList<SendCoinsRecipient> recipients;
     bool valid = true;
 
     for (int i = 0; i < ui->entries->count(); ++i) {
         SendCoinsEntry *entry =
             qobject_cast<SendCoinsEntry *>(ui->entries->itemAt(i)->widget());
         if (entry) {
-            if (entry->validate()) {
+            if (entry->validate(model->node())) {
                 recipients.append(entry->getValue());
             } else {
                 valid = false;
             }
         }
     }
 
     if (!valid || recipients.isEmpty()) {
         return;
     }
 
     fNewRecipientAllowed = false;
     WalletModel::UnlockContext ctx(model->requestUnlock());
     if (!ctx.isValid()) {
         // Unlock wallet was cancelled
         fNewRecipientAllowed = true;
         return;
     }
 
     // prepare transaction for getting txFee earlier
     WalletModelTransaction currentTransaction(recipients);
     WalletModel::SendCoinsReturn prepareStatus;
 
     // Always use a CCoinControl instance, use the CoinControlDialog instance if
     // CoinControl has been enabled
     CCoinControl ctrl;
     if (model->getOptionsModel()->getCoinControlFeatures()) {
         ctrl = *CoinControlDialog::coinControl();
     }
 
     updateCoinControlState(ctrl);
 
     prepareStatus = model->prepareTransaction(currentTransaction, ctrl);
 
     // process prepareStatus and on error generate message shown to user
     processSendCoinsReturn(
         prepareStatus,
         BitcoinUnits::formatWithUnit(model->getOptionsModel()->getDisplayUnit(),
                                      currentTransaction.getTransactionFee()));
 
     if (prepareStatus.status != WalletModel::OK) {
         fNewRecipientAllowed = true;
         return;
     }
 
     Amount txFee = currentTransaction.getTransactionFee();
 
     // Format confirmation message
     QStringList formatted;
     for (const SendCoinsRecipient &rcp : currentTransaction.getRecipients()) {
         // generate bold amount string with wallet name in case of multiwallet
         QString amount =
             "<b>" + BitcoinUnits::formatHtmlWithUnit(
                         model->getOptionsModel()->getDisplayUnit(), rcp.amount);
         if (model->isMultiwallet()) {
             amount.append(
                 " <u>" +
                 tr("from wallet %1")
                     .arg(GUIUtil::HtmlEscape(model->getWalletName())) +
                 "</u> ");
         }
         amount.append("</b>");
         // generate monospace address string
         QString address =
             "<span style='font-family: monospace;'>" + rcp.address;
         address.append("</span>");
 
         QString recipientElement;
 
         // normal payment
         if (!rcp.paymentRequest.IsInitialized()) {
             if (rcp.label.length() > 0) {
                 // label with address
                 recipientElement =
                     tr("%1 to %2").arg(amount, GUIUtil::HtmlEscape(rcp.label));
                 recipientElement.append(QString(" (%1)").arg(address));
             } else {
                 // just address
                 recipientElement = tr("%1 to %2").arg(amount, address);
             }
         } else if (!rcp.authenticatedMerchant.isEmpty()) {
             // authenticated payment request
             recipientElement =
                 tr("%1 to %2")
                     .arg(amount,
                          GUIUtil::HtmlEscape(rcp.authenticatedMerchant));
         } else {
             // unauthenticated payment request
             recipientElement = tr("%1 to %2").arg(amount, address);
         }
 
         formatted.append(recipientElement);
     }
 
     QString questionString = tr("Are you sure you want to send?");
     questionString.append("<br /><br />%1");
 
     if (txFee > Amount::zero()) {
         // append fee string if a fee is required
         questionString.append("<hr /><span style='color:#aa0000;'>");
         questionString.append(BitcoinUnits::formatHtmlWithUnit(
             model->getOptionsModel()->getDisplayUnit(), txFee));
         questionString.append("</span> ");
         questionString.append(tr("added as transaction fee"));
 
         // append transaction size
         questionString.append(
             " (" +
             QString::number((double)currentTransaction.getTransactionSize() /
                             1000) +
             " kB)");
     }
 
     // add total amount in all subdivision units
     questionString.append("<hr />");
     Amount totalAmount = currentTransaction.getTotalTransactionAmount() + txFee;
     QStringList alternativeUnits;
     for (BitcoinUnits::Unit u : BitcoinUnits::availableUnits()) {
         if (u != model->getOptionsModel()->getDisplayUnit()) {
             alternativeUnits.append(
                 BitcoinUnits::formatHtmlWithUnit(u, totalAmount));
         }
     }
     questionString.append(
         tr("Total Amount %1")
             .arg(BitcoinUnits::formatHtmlWithUnit(
                 model->getOptionsModel()->getDisplayUnit(), totalAmount)));
     questionString.append(
         QString("<span style='font-size:10pt;font-weight:normal;'><br "
                 "/>(=%2)</span>")
             .arg(alternativeUnits.join(" " + tr("or") + "<br />")));
 
     SendConfirmationDialog confirmationDialog(
         tr("Confirm send coins"), questionString.arg(formatted.join("<br />")),
         SEND_CONFIRM_DELAY, this);
     confirmationDialog.exec();
     QMessageBox::StandardButton retval =
         static_cast<QMessageBox::StandardButton>(confirmationDialog.result());
 
     if (retval != QMessageBox::Yes) {
         fNewRecipientAllowed = true;
         return;
     }
 
     // now send the prepared transaction
     WalletModel::SendCoinsReturn sendStatus =
         model->sendCoins(currentTransaction);
     // process sendStatus and on error generate message shown to user
     processSendCoinsReturn(sendStatus);
 
     if (sendStatus.status == WalletModel::OK) {
         accept();
         CoinControlDialog::coinControl()->UnSelectAll();
         coinControlUpdateLabels();
         Q_EMIT coinsSent(currentTransaction.getWtx()->get().GetId());
     }
     fNewRecipientAllowed = true;
 }
 
 void SendCoinsDialog::clear() {
     // Remove entries until only one left
     while (ui->entries->count()) {
         ui->entries->takeAt(0)->widget()->deleteLater();
     }
     addEntry();
 
     updateTabsAndLabels();
 }
 
 void SendCoinsDialog::reject() {
     clear();
 }
 
 void SendCoinsDialog::accept() {
     clear();
 }
 
 SendCoinsEntry *SendCoinsDialog::addEntry() {
     SendCoinsEntry *entry = new SendCoinsEntry(platformStyle, this);
     entry->setModel(model);
     ui->entries->addWidget(entry);
     connect(entry, SIGNAL(removeEntry(SendCoinsEntry *)), this,
             SLOT(removeEntry(SendCoinsEntry *)));
     connect(entry, SIGNAL(useAvailableBalance(SendCoinsEntry *)), this,
             SLOT(useAvailableBalance(SendCoinsEntry *)));
     connect(entry, SIGNAL(payAmountChanged()), this,
             SLOT(coinControlUpdateLabels()));
     connect(entry, SIGNAL(subtractFeeFromAmountChanged()), this,
             SLOT(coinControlUpdateLabels()));
 
     // Focus the field, so that entry can start immediately
     entry->clear();
     entry->setFocus();
     ui->scrollAreaWidgetContents->resize(
         ui->scrollAreaWidgetContents->sizeHint());
     qApp->processEvents();
     QScrollBar *bar = ui->scrollArea->verticalScrollBar();
     if (bar) {
         bar->setSliderPosition(bar->maximum());
     }
 
     updateTabsAndLabels();
     return entry;
 }
 
 void SendCoinsDialog::updateTabsAndLabels() {
     setupTabChain(0);
     coinControlUpdateLabels();
 }
 
 void SendCoinsDialog::removeEntry(SendCoinsEntry *entry) {
     entry->hide();
 
     // If the last entry is about to be removed add an empty one
     if (ui->entries->count() == 1) {
         addEntry();
     }
 
     entry->deleteLater();
 
     updateTabsAndLabels();
 }
 
 QWidget *SendCoinsDialog::setupTabChain(QWidget *prev) {
     for (int i = 0; i < ui->entries->count(); ++i) {
         SendCoinsEntry *entry =
             qobject_cast<SendCoinsEntry *>(ui->entries->itemAt(i)->widget());
         if (entry) {
             prev = entry->setupTabChain(prev);
         }
     }
     QWidget::setTabOrder(prev, ui->sendButton);
     QWidget::setTabOrder(ui->sendButton, ui->clearButton);
     QWidget::setTabOrder(ui->clearButton, ui->addButton);
     return ui->addButton;
 }
 
 void SendCoinsDialog::setAddress(const QString &address) {
     SendCoinsEntry *entry = 0;
     // Replace the first entry if it is still unused
     if (ui->entries->count() == 1) {
         SendCoinsEntry *first =
             qobject_cast<SendCoinsEntry *>(ui->entries->itemAt(0)->widget());
         if (first->isClear()) {
             entry = first;
         }
     }
     if (!entry) {
         entry = addEntry();
     }
 
     entry->setAddress(address);
 }
 
 void SendCoinsDialog::pasteEntry(const SendCoinsRecipient &rv) {
     if (!fNewRecipientAllowed) {
         return;
     }
 
     SendCoinsEntry *entry = 0;
     // Replace the first entry if it is still unused
     if (ui->entries->count() == 1) {
         SendCoinsEntry *first =
             qobject_cast<SendCoinsEntry *>(ui->entries->itemAt(0)->widget());
         if (first->isClear()) {
             entry = first;
         }
     }
     if (!entry) {
         entry = addEntry();
     }
 
     entry->setValue(rv);
     updateTabsAndLabels();
 }
 
 bool SendCoinsDialog::handlePaymentRequest(const SendCoinsRecipient &rv) {
     // Just paste the entry, all pre-checks are done in paymentserver.cpp.
     pasteEntry(rv);
     return true;
 }
 
 void SendCoinsDialog::setBalance(const Amount balance,
                                  const Amount unconfirmedBalance,
                                  const Amount immatureBalance,
                                  const Amount watchBalance,
                                  const Amount watchUnconfirmedBalance,
                                  const Amount watchImmatureBalance) {
     Q_UNUSED(unconfirmedBalance);
     Q_UNUSED(immatureBalance);
     Q_UNUSED(watchBalance);
     Q_UNUSED(watchUnconfirmedBalance);
     Q_UNUSED(watchImmatureBalance);
 
     if (model && model->getOptionsModel()) {
         ui->labelBalance->setText(BitcoinUnits::formatWithUnit(
             model->getOptionsModel()->getDisplayUnit(), balance));
     }
 }
 
 void SendCoinsDialog::updateDisplayUnit() {
     setBalance(model->wallet().getBalance(), Amount::zero(), Amount::zero(),
                Amount::zero(), Amount::zero(), Amount::zero());
     ui->customFee->setDisplayUnit(model->getOptionsModel()->getDisplayUnit());
     updateMinFeeLabel();
     updateSmartFeeLabel();
 }
 
 void SendCoinsDialog::processSendCoinsReturn(
     const WalletModel::SendCoinsReturn &sendCoinsReturn,
     const QString &msgArg) {
     QPair<QString, CClientUIInterface::MessageBoxFlags> msgParams;
     // Default to a warning message, override if error message is needed
     msgParams.second = CClientUIInterface::MSG_WARNING;
 
     // This comment is specific to SendCoinsDialog usage of
     // WalletModel::SendCoinsReturn.
     // WalletModel::TransactionCommitFailed is used only in
     // WalletModel::sendCoins() all others are used only in
     // WalletModel::prepareTransaction()
     switch (sendCoinsReturn.status) {
         case WalletModel::InvalidAddress:
             msgParams.first =
                 tr("The recipient address is not valid. Please recheck.");
             break;
         case WalletModel::InvalidAmount:
             msgParams.first = tr("The amount to pay must be larger than 0.");
             break;
         case WalletModel::AmountExceedsBalance:
             msgParams.first = tr("The amount exceeds your balance.");
             break;
         case WalletModel::AmountWithFeeExceedsBalance:
             msgParams.first = tr("The total exceeds your balance when the %1 "
                                  "transaction fee is included.")
                                   .arg(msgArg);
             break;
         case WalletModel::DuplicateAddress:
             msgParams.first = tr("Duplicate address found: addresses should "
                                  "only be used once each.");
             break;
         case WalletModel::TransactionCreationFailed:
             msgParams.first = tr("Transaction creation failed!");
             msgParams.second = CClientUIInterface::MSG_ERROR;
             break;
         case WalletModel::TransactionCommitFailed:
             msgParams.first =
                 tr("The transaction was rejected with the following reason: %1")
                     .arg(sendCoinsReturn.reasonCommitFailed);
             msgParams.second = CClientUIInterface::MSG_ERROR;
             break;
         case WalletModel::AbsurdFee:
             msgParams.first =
                 tr("A fee higher than %1 is considered an absurdly high fee.")
                     .arg(BitcoinUnits::formatWithUnit(
                         model->getOptionsModel()->getDisplayUnit(), maxTxFee));
             break;
         case WalletModel::PaymentRequestExpired:
             msgParams.first = tr("Payment request expired.");
             msgParams.second = CClientUIInterface::MSG_ERROR;
             break;
         // included to prevent a compiler warning.
         case WalletModel::OK:
         default:
             return;
     }
 
     Q_EMIT message(tr("Send Coins"), msgParams.first, msgParams.second);
 }
 
 void SendCoinsDialog::minimizeFeeSection(bool fMinimize) {
     ui->labelFeeMinimized->setVisible(fMinimize);
     ui->buttonChooseFee->setVisible(fMinimize);
     ui->buttonMinimizeFee->setVisible(!fMinimize);
     ui->frameFeeSelection->setVisible(!fMinimize);
     ui->horizontalLayoutSmartFee->setContentsMargins(0, (fMinimize ? 0 : 6), 0,
                                                      0);
     fFeeMinimized = fMinimize;
 }
 
 void SendCoinsDialog::on_buttonChooseFee_clicked() {
     minimizeFeeSection(false);
 }
 
 void SendCoinsDialog::on_buttonMinimizeFee_clicked() {
     updateFeeMinimizedLabel();
     minimizeFeeSection(true);
 }
 
 void SendCoinsDialog::useAvailableBalance(SendCoinsEntry *entry) {
     // Get CCoinControl instance if CoinControl is enabled or create a new one.
     CCoinControl coin_control;
     if (model->getOptionsModel()->getCoinControlFeatures()) {
         coin_control = *CoinControlDialog::coinControl();
     }
 
     // Calculate available amount to send.
     Amount amount = model->wallet().getAvailableBalance(coin_control);
     for (int i = 0; i < ui->entries->count(); ++i) {
         SendCoinsEntry *e =
             qobject_cast<SendCoinsEntry *>(ui->entries->itemAt(i)->widget());
         if (e && !e->isHidden() && e != entry) {
             amount -= e->getValue().amount;
         }
     }
 
     if (amount > Amount::zero()) {
         entry->checkSubtractFeeFromAmount();
         entry->setAmount(amount);
     } else {
         entry->setAmount(Amount::zero());
     }
 }
 
 void SendCoinsDialog::setMinimumFee() {
     ui->radioCustomPerKilobyte->setChecked(true);
     ui->customFee->setValue(GetMinimumFee(1000, g_mempool));
 }
 
 void SendCoinsDialog::updateFeeSectionControls() {
     ui->labelSmartFee->setEnabled(ui->radioSmartFee->isChecked());
     ui->labelSmartFee2->setEnabled(ui->radioSmartFee->isChecked());
     ui->labelFeeEstimation->setEnabled(ui->radioSmartFee->isChecked());
     ui->checkBoxMinimumFee->setEnabled(ui->radioCustomFee->isChecked());
     ui->labelMinFeeWarning->setEnabled(ui->radioCustomFee->isChecked());
     ui->radioCustomPerKilobyte->setEnabled(
         ui->radioCustomFee->isChecked() &&
         !ui->checkBoxMinimumFee->isChecked());
     ui->customFee->setEnabled(ui->radioCustomFee->isChecked() &&
                               !ui->checkBoxMinimumFee->isChecked());
 }
 
 void SendCoinsDialog::updateFeeMinimizedLabel() {
     if (!model || !model->getOptionsModel()) {
         return;
     }
 
     if (ui->radioSmartFee->isChecked()) {
         ui->labelFeeMinimized->setText(ui->labelSmartFee->text());
     } else {
         ui->labelFeeMinimized->setText(
             BitcoinUnits::formatWithUnit(
                 model->getOptionsModel()->getDisplayUnit(),
                 ui->customFee->value()) +
             ((ui->radioCustomPerKilobyte->isChecked()) ? "/kB" : ""));
     }
 }
 
 void SendCoinsDialog::updateMinFeeLabel() {
     if (model && model->getOptionsModel()) {
         ui->checkBoxMinimumFee->setText(
             tr("Pay only the required fee of %1")
                 .arg(BitcoinUnits::formatWithUnit(
                          model->getOptionsModel()->getDisplayUnit(),
                          GetMinimumFee(1000, g_mempool)) +
                      "/kB"));
     }
 }
 
 void SendCoinsDialog::updateCoinControlState(CCoinControl &ctrl) {
     if (ui->radioCustomFee->isChecked()) {
         ctrl.m_feerate = CFeeRate(ui->customFee->value());
     } else {
         ctrl.m_feerate.reset();
     }
 }
 
 void SendCoinsDialog::updateSmartFeeLabel() {
     if (!model || !model->getOptionsModel()) {
         return;
     }
 
     CFeeRate feeRate = g_mempool.estimateFee();
 
     ui->labelSmartFee->setText(
         BitcoinUnits::formatWithUnit(
             model->getOptionsModel()->getDisplayUnit(),
             std::max(feeRate.GetFeePerK(), GetMinimumFee(1000, g_mempool))) +
         "/kB");
     // not enough data => minfee
     if (feeRate <= CFeeRate(Amount::zero())) {
         // (Smart fee not initialized yet. This usually takes a few blocks...)
         ui->labelSmartFee2->show();
         ui->labelFeeEstimation->setText("");
     } else {
         ui->labelSmartFee2->hide();
         ui->labelFeeEstimation->setText(
             tr("Estimated to begin confirmation by next block."));
     }
 
     updateFeeMinimizedLabel();
 }
 
 // Coin Control: copy label "Quantity" to clipboard
 void SendCoinsDialog::coinControlClipboardQuantity() {
     GUIUtil::setClipboard(ui->labelCoinControlQuantity->text());
 }
 
 // Coin Control: copy label "Amount" to clipboard
 void SendCoinsDialog::coinControlClipboardAmount() {
     GUIUtil::setClipboard(ui->labelCoinControlAmount->text().left(
         ui->labelCoinControlAmount->text().indexOf(" ")));
 }
 
 // Coin Control: copy label "Fee" to clipboard
 void SendCoinsDialog::coinControlClipboardFee() {
     GUIUtil::setClipboard(
         ui->labelCoinControlFee->text()
             .left(ui->labelCoinControlFee->text().indexOf(" "))
             .replace(ASYMP_UTF8, ""));
 }
 
 // Coin Control: copy label "After fee" to clipboard
 void SendCoinsDialog::coinControlClipboardAfterFee() {
     GUIUtil::setClipboard(
         ui->labelCoinControlAfterFee->text()
             .left(ui->labelCoinControlAfterFee->text().indexOf(" "))
             .replace(ASYMP_UTF8, ""));
 }
 
 // Coin Control: copy label "Bytes" to clipboard
 void SendCoinsDialog::coinControlClipboardBytes() {
     GUIUtil::setClipboard(
         ui->labelCoinControlBytes->text().replace(ASYMP_UTF8, ""));
 }
 
 // Coin Control: copy label "Dust" to clipboard
 void SendCoinsDialog::coinControlClipboardLowOutput() {
     GUIUtil::setClipboard(ui->labelCoinControlLowOutput->text());
 }
 
 // Coin Control: copy label "Change" to clipboard
 void SendCoinsDialog::coinControlClipboardChange() {
     GUIUtil::setClipboard(
         ui->labelCoinControlChange->text()
             .left(ui->labelCoinControlChange->text().indexOf(" "))
             .replace(ASYMP_UTF8, ""));
 }
 
 // Coin Control: settings menu - coin control enabled/disabled by user
 void SendCoinsDialog::coinControlFeatureChanged(bool checked) {
     ui->frameCoinControl->setVisible(checked);
 
     // coin control features disabled
     if (!checked && model) {
         CoinControlDialog::coinControl()->SetNull();
     }
 
     coinControlUpdateLabels();
 }
 
 // Coin Control: button inputs -> show actual coin control dialog
 void SendCoinsDialog::coinControlButtonClicked() {
     CoinControlDialog dlg(platformStyle);
     dlg.setModel(model);
     dlg.exec();
     coinControlUpdateLabels();
 }
 
 // Coin Control: checkbox custom change address
 void SendCoinsDialog::coinControlChangeChecked(int state) {
     if (state == Qt::Unchecked) {
         CoinControlDialog::coinControl()->destChange = CNoDestination();
         ui->labelCoinControlChangeLabel->clear();
     } else {
         // use this to re-validate an already entered address
         coinControlChangeEdited(ui->lineEditCoinControlChange->text());
     }
 
     ui->lineEditCoinControlChange->setEnabled((state == Qt::Checked));
 }
 
 // Coin Control: custom change address changed
 void SendCoinsDialog::coinControlChangeEdited(const QString &text) {
     if (model && model->getAddressTableModel()) {
         // Default to no change address until verified
         CoinControlDialog::coinControl()->destChange = CNoDestination();
         ui->labelCoinControlChangeLabel->setStyleSheet("QLabel{color:red;}");
 
         const CTxDestination dest =
             DecodeDestination(text.toStdString(), model->getChainParams());
 
         if (text.isEmpty()) {
             // Nothing entered
             ui->labelCoinControlChangeLabel->setText("");
         } else if (!IsValidDestination(dest)) {
             // Invalid address
             ui->labelCoinControlChangeLabel->setText(
                 tr("Warning: Invalid Bitcoin address"));
         } else {
             // Valid address
             if (!model->wallet().isSpendable(dest)) {
                 ui->labelCoinControlChangeLabel->setText(
                     tr("Warning: Unknown change address"));
 
                 // confirmation dialog
                 QMessageBox::StandardButton btnRetVal = QMessageBox::question(
                     this, tr("Confirm custom change address"),
                     tr("The address you selected for change is not part of "
                        "this wallet. Any or all funds in your wallet may be "
                        "sent to this address. Are you sure?"),
                     QMessageBox::Yes | QMessageBox::Cancel,
                     QMessageBox::Cancel);
 
                 if (btnRetVal == QMessageBox::Yes) {
                     CoinControlDialog::coinControl()->destChange = dest;
                 } else {
                     ui->lineEditCoinControlChange->setText("");
                     ui->labelCoinControlChangeLabel->setStyleSheet(
                         "QLabel{color:black;}");
                     ui->labelCoinControlChangeLabel->setText("");
                 }
             } else {
                 // Known change address
                 ui->labelCoinControlChangeLabel->setStyleSheet(
                     "QLabel{color:black;}");
 
                 // Query label
                 QString associatedLabel =
                     model->getAddressTableModel()->labelForAddress(text);
                 if (!associatedLabel.isEmpty()) {
                     ui->labelCoinControlChangeLabel->setText(associatedLabel);
                 } else {
                     ui->labelCoinControlChangeLabel->setText(tr("(no label)"));
                 }
 
                 CoinControlDialog::coinControl()->destChange = dest;
             }
         }
     }
 }
 
 // Coin Control: update labels
 void SendCoinsDialog::coinControlUpdateLabels() {
     if (!model || !model->getOptionsModel()) {
         return;
     }
 
     updateCoinControlState(*CoinControlDialog::coinControl());
 
     // set pay amounts
     CoinControlDialog::payAmounts.clear();
     CoinControlDialog::fSubtractFeeFromAmount = false;
     for (int i = 0; i < ui->entries->count(); ++i) {
         SendCoinsEntry *entry =
             qobject_cast<SendCoinsEntry *>(ui->entries->itemAt(i)->widget());
         if (entry && !entry->isHidden()) {
             SendCoinsRecipient rcp = entry->getValue();
             CoinControlDialog::payAmounts.append(rcp.amount);
             if (rcp.fSubtractFeeFromAmount) {
                 CoinControlDialog::fSubtractFeeFromAmount = true;
             }
         }
     }
 
     if (CoinControlDialog::coinControl()->HasSelected()) {
         // actual coin control calculation
         CoinControlDialog::updateLabels(model, this);
 
         // show coin control stats
         ui->labelCoinControlAutomaticallySelected->hide();
         ui->widgetCoinControl->show();
     } else {
         // hide coin control stats
         ui->labelCoinControlAutomaticallySelected->show();
         ui->widgetCoinControl->hide();
         ui->labelCoinControlInsuffFunds->hide();
     }
 }
 
 SendConfirmationDialog::SendConfirmationDialog(const QString &title,
                                                const QString &text,
                                                int _secDelay, QWidget *parent)
     : QMessageBox(QMessageBox::Question, title, text,
                   QMessageBox::Yes | QMessageBox::Cancel, parent),
       secDelay(_secDelay) {
     setDefaultButton(QMessageBox::Cancel);
     yesButton = button(QMessageBox::Yes);
     updateYesButton();
     connect(&countDownTimer, SIGNAL(timeout()), this, SLOT(countDown()));
 }
 
 int SendConfirmationDialog::exec() {
     updateYesButton();
     countDownTimer.start(1000);
     return QMessageBox::exec();
 }
 
 void SendConfirmationDialog::countDown() {
     secDelay--;
     updateYesButton();
 
     if (secDelay <= 0) {
         countDownTimer.stop();
     }
 }
 
 void SendConfirmationDialog::updateYesButton() {
     if (secDelay > 0) {
         yesButton->setEnabled(false);
         yesButton->setText(tr("Yes") + " (" + QString::number(secDelay) + ")");
     } else {
         yesButton->setEnabled(true);
         yesButton->setText(tr("Yes"));
     }
 }
diff --git a/src/qt/sendcoinsentry.cpp b/src/qt/sendcoinsentry.cpp
index d61ff54828..2e43554a93 100644
--- a/src/qt/sendcoinsentry.cpp
+++ b/src/qt/sendcoinsentry.cpp
@@ -1,278 +1,279 @@
 // 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 "sendcoinsentry.h"
-#include "ui_sendcoinsentry.h"
+#include <qt/forms/ui_sendcoinsentry.h>
+#include <qt/sendcoinsentry.h>
 
-#include "addressbookpage.h"
-#include "addresstablemodel.h"
-#include "config.h"
-#include "guiutil.h"
-#include "optionsmodel.h"
-#include "platformstyle.h"
-#include "walletmodel.h"
+#include <config.h>
+#include <qt/addressbookpage.h>
+#include <qt/addresstablemodel.h>
+#include <qt/guiutil.h>
+#include <qt/optionsmodel.h>
+#include <qt/platformstyle.h>
+#include <qt/walletmodel.h>
 
 #include <QApplication>
 #include <QClipboard>
 
 SendCoinsEntry::SendCoinsEntry(const PlatformStyle *_platformStyle,
                                QWidget *parent)
     : QStackedWidget(parent), ui(new Ui::SendCoinsEntry), model(0),
       platformStyle(_platformStyle) {
     ui->setupUi(this);
 
     ui->addressBookButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/address-book"));
     ui->pasteButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/editpaste"));
     ui->deleteButton->setIcon(platformStyle->SingleColorIcon(":/icons/remove"));
     ui->deleteButton_is->setIcon(
         platformStyle->SingleColorIcon(":/icons/remove"));
     ui->deleteButton_s->setIcon(
         platformStyle->SingleColorIcon(":/icons/remove"));
 
     ui->messageTextLabel->setToolTip(
         tr("A message that was attached to the %1 URI which will be"
            " stored with the transaction for your reference. Note: "
            "This message will not be sent over the Bitcoin network.")
             .arg(GUIUtil::bitcoinURIScheme(GetConfig())));
 
     setCurrentWidget(ui->SendCoins);
 
     if (platformStyle->getUseExtraSpacing()) ui->payToLayout->setSpacing(4);
     ui->addAsLabel->setPlaceholderText(
         tr("Enter a label for this address to add it to your address book"));
 
     // normal bitcoin address field
     GUIUtil::setupAddressWidget(ui->payTo, this);
     // just a label for displaying bitcoin address(es)
     ui->payTo_is->setFont(GUIUtil::fixedPitchFont());
 
     // Connect signals
     connect(ui->payAmount, SIGNAL(valueChanged()), this,
             SIGNAL(payAmountChanged()));
     connect(ui->checkboxSubtractFeeFromAmount, SIGNAL(toggled(bool)), this,
             SIGNAL(subtractFeeFromAmountChanged()));
     connect(ui->deleteButton, SIGNAL(clicked()), this, SLOT(deleteClicked()));
     connect(ui->deleteButton_is, SIGNAL(clicked()), this,
             SLOT(deleteClicked()));
     connect(ui->deleteButton_s, SIGNAL(clicked()), this, SLOT(deleteClicked()));
     connect(ui->useAvailableBalanceButton, SIGNAL(clicked()), this,
             SLOT(useAvailableBalanceClicked()));
 }
 
 SendCoinsEntry::~SendCoinsEntry() {
     delete ui;
 }
 
 void SendCoinsEntry::on_pasteButton_clicked() {
     // Paste text from clipboard into recipient field
     ui->payTo->setText(QApplication::clipboard()->text());
 }
 
 void SendCoinsEntry::on_addressBookButton_clicked() {
     if (!model) return;
     AddressBookPage dlg(platformStyle, AddressBookPage::ForSelection,
                         AddressBookPage::SendingTab, this);
     dlg.setModel(model->getAddressTableModel());
     if (dlg.exec()) {
         ui->payTo->setText(dlg.getReturnValue());
         ui->payAmount->setFocus();
     }
 }
 
 void SendCoinsEntry::on_payTo_textChanged(const QString &address) {
     updateLabel(address);
 }
 
 void SendCoinsEntry::setModel(WalletModel *_model) {
     this->model = _model;
 
     if (_model && _model->getOptionsModel())
         connect(_model->getOptionsModel(), SIGNAL(displayUnitChanged(int)),
                 this, SLOT(updateDisplayUnit()));
 
     clear();
 }
 
 void SendCoinsEntry::clear() {
     // clear UI elements for normal payment
     ui->payTo->clear();
     ui->addAsLabel->clear();
     ui->payAmount->clear();
     ui->checkboxSubtractFeeFromAmount->setCheckState(Qt::Unchecked);
     ui->messageTextLabel->clear();
     ui->messageTextLabel->hide();
     ui->messageLabel->hide();
     // clear UI elements for unauthenticated payment request
     ui->payTo_is->clear();
     ui->memoTextLabel_is->clear();
     ui->payAmount_is->clear();
     // clear UI elements for authenticated payment request
     ui->payTo_s->clear();
     ui->memoTextLabel_s->clear();
     ui->payAmount_s->clear();
 
     // update the display unit, to not use the default ("BCH")
     updateDisplayUnit();
 }
 
 void SendCoinsEntry::checkSubtractFeeFromAmount() {
     ui->checkboxSubtractFeeFromAmount->setChecked(true);
 }
 
 void SendCoinsEntry::deleteClicked() {
     Q_EMIT removeEntry(this);
 }
 
 void SendCoinsEntry::useAvailableBalanceClicked() {
     Q_EMIT useAvailableBalance(this);
 }
 
-bool SendCoinsEntry::validate() {
+bool SendCoinsEntry::validate(interfaces::Node &node) {
     if (!model) {
         return false;
     }
 
     // Check input validity
     bool retval = true;
 
     // Skip checks for payment request
     if (recipient.paymentRequest.IsInitialized()) {
         return retval;
     }
 
     if (!model->validateAddress(ui->payTo->text())) {
         ui->payTo->setValid(false);
         retval = false;
     }
 
     if (!ui->payAmount->validate()) {
         retval = false;
     }
 
     // Sending a zero amount is invalid
     if (ui->payAmount->value(0) <= Amount::zero()) {
         ui->payAmount->setValid(false);
         retval = false;
     }
 
     // Reject dust outputs:
-    if (retval && GUIUtil::isDust(ui->payTo->text(), ui->payAmount->value(),
-                                  model->getChainParams())) {
+    if (retval &&
+        GUIUtil::isDust(node, ui->payTo->text(), ui->payAmount->value(),
+                        model->getChainParams())) {
         ui->payAmount->setValid(false);
         retval = false;
     }
 
     return retval;
 }
 
 SendCoinsRecipient SendCoinsEntry::getValue() {
     // Payment request
     if (recipient.paymentRequest.IsInitialized()) return recipient;
 
     // Normal payment
     recipient.address = ui->payTo->text();
     recipient.label = ui->addAsLabel->text();
     recipient.amount = ui->payAmount->value();
     recipient.message = ui->messageTextLabel->text();
     recipient.fSubtractFeeFromAmount =
         (ui->checkboxSubtractFeeFromAmount->checkState() == Qt::Checked);
 
     return recipient;
 }
 
 QWidget *SendCoinsEntry::setupTabChain(QWidget *prev) {
     QWidget::setTabOrder(prev, ui->payTo);
     QWidget::setTabOrder(ui->payTo, ui->addAsLabel);
     QWidget *w = ui->payAmount->setupTabChain(ui->addAsLabel);
     QWidget::setTabOrder(w, ui->checkboxSubtractFeeFromAmount);
     QWidget::setTabOrder(ui->checkboxSubtractFeeFromAmount,
                          ui->addressBookButton);
     QWidget::setTabOrder(ui->addressBookButton, ui->pasteButton);
     QWidget::setTabOrder(ui->pasteButton, ui->deleteButton);
     return ui->deleteButton;
 }
 
 void SendCoinsEntry::setValue(const SendCoinsRecipient &value) {
     recipient = value;
 
     if (recipient.paymentRequest.IsInitialized()) // payment request
     {
         if (recipient.authenticatedMerchant.isEmpty()) // unauthenticated
         {
             ui->payTo_is->setText(recipient.address);
             ui->memoTextLabel_is->setText(recipient.message);
             ui->payAmount_is->setValue(recipient.amount);
             ui->payAmount_is->setReadOnly(true);
             setCurrentWidget(ui->SendCoins_UnauthenticatedPaymentRequest);
         } else // authenticated
         {
             ui->payTo_s->setText(recipient.authenticatedMerchant);
             ui->memoTextLabel_s->setText(recipient.message);
             ui->payAmount_s->setValue(recipient.amount);
             ui->payAmount_s->setReadOnly(true);
             setCurrentWidget(ui->SendCoins_AuthenticatedPaymentRequest);
         }
     } else // normal payment
     {
         // message
         ui->messageTextLabel->setText(recipient.message);
         ui->messageTextLabel->setVisible(!recipient.message.isEmpty());
         ui->messageLabel->setVisible(!recipient.message.isEmpty());
 
         ui->addAsLabel->clear();
         ui->payTo->setText(
             recipient.address);         // this may set a label from addressbook
         if (!recipient.label.isEmpty()) // if a label had been set from the
                                         // addressbook, don't overwrite with an
                                         // empty label
             ui->addAsLabel->setText(recipient.label);
         ui->payAmount->setValue(recipient.amount);
     }
 }
 
 void SendCoinsEntry::setAddress(const QString &address) {
     ui->payTo->setText(address);
     ui->payAmount->setFocus();
 }
 
 void SendCoinsEntry::setAmount(const Amount amount) {
     ui->payAmount->setValue(amount);
 }
 
 bool SendCoinsEntry::isClear() {
     return ui->payTo->text().isEmpty() && ui->payTo_is->text().isEmpty() &&
            ui->payTo_s->text().isEmpty();
 }
 
 void SendCoinsEntry::setFocus() {
     ui->payTo->setFocus();
 }
 
 void SendCoinsEntry::updateDisplayUnit() {
     if (model && model->getOptionsModel()) {
         // Update payAmount with the current unit
         ui->payAmount->setDisplayUnit(
             model->getOptionsModel()->getDisplayUnit());
         ui->payAmount_is->setDisplayUnit(
             model->getOptionsModel()->getDisplayUnit());
         ui->payAmount_s->setDisplayUnit(
             model->getOptionsModel()->getDisplayUnit());
     }
 }
 
 bool SendCoinsEntry::updateLabel(const QString &address) {
     if (!model) return false;
 
     // Fill in label from address book, if address has an associated label
     QString associatedLabel =
         model->getAddressTableModel()->labelForAddress(address);
     if (!associatedLabel.isEmpty()) {
         ui->addAsLabel->setText(associatedLabel);
         return true;
     }
 
     return false;
 }
diff --git a/src/qt/sendcoinsentry.h b/src/qt/sendcoinsentry.h
index d9c8017fc7..7dcfe52769 100644
--- a/src/qt/sendcoinsentry.h
+++ b/src/qt/sendcoinsentry.h
@@ -1,78 +1,78 @@
 // Copyright (c) 2011-2015 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_SENDCOINSENTRY_H
 #define BITCOIN_QT_SENDCOINSENTRY_H
 
-#include "walletmodel.h"
+#include <qt/walletmodel.h>
 
 #include <QStackedWidget>
 
 class WalletModel;
 class PlatformStyle;
 
 namespace Ui {
 class SendCoinsEntry;
 }
 
 /**
  * A single entry in the dialog for sending bitcoins.
  * Stacked widget, with different UIs for payment requests
  * with a strong payee identity.
  */
 class SendCoinsEntry : public QStackedWidget {
     Q_OBJECT
 
 public:
     explicit SendCoinsEntry(const PlatformStyle *platformStyle,
                             QWidget *parent = 0);
     ~SendCoinsEntry();
 
     void setModel(WalletModel *model);
-    bool validate();
+    bool validate(interfaces::Node &node);
     SendCoinsRecipient getValue();
 
     /** Return whether the entry is still empty and unedited */
     bool isClear();
 
     void setValue(const SendCoinsRecipient &value);
     void setAddress(const QString &address);
     void setAmount(const Amount amount);
 
     /** Set up the tab chain manually, as Qt messes up the tab chain by default
      * in some cases
      *  (issue https://bugreports.qt-project.org/browse/QTBUG-10907).
      */
     QWidget *setupTabChain(QWidget *prev);
 
     void setFocus();
 
 public Q_SLOTS:
     void clear();
     void checkSubtractFeeFromAmount();
 
 Q_SIGNALS:
     void removeEntry(SendCoinsEntry *entry);
     void useAvailableBalance(SendCoinsEntry *entry);
     void payAmountChanged();
     void subtractFeeFromAmountChanged();
 
 private Q_SLOTS:
     void deleteClicked();
     void useAvailableBalanceClicked();
     void on_payTo_textChanged(const QString &address);
     void on_addressBookButton_clicked();
     void on_pasteButton_clicked();
     void updateDisplayUnit();
 
 private:
     SendCoinsRecipient recipient;
     Ui::SendCoinsEntry *ui;
     WalletModel *model;
     const PlatformStyle *platformStyle;
 
     bool updateLabel(const QString &address);
 };
 
 #endif // BITCOIN_QT_SENDCOINSENTRY_H