diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
index c8dc0674f..2df67636c 100644
--- a/src/qt/guiutil.cpp
+++ b/src/qt/guiutil.cpp
@@ -1,1002 +1,1001 @@
 // 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/guiutil.h>
 
 #include <cashaddrenc.h>
 #include <chainparams.h>
 #include <interfaces/node.h>
 #include <key_io.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/sendcoinsrecipient.h>
-#include <qt/walletmodel.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <util/strencodings.h>
 #include <util/system.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>
 #endif
 
 #include <QAbstractItemView>
 #include <QApplication>
 #include <QClipboard>
 #include <QDateTime>
 #include <QDesktopServices>
 #include <QDoubleValidator>
 #include <QFileDialog>
 #include <QFont>
 #include <QFontDatabase>
 #include <QFontMetrics>
 #include <QKeyEvent>
 #include <QLineEdit>
 #include <QMouseEvent>
 #include <QProgressDialog>
 #include <QSettings>
 #include <QTextDocument> // for Qt::mightBeRichText
 #include <QThread>
 #include <QUrlQuery>
 
 #if defined(Q_OS_MAC)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 
 #include <CoreServices/CoreServices.h>
 
 void ForceActivation();
 #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() {
     return QFontDatabase::systemFont(QFontDatabase::FixedFont);
 }
 
 static std::string MakeAddrInvalid(std::string addr,
                                    const CChainParams &params) {
     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, params)) {
         return addr;
     }
 
     return "";
 }
 
 std::string DummyAddress(const CChainParams &params) {
     // Just some dummy data to generate a 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 = PKHash(uint160(dummydata));
     return MakeAddrInvalid(EncodeCashAddr(dstKey, params), params);
 }
 
 // Addresses are stored in the database with the encoding that the client was
 // configured with at the time of creation.
 //
 // This converts to cashaddr.
 QString convertToCashAddr(const CChainParams &params, const QString &addr) {
     if (!IsValidDestinationString(addr.toStdString(), params)) {
         // We have something sketchy as input. Do not try to convert.
         return addr;
     }
     CTxDestination dst = DecodeDestination(addr.toStdString(), params);
     return QString::fromStdString(EncodeCashAddr(dst, params));
 }
 
 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(Params()))));
     widget->setValidator(
         new BitcoinAddressEntryValidator(Params().CashAddrPrefix(), parent));
     widget->setCheckValidator(new BitcoinAddressCheckValidator(parent));
 }
 
 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;
     rv.address = uri.scheme() + ":" + 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 SendCoinsRecipient &info) {
     return formatBitcoinURI(Params(), info);
 }
 
 QString formatBitcoinURI(const CChainParams &params,
                          const SendCoinsRecipient &info) {
     QString ret = convertToCashAddr(params, info.address);
     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(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 IsDust(txOut, 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->window() == 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 bringToFront(QWidget *w) {
 #ifdef Q_OS_MAC
     ForceActivation();
 #endif
 
     if (w) {
         // activateWindow() (sometimes) helps with keyboard focus on Windows
         if (w->isMinimized()) {
             w->showNormal();
         } else {
             w->show();
         }
         w->activateWindow();
         w->raise();
     }
 }
 
 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)));
     }
 }
 
 bool openBitcoinConf() {
     fs::path pathConfig =
         GetConfigFile(gArgs.GetArg("-conf", BITCOIN_CONF_FILENAME));
 
     /* Create the file */
     fsbridge::ofstream configFile(pathConfig, std::ios_base::app);
 
     if (!configFile.good()) {
         return false;
     }
 
     configFile.close();
 
     /* Open bitcoin.conf with the associated application */
     return QDesktopServices::openUrl(
         QUrl::fromLocalFile(boostPathToQString(pathConfig)));
 }
 
 QStringList splitSkipEmptyParts(const QString &s, const QString &separator) {
     return s.split(separator,
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
                    Qt::SkipEmptyParts
 #else
                    QString::SkipEmptyParts
 #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(), &QHeaderView::sectionResized, this,
             &TableViewLastColumnResizingFixer::on_sectionResized);
     connect(tableView->horizontalHeader(), &QHeaderView::geometriesChanged,
             this, &TableViewLastColumnResizingFixer::on_geometriesChanged);
 }
 
 // We need to disconnect these while handling the resize events, otherwise we
 // can enter infinite loops.
 void TableViewLastColumnResizingFixer::disconnectViewHeadersSignals() {
     disconnect(tableView->horizontalHeader(), &QHeaderView::sectionResized,
                this, &TableViewLastColumnResizingFixer::on_sectionResized);
     disconnect(tableView->horizontalHeader(), &QHeaderView::geometriesChanged,
                this, &TableViewLastColumnResizingFixer::on_geometriesChanged);
 } // namespace GUIUtil
 
 // 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.
         IShellLinkW *psl = nullptr;
         HRESULT hres =
             CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_INPROC_SERVER,
                              IID_IShellLinkW, reinterpret_cast<void **>(&psl));
 
         if (SUCCEEDED(hres)) {
             // Get the current executable path
             WCHAR pszExePath[MAX_PATH];
             GetModuleFileNameW(nullptr, pszExePath, ARRAYSIZE(pszExePath));
 
             // Start client minimized
             QString strArgs = "-min";
             // Set -testnet /-regtest options
             strArgs += QString::fromStdString(
                 strprintf(" -chain=%s", gArgs.GetChainName()));
 
             // Set the path to the shortcut target
             psl->SetPath(pszExePath);
             PathRemoveFileSpecW(pszExePath);
             psl->SetWorkingDirectory(pszExePath);
             psl->SetShowCmd(SW_SHOWMINNOACTIVE);
             psl->SetArguments(strArgs.toStdWString().c_str());
 
             // 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)) {
                 // Save the link by calling IPersistFile::Save.
                 hres = ppf->Save(StartupShortcutPath().wstring().c_str(), 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() {
     fsbridge::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];
         ssize_t r =
             readlink("/proc/self/exe", pszExePath, sizeof(pszExePath) - 1);
         if (r == -1) {
             return false;
         }
         pszExePath[r] = '\0';
 
         fs::create_directories(GetAutostartDir());
 
         fsbridge::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 -chain=%s\n", chain);
         optionFile << "Terminal=false\n";
         optionFile << "Hidden=false\n";
         optionFile.close();
     }
     return true;
 }
 
 #elif defined(Q_OS_MAC)
 // 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());
 }
 
 QString boostPathToQString(const fs::path &path) {
     return QString::fromStdString(path.string());
 }
 
 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(int64_t ping_usec) {
     return (ping_usec == std::numeric_limits<int64_t>::max() || ping_usec == 0)
                ? QObject::tr("N/A")
                : QString(QObject::tr("%1 ms"))
                      .arg(QString::number(int(ping_usec / 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);
 }
 
 bool ClickableLabel::hasPixmap() const {
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 15, 0))
     return !pixmap(Qt::ReturnByValue).isNull();
 #else
     return pixmap() != nullptr;
 #endif
 }
 
 qreal calculateIdealFontSize(int width, const QString &text, QFont font,
                              qreal minPointSize, qreal font_size) {
     while (font_size >= minPointSize) {
         font.setPointSizeF(font_size);
         QFontMetrics fm(font);
         if (GUIUtil::TextWidth(fm, text) < width) {
             break;
         }
         font_size -= 0.5;
     }
     return font_size;
 }
 
 void ClickableLabel::mouseReleaseEvent(QMouseEvent *event) {
     Q_EMIT clicked(event->pos());
 }
 
 void ClickableProgressBar::mouseReleaseEvent(QMouseEvent *event) {
     Q_EMIT clicked(event->pos());
 }
 
 bool ItemDelegate::eventFilter(QObject *object, QEvent *event) {
     if (event->type() == QEvent::KeyPress) {
         if (static_cast<QKeyEvent *>(event)->key() == Qt::Key_Escape) {
             Q_EMIT keyEscapePressed();
         }
     }
     return QItemDelegate::eventFilter(object, event);
 }
 
 int TextWidth(const QFontMetrics &fm, const QString &text) {
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 11, 0))
     return fm.horizontalAdvance(text);
 #else
     return fm.width(text);
 #endif
 }
 
 void PolishProgressDialog(QProgressDialog *dialog) {
 #ifdef Q_OS_MAC
     // Workaround for macOS-only Qt bug; see: QTBUG-65750, QTBUG-70357.
     const int margin = dialog->fontMetrics().width("X");
     dialog->resize(dialog->width() + 2 * margin, dialog->height());
     dialog->show();
 #else
     Q_UNUSED(dialog);
 #endif
 }
 
 } // namespace GUIUtil
diff --git a/src/qt/paymentserver.cpp b/src/qt/paymentserver.cpp
index 08a072a94..d08b2a6a3 100644
--- a/src/qt/paymentserver.cpp
+++ b/src/qt/paymentserver.cpp
@@ -1,914 +1,914 @@
 // 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/paymentserver.h>
 
 #include <cashaddrenc.h>
 #include <chainparams.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <policy/policy.h>
 #include <qt/bitcoinunits.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 #include <ui_interface.h>
 #include <util/system.h>
 #include <wallet/wallet.h>
 
 #include <openssl/x509_vfy.h>
 
 #include <QApplication>
 #include <QByteArray>
 #include <QDataStream>
 #include <QDateTime>
 #include <QDebug>
 #include <QFile>
 #include <QFileOpenEvent>
 #include <QHash>
 #include <QList>
 #include <QLocalServer>
 #include <QLocalSocket>
 #include <QNetworkAccessManager>
 #include <QNetworkProxy>
 #include <QNetworkReply>
 #include <QNetworkRequest>
 #include <QSslCertificate>
 #include <QSslConfiguration>
 #include <QSslError>
 #include <QStringList>
 #include <QTextDocument>
 #include <QUrlQuery>
 
 #include <cstdlib>
 #include <memory>
 
 const int BITCOIN_IPC_CONNECT_TIMEOUT = 1000; // milliseconds
 #ifdef ENABLE_BIP70
 // BIP70 payment protocol messages
 const char *BIP70_MESSAGE_PAYMENTACK = "PaymentACK";
 const char *BIP70_MESSAGE_PAYMENTREQUEST = "PaymentRequest";
 // BIP71 payment protocol media types
 const char *BIP71_MIMETYPE_PAYMENT = "application/bitcoincash-payment";
 const char *BIP71_MIMETYPE_PAYMENTACK = "application/bitcoincash-paymentack";
 const char *BIP71_MIMETYPE_PAYMENTREQUEST =
     "application/bitcoincash-paymentrequest";
 #endif
 
 //
 // Create a name that is unique for:
 //  testnet / non-testnet
 //  data directory
 //
 static QString ipcServerName() {
     QString name("BitcoinQt");
 
     // Append a simple hash of the datadir
     // Note that GetDataDir(true) returns a different path for -testnet versus
     // main net
     QString ddir(GUIUtil::boostPathToQString(GetDataDir(true)));
     name.append(QString::number(qHash(ddir)));
 
     return name;
 }
 
 //
 // We store payment URIs and requests received before the main GUI window is up
 // and ready to ask the user to send payment.
 //
 static QList<QString> savedPaymentRequests;
 
 static std::string ipcParseURI(const QString &arg, const CChainParams &params,
                                bool useCashAddr) {
     const QString scheme = QString::fromStdString(params.CashAddrPrefix());
     if (!arg.startsWith(scheme + ":", Qt::CaseInsensitive)) {
         return {};
     }
 
     SendCoinsRecipient r;
     if (!GUIUtil::parseBitcoinURI(scheme, arg, &r)) {
         return {};
     }
 
     return r.address.toStdString();
 }
 
 static bool ipcCanParseCashAddrURI(const QString &arg,
                                    const std::string &network) {
     auto tempChainParams = CreateChainParams(network);
     std::string addr = ipcParseURI(arg, *tempChainParams, true);
     return IsValidDestinationString(addr, *tempChainParams);
 }
 
 static bool ipcCanParseLegacyURI(const QString &arg,
                                  const std::string &network) {
     auto tempChainParams = CreateChainParams(network);
     std::string addr = ipcParseURI(arg, *tempChainParams, false);
     return IsValidDestinationString(addr, *tempChainParams);
 }
 
 //
 // Sending to the server is done synchronously, at startup.
 // If the server isn't already running, startup continues, and the items in
 // savedPaymentRequest will be handled when uiReady() is called.
 //
 // Warning: ipcSendCommandLine() is called early in init, so don't use "Q_EMIT
 // message()", but "QMessageBox::"!
 //
 void PaymentServer::ipcParseCommandLine(interfaces::Node &node, int argc,
                                         char *argv[]) {
     std::array<const std::string *, 3> networks = {
         {&CBaseChainParams::MAIN, &CBaseChainParams::TESTNET,
          &CBaseChainParams::REGTEST}};
 
     const std::string *chosenNetwork = nullptr;
 
     for (int i = 1; i < argc; i++) {
         QString arg(argv[i]);
         if (arg.startsWith("-")) {
             continue;
         }
 
         const std::string *itemNetwork = nullptr;
 
         // Try to parse as a URI
         for (auto net : networks) {
             if (ipcCanParseCashAddrURI(arg, *net)) {
                 itemNetwork = net;
                 break;
             }
 
             if (ipcCanParseLegacyURI(arg, *net)) {
                 itemNetwork = net;
                 break;
             }
         }
 
 #ifdef ENABLE_BIP70
         if (!itemNetwork && QFile::exists(arg)) {
             // Filename
             PaymentRequestPlus request;
             if (readPaymentRequestFromFile(arg, request)) {
                 for (auto net : networks) {
                     if (*net == request.getDetails().network()) {
                         itemNetwork = net;
                     }
                 }
             }
         }
 #endif
 
         if (itemNetwork == nullptr) {
             // Printing to debug.log is about the best we can do here, the GUI
             // hasn't started yet so we can't pop up a message box.
             qWarning() << "PaymentServer::ipcSendCommandLine: Payment request "
                           "file or URI does not exist or is invalid: "
                        << arg;
             continue;
         }
 
 #ifdef ENABLE_BIP70
         if (chosenNetwork && chosenNetwork != itemNetwork) {
             qWarning() << "PaymentServer::ipcSendCommandLine: Payment request "
                           "from network "
                        << QString(itemNetwork->c_str())
                        << " does not match already chosen network "
                        << QString(chosenNetwork->c_str());
             continue;
         }
 
         savedPaymentRequests.append(arg);
 #endif
         chosenNetwork = itemNetwork;
     }
 
     if (chosenNetwork) {
         node.selectParams(*chosenNetwork);
     }
 }
 
 //
 // Sending to the server is done synchronously, at startup.
 // If the server isn't already running, startup continues, and the items in
 // savedPaymentRequest will be handled when uiReady() is called.
 //
 bool PaymentServer::ipcSendCommandLine() {
     bool fResult = false;
     for (const QString &r : savedPaymentRequests) {
         QLocalSocket *socket = new QLocalSocket();
         socket->connectToServer(ipcServerName(), QIODevice::WriteOnly);
         if (!socket->waitForConnected(BITCOIN_IPC_CONNECT_TIMEOUT)) {
             delete socket;
             socket = nullptr;
             return false;
         }
 
         QByteArray block;
         QDataStream out(&block, QIODevice::WriteOnly);
         out.setVersion(QDataStream::Qt_4_0);
         out << r;
         out.device()->seek(0);
 
         socket->write(block);
         socket->flush();
         socket->waitForBytesWritten(BITCOIN_IPC_CONNECT_TIMEOUT);
         socket->disconnectFromServer();
 
         delete socket;
         socket = nullptr;
         fResult = true;
     }
 
     return fResult;
 }
 
 PaymentServer::PaymentServer(QObject *parent, bool startLocalServer)
     : QObject(parent), saveURIs(true), uriServer(nullptr), optionsModel(nullptr)
 // clang-format off
 #ifdef ENABLE_BIP70
       ,netManager(nullptr)
 #endif
 // clang-format on
 {
 #ifdef ENABLE_BIP70
     // Verify that the version of the library that we linked against is
     // compatible with the version of the headers we compiled against.
     GOOGLE_PROTOBUF_VERIFY_VERSION;
 #endif
 
     // Install global event filter to catch QFileOpenEvents
     // on Mac: sent when you click bitcoincash: links
     // other OSes: helpful when dealing with payment request files
     if (parent) {
         parent->installEventFilter(this);
     }
 
     QString name = ipcServerName();
 
     // Clean up old socket leftover from a crash:
     QLocalServer::removeServer(name);
 
     if (startLocalServer) {
         uriServer = new QLocalServer(this);
 
         if (!uriServer->listen(name)) {
             // constructor is called early in init, so don't use "Q_EMIT
             // message()" here
             QMessageBox::critical(nullptr, tr("Payment request error"),
                                   tr("Cannot start click-to-pay handler"));
         } else {
             connect(uriServer, &QLocalServer::newConnection, this,
                     &PaymentServer::handleURIConnection);
 #ifdef ENABLE_BIP70
             connect(this, &PaymentServer::receivedPaymentACK, this,
                     &PaymentServer::handlePaymentACK);
 #endif
         }
     }
 }
 
 PaymentServer::~PaymentServer() {
 #ifdef ENABLE_BIP70
     google::protobuf::ShutdownProtobufLibrary();
 #endif
 }
 
 //
 // OSX-specific way of handling bitcoincash: URIs and PaymentRequest mime types.
 // Also used by paymentservertests.cpp and when opening a payment request file
 // via "Open URI..." menu entry.
 //
 bool PaymentServer::eventFilter(QObject *object, QEvent *event) {
     if (event->type() == QEvent::FileOpen) {
         QFileOpenEvent *fileEvent = static_cast<QFileOpenEvent *>(event);
         if (!fileEvent->file().isEmpty()) {
             handleURIOrFile(fileEvent->file());
         } else if (!fileEvent->url().isEmpty()) {
             handleURIOrFile(fileEvent->url().toString());
         }
 
         return true;
     }
 
     return QObject::eventFilter(object, event);
 }
 
 void PaymentServer::uiReady() {
 #ifdef ENABLE_BIP70
     initNetManager();
 #endif
 
     saveURIs = false;
     for (const QString &s : savedPaymentRequests) {
         handleURIOrFile(s);
     }
     savedPaymentRequests.clear();
 }
 
 bool PaymentServer::handleURI(const CChainParams &params, const QString &s) {
     const QString scheme = QString::fromStdString(params.CashAddrPrefix());
     if (!s.startsWith(scheme + ":", Qt::CaseInsensitive)) {
         return false;
     }
 
     QUrlQuery uri((QUrl(s)));
     // payment request URI
     if (uri.hasQueryItem("r")) {
 #ifdef ENABLE_BIP70
         QByteArray temp;
         temp.append(uri.queryItemValue("r").toUtf8());
         QString decoded = QUrl::fromPercentEncoding(temp);
         QUrl fetchUrl(decoded, QUrl::StrictMode);
 
         if (fetchUrl.isValid()) {
             qDebug() << "PaymentServer::handleURIOrFile: fetchRequest("
                      << fetchUrl << ")";
             fetchRequest(fetchUrl);
         } else {
             qWarning() << "PaymentServer::handleURIOrFile: Invalid URL: "
                        << fetchUrl;
             Q_EMIT message(tr("URI handling"),
                            tr("Payment request fetch URL is invalid: %1")
                                .arg(fetchUrl.toString()),
                            CClientUIInterface::ICON_WARNING);
         }
 
 #else
         Q_EMIT message(tr("URI handling"),
                        tr("Cannot process payment request because BIP70 "
                           "support was not compiled in."),
                        CClientUIInterface::ICON_WARNING);
 #endif
         return true;
     }
 
     // normal URI
     SendCoinsRecipient recipient;
     if (GUIUtil::parseBitcoinURI(scheme, s, &recipient)) {
         if (!IsValidDestinationString(recipient.address.toStdString(),
                                       params)) {
             Q_EMIT message(
                 tr("URI handling"),
                 tr("Invalid payment address %1").arg(recipient.address),
                 CClientUIInterface::MSG_ERROR);
         } else {
             Q_EMIT receivedPaymentRequest(recipient);
         }
     } else {
         Q_EMIT message(
             tr("URI handling"),
             tr("URI cannot be parsed! This can be caused by an invalid "
                "Bitcoin address or malformed URI parameters."),
             CClientUIInterface::ICON_WARNING);
     }
 
     return true;
 }
 
 void PaymentServer::handleURIOrFile(const QString &s) {
     if (saveURIs) {
         savedPaymentRequests.append(s);
         return;
     }
 
     // bitcoincash: CashAddr URI
     if (handleURI(Params(), s)) {
         return;
     }
 
 #ifdef ENABLE_BIP70
     // payment request file
     if (QFile::exists(s)) {
         PaymentRequestPlus request;
         SendCoinsRecipient recipient;
         if (!readPaymentRequestFromFile(s, request)) {
             Q_EMIT message(tr("Payment request file handling"),
                            tr("Payment request file cannot be read! This can "
                               "be caused by an invalid payment request file."),
                            CClientUIInterface::ICON_WARNING);
         } else if (processPaymentRequest(request, recipient)) {
             Q_EMIT receivedPaymentRequest(recipient);
         }
 
         return;
     }
 #endif
 }
 
 void PaymentServer::handleURIConnection() {
     QLocalSocket *clientConnection = uriServer->nextPendingConnection();
 
     while (clientConnection->bytesAvailable() < (int)sizeof(quint32)) {
         clientConnection->waitForReadyRead();
     }
 
     connect(clientConnection, &QLocalSocket::disconnected, clientConnection,
             &QLocalSocket::deleteLater);
 
     QDataStream in(clientConnection);
     in.setVersion(QDataStream::Qt_4_0);
     if (clientConnection->bytesAvailable() < (int)sizeof(quint16)) {
         return;
     }
     QString msg;
     in >> msg;
 
     handleURIOrFile(msg);
 }
 
 void PaymentServer::setOptionsModel(OptionsModel *_optionsModel) {
     this->optionsModel = _optionsModel;
 }
 
 #ifdef ENABLE_BIP70
 struct X509StoreDeleter {
     void operator()(X509_STORE *b) { X509_STORE_free(b); }
 };
 
 struct X509Deleter {
     void operator()(X509 *b) { X509_free(b); }
 };
 
 // Anon namespace
 namespace {
 std::unique_ptr<X509_STORE, X509StoreDeleter> certStore;
 }
 
 static void ReportInvalidCertificate(const QSslCertificate &cert) {
     qDebug() << QString("%1: Payment server found an invalid certificate: ")
                     .arg(__func__)
              << cert.serialNumber()
              << cert.subjectInfo(QSslCertificate::CommonName)
              << cert.subjectInfo(QSslCertificate::DistinguishedNameQualifier)
              << cert.subjectInfo(QSslCertificate::OrganizationalUnitName);
 }
 
 //
 // Load OpenSSL's list of root certificate authorities
 //
 void PaymentServer::LoadRootCAs(X509_STORE *_store) {
     // Unit tests mostly use this, to pass in fake root CAs:
     if (_store) {
         certStore.reset(_store);
         return;
     }
 
     // Normal execution, use either -rootcertificates or system certs:
     certStore.reset(X509_STORE_new());
 
     // Note: use "-system-" default here so that users can pass
     // -rootcertificates="" and get 'I don't like X.509 certificates, don't
     // trust anybody' behavior:
     QString certFile =
         QString::fromStdString(gArgs.GetArg("-rootcertificates", "-system-"));
 
     // Empty store
     if (certFile.isEmpty()) {
         qDebug() << QString("PaymentServer::%1: Payment request authentication "
                             "via X.509 certificates disabled.")
                         .arg(__func__);
         return;
     }
 
     QList<QSslCertificate> certList;
 
     if (certFile != "-system-") {
         qDebug() << QString("PaymentServer::%1: Using \"%2\" as trusted root "
                             "certificate.")
                         .arg(__func__)
                         .arg(certFile);
 
         certList = QSslCertificate::fromPath(certFile);
         // Use those certificates when fetching payment requests, too:
         QSslConfiguration::defaultConfiguration().setCaCertificates(certList);
     } else {
         certList = QSslConfiguration::systemCaCertificates();
     }
 
     int nRootCerts = 0;
     const QDateTime currentTime = QDateTime::currentDateTime();
 
     for (const QSslCertificate &cert : certList) {
         // Don't log NULL certificates
         if (cert.isNull()) {
             continue;
         }
 
         // Not yet active/valid, or expired certificate
         if (currentTime < cert.effectiveDate() ||
             currentTime > cert.expiryDate()) {
             ReportInvalidCertificate(cert);
             continue;
         }
 
         // Blacklisted certificate
         if (cert.isBlacklisted()) {
             ReportInvalidCertificate(cert);
             continue;
         }
 
         QByteArray certData = cert.toDer();
         const uint8_t *data = (const uint8_t *)certData.data();
 
         std::unique_ptr<X509, X509Deleter> x509(
             d2i_X509(0, &data, certData.size()));
         if (x509 && X509_STORE_add_cert(certStore.get(), x509.get())) {
             // Note: X509_STORE increases the reference count to the X509
             // object, we still have to release our reference to it.
             ++nRootCerts;
         } else {
             ReportInvalidCertificate(cert);
             continue;
         }
     }
     qWarning() << "PaymentServer::LoadRootCAs: Loaded " << nRootCerts
                << " root certificates";
 
     // Project for another day:
     // Fetch certificate revocation lists, and add them to certStore.
     // Issues to consider:
     //   performance (start a thread to fetch in background?)
     //   privacy (fetch through tor/proxy so IP address isn't revealed)
     //   would it be easier to just use a compiled-in blacklist?
     //    or use Qt's blacklist?
     //   "certificate stapling" with server-side caching is more efficient
 }
 
 void PaymentServer::initNetManager() {
     if (!optionsModel) {
         return;
     }
     if (netManager != nullptr) {
         delete netManager;
     }
 
     // netManager is used to fetch paymentrequests given in bitcoincash: URIs
     netManager = new QNetworkAccessManager(this);
 
     QNetworkProxy proxy;
 
     // Query active SOCKS5 proxy
     if (optionsModel->getProxySettings(proxy)) {
         netManager->setProxy(proxy);
 
         qDebug() << "PaymentServer::initNetManager: Using SOCKS5 proxy"
                  << proxy.hostName() << ":" << proxy.port();
     } else {
         qDebug()
             << "PaymentServer::initNetManager: No active proxy server found.";
     }
 
     connect(netManager, &QNetworkAccessManager::finished, this,
             &PaymentServer::netRequestFinished);
     connect(netManager, &QNetworkAccessManager::sslErrors, this,
             &PaymentServer::reportSslErrors);
 }
 
 //
 // Warning: readPaymentRequestFromFile() is used in ipcSendCommandLine()
 // so don't use "Q_EMIT message()", but "QMessageBox::"!
 //
 bool PaymentServer::readPaymentRequestFromFile(const QString &filename,
                                                PaymentRequestPlus &request) {
     QFile f(filename);
     if (!f.open(QIODevice::ReadOnly)) {
         qWarning() << QString("PaymentServer::%1: Failed to open %2")
                           .arg(__func__)
                           .arg(filename);
         return false;
     }
 
     // BIP70 DoS protection
     if (!verifySize(f.size())) {
         return false;
     }
 
     QByteArray data = f.readAll();
 
     return request.parse(data);
 }
 
 bool PaymentServer::processPaymentRequest(const PaymentRequestPlus &request,
                                           SendCoinsRecipient &recipient) {
     if (!optionsModel) {
         return false;
     }
 
     if (request.IsInitialized()) {
         // Payment request network matches client network?
         if (!verifyNetwork(optionsModel->node(), request.getDetails())) {
             Q_EMIT message(
                 tr("Payment request rejected"),
                 tr("Payment request network doesn't match client network."),
                 CClientUIInterface::MSG_ERROR);
 
             return false;
         }
 
         // Make sure any payment requests involved are still valid.
         // This is re-checked just before sending coins in
         // WalletModel::sendCoins().
         if (verifyExpired(request.getDetails())) {
             Q_EMIT message(tr("Payment request rejected"),
                            tr("Payment request expired."),
                            CClientUIInterface::MSG_ERROR);
 
             return false;
         }
     } else {
         Q_EMIT message(tr("Payment request error"),
                        tr("Payment request is not initialized."),
                        CClientUIInterface::MSG_ERROR);
 
         return false;
     }
 
     recipient.paymentRequest = request;
     recipient.message = GUIUtil::HtmlEscape(request.getDetails().memo());
 
     request.getMerchant(certStore.get(), recipient.authenticatedMerchant);
 
     QList<std::pair<CScript, Amount>> sendingTos = request.getPayTo();
     QStringList addresses;
 
     for (const std::pair<CScript, Amount> &sendingTo : sendingTos) {
         // Extract and check destination addresses
         CTxDestination dest;
         if (ExtractDestination(sendingTo.first, dest)) {
             // Append destination address
             addresses.append(
                 QString::fromStdString(EncodeCashAddr(dest, Params())));
         } else if (!recipient.authenticatedMerchant.isEmpty()) {
             // Unauthenticated payment requests to custom bitcoin addresses are
             // not supported (there is no good way to tell the user where they
             // are paying in a way they'd have a chance of understanding).
             Q_EMIT message(tr("Payment request rejected"),
                            tr("Unverified payment requests to custom payment "
                               "scripts are unsupported."),
                            CClientUIInterface::MSG_ERROR);
             return false;
         }
 
         // Bitcoin amounts are stored as (optional) uint64 in the protobuf
         // messages (see paymentrequest.proto), but Amount is defined as
         // int64_t. Because of that we need to verify that amounts are in a
         // valid range and no overflow has happened.
         if (!verifyAmount(sendingTo.second)) {
             Q_EMIT message(tr("Payment request rejected"),
                            tr("Invalid payment request."),
                            CClientUIInterface::MSG_ERROR);
             return false;
         }
 
         // Extract and check amounts
         CTxOut txOut(Amount(sendingTo.second), sendingTo.first);
         if (IsDust(txOut, optionsModel->node().getDustRelayFee())) {
             Q_EMIT message(
                 tr("Payment request error"),
                 tr("Requested payment amount of %1 is too small (considered "
                    "dust).")
                     .arg(BitcoinUnits::formatWithUnit(
                         optionsModel->getDisplayUnit(), sendingTo.second)),
                 CClientUIInterface::MSG_ERROR);
 
             return false;
         }
 
         recipient.amount += sendingTo.second;
         // Also verify that the final amount is still in a valid range after
         // adding additional amounts.
         if (!verifyAmount(recipient.amount)) {
             Q_EMIT message(tr("Payment request rejected"),
                            tr("Invalid payment request."),
                            CClientUIInterface::MSG_ERROR);
             return false;
         }
     }
     // Store addresses and format them to fit nicely into the GUI
     recipient.address = addresses.join("<br />");
 
     if (!recipient.authenticatedMerchant.isEmpty()) {
         qDebug() << "PaymentServer::processPaymentRequest: Secure payment "
                     "request from "
                  << recipient.authenticatedMerchant;
     } else {
         qDebug() << "PaymentServer::processPaymentRequest: Insecure payment "
                     "request to "
                  << addresses.join(", ");
     }
 
     return true;
 }
 
 void PaymentServer::fetchRequest(const QUrl &url) {
     QNetworkRequest netRequest;
     netRequest.setAttribute(QNetworkRequest::User,
                             BIP70_MESSAGE_PAYMENTREQUEST);
     netRequest.setUrl(url);
     netRequest.setRawHeader("User-Agent", CLIENT_NAME.c_str());
     netRequest.setRawHeader("Accept", BIP71_MIMETYPE_PAYMENTREQUEST);
     netManager->get(netRequest);
 }
 
-void PaymentServer::fetchPaymentACK(WalletModel *walletModel,
+void PaymentServer::fetchPaymentACK(interfaces::Wallet &wallet,
                                     const SendCoinsRecipient &recipient,
                                     QByteArray transaction) {
     const payments::PaymentDetails &details =
         recipient.paymentRequest.getDetails();
     if (!details.has_payment_url()) {
         return;
     }
 
     QNetworkRequest netRequest;
     netRequest.setAttribute(QNetworkRequest::User, BIP70_MESSAGE_PAYMENTACK);
     netRequest.setUrl(QString::fromStdString(details.payment_url()));
     netRequest.setHeader(QNetworkRequest::ContentTypeHeader,
                          BIP71_MIMETYPE_PAYMENT);
     netRequest.setRawHeader("User-Agent", CLIENT_NAME.c_str());
     netRequest.setRawHeader("Accept", BIP71_MIMETYPE_PAYMENTACK);
 
     payments::Payment payment;
     payment.set_merchant_data(details.merchant_data());
     payment.add_transactions(transaction.data(), transaction.size());
 
     // Create a new refund address, or re-use:
     CTxDestination dest;
     const OutputType change_type =
-        walletModel->wallet().getDefaultChangeType() != OutputType::CHANGE_AUTO
-            ? walletModel->wallet().getDefaultChangeType()
-            : walletModel->wallet().getDefaultAddressType();
-    if (walletModel->wallet().getNewDestination(change_type, "", dest)) {
+        wallet.getDefaultChangeType() != OutputType::CHANGE_AUTO
+            ? wallet.getDefaultChangeType()
+            : wallet.getDefaultAddressType();
+    if (wallet.getNewDestination(change_type, "", dest)) {
         // BIP70 requests encode the scriptPubKey directly, so we are not
         // restricted to address types supported by the receiver. As a result,
         // we choose the address format we also use for change. Despite an
         // actual payment and not change, this is a close match: it's the output
         // type we use subject to privacy issues, but not restricted by what
         // other software supports.
         std::string label = tr("Refund from %1")
                                 .arg(recipient.authenticatedMerchant)
                                 .toStdString();
-        walletModel->wallet().setAddressBook(dest, label, "refund");
+        wallet.setAddressBook(dest, label, "refund");
 
         CScript s = GetScriptForDestination(dest);
         payments::Output *refund_to = payment.add_refund_to();
         refund_to->set_script(&s[0], s.size());
     } else {
         // This should never happen, because sending coins should have
         // just unlocked the wallet and refilled the keypool.
         qWarning() << "PaymentServer::fetchPaymentACK: Error getting refund "
                       "key, refund_to not set";
     }
 
     QVariant length;
 #ifdef USE_PROTOBUF_MESSAGE_BYTESIZELONG
     length.setValue(payment.ByteSizeLong());
 #else
     length.setValue(payment.ByteSize());
 #endif
 
     netRequest.setHeader(QNetworkRequest::ContentLengthHeader, length);
     QByteArray serData(length.toInt(), '\0');
     if (payment.SerializeToArray(serData.data(), length.toInt())) {
         netManager->post(netRequest, serData);
     } else {
         // This should never happen, either.
         qWarning() << "PaymentServer::fetchPaymentACK: Error serializing "
                       "payment message";
     }
 }
 
 void PaymentServer::netRequestFinished(QNetworkReply *reply) {
     reply->deleteLater();
 
     // BIP70 DoS protection
     if (!verifySize(reply->size())) {
         Q_EMIT message(
             tr("Payment request rejected"),
             tr("Payment request %1 is too large (%2 bytes, allowed %3 bytes).")
                 .arg(reply->request().url().toString())
                 .arg(reply->size())
                 .arg(BIP70_MAX_PAYMENTREQUEST_SIZE),
             CClientUIInterface::MSG_ERROR);
         return;
     }
 
     if (reply->error() != QNetworkReply::NoError) {
         QString msg = tr("Error communicating with %1: %2")
                           .arg(reply->request().url().toString())
                           .arg(reply->errorString());
 
         qWarning() << "PaymentServer::netRequestFinished: " << msg;
         Q_EMIT message(tr("Payment request error"), msg,
                        CClientUIInterface::MSG_ERROR);
         return;
     }
 
     QByteArray data = reply->readAll();
 
     QString requestType =
         reply->request().attribute(QNetworkRequest::User).toString();
     if (requestType == BIP70_MESSAGE_PAYMENTREQUEST) {
         PaymentRequestPlus request;
         SendCoinsRecipient recipient;
         if (!request.parse(data)) {
             qWarning() << "PaymentServer::netRequestFinished: Error parsing "
                           "payment request";
             Q_EMIT message(tr("Payment request error"),
                            tr("Payment request cannot be parsed!"),
                            CClientUIInterface::MSG_ERROR);
         } else if (processPaymentRequest(request, recipient)) {
             Q_EMIT receivedPaymentRequest(recipient);
         }
 
         return;
     } else if (requestType == BIP70_MESSAGE_PAYMENTACK) {
         payments::PaymentACK paymentACK;
         if (!paymentACK.ParseFromArray(data.data(), data.size())) {
             QString msg = tr("Bad response from server %1")
                               .arg(reply->request().url().toString());
 
             qWarning() << "PaymentServer::netRequestFinished: " << msg;
             Q_EMIT message(tr("Payment request error"), msg,
                            CClientUIInterface::MSG_ERROR);
         } else {
             Q_EMIT receivedPaymentACK(GUIUtil::HtmlEscape(paymentACK.memo()));
         }
     }
 }
 
 void PaymentServer::reportSslErrors(QNetworkReply *reply,
                                     const QList<QSslError> &errs) {
     Q_UNUSED(reply);
 
     QString errString;
     for (const QSslError &err : errs) {
         qWarning() << "PaymentServer::reportSslErrors: " << err;
         errString += err.errorString() + "\n";
     }
     Q_EMIT message(tr("Network request error"), errString,
                    CClientUIInterface::MSG_ERROR);
 }
 
 void PaymentServer::handlePaymentACK(const QString &paymentACKMsg) {
     // currently we don't further process or store the paymentACK message
     Q_EMIT message(tr("Payment acknowledged"), paymentACKMsg,
                    CClientUIInterface::ICON_INFORMATION |
                        CClientUIInterface::MODAL);
 }
 
 bool PaymentServer::verifyNetwork(
     interfaces::Node &node, const payments::PaymentDetails &requestDetails) {
     bool fVerified = requestDetails.network() == node.getNetwork();
     if (!fVerified) {
         qWarning() << QString("PaymentServer::%1: Payment request network "
                               "\"%2\" doesn't match client network \"%3\".")
                           .arg(__func__)
                           .arg(QString::fromStdString(requestDetails.network()))
                           .arg(QString::fromStdString(node.getNetwork()));
     }
     return fVerified;
 }
 
 bool PaymentServer::verifyExpired(
     const payments::PaymentDetails &requestDetails) {
     bool fVerified = (requestDetails.has_expires() &&
                       (int64_t)requestDetails.expires() < GetTime());
     if (fVerified) {
         const QString requestExpires = QString::fromStdString(
             FormatISO8601DateTime((int64_t)requestDetails.expires()));
         qWarning() << QString(
                           "PaymentServer::%1: Payment request expired \"%2\".")
                           .arg(__func__)
                           .arg(requestExpires);
     }
     return fVerified;
 }
 
 bool PaymentServer::verifySize(qint64 requestSize) {
     bool fVerified = (requestSize <= BIP70_MAX_PAYMENTREQUEST_SIZE);
     if (!fVerified) {
         qWarning() << QString("PaymentServer::%1: Payment request too large "
                               "(%2 bytes, allowed %3 bytes).")
                           .arg(__func__)
                           .arg(requestSize)
                           .arg(BIP70_MAX_PAYMENTREQUEST_SIZE);
     }
     return fVerified;
 }
 
 bool PaymentServer::verifyAmount(const Amount requestAmount) {
     bool fVerified = MoneyRange(Amount(requestAmount));
     if (!fVerified) {
         qWarning() << QString("PaymentServer::%1: Payment request amount out "
                               "of allowed range (%2, allowed 0 - %3).")
                           .arg(__func__)
                           .arg(requestAmount / SATOSHI)
                           .arg(MAX_MONEY / SATOSHI);
     }
     return fVerified;
 }
 
 X509_STORE *PaymentServer::getCertStore() {
     return certStore.get();
 }
 #endif
diff --git a/src/qt/paymentserver.h b/src/qt/paymentserver.h
index 6376df953..eda9af067 100644
--- a/src/qt/paymentserver.h
+++ b/src/qt/paymentserver.h
@@ -1,167 +1,171 @@
 // 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_PAYMENTSERVER_H
 #define BITCOIN_QT_PAYMENTSERVER_H
 
 // This class handles payment requests from clicking on
 // bitcoincash: URIs
 //
 // This is somewhat tricky, because we have to deal with the situation where the
 // user clicks on a link during startup/initialization, when the splash-screen
 // is up but the main window (and the Send Coins tab) is not.
 //
 // So, the strategy is:
 //
 // Create the server, and register the event handler, when the application is
 // created. Save any URIs received at or during startup in a list.
 //
 // When startup is finished and the main window is shown, a signal is sent to
 // slot uiReady(), which emits a receivedURI() signal for any payment requests
 // that happened during startup.
 //
 // After startup, receivedURI() happens as usual.
 //
 // This class has one more feature: a static method that finds URIs passed in
 // the command line and, if a server is running in another process, sends them
 // to the server.
 //
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #ifdef ENABLE_BIP70
 #include <qt/paymentrequestplus.h>
 #endif
+#include <interfaces/wallet.h>
 #include <qt/sendcoinsrecipient.h>
-#include <qt/walletmodel.h>
 
 #include <QObject>
 #include <QString>
 
 class OptionsModel;
 
+namespace interfaces {
+class Node;
+} // namespace interfaces
+
 QT_BEGIN_NAMESPACE
 class QApplication;
 class QByteArray;
 class QLocalServer;
 class QNetworkAccessManager;
 class QNetworkReply;
 class QSslError;
 class QUrl;
 QT_END_NAMESPACE
 
 // BIP70 max payment request size in bytes (DoS protection)
 static const qint64 BIP70_MAX_PAYMENTREQUEST_SIZE = 50000;
 
 class PaymentServer : public QObject {
     Q_OBJECT
 
 public:
     // Parse URIs on command line
     // Returns false on error
     static void ipcParseCommandLine(interfaces::Node &node, int argc,
                                     char *argv[]);
 
     // Returns true if there were URIs on the command line which were
     // successfully sent to an already-running process.
     // Note: if a payment request is given, SelectParams(MAIN/TESTNET)  will be
     // called so we startup in the right mode.
     static bool ipcSendCommandLine();
 
     // parent should be QApplication object
     explicit PaymentServer(QObject *parent, bool startLocalServer = true);
     ~PaymentServer();
 
     // OptionsModel is used for getting proxy settings and display unit
     void setOptionsModel(OptionsModel *optionsModel);
 
 #ifdef ENABLE_BIP70
     // Load root certificate authorities. Pass nullptr (default) to read from
     // the file specified in the -rootcertificates setting, or, if that's not
     // set, to use the system default root certificates. If you pass in a store,
     // you should not X509_STORE_free it: it will be freed either at exit or
     // when another set of CAs are loaded.
     static void LoadRootCAs(X509_STORE *store = nullptr);
 
     // Return certificate store
     static X509_STORE *getCertStore();
 
     // Verify that the payment request network matches the client network
     static bool verifyNetwork(interfaces::Node &node,
                               const payments::PaymentDetails &requestDetails);
     // Verify if the payment request is expired
     static bool verifyExpired(const payments::PaymentDetails &requestDetails);
     // Verify the payment request size is valid as per BIP70
     static bool verifySize(qint64 requestSize);
     // Verify the payment request amount is valid
     static bool verifyAmount(const Amount requestAmount);
 #endif
 
 Q_SIGNALS:
     // Fired when a valid payment request is received
     void receivedPaymentRequest(SendCoinsRecipient);
 
     // Fired when a message should be reported to the user
     void message(const QString &title, const QString &message,
                  unsigned int style);
 
 #ifdef ENABLE_BIP70
     // Fired when a valid PaymentACK is received
     void receivedPaymentACK(const QString &paymentACKMsg);
 #endif
 
 public Q_SLOTS:
     // Signal this when the main window's UI is ready to display payment
     // requests to the user
     void uiReady();
 
     // Handle an incoming URI, URI with local file scheme or file
     void handleURIOrFile(const QString &s);
 
 #ifdef ENABLE_BIP70
     // Submit Payment message to a merchant, get back PaymentACK:
-    void fetchPaymentACK(WalletModel *walletModel,
+    void fetchPaymentACK(interfaces::Wallet &wallet,
                          const SendCoinsRecipient &recipient,
                          QByteArray transaction);
 #endif
 
 private Q_SLOTS:
     void handleURIConnection();
 #ifdef ENABLE_BIP70
     void netRequestFinished(QNetworkReply *);
     void reportSslErrors(QNetworkReply *, const QList<QSslError> &);
     void handlePaymentACK(const QString &paymentACKMsg);
 #endif
 
 protected:
     // Constructor registers this on the parent QApplication to receive
     // QEvent::FileOpen and QEvent:Drop events
     bool eventFilter(QObject *object, QEvent *event) override;
 
 private:
     // true during startup
     bool saveURIs;
     QLocalServer *uriServer;
     OptionsModel *optionsModel;
 
     bool handleURI(const CChainParams &params, const QString &s);
 
 #ifdef ENABLE_BIP70
     static bool readPaymentRequestFromFile(const QString &filename,
                                            PaymentRequestPlus &request);
     bool processPaymentRequest(const PaymentRequestPlus &request,
                                SendCoinsRecipient &recipient);
     void fetchRequest(const QUrl &url);
 
     // Setup networking
     void initNetManager();
 
     // Used to fetch payment requests
     QNetworkAccessManager *netManager;
 #endif
 };
 
 #endif // BITCOIN_QT_PAYMENTSERVER_H
diff --git a/src/qt/transactiondesc.cpp b/src/qt/transactiondesc.cpp
index 31b275580..ab3d4e4ce 100644
--- a/src/qt/transactiondesc.cpp
+++ b/src/qt/transactiondesc.cpp
@@ -1,411 +1,412 @@
 // 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.
 
 #ifdef HAVE_CONFIG_H
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/transactiondesc.h>
 
 #include <cashaddrenc.h>
 #include <chain.h>
 #include <consensus/consensus.h>
 #include <interfaces/node.h>
+#include <interfaces/wallet.h>
 #include <key_io.h>
 #include <policy/policy.h>
 #include <qt/bitcoinunits.h>
 #include <qt/guiutil.h>
 #include <qt/paymentserver.h>
 #include <qt/transactionrecord.h>
 #include <script/script.h>
 #include <util/system.h>
 #include <validation.h>
 #include <wallet/ismine.h>
 
 #include <cstdint>
 #include <string>
 
 QString
 TransactionDesc::FormatTxStatus(const interfaces::WalletTx &wtx,
                                 const interfaces::WalletTxStatus &status,
                                 bool inMempool, int numBlocks) {
     if (!status.is_final) {
         if (wtx.tx->nLockTime < LOCKTIME_THRESHOLD) {
             return tr("Open for %n more block(s)", "",
                       wtx.tx->nLockTime - numBlocks);
         } else {
             return tr("Open until %1")
                 .arg(GUIUtil::dateTimeStr(wtx.tx->nLockTime));
         }
     } else {
         int nDepth = status.depth_in_main_chain;
         if (nDepth < 0) {
             return tr("conflicted with a transaction with %1 confirmations")
                 .arg(-nDepth);
         } else if (nDepth == 0) {
             return tr("0/unconfirmed, %1")
                        .arg((inMempool ? tr("in memory pool")
                                        : tr("not in memory pool"))) +
                    (status.is_abandoned ? ", " + tr("abandoned") : "");
         } else if (nDepth < 6) {
             return tr("%1/unconfirmed").arg(nDepth);
         } else {
             return tr("%1 confirmations").arg(nDepth);
         }
     }
 }
 
 QString TransactionDesc::toHTML(interfaces::Node &node,
                                 interfaces::Wallet &wallet,
                                 TransactionRecord *rec, int unit) {
     int numBlocks;
     interfaces::WalletTxStatus status;
     interfaces::WalletOrderForm orderForm;
     bool inMempool;
     interfaces::WalletTx wtx = wallet.getWalletTxDetails(
         rec->txid, status, orderForm, inMempool, numBlocks);
 
     QString strHTML;
 
     strHTML.reserve(4000);
     strHTML += "<html><font face='verdana, arial, helvetica, sans-serif'>";
 
     int64_t nTime = wtx.time;
     Amount nCredit = wtx.credit;
     Amount nDebit = wtx.debit;
     Amount nNet = nCredit - nDebit;
 
     strHTML += "<b>" + tr("Status") + ":</b> " +
                FormatTxStatus(wtx, status, inMempool, numBlocks);
     strHTML += "<br>";
 
     strHTML += "<b>" + tr("Date") + ":</b> " +
                (nTime ? GUIUtil::dateTimeStr(nTime) : "") + "<br>";
 
     //
     // From
     //
     if (wtx.is_coinbase) {
         strHTML += "<b>" + tr("Source") + ":</b> " + tr("Generated") + "<br>";
     } else if (wtx.value_map.count("from") && !wtx.value_map["from"].empty()) {
         // Online transaction
         strHTML += "<b>" + tr("From") + ":</b> " +
                    GUIUtil::HtmlEscape(wtx.value_map["from"]) + "<br>";
     } else {
         // Offline transaction
         if (nNet > Amount::zero()) {
             // Credit
             CTxDestination address =
                 DecodeDestination(rec->address, wallet.getChainParams());
             if (IsValidDestination(address)) {
                 std::string name;
                 isminetype ismine;
                 if (wallet.getAddress(address, &name, &ismine,
                                       /* purpose= */ nullptr)) {
                     strHTML +=
                         "<b>" + tr("From") + ":</b> " + tr("unknown") + "<br>";
                     strHTML += "<b>" + tr("To") + ":</b> ";
                     strHTML += GUIUtil::HtmlEscape(rec->address);
                     QString addressOwned = ismine == ISMINE_SPENDABLE
                                                ? tr("own address")
                                                : tr("watch-only");
                     if (!name.empty()) {
                         strHTML += " (" + addressOwned + ", " + tr("label") +
                                    ": " + GUIUtil::HtmlEscape(name) + ")";
                     } else {
                         strHTML += " (" + addressOwned + ")";
                     }
                     strHTML += "<br>";
                 }
             }
         }
     }
 
     //
     // To
     //
     if (wtx.value_map.count("to") && !wtx.value_map["to"].empty()) {
         // Online transaction
         std::string strAddress = wtx.value_map["to"];
         strHTML += "<b>" + tr("To") + ":</b> ";
         CTxDestination dest =
             DecodeDestination(strAddress, wallet.getChainParams());
         std::string name;
         if (wallet.getAddress(dest, &name, /* is_mine= */ nullptr,
                               /* purpose= */ nullptr) &&
             !name.empty()) {
             strHTML += GUIUtil::HtmlEscape(name) + " ";
         }
         strHTML += GUIUtil::HtmlEscape(strAddress) + "<br>";
     }
 
     //
     // Amount
     //
     if (wtx.is_coinbase && nCredit == Amount::zero()) {
         //
         // Coinbase
         //
         Amount nUnmatured = Amount::zero();
         for (const CTxOut &txout : wtx.tx->vout) {
             nUnmatured += wallet.getCredit(txout, ISMINE_ALL);
         }
         strHTML += "<b>" + tr("Credit") + ":</b> ";
         if (status.is_in_main_chain) {
             strHTML += BitcoinUnits::formatHtmlWithUnit(unit, nUnmatured) +
                        " (" +
                        tr("matures in %n more block(s)", "",
                           status.blocks_to_maturity) +
                        ")";
         } else {
             strHTML += "(" + tr("not accepted") + ")";
         }
         strHTML += "<br>";
     } else if (nNet > Amount::zero()) {
         //
         // Credit
         //
         strHTML += "<b>" + tr("Credit") + ":</b> " +
                    BitcoinUnits::formatHtmlWithUnit(unit, nNet) + "<br>";
     } else {
         isminetype fAllFromMe = ISMINE_SPENDABLE;
         for (const isminetype mine : wtx.txin_is_mine) {
             if (fAllFromMe > mine) {
                 fAllFromMe = mine;
             }
         }
 
         isminetype fAllToMe = ISMINE_SPENDABLE;
         for (const isminetype mine : wtx.txout_is_mine) {
             if (fAllToMe > mine) {
                 fAllToMe = mine;
             }
         }
 
         if (fAllFromMe) {
             if (fAllFromMe & ISMINE_WATCH_ONLY) {
                 strHTML +=
                     "<b>" + tr("From") + ":</b> " + tr("watch-only") + "<br>";
             }
 
             //
             // Debit
             //
             auto mine = wtx.txout_is_mine.begin();
             for (const CTxOut &txout : wtx.tx->vout) {
                 // Ignore change
                 isminetype toSelf = *(mine++);
                 if ((toSelf == ISMINE_SPENDABLE) &&
                     (fAllFromMe == ISMINE_SPENDABLE)) {
                     continue;
                 }
 
                 if (!wtx.value_map.count("to") || wtx.value_map["to"].empty()) {
                     // Offline transaction
                     CTxDestination address;
                     if (ExtractDestination(txout.scriptPubKey, address)) {
                         strHTML += "<b>" + tr("To") + ":</b> ";
                         std::string name;
                         if (wallet.getAddress(address, &name,
                                               /* is_mine= */ nullptr,
                                               /* purpose= */ nullptr) &&
                             !name.empty()) {
                             strHTML += GUIUtil::HtmlEscape(name) + " ";
                         }
                         strHTML += GUIUtil::HtmlEscape(
                             EncodeCashAddr(address, wallet.getChainParams()));
                         if (toSelf == ISMINE_SPENDABLE) {
                             strHTML += " (own address)";
                         } else if (toSelf & ISMINE_WATCH_ONLY) {
                             strHTML += " (watch-only)";
                         }
                         strHTML += "<br>";
                     }
                 }
 
                 strHTML +=
                     "<b>" + tr("Debit") + ":</b> " +
                     BitcoinUnits::formatHtmlWithUnit(unit, -1 * txout.nValue) +
                     "<br>";
                 if (toSelf) {
                     strHTML +=
                         "<b>" + tr("Credit") + ":</b> " +
                         BitcoinUnits::formatHtmlWithUnit(unit, txout.nValue) +
                         "<br>";
                 }
             }
 
             if (fAllToMe) {
                 // Payment to self
                 Amount nChange = wtx.change;
                 Amount nValue = nCredit - nChange;
                 strHTML += "<b>" + tr("Total debit") + ":</b> " +
                            BitcoinUnits::formatHtmlWithUnit(unit, -1 * nValue) +
                            "<br>";
                 strHTML += "<b>" + tr("Total credit") + ":</b> " +
                            BitcoinUnits::formatHtmlWithUnit(unit, nValue) +
                            "<br>";
             }
 
             Amount nTxFee = nDebit - wtx.tx->GetValueOut();
             if (nTxFee > Amount::zero()) {
                 strHTML += "<b>" + tr("Transaction fee") + ":</b> " +
                            BitcoinUnits::formatHtmlWithUnit(unit, -1 * nTxFee) +
                            "<br>";
             }
         } else {
             //
             // Mixed debit transaction
             //
             auto mine = wtx.txin_is_mine.begin();
             for (const CTxIn &txin : wtx.tx->vin) {
                 if (*(mine++)) {
                     strHTML += "<b>" + tr("Debit") + ":</b> " +
                                BitcoinUnits::formatHtmlWithUnit(
                                    unit, -wallet.getDebit(txin, ISMINE_ALL)) +
                                "<br>";
                 }
             }
             mine = wtx.txout_is_mine.begin();
             for (const CTxOut &txout : wtx.tx->vout) {
                 if (*(mine++)) {
                     strHTML += "<b>" + tr("Credit") + ":</b> " +
                                BitcoinUnits::formatHtmlWithUnit(
                                    unit, wallet.getCredit(txout, ISMINE_ALL)) +
                                "<br>";
                 }
             }
         }
     }
 
     strHTML += "<b>" + tr("Net amount") + ":</b> " +
                BitcoinUnits::formatHtmlWithUnit(unit, nNet, true) + "<br>";
 
     //
     // Message
     //
     if (wtx.value_map.count("message") && !wtx.value_map["message"].empty()) {
         strHTML += "<br><b>" + tr("Message") + ":</b><br>" +
                    GUIUtil::HtmlEscape(wtx.value_map["message"], true) + "<br>";
     }
     if (wtx.value_map.count("comment") && !wtx.value_map["comment"].empty()) {
         strHTML += "<br><b>" + tr("Comment") + ":</b><br>" +
                    GUIUtil::HtmlEscape(wtx.value_map["comment"], true) + "<br>";
     }
 
     strHTML +=
         "<b>" + tr("Transaction ID") + ":</b> " + rec->getTxID() + "<br>";
     strHTML += "<b>" + tr("Transaction total size") + ":</b> " +
                QString::number(wtx.tx->GetTotalSize()) + " bytes<br>";
     strHTML += "<b>" + tr("Output index") + ":</b> " +
                QString::number(rec->getOutputIndex()) + "<br>";
 
     // Message from normal bitcoincash:URI (bitcoincash:123...?message=example)
     for (const std::pair<std::string, std::string> &r : orderForm) {
         if (r.first == "Message") {
             strHTML += "<br><b>" + tr("Message") + ":</b><br>" +
                        GUIUtil::HtmlEscape(r.second, true) + "<br>";
         }
     }
 
 #ifdef ENABLE_BIP70
     //
     // PaymentRequest info:
     //
     for (const std::pair<std::string, std::string> &r : orderForm) {
         if (r.first == "PaymentRequest") {
             PaymentRequestPlus req;
             req.parse(
                 QByteArray::fromRawData(r.second.data(), r.second.size()));
             QString merchant;
             if (req.getMerchant(PaymentServer::getCertStore(), merchant)) {
                 strHTML += "<b>" + tr("Merchant") + ":</b> " +
                            GUIUtil::HtmlEscape(merchant) + "<br>";
             }
         }
     }
 #endif
 
     if (wtx.is_coinbase) {
         quint32 numBlocksToMaturity = COINBASE_MATURITY + 1;
         strHTML +=
             "<br>" +
             tr("Generated coins must mature %1 blocks before they can be "
                "spent. When you generated this block, it was broadcast to the "
                "network to be added to the block chain. If it fails to get "
                "into the chain, its state will change to \"not accepted\" and "
                "it won't be spendable. This may occasionally happen if another "
                "node generates a block within a few seconds of yours.")
                 .arg(QString::number(numBlocksToMaturity)) +
             "<br>";
     }
 
     //
     // Debug view
     //
     if (gArgs.GetBoolArg("-debug", false)) {
         strHTML += "<hr><br>" + tr("Debug information") + "<br><br>";
         for (const CTxIn &txin : wtx.tx->vin) {
             if (wallet.txinIsMine(txin)) {
                 strHTML += "<b>" + tr("Debit") + ":</b> " +
                            BitcoinUnits::formatHtmlWithUnit(
                                unit, -wallet.getDebit(txin, ISMINE_ALL)) +
                            "<br>";
             }
         }
         for (const CTxOut &txout : wtx.tx->vout) {
             if (wallet.txoutIsMine(txout)) {
                 strHTML += "<b>" + tr("Credit") + ":</b> " +
                            BitcoinUnits::formatHtmlWithUnit(
                                unit, wallet.getCredit(txout, ISMINE_ALL)) +
                            "<br>";
             }
         }
 
         strHTML += "<br><b>" + tr("Transaction") + ":</b><br>";
         strHTML += GUIUtil::HtmlEscape(wtx.tx->ToString(), true);
 
         strHTML += "<br><b>" + tr("Inputs") + ":</b>";
         strHTML += "<ul>";
 
         for (const CTxIn &txin : wtx.tx->vin) {
             COutPoint prevout = txin.prevout;
 
             Coin prev;
             if (node.getUnspentOutput(prevout, prev)) {
                 strHTML += "<li>";
                 const CTxOut &vout = prev.GetTxOut();
                 CTxDestination address;
                 if (ExtractDestination(vout.scriptPubKey, address)) {
                     std::string name;
                     if (wallet.getAddress(address, &name,
                                           /* is_mine= */ nullptr,
                                           /* purpose= */ nullptr) &&
                         !name.empty()) {
                         strHTML += GUIUtil::HtmlEscape(name) + " ";
                     }
                     strHTML += QString::fromStdString(
                         EncodeCashAddr(address, wallet.getChainParams()));
                 }
                 strHTML = strHTML + " " + tr("Amount") + "=" +
                           BitcoinUnits::formatHtmlWithUnit(unit, vout.nValue);
                 strHTML = strHTML + " IsMine=" +
                           (wallet.txoutIsMine(vout) & ISMINE_SPENDABLE
                                ? tr("true")
                                : tr("false")) +
                           "</li>";
                 strHTML = strHTML + " IsWatchOnly=" +
                           (wallet.txoutIsMine(vout) & ISMINE_WATCH_ONLY
                                ? tr("true")
                                : tr("false")) +
                           "</li>";
             }
         }
 
         strHTML += "</ul>";
     }
 
     strHTML += "</font></html>";
     return strHTML;
 }
diff --git a/src/qt/walletcontroller.h b/src/qt/walletcontroller.h
index e89b92da3..ea6fb727b 100644
--- a/src/qt/walletcontroller.h
+++ b/src/qt/walletcontroller.h
@@ -1,153 +1,154 @@
 // Copyright (c) 2019 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_WALLETCONTROLLER_H
 #define BITCOIN_QT_WALLETCONTROLLER_H
 
+#include <interfaces/wallet.h>
 #include <qt/sendcoinsrecipient.h>
 #include <qt/walletmodel.h>
 #include <support/allocators/secure.h>
 #include <sync.h>
 
 #include <QMutex>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include <QMessageBox>
 #include <QProgressDialog>
 #include <QString>
 #include <QThread>
 #include <QTimer>
 
 class OptionsModel;
 class PlatformStyle;
 
 namespace interfaces {
 class Handler;
 class Node;
 } // namespace interfaces
 
 class AskPassphraseDialog;
 class CreateWalletActivity;
 class CreateWalletDialog;
 class OpenWalletActivity;
 class WalletControllerActivity;
 
 /**
  * Controller between interfaces::Node, WalletModel instances and the GUI.
  */
 class WalletController : public QObject {
     Q_OBJECT
 
     void removeAndDeleteWallet(WalletModel *wallet_model);
 
 public:
     WalletController(interfaces::Node &node,
                      const PlatformStyle *platform_style,
                      OptionsModel *options_model, QObject *parent);
     ~WalletController();
 
     //! Returns wallet models currently open.
     std::vector<WalletModel *> getOpenWallets() const;
 
     WalletModel *getOrCreateWallet(std::unique_ptr<interfaces::Wallet> wallet);
 
     //! Returns all wallet names in the wallet dir mapped to whether the wallet
     //! is loaded.
     std::map<std::string, bool> listWalletDir() const;
 
     void closeWallet(WalletModel *wallet_model, QWidget *parent = nullptr);
 
 Q_SIGNALS:
     void walletAdded(WalletModel *wallet_model);
     void walletRemoved(WalletModel *wallet_model);
 
-    void coinsSent(WalletModel *wallet_model, SendCoinsRecipient recipient,
+    void coinsSent(interfaces::Wallet &wallet, SendCoinsRecipient recipient,
                    QByteArray transaction);
 
 private:
     QThread *const m_activity_thread;
     QObject *const m_activity_worker;
     interfaces::Node &m_node;
     const PlatformStyle *const m_platform_style;
     OptionsModel *const m_options_model;
     mutable QMutex m_mutex;
     std::vector<WalletModel *> m_wallets;
     std::unique_ptr<interfaces::Handler> m_handler_load_wallet;
 
     friend class WalletControllerActivity;
 };
 
 class WalletControllerActivity : public QObject {
     Q_OBJECT
 
 public:
     WalletControllerActivity(WalletController *wallet_controller,
                              QWidget *parent_widget,
                              const CChainParams &chainparams);
     virtual ~WalletControllerActivity();
 
 Q_SIGNALS:
     void finished();
 
 protected:
     interfaces::Node &node() const { return m_wallet_controller->m_node; }
     QObject *worker() const { return m_wallet_controller->m_activity_worker; }
 
     void showProgressDialog(const QString &label_text);
 
     WalletController *const m_wallet_controller;
     QWidget *const m_parent_widget;
     QProgressDialog *m_progress_dialog{nullptr};
     WalletModel *m_wallet_model{nullptr};
     std::string m_error_message;
     std::vector<std::string> m_warning_message;
 
     const CChainParams &m_chainparams;
 };
 
 class CreateWalletActivity : public WalletControllerActivity {
     Q_OBJECT
 
 public:
     CreateWalletActivity(WalletController *wallet_controller,
                          QWidget *parent_widget,
                          const CChainParams &chainparams);
     virtual ~CreateWalletActivity();
 
     void create();
 
 Q_SIGNALS:
     void created(WalletModel *wallet_model);
 
 private:
     void askPassphrase();
     void createWallet();
     void finish();
 
     SecureString m_passphrase;
     CreateWalletDialog *m_create_wallet_dialog{nullptr};
     AskPassphraseDialog *m_passphrase_dialog{nullptr};
 };
 
 class OpenWalletActivity : public WalletControllerActivity {
     Q_OBJECT
 
 public:
     OpenWalletActivity(WalletController *wallet_controller,
                        QWidget *parent_widget, const CChainParams &chainparams);
 
     void open(const std::string &path);
 
 Q_SIGNALS:
     void opened(WalletModel *wallet_model);
 
 private:
     void finish();
 };
 
 #endif // BITCOIN_QT_WALLETCONTROLLER_H
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
index 6a6dd43fc..6e7f2edf4 100644
--- a/src/qt/walletmodel.cpp
+++ b/src/qt/walletmodel.cpp
@@ -1,527 +1,527 @@
 // Copyright (c) 2011-2019 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/walletmodel.h>
 
 #include <cashaddrenc.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <qt/addresstablemodel.h>
 #include <qt/guiconstants.h>
 #include <qt/paymentserver.h>
 #include <qt/recentrequeststablemodel.h>
 #include <qt/transactiontablemodel.h>
 #include <ui_interface.h>
 #include <util/system.h> // for GetBoolArg
 #include <wallet/coincontrol.h>
 #include <wallet/wallet.h>
 
 #include <QDebug>
 #include <QSet>
 #include <QTimer>
 
 #include <cstdint>
 
 WalletModel::WalletModel(std::unique_ptr<interfaces::Wallet> wallet,
                          interfaces::Node &node,
                          const PlatformStyle *platformStyle,
                          OptionsModel *_optionsModel, QObject *parent)
     : QObject(parent), m_wallet(std::move(wallet)), m_node(node),
       optionsModel(_optionsModel), addressTableModel(nullptr),
       transactionTableModel(nullptr), recentRequestsTableModel(nullptr),
       cachedEncryptionStatus(Unencrypted), cachedNumBlocks(0) {
     fHaveWatchOnly = m_wallet->haveWatchOnly();
     addressTableModel = new AddressTableModel(this);
     transactionTableModel = new TransactionTableModel(platformStyle, this);
     recentRequestsTableModel = new RecentRequestsTableModel(this);
 
     subscribeToCoreSignals();
 }
 
 WalletModel::~WalletModel() {
     unsubscribeFromCoreSignals();
 }
 
 void WalletModel::startPollBalance() {
     // This timer will be fired repeatedly to update the balance
     QTimer *timer = new QTimer(this);
     connect(timer, &QTimer::timeout, this, &WalletModel::pollBalanceChanged);
     timer->start(MODEL_UPDATE_DELAY);
 }
 
 void WalletModel::updateStatus() {
     EncryptionStatus newEncryptionStatus = getEncryptionStatus();
 
     if (cachedEncryptionStatus != newEncryptionStatus) {
         Q_EMIT encryptionStatusChanged();
     }
 }
 
 void WalletModel::pollBalanceChanged() {
     // Try to get balances and return early if locks can't be acquired. This
     // avoids the GUI from getting stuck on periodical polls if the core is
     // holding the locks for a longer time - for example, during a wallet
     // rescan.
     interfaces::WalletBalances new_balances;
     int numBlocks = -1;
     if (!m_wallet->tryGetBalances(new_balances, numBlocks)) {
         return;
     }
 
     if (fForceCheckBalanceChanged || m_node.getNumBlocks() != cachedNumBlocks) {
         fForceCheckBalanceChanged = false;
 
         // Balance and number of transactions might have changed
         cachedNumBlocks = m_node.getNumBlocks();
 
         checkBalanceChanged(new_balances);
         if (transactionTableModel) {
             transactionTableModel->updateConfirmations();
         }
     }
 }
 
 void WalletModel::checkBalanceChanged(
     const interfaces::WalletBalances &new_balances) {
     if (new_balances.balanceChanged(m_cached_balances)) {
         m_cached_balances = new_balances;
         Q_EMIT balanceChanged(new_balances);
     }
 }
 
 void WalletModel::updateTransaction() {
     // Balance and number of transactions might have changed
     fForceCheckBalanceChanged = true;
 }
 
 void WalletModel::updateAddressBook(const QString &address,
                                     const QString &label, bool isMine,
                                     const QString &purpose, int status) {
     if (addressTableModel) {
         addressTableModel->updateEntry(address, label, isMine, purpose, status);
     }
 }
 
 void WalletModel::updateWatchOnlyFlag(bool fHaveWatchonly) {
     fHaveWatchOnly = fHaveWatchonly;
     Q_EMIT notifyWatchonlyChanged(fHaveWatchonly);
 }
 
 bool WalletModel::validateAddress(const QString &address) {
     return IsValidDestinationString(address.toStdString(), getChainParams());
 }
 
 WalletModel::SendCoinsReturn
 WalletModel::prepareTransaction(WalletModelTransaction &transaction,
                                 const CCoinControl &coinControl) {
     Amount total = Amount::zero();
     bool fSubtractFeeFromAmount = false;
     QList<SendCoinsRecipient> recipients = transaction.getRecipients();
     std::vector<CRecipient> vecSend;
 
     if (recipients.empty()) {
         return OK;
     }
 
     // Used to detect duplicates
     QSet<QString> setAddress;
     int nAddresses = 0;
 
     // Pre-check input data for validity
     for (const SendCoinsRecipient &rcp : recipients) {
         if (rcp.fSubtractFeeFromAmount) {
             fSubtractFeeFromAmount = true;
         }
 
 #ifdef ENABLE_BIP70
         // PaymentRequest...
         if (rcp.paymentRequest.IsInitialized()) {
             Amount subtotal = Amount::zero();
             const payments::PaymentDetails &details =
                 rcp.paymentRequest.getDetails();
             for (int i = 0; i < details.outputs_size(); i++) {
                 const payments::Output &out = details.outputs(i);
                 if (out.amount() <= 0) {
                     continue;
                 }
 
                 subtotal += int64_t(out.amount()) * SATOSHI;
                 const uint8_t *scriptStr = (const uint8_t *)out.script().data();
                 CScript scriptPubKey(scriptStr,
                                      scriptStr + out.script().size());
                 Amount nAmount = int64_t(out.amount()) * SATOSHI;
                 CRecipient recipient = {scriptPubKey, nAmount,
                                         rcp.fSubtractFeeFromAmount};
                 vecSend.push_back(recipient);
             }
 
             if (subtotal <= Amount::zero()) {
                 return InvalidAmount;
             }
             total += subtotal;
         }
 
         // User-entered bitcoin address / amount:
         else
 #endif
         {
             if (!validateAddress(rcp.address)) {
                 return InvalidAddress;
             }
             if (rcp.amount <= Amount::zero()) {
                 return InvalidAmount;
             }
             setAddress.insert(rcp.address);
             ++nAddresses;
 
             CScript scriptPubKey = GetScriptForDestination(
                 DecodeDestination(rcp.address.toStdString(), getChainParams()));
             CRecipient recipient = {scriptPubKey, Amount(rcp.amount),
                                     rcp.fSubtractFeeFromAmount};
             vecSend.push_back(recipient);
 
             total += rcp.amount;
         }
     }
     if (setAddress.size() != nAddresses) {
         return DuplicateAddress;
     }
 
     Amount nBalance = m_wallet->getAvailableBalance(coinControl);
 
     if (total > nBalance) {
         return AmountExceedsBalance;
     }
 
     Amount nFeeRequired = Amount::zero();
     int nChangePosRet = -1;
     std::string strFailReason;
 
     auto &newTx = transaction.getWtx();
     newTx =
         m_wallet->createTransaction(vecSend, coinControl, true /* sign */,
                                     nChangePosRet, nFeeRequired, strFailReason);
     transaction.setTransactionFee(nFeeRequired);
     if (fSubtractFeeFromAmount && newTx) {
         transaction.reassignAmounts(nChangePosRet);
     }
 
     if (!newTx) {
         if (!fSubtractFeeFromAmount && (total + nFeeRequired) > nBalance) {
             return SendCoinsReturn(AmountWithFeeExceedsBalance);
         }
         Q_EMIT message(tr("Send Coins"), QString::fromStdString(strFailReason),
                        CClientUIInterface::MSG_ERROR);
         return TransactionCreationFailed;
     }
 
     // Reject absurdly high fee. (This can never happen because the
     // wallet never creates transactions with fee greater than
     // m_default_max_tx_fee. This merely a belt-and-suspenders check).
     if (nFeeRequired > m_wallet->getDefaultMaxTxFee()) {
         return AbsurdFee;
     }
 
     return SendCoinsReturn(OK);
 }
 
 WalletModel::SendCoinsReturn
 WalletModel::sendCoins(WalletModelTransaction &transaction) {
     /* store serialized transaction */
     QByteArray transaction_array;
 
     std::vector<std::pair<std::string, std::string>> vOrderForm;
     for (const SendCoinsRecipient &rcp : transaction.getRecipients()) {
 #ifdef ENABLE_BIP70
         if (rcp.paymentRequest.IsInitialized()) {
             // Make sure any payment requests involved are still valid.
             if (PaymentServer::verifyExpired(rcp.paymentRequest.getDetails())) {
                 return PaymentRequestExpired;
             }
 
             // Store PaymentRequests in wtx.vOrderForm in wallet.
             std::string value;
             rcp.paymentRequest.SerializeToString(&value);
             vOrderForm.emplace_back("PaymentRequest", std::move(value));
         } else
 #endif
         {
             if (!rcp.message.isEmpty()) {
                 // Message from normal bitcoincash:URI
                 // (bitcoincash:123...?message=example)
                 vOrderForm.emplace_back("Message", rcp.message.toStdString());
             }
         }
     }
 
     auto &newTx = transaction.getWtx();
     wallet().commitTransaction(newTx, {} /* mapValue */, std::move(vOrderForm));
 
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << *newTx;
     transaction_array.append(&(ssTx[0]), ssTx.size());
 
     // Add addresses / update labels that we've sent to the address book, and
     // emit coinsSent signal for each recipient
     for (const SendCoinsRecipient &rcp : transaction.getRecipients()) {
         // Don't touch the address book when we have a payment request
 #ifdef ENABLE_BIP70
         if (!rcp.paymentRequest.IsInitialized())
 #endif
         {
             std::string strAddress = rcp.address.toStdString();
             CTxDestination dest =
                 DecodeDestination(strAddress, getChainParams());
             std::string strLabel = rcp.label.toStdString();
             // Check if we have a new address or an updated label
             std::string name;
             if (!m_wallet->getAddress(dest, &name, /* is_mine= */ nullptr,
                                       /* purpose= */ nullptr)) {
                 m_wallet->setAddressBook(dest, strLabel, "send");
             } else if (name != strLabel) {
                 // "" means don't change purpose
                 m_wallet->setAddressBook(dest, strLabel, "");
             }
         }
-        Q_EMIT coinsSent(this, rcp, transaction_array);
+        Q_EMIT coinsSent(this->wallet(), rcp, transaction_array);
     }
 
     // update balance immediately, otherwise there could be a short noticeable
     // delay until pollBalanceChanged hits
     checkBalanceChanged(m_wallet->getBalances());
 
     return SendCoinsReturn(OK);
 }
 
 OptionsModel *WalletModel::getOptionsModel() {
     return optionsModel;
 }
 
 AddressTableModel *WalletModel::getAddressTableModel() {
     return addressTableModel;
 }
 
 TransactionTableModel *WalletModel::getTransactionTableModel() {
     return transactionTableModel;
 }
 
 RecentRequestsTableModel *WalletModel::getRecentRequestsTableModel() {
     return recentRequestsTableModel;
 }
 
 WalletModel::EncryptionStatus WalletModel::getEncryptionStatus() const {
     if (!m_wallet->isCrypted()) {
         return Unencrypted;
     } else if (m_wallet->isLocked()) {
         return Locked;
     } else {
         return Unlocked;
     }
 }
 
 bool WalletModel::setWalletEncrypted(bool encrypted,
                                      const SecureString &passphrase) {
     if (encrypted) {
         // Encrypt
         return m_wallet->encryptWallet(passphrase);
     } else {
         // Decrypt -- TODO; not supported yet
         return false;
     }
 }
 
 bool WalletModel::setWalletLocked(bool locked, const SecureString &passPhrase) {
     if (locked) {
         // Lock
         return m_wallet->lock();
     } else {
         // Unlock
         return m_wallet->unlock(passPhrase);
     }
 }
 
 bool WalletModel::changePassphrase(const SecureString &oldPass,
                                    const SecureString &newPass) {
     // Make sure wallet is locked before attempting pass change
     m_wallet->lock();
     return m_wallet->changeWalletPassphrase(oldPass, newPass);
 }
 
 // Handlers for core signals
 static void NotifyUnload(WalletModel *walletModel) {
     qDebug() << "NotifyUnload";
     bool invoked = QMetaObject::invokeMethod(walletModel, "unload");
     assert(invoked);
 }
 
 static void NotifyKeyStoreStatusChanged(WalletModel *walletmodel) {
     qDebug() << "NotifyKeyStoreStatusChanged";
     bool invoked = QMetaObject::invokeMethod(walletmodel, "updateStatus",
                                              Qt::QueuedConnection);
     assert(invoked);
 }
 
 static void NotifyAddressBookChanged(WalletModel *walletmodel,
                                      const CTxDestination &address,
                                      const std::string &label, bool isMine,
                                      const std::string &purpose,
                                      ChangeType status) {
     QString strAddress = QString::fromStdString(
         EncodeCashAddr(address, walletmodel->getChainParams()));
     QString strLabel = QString::fromStdString(label);
     QString strPurpose = QString::fromStdString(purpose);
 
     qDebug() << "NotifyAddressBookChanged: " + strAddress + " " + strLabel +
                     " isMine=" + QString::number(isMine) +
                     " purpose=" + strPurpose +
                     " status=" + QString::number(status);
     bool invoked = QMetaObject::invokeMethod(
         walletmodel, "updateAddressBook", Qt::QueuedConnection,
         Q_ARG(QString, strAddress), Q_ARG(QString, strLabel),
         Q_ARG(bool, isMine), Q_ARG(QString, strPurpose), Q_ARG(int, status));
     assert(invoked);
 }
 
 static void NotifyTransactionChanged(WalletModel *walletmodel, const TxId &hash,
                                      ChangeType status) {
     Q_UNUSED(hash);
     Q_UNUSED(status);
     bool invoked = QMetaObject::invokeMethod(walletmodel, "updateTransaction",
                                              Qt::QueuedConnection);
     assert(invoked);
 }
 
 static void ShowProgress(WalletModel *walletmodel, const std::string &title,
                          int nProgress) {
     // emits signal "showProgress"
     bool invoked = QMetaObject::invokeMethod(
         walletmodel, "showProgress", Qt::QueuedConnection,
         Q_ARG(QString, QString::fromStdString(title)), Q_ARG(int, nProgress));
     assert(invoked);
 }
 
 static void NotifyWatchonlyChanged(WalletModel *walletmodel,
                                    bool fHaveWatchonly) {
     bool invoked = QMetaObject::invokeMethod(walletmodel, "updateWatchOnlyFlag",
                                              Qt::QueuedConnection,
                                              Q_ARG(bool, fHaveWatchonly));
     assert(invoked);
 }
 
 static void NotifyCanGetAddressesChanged(WalletModel *walletmodel) {
     bool invoked =
         QMetaObject::invokeMethod(walletmodel, "canGetAddressesChanged");
     assert(invoked);
 }
 
 void WalletModel::subscribeToCoreSignals() {
     // Connect signals to wallet
     m_handler_unload = m_wallet->handleUnload(std::bind(&NotifyUnload, this));
     m_handler_status_changed = m_wallet->handleStatusChanged(
         std::bind(&NotifyKeyStoreStatusChanged, this));
     m_handler_address_book_changed = m_wallet->handleAddressBookChanged(
         std::bind(NotifyAddressBookChanged, this, std::placeholders::_1,
                   std::placeholders::_2, std::placeholders::_3,
                   std::placeholders::_4, std::placeholders::_5));
     m_handler_transaction_changed = m_wallet->handleTransactionChanged(
         std::bind(NotifyTransactionChanged, this, std::placeholders::_1,
                   std::placeholders::_2));
     m_handler_show_progress = m_wallet->handleShowProgress(std::bind(
         ShowProgress, this, std::placeholders::_1, std::placeholders::_2));
     m_handler_watch_only_changed = m_wallet->handleWatchOnlyChanged(
         std::bind(NotifyWatchonlyChanged, this, std::placeholders::_1));
     m_handler_can_get_addrs_changed = m_wallet->handleCanGetAddressesChanged(
         std::bind(NotifyCanGetAddressesChanged, this));
 }
 
 void WalletModel::unsubscribeFromCoreSignals() {
     // Disconnect signals from wallet
     m_handler_unload->disconnect();
     m_handler_status_changed->disconnect();
     m_handler_address_book_changed->disconnect();
     m_handler_transaction_changed->disconnect();
     m_handler_show_progress->disconnect();
     m_handler_watch_only_changed->disconnect();
     m_handler_can_get_addrs_changed->disconnect();
 }
 
 // WalletModel::UnlockContext implementation
 WalletModel::UnlockContext WalletModel::requestUnlock() {
     bool was_locked = getEncryptionStatus() == Locked;
     if (was_locked) {
         // Request UI to unlock wallet
         Q_EMIT requireUnlock();
     }
     // If wallet is still locked, unlock was failed or cancelled, mark context
     // as invalid
     bool valid = getEncryptionStatus() != Locked;
 
     return UnlockContext(this, valid, was_locked);
 }
 
 WalletModel::UnlockContext::UnlockContext(WalletModel *_wallet, bool _valid,
                                           bool _relock)
     : wallet(_wallet), valid(_valid), relock(_relock) {}
 
 WalletModel::UnlockContext::~UnlockContext() {
     if (valid && relock) {
         wallet->setWalletLocked(true);
     }
 }
 
 void WalletModel::UnlockContext::CopyFrom(UnlockContext &&rhs) {
     // Transfer context; old object no longer relocks wallet
     *this = rhs;
     rhs.relock = false;
 }
 
 void WalletModel::loadReceiveRequests(
     std::vector<std::string> &vReceiveRequests) {
     // receive request
     vReceiveRequests = m_wallet->getDestValues("rr");
 }
 
 bool WalletModel::saveReceiveRequest(const std::string &sAddress,
                                      const int64_t nId,
                                      const std::string &sRequest) {
     CTxDestination dest = DecodeDestination(sAddress, getChainParams());
 
     std::stringstream ss;
     ss << nId;
     // "rr" prefix = "receive request" in destdata
     std::string key = "rr" + ss.str();
 
     return sRequest.empty() ? m_wallet->eraseDestData(dest, key)
                             : m_wallet->addDestData(dest, key, sRequest);
 }
 
 bool WalletModel::isWalletEnabled() {
     return !gArgs.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET);
 }
 
 bool WalletModel::privateKeysDisabled() const {
     return m_wallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
 }
 
 bool WalletModel::canGetAddresses() const {
     return m_wallet->canGetAddresses();
 }
 
 QString WalletModel::getWalletName() const {
     return QString::fromStdString(m_wallet->getWalletName());
 }
 
 QString WalletModel::getDisplayName() const {
     const QString name = getWalletName();
     return name.isEmpty() ? "[" + tr("default wallet") + "]" : name;
 }
 
 bool WalletModel::isMultiwallet() {
     return m_node.getWallets().size() > 1;
 }
 
 const CChainParams &WalletModel::getChainParams() const {
     return Params();
 }
diff --git a/src/qt/walletmodel.h b/src/qt/walletmodel.h
index 6f74a5ab9..f52ba14af 100644
--- a/src/qt/walletmodel.h
+++ b/src/qt/walletmodel.h
@@ -1,247 +1,247 @@
 // Copyright (c) 2011-2019 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_WALLETMODEL_H
 #define BITCOIN_QT_WALLETMODEL_H
 
 #include <chainparams.h>
 #include <interfaces/wallet.h>
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/walletmodeltransaction.h>
 #include <support/allocators/secure.h>
 
 #include <QObject>
 
 #include <memory>
 #include <vector>
 
 class AddressTableModel;
 class OptionsModel;
 class PlatformStyle;
 class RecentRequestsTableModel;
 class SendCoinsRecipient;
 class TransactionTableModel;
 class WalletModelTransaction;
 
 class CCoinControl;
 class CKeyID;
 class COutPoint;
 class COutput;
 class CPubKey;
 
 namespace interfaces {
 class Node;
 } // namespace interfaces
 
 QT_BEGIN_NAMESPACE
 class QTimer;
 QT_END_NAMESPACE
 
 /** Interface to Bitcoin wallet from Qt view code. */
 class WalletModel : public QObject {
     Q_OBJECT
 
 public:
     explicit WalletModel(std::unique_ptr<interfaces::Wallet> wallet,
                          interfaces::Node &node,
                          const PlatformStyle *platformStyle,
                          OptionsModel *optionsModel, QObject *parent = nullptr);
     ~WalletModel();
 
     // Returned by sendCoins
     enum StatusCode {
         OK,
         InvalidAmount,
         InvalidAddress,
         AmountExceedsBalance,
         AmountWithFeeExceedsBalance,
         DuplicateAddress,
         // Error returned when wallet is still locked
         TransactionCreationFailed,
         AbsurdFee,
         PaymentRequestExpired
     };
 
     enum EncryptionStatus {
         // !wallet->IsCrypted()
         Unencrypted,
         // wallet->IsCrypted() && wallet->IsLocked()
         Locked,
         // wallet->IsCrypted() && !wallet->IsLocked()
         Unlocked
     };
 
     OptionsModel *getOptionsModel();
     AddressTableModel *getAddressTableModel();
     TransactionTableModel *getTransactionTableModel();
     RecentRequestsTableModel *getRecentRequestsTableModel();
 
     EncryptionStatus getEncryptionStatus() const;
 
     // Check address for validity
     bool validateAddress(const QString &address);
 
     // Return status record for SendCoins, contains error id + information
     struct SendCoinsReturn {
         SendCoinsReturn(StatusCode _status = OK,
                         QString _reasonCommitFailed = "")
             : status(_status), reasonCommitFailed(_reasonCommitFailed) {}
         StatusCode status;
         QString reasonCommitFailed;
     };
 
     // prepare transaction for getting txfee before sending coins
     SendCoinsReturn prepareTransaction(WalletModelTransaction &transaction,
                                        const CCoinControl &coinControl);
 
     // Send coins to a list of recipients
     SendCoinsReturn sendCoins(WalletModelTransaction &transaction);
 
     // Wallet encryption
     bool setWalletEncrypted(bool encrypted, const SecureString &passphrase);
     // Passphrase only needed when unlocking
     bool setWalletLocked(bool locked,
                          const SecureString &passPhrase = SecureString());
     bool changePassphrase(const SecureString &oldPass,
                           const SecureString &newPass);
 
     // RAI object for unlocking wallet, returned by requestUnlock()
     class UnlockContext {
     public:
         UnlockContext(WalletModel *wallet, bool valid, bool relock);
         ~UnlockContext();
 
         bool isValid() const { return valid; }
 
         // Copy constructor is disabled.
         UnlockContext(const UnlockContext &) = delete;
         // Move operator and constructor transfer the context
         UnlockContext(UnlockContext &&obj) { CopyFrom(std::move(obj)); }
         UnlockContext &operator=(UnlockContext &&rhs) {
             CopyFrom(std::move(rhs));
             return *this;
         }
 
     private:
         WalletModel *wallet;
         bool valid;
         // mutable, as it can be set to false by copying
         mutable bool relock;
 
         UnlockContext &operator=(const UnlockContext &) = default;
         void CopyFrom(UnlockContext &&rhs);
     };
 
     UnlockContext requestUnlock();
 
     void loadReceiveRequests(std::vector<std::string> &vReceiveRequests);
     bool saveReceiveRequest(const std::string &sAddress, const int64_t nId,
                             const std::string &sRequest);
 
     static bool isWalletEnabled();
     bool privateKeysDisabled() const;
     bool canGetAddresses() const;
 
     interfaces::Node &node() const { return m_node; }
     interfaces::Wallet &wallet() const { return *m_wallet; }
 
     const CChainParams &getChainParams() const;
 
     QString getWalletName() const;
     QString getDisplayName() const;
 
     bool isMultiwallet();
 
     AddressTableModel *getAddressTableModel() const {
         return addressTableModel;
     }
 
 private:
     std::unique_ptr<interfaces::Wallet> m_wallet;
     std::unique_ptr<interfaces::Handler> m_handler_unload;
     std::unique_ptr<interfaces::Handler> m_handler_status_changed;
     std::unique_ptr<interfaces::Handler> m_handler_address_book_changed;
     std::unique_ptr<interfaces::Handler> m_handler_transaction_changed;
     std::unique_ptr<interfaces::Handler> m_handler_show_progress;
     std::unique_ptr<interfaces::Handler> m_handler_watch_only_changed;
     std::unique_ptr<interfaces::Handler> m_handler_can_get_addrs_changed;
     interfaces::Node &m_node;
 
     bool fHaveWatchOnly;
     bool fForceCheckBalanceChanged{false};
 
     // Wallet has an options model for wallet-specific options (transaction fee,
     // for example)
     OptionsModel *optionsModel;
 
     AddressTableModel *addressTableModel;
     TransactionTableModel *transactionTableModel;
     RecentRequestsTableModel *recentRequestsTableModel;
 
     // Cache some values to be able to detect changes
     interfaces::WalletBalances m_cached_balances;
     EncryptionStatus cachedEncryptionStatus;
     int cachedNumBlocks;
 
     void subscribeToCoreSignals();
     void unsubscribeFromCoreSignals();
     void checkBalanceChanged(const interfaces::WalletBalances &new_balances);
 
 Q_SIGNALS:
     // Signal that balance in wallet changed
     void balanceChanged(const interfaces::WalletBalances &balances);
 
     // Encryption status of wallet changed
     void encryptionStatusChanged();
 
     // Signal emitted when wallet needs to be unlocked
     // It is valid behaviour for listeners to keep the wallet locked after this
     // signal; this means that the unlocking failed or was cancelled.
     void requireUnlock();
 
     // Fired when a message should be reported to the user
     void message(const QString &title, const QString &message,
                  unsigned int style);
 
     // Coins sent: from wallet, to recipient, in (serialized) transaction:
-    void coinsSent(WalletModel *wallet, SendCoinsRecipient recipient,
+    void coinsSent(interfaces::Wallet &wallet, SendCoinsRecipient recipient,
                    QByteArray transaction);
 
     // Show progress dialog e.g. for rescan
     void showProgress(const QString &title, int nProgress);
 
     // Watch-only address added
     void notifyWatchonlyChanged(bool fHaveWatchonly);
 
     // Signal that wallet is about to be removed
     void unload();
 
     // Notify that there are now keys in the keypool
     void canGetAddressesChanged();
 
 public Q_SLOTS:
     /* Starts a timer to periodically update the balance */
     void startPollBalance();
 
     /* Wallet status might have changed */
     void updateStatus();
     /** New transaction, or transaction changed status. */
     void updateTransaction();
     /** New, updated or removed address book entry. */
     void updateAddressBook(const QString &address, const QString &label,
                            bool isMine, const QString &purpose, int status);
     /** Watch-only added. */
     void updateWatchOnlyFlag(bool fHaveWatchonly);
     /**
      * Current, immature or unconfirmed balance might have changed - emit
      * 'balanceChanged' if so.
      */
     void pollBalanceChanged();
 };
 
 #endif // BITCOIN_QT_WALLETMODEL_H
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index 41c110fb8..a0e000e13 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -1,86 +1,85 @@
 #!/usr/bin/env bash
 #
 # Copyright (c) 2018 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 # Check for circular dependencies
 
 export LC_ALL=C
 
 set -euo pipefail
 
 : "${TOPLEVEL:=$(git rev-parse --show-toplevel)}"
 
 EXPECTED_CIRCULAR_DEPENDENCIES=(
     "index/txindex -> validation -> index/txindex"
     "qt/addresstablemodel -> qt/walletmodel -> qt/addresstablemodel"
     "qt/bantablemodel -> qt/clientmodel -> qt/bantablemodel"
     "qt/bitcoingui -> qt/utilitydialog -> qt/bitcoingui"
     "qt/bitcoingui -> qt/walletframe -> qt/bitcoingui"
     "qt/bitcoingui -> qt/walletview -> qt/bitcoingui"
     "qt/clientmodel -> qt/peertablemodel -> qt/clientmodel"
-    "qt/paymentserver -> qt/walletmodel -> qt/paymentserver"
     "qt/recentrequeststablemodel -> qt/walletmodel -> qt/recentrequeststablemodel"
     "qt/transactiontablemodel -> qt/walletmodel -> qt/transactiontablemodel"
     "qt/walletmodel -> qt/walletmodeltransaction -> qt/walletmodel"
     "txmempool -> validation -> txmempool"
     "wallet/fees -> wallet/wallet -> wallet/fees"
     "wallet/rpcwallet -> wallet/wallet -> wallet/rpcwallet"
     "wallet/wallet -> wallet/walletdb -> wallet/wallet"
     "avalanche/processor -> validation -> avalanche/processor"
     "chainparams -> protocol -> chainparams"
     "chainparamsbase -> util/system -> chainparamsbase"
     "minerfund -> validation -> minerfund"
     "script/scriptcache -> validation -> script/scriptcache"
     "seeder/bitcoin -> seeder/db -> seeder/bitcoin"
     "chainparams -> protocol -> config -> chainparams"
     "wallet/scriptpubkeyman -> wallet/wallet -> wallet/scriptpubkeyman"
     "checkpoints -> validation -> checkpoints"
     "pow/aserti32d -> validation -> pow/aserti32d"
     "pow/aserti32d -> validation -> pow/pow -> pow/aserti32d"
 )
 
 EXIT_CODE=0
 
 CIRCULAR_DEPENDENCIES=()
 
 pushd "${TOPLEVEL}"
 
 IFS=$'\n'
 for CIRC in $(cd src && ../contrib/devtools/circular-dependencies.py {*,*/*,*/*/*}.{h,cpp} | sed -e 's/^Circular dependency: //'); do
     CIRCULAR_DEPENDENCIES+=("$CIRC")
     IS_EXPECTED_CIRC=0
     for EXPECTED_CIRC in "${EXPECTED_CIRCULAR_DEPENDENCIES[@]}"; do
         if [[ "${CIRC}" == "${EXPECTED_CIRC}" ]]; then
             IS_EXPECTED_CIRC=1
             break
         fi
     done
     if [[ ${IS_EXPECTED_CIRC} == 0 ]]; then
         echo "A new circular dependency in the form of \"${CIRC}\" appears to have been introduced."
         echo
         EXIT_CODE=1
     fi
 done
 
 for EXPECTED_CIRC in "${EXPECTED_CIRCULAR_DEPENDENCIES[@]}"; do
     IS_PRESENT_EXPECTED_CIRC=0
     for CIRC in "${CIRCULAR_DEPENDENCIES[@]}"; do
         if [[ "${CIRC}" == "${EXPECTED_CIRC}" ]]; then
             IS_PRESENT_EXPECTED_CIRC=1
             break
         fi
     done
     if [[ ${IS_PRESENT_EXPECTED_CIRC} == 0 ]]; then
         echo "Good job! The circular dependency \"${EXPECTED_CIRC}\" is no longer present."
         echo "Please remove it from EXPECTED_CIRCULAR_DEPENDENCIES in $0"
         echo "to make sure this circular dependency is not accidentally reintroduced."
         echo
         EXIT_CODE=1
     fi
 done
 
 popd
 
 exit ${EXIT_CODE}