diff --git a/src/qt/askpassphrasedialog.cpp b/src/qt/askpassphrasedialog.cpp
index 0cc07b4d1b..3db9eba60f 100644
--- a/src/qt/askpassphrasedialog.cpp
+++ b/src/qt/askpassphrasedialog.cpp
@@ -1,278 +1,280 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/askpassphrasedialog.h>
 #include <qt/forms/ui_askpassphrasedialog.h>
 
 #include <qt/guiconstants.h>
 #include <qt/walletmodel.h>
 #include <support/allocators/secure.h>
 
 #include <QKeyEvent>
 #include <QMessageBox>
 #include <QPushButton>
 
 AskPassphraseDialog::AskPassphraseDialog(Mode _mode, QWidget *parent)
     : QDialog(parent), ui(new Ui::AskPassphraseDialog), mode(_mode), model(0),
       fCapsLock(false) {
     ui->setupUi(this);
 
     ui->passEdit1->setMinimumSize(ui->passEdit1->sizeHint());
     ui->passEdit2->setMinimumSize(ui->passEdit2->sizeHint());
     ui->passEdit3->setMinimumSize(ui->passEdit3->sizeHint());
 
     ui->passEdit1->setMaxLength(MAX_PASSPHRASE_SIZE);
     ui->passEdit2->setMaxLength(MAX_PASSPHRASE_SIZE);
     ui->passEdit3->setMaxLength(MAX_PASSPHRASE_SIZE);
 
     // Setup Caps Lock detection.
     ui->passEdit1->installEventFilter(this);
     ui->passEdit2->installEventFilter(this);
     ui->passEdit3->installEventFilter(this);
 
     switch (mode) {
         case Encrypt: // Ask passphrase x2
             ui->warningLabel->setText(
                 tr("Enter the new passphrase to the wallet.<br/>Please use a "
                    "passphrase of <b>ten or more random characters</b>, or "
                    "<b>eight or more words</b>."));
             ui->passLabel1->hide();
             ui->passEdit1->hide();
             setWindowTitle(tr("Encrypt wallet"));
             break;
         case Unlock: // Ask passphrase
             ui->warningLabel->setText(tr("This operation needs your wallet "
                                          "passphrase to unlock the wallet."));
             ui->passLabel2->hide();
             ui->passEdit2->hide();
             ui->passLabel3->hide();
             ui->passEdit3->hide();
             setWindowTitle(tr("Unlock wallet"));
             break;
         case Decrypt: // Ask passphrase
             ui->warningLabel->setText(tr("This operation needs your wallet "
                                          "passphrase to decrypt the wallet."));
             ui->passLabel2->hide();
             ui->passEdit2->hide();
             ui->passLabel3->hide();
             ui->passEdit3->hide();
             setWindowTitle(tr("Decrypt wallet"));
             break;
         case ChangePass: // Ask old passphrase + new passphrase x2
             setWindowTitle(tr("Change passphrase"));
             ui->warningLabel->setText(tr(
                 "Enter the old passphrase and new passphrase to the wallet."));
             break;
     }
     textChanged();
     connect(ui->toggleShowPasswordButton, &QPushButton::toggled, this,
             &AskPassphraseDialog::toggleShowPassword);
     connect(ui->passEdit1, &QLineEdit::textChanged, this,
             &AskPassphraseDialog::textChanged);
     connect(ui->passEdit2, &QLineEdit::textChanged, this,
             &AskPassphraseDialog::textChanged);
     connect(ui->passEdit3, &QLineEdit::textChanged, this,
             &AskPassphraseDialog::textChanged);
 }
 
 AskPassphraseDialog::~AskPassphraseDialog() {
     secureClearPassFields();
     delete ui;
 }
 
 void AskPassphraseDialog::setModel(WalletModel *_model) {
     this->model = _model;
 }
 
 void AskPassphraseDialog::accept() {
     SecureString oldpass, newpass1, newpass2;
-    if (!model) return;
+    if (!model) {
+        return;
+    }
     oldpass.reserve(MAX_PASSPHRASE_SIZE);
     newpass1.reserve(MAX_PASSPHRASE_SIZE);
     newpass2.reserve(MAX_PASSPHRASE_SIZE);
     // TODO: get rid of this .c_str() by implementing
     // SecureString::operator=(std::string)
     // Alternately, find a way to make this input mlock()'d to begin with.
     oldpass.assign(ui->passEdit1->text().toStdString().c_str());
     newpass1.assign(ui->passEdit2->text().toStdString().c_str());
     newpass2.assign(ui->passEdit3->text().toStdString().c_str());
 
     secureClearPassFields();
 
     switch (mode) {
         case Encrypt: {
             if (newpass1.empty() || newpass2.empty()) {
                 // Cannot encrypt with empty passphrase
                 break;
             }
             QMessageBox::StandardButton retval = QMessageBox::question(
                 this, tr("Confirm wallet encryption"),
                 tr("Warning: If you encrypt your wallet and lose your "
                    "passphrase, you will <b>LOSE ALL OF YOUR BITCOINS</b>!") +
                     "<br><br>" +
                     tr("Are you sure you wish to encrypt your wallet?"),
                 QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Cancel);
             if (retval == QMessageBox::Yes) {
                 if (newpass1 == newpass2) {
                     if (model->setWalletEncrypted(true, newpass1)) {
                         QMessageBox::warning(
                             this, tr("Wallet encrypted"),
                             "<qt>" +
                                 tr("Your wallet is now encrypted. "
                                    "Remember that encrypting your wallet "
                                    "cannot fully protect your bitcoins from "
                                    "being stolen by malware infecting your "
                                    "computer.") +
                                 "<br><br><b>" +
                                 tr("IMPORTANT: Any previous backups you have "
                                    "made of your wallet file should be "
                                    "replaced with the newly generated, "
                                    "encrypted wallet file. "
                                    "For security reasons, previous backups of "
                                    "the unencrypted wallet file will become "
                                    "useless as soon as you start using the "
                                    "new, encrypted wallet.") +
                                 "</b></qt>");
                     } else {
                         QMessageBox::critical(
                             this, tr("Wallet encryption failed"),
                             tr("Wallet encryption failed due to an internal "
                                "error. Your wallet was not encrypted."));
                     }
                     QDialog::accept(); // Success
                 } else {
                     QMessageBox::critical(
                         this, tr("Wallet encryption failed"),
                         tr("The supplied passphrases do not match."));
                 }
             } else {
                 QDialog::reject(); // Cancelled
             }
         } break;
         case Unlock:
             if (!model->setWalletLocked(false, oldpass)) {
                 QMessageBox::critical(this, tr("Wallet unlock failed"),
                                       tr("The passphrase entered for the "
                                          "wallet decryption was incorrect."));
             } else {
                 QDialog::accept(); // Success
             }
             break;
         case Decrypt:
             if (!model->setWalletEncrypted(false, oldpass)) {
                 QMessageBox::critical(this, tr("Wallet decryption failed"),
                                       tr("The passphrase entered for the "
                                          "wallet decryption was incorrect."));
             } else {
                 QDialog::accept(); // Success
             }
             break;
         case ChangePass:
             if (newpass1 == newpass2) {
                 if (model->changePassphrase(oldpass, newpass1)) {
                     QMessageBox::information(
                         this, tr("Wallet encrypted"),
                         tr("Wallet passphrase was successfully changed."));
                     QDialog::accept(); // Success
                 } else {
                     QMessageBox::critical(
                         this, tr("Wallet encryption failed"),
                         tr("The passphrase entered for the wallet decryption "
                            "was incorrect."));
                 }
             } else {
                 QMessageBox::critical(
                     this, tr("Wallet encryption failed"),
                     tr("The supplied passphrases do not match."));
             }
             break;
     }
 }
 
 void AskPassphraseDialog::textChanged() {
     // Validate input, set Ok button to enabled when acceptable
     bool acceptable = false;
     switch (mode) {
         case Encrypt: // New passphrase x2
             acceptable = !ui->passEdit2->text().isEmpty() &&
                          !ui->passEdit3->text().isEmpty();
             break;
         case Unlock: // Old passphrase x1
         case Decrypt:
             acceptable = !ui->passEdit1->text().isEmpty();
             break;
         case ChangePass: // Old passphrase x1, new passphrase x2
             acceptable = !ui->passEdit1->text().isEmpty() &&
                          !ui->passEdit2->text().isEmpty() &&
                          !ui->passEdit3->text().isEmpty();
             break;
     }
     ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(acceptable);
 }
 
 bool AskPassphraseDialog::event(QEvent *event) {
     // Detect Caps Lock key press.
     if (event->type() == QEvent::KeyPress) {
         QKeyEvent *ke = static_cast<QKeyEvent *>(event);
         if (ke->key() == Qt::Key_CapsLock) {
             fCapsLock = !fCapsLock;
         }
         if (fCapsLock) {
             ui->capsLabel->setText(tr("Warning: The Caps Lock key is on!"));
         } else {
             ui->capsLabel->clear();
         }
     }
     return QWidget::event(event);
 }
 
 void AskPassphraseDialog::toggleShowPassword(bool show) {
     ui->toggleShowPasswordButton->setDown(show);
     const auto renderingMode = show ? QLineEdit::Normal : QLineEdit::Password;
     ui->passEdit1->setEchoMode(renderingMode);
     ui->passEdit2->setEchoMode(renderingMode);
     ui->passEdit3->setEchoMode(renderingMode);
 }
 
 bool AskPassphraseDialog::eventFilter(QObject *object, QEvent *event) {
     /* Detect Caps Lock.
      * There is no good OS-independent way to check a key state in Qt, but we
      * can detect Caps Lock by checking for the following condition:
      * Shift key is down and the result is a lower case character, or
      * Shift key is not down and the result is an upper case character.
      */
     if (event->type() == QEvent::KeyPress) {
         QKeyEvent *ke = static_cast<QKeyEvent *>(event);
         QString str = ke->text();
         if (str.length() != 0) {
             const QChar *psz = str.unicode();
             bool fShift = (ke->modifiers() & Qt::ShiftModifier) != 0;
             if ((fShift && *psz >= 'a' && *psz <= 'z') ||
                 (!fShift && *psz >= 'A' && *psz <= 'Z')) {
                 fCapsLock = true;
                 ui->capsLabel->setText(tr("Warning: The Caps Lock key is on!"));
             } else if (psz->isLetter()) {
                 fCapsLock = false;
                 ui->capsLabel->clear();
             }
         }
     }
     return QDialog::eventFilter(object, event);
 }
 
 static void SecureClearQLineEdit(QLineEdit *edit) {
     // Attempt to overwrite text so that they do not linger around in memory
     edit->setText(QString(" ").repeated(edit->text().size()));
     edit->clear();
 }
 
 void AskPassphraseDialog::secureClearPassFields() {
     SecureClearQLineEdit(ui->passEdit1);
     SecureClearQLineEdit(ui->passEdit2);
     SecureClearQLineEdit(ui->passEdit3);
 }
diff --git a/src/qt/bantablemodel.cpp b/src/qt/bantablemodel.cpp
index 646187b521..99d76a2409 100644
--- a/src/qt/bantablemodel.cpp
+++ b/src/qt/bantablemodel.cpp
@@ -1,161 +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.
 
 #include <qt/bantablemodel.h>
 
 #include <qt/clientmodel.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 
 #include <interfaces/node.h>
 #include <sync.h>
 #include <util/time.h>
 
 #include <algorithm>
 
 #include <QDebug>
 #include <QList>
 
 bool BannedNodeLessThan::operator()(const CCombinedBan &left,
                                     const CCombinedBan &right) const {
     const CCombinedBan *pLeft = &left;
     const CCombinedBan *pRight = &right;
 
-    if (order == Qt::DescendingOrder) std::swap(pLeft, pRight);
+    if (order == Qt::DescendingOrder) {
+        std::swap(pLeft, pRight);
+    }
 
     switch (column) {
         case BanTableModel::Address:
             return pLeft->subnet.ToString().compare(pRight->subnet.ToString()) <
                    0;
         case BanTableModel::Bantime:
             return pLeft->banEntry.nBanUntil < pRight->banEntry.nBanUntil;
     }
 
     return false;
 }
 
 // private implementation
 class BanTablePriv {
 public:
     /** Local cache of peer information */
     QList<CCombinedBan> cachedBanlist;
     /** Column to sort nodes by (default to unsorted) */
     int sortColumn{-1};
     /** Order (ascending or descending) to sort nodes by */
     Qt::SortOrder sortOrder;
 
     /** Pull a full list of banned nodes from CNode into our cache */
     void refreshBanlist(interfaces::Node &node) {
         banmap_t banMap;
         node.getBanned(banMap);
 
         cachedBanlist.clear();
         cachedBanlist.reserve(banMap.size());
         for (const auto &entry : banMap) {
             CCombinedBan banEntry;
             banEntry.subnet = entry.first;
             banEntry.banEntry = entry.second;
             cachedBanlist.append(banEntry);
         }
 
         if (sortColumn >= 0) {
             // sort cachedBanlist (use stable sort to prevent rows jumping
             // around unnecessarily)
             std::stable_sort(cachedBanlist.begin(), cachedBanlist.end(),
                              BannedNodeLessThan(sortColumn, sortOrder));
         }
     }
 
     int size() const { return cachedBanlist.size(); }
 
     CCombinedBan *index(int idx) {
-        if (idx >= 0 && idx < cachedBanlist.size()) return &cachedBanlist[idx];
+        if (idx >= 0 && idx < cachedBanlist.size()) {
+            return &cachedBanlist[idx];
+        }
 
         return 0;
     }
 };
 
 BanTableModel::BanTableModel(interfaces::Node &node, ClientModel *parent)
     : QAbstractTableModel(parent), m_node(node), clientModel(parent) {
     columns << tr("IP/Netmask") << tr("Banned Until");
     priv.reset(new BanTablePriv());
 
     // load initial data
     refresh();
 }
 
 BanTableModel::~BanTableModel() {
     // Intentionally left empty
 }
 
 int BanTableModel::rowCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return priv->size();
 }
 
 int BanTableModel::columnCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return columns.length();
 }
 
 QVariant BanTableModel::data(const QModelIndex &index, int role) const {
-    if (!index.isValid()) return QVariant();
+    if (!index.isValid()) {
+        return QVariant();
+    }
 
     CCombinedBan *rec = static_cast<CCombinedBan *>(index.internalPointer());
 
     if (role == Qt::DisplayRole) {
         switch (index.column()) {
             case Address:
                 return QString::fromStdString(rec->subnet.ToString());
             case Bantime:
                 QDateTime date = QDateTime::fromMSecsSinceEpoch(0);
                 date = date.addSecs(rec->banEntry.nBanUntil);
                 return date.toString(Qt::SystemLocaleLongDate);
         }
     }
 
     return QVariant();
 }
 
 QVariant BanTableModel::headerData(int section, Qt::Orientation orientation,
                                    int role) const {
     if (orientation == Qt::Horizontal) {
         if (role == Qt::DisplayRole && section < columns.size()) {
             return columns[section];
         }
     }
     return QVariant();
 }
 
 Qt::ItemFlags BanTableModel::flags(const QModelIndex &index) const {
-    if (!index.isValid()) return 0;
+    if (!index.isValid()) {
+        return 0;
+    }
 
     Qt::ItemFlags retval = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
     return retval;
 }
 
 QModelIndex BanTableModel::index(int row, int column,
                                  const QModelIndex &parent) const {
     Q_UNUSED(parent);
     CCombinedBan *data = priv->index(row);
 
-    if (data) return createIndex(row, column, data);
+    if (data) {
+        return createIndex(row, column, data);
+    }
     return QModelIndex();
 }
 
 void BanTableModel::refresh() {
     Q_EMIT layoutAboutToBeChanged();
     priv->refreshBanlist(m_node);
     Q_EMIT layoutChanged();
 }
 
 void BanTableModel::sort(int column, Qt::SortOrder order) {
     priv->sortColumn = column;
     priv->sortOrder = order;
     refresh();
 }
 
 bool BanTableModel::shouldShow() {
     return priv->size() > 0;
 }
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index cb679f04c5..eacdc7ab81 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -1,1463 +1,1481 @@
 // 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.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/bitcoingui.h>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <noui.h>
 #include <qt/bitcoinunits.h>
 #include <qt/clientmodel.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #ifdef Q_OS_MAC
 #include <qt/macdockiconhandler.h>
 #endif
 #include <qt/modaloverlay.h>
 #include <qt/networkstyle.h>
 #include <qt/notificator.h>
 #include <qt/openuridialog.h>
 #include <qt/optionsdialog.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/rpcconsole.h>
 #include <qt/utilitydialog.h>
 #ifdef ENABLE_WALLET
 #include <qt/walletcontroller.h>
 #include <qt/walletframe.h>
 #include <qt/walletmodel.h>
 #include <qt/walletview.h>
 #endif // ENABLE_WALLET
 #include <ui_interface.h>
 #include <util/system.h>
 
 #include <QAction>
 #include <QApplication>
 #include <QComboBox>
 #include <QDateTime>
 #include <QDesktopWidget>
 #include <QDragEnterEvent>
 #include <QListWidget>
 #include <QMenuBar>
 #include <QMessageBox>
 #include <QMimeData>
 #include <QProgressDialog>
 #include <QSettings>
 #include <QShortcut>
 #include <QStackedWidget>
 #include <QStatusBar>
 #include <QStyle>
 #include <QTimer>
 #include <QToolBar>
 #include <QUrlQuery>
 #include <QVBoxLayout>
 
 const std::string BitcoinGUI::DEFAULT_UIPLATFORM =
 #if defined(Q_OS_MAC)
     "macosx"
 #elif defined(Q_OS_WIN)
     "windows"
 #else
     "other"
 #endif
     ;
 
 BitcoinGUI::BitcoinGUI(interfaces::Node &node, const Config *configIn,
                        const PlatformStyle *_platformStyle,
                        const NetworkStyle *networkStyle, QWidget *parent)
     : QMainWindow(parent), m_node(node), config(configIn),
       platformStyle(_platformStyle), m_network_style(networkStyle) {
     QSettings settings;
     if (!restoreGeometry(settings.value("MainWindowGeometry").toByteArray())) {
         // Restore failed (perhaps missing setting), center the window
         move(QApplication::desktop()->availableGeometry().center() -
              frameGeometry().center());
     }
 
 #ifdef ENABLE_WALLET
     enableWallet = WalletModel::isWalletEnabled();
 #endif // ENABLE_WALLET
     QApplication::setWindowIcon(m_network_style->getTrayAndWindowIcon());
     setWindowIcon(m_network_style->getTrayAndWindowIcon());
     updateWindowTitle();
 
     rpcConsole = new RPCConsole(node, _platformStyle, 0);
     helpMessageDialog = new HelpMessageDialog(node, this, false);
 #ifdef ENABLE_WALLET
     if (enableWallet) {
         /** Create wallet frame and make it the central widget */
         walletFrame = new WalletFrame(_platformStyle, this);
         setCentralWidget(walletFrame);
     } else
 #endif // ENABLE_WALLET
     {
         /**
          * When compiled without wallet or -disablewallet is provided,  the
          * central widget is the rpc console.
          */
         setCentralWidget(rpcConsole);
         Q_EMIT consoleShown(rpcConsole);
     }
 
     // Accept D&D of URIs
     setAcceptDrops(true);
 
     // Create actions for the toolbar, menu bar and tray/dock icon
     // Needs walletFrame to be initialized
     createActions();
 
     // Create application menu bar
     createMenuBar();
 
     // Create the toolbars
     createToolBars();
 
     // Create system tray icon and notification
     if (QSystemTrayIcon::isSystemTrayAvailable()) {
         createTrayIcon();
     }
     notificator =
         new Notificator(QApplication::applicationName(), trayIcon, this);
 
     // Create status bar
     statusBar();
 
     // Disable size grip because it looks ugly and nobody needs it
     statusBar()->setSizeGripEnabled(false);
 
     // Status bar notification icons
     QFrame *frameBlocks = new QFrame();
     frameBlocks->setContentsMargins(0, 0, 0, 0);
     frameBlocks->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
     QHBoxLayout *frameBlocksLayout = new QHBoxLayout(frameBlocks);
     frameBlocksLayout->setContentsMargins(3, 0, 3, 0);
     frameBlocksLayout->setSpacing(3);
     unitDisplayControl = new UnitDisplayStatusBarControl(platformStyle);
     labelWalletEncryptionIcon = new QLabel();
     labelWalletHDStatusIcon = new QLabel();
     labelProxyIcon = new GUIUtil::ClickableLabel();
     connectionsControl = new GUIUtil::ClickableLabel();
     labelBlocksIcon = new GUIUtil::ClickableLabel();
     if (enableWallet) {
         frameBlocksLayout->addStretch();
         frameBlocksLayout->addWidget(unitDisplayControl);
         frameBlocksLayout->addStretch();
         frameBlocksLayout->addWidget(labelWalletEncryptionIcon);
         frameBlocksLayout->addWidget(labelWalletHDStatusIcon);
     }
     frameBlocksLayout->addWidget(labelProxyIcon);
     frameBlocksLayout->addStretch();
     frameBlocksLayout->addWidget(connectionsControl);
     frameBlocksLayout->addStretch();
     frameBlocksLayout->addWidget(labelBlocksIcon);
     frameBlocksLayout->addStretch();
 
     // Progress bar and label for blocks download
     progressBarLabel = new QLabel();
     progressBarLabel->setVisible(false);
     progressBar = new GUIUtil::ProgressBar();
     progressBar->setAlignment(Qt::AlignCenter);
     progressBar->setVisible(false);
 
     // Override style sheet for progress bar for styles that have a segmented
     // progress bar, as they make the text unreadable (workaround for issue
     // #1071)
     // See https://doc.qt.io/qt-5/gallery.html
     QString curStyle = QApplication::style()->metaObject()->className();
     if (curStyle == "QWindowsStyle" || curStyle == "QWindowsXPStyle") {
         progressBar->setStyleSheet(
             "QProgressBar { background-color: #e8e8e8; border: 1px solid grey; "
             "border-radius: 7px; padding: 1px; text-align: center; } "
             "QProgressBar::chunk { background: QLinearGradient(x1: 0, y1: 0, "
             "x2: 1, y2: 0, stop: 0 #FF8000, stop: 1 orange); border-radius: "
             "7px; margin: 0px; }");
     }
 
     statusBar()->addWidget(progressBarLabel);
     statusBar()->addWidget(progressBar);
     statusBar()->addPermanentWidget(frameBlocks);
 
     // Install event filter to be able to catch status tip events
     // (QEvent::StatusTip)
     this->installEventFilter(this);
 
     // Initially wallet actions should be disabled
     setWalletActionsEnabled(false);
 
     // Subscribe to notifications from core
     subscribeToCoreSignals();
 
     connect(connectionsControl, &GUIUtil::ClickableLabel::clicked,
             [this] { m_node.setNetworkActive(!m_node.getNetworkActive()); });
     connect(labelProxyIcon, &GUIUtil::ClickableLabel::clicked,
             [this] { openOptionsDialogWithTab(OptionsDialog::TAB_NETWORK); });
 
     modalOverlay = new ModalOverlay(this->centralWidget());
 #ifdef ENABLE_WALLET
     if (enableWallet) {
         connect(walletFrame, &WalletFrame::requestedSyncWarningInfo, this,
                 &BitcoinGUI::showModalOverlay);
         connect(labelBlocksIcon, &GUIUtil::ClickableLabel::clicked, this,
                 &BitcoinGUI::showModalOverlay);
         connect(progressBar, &GUIUtil::ClickableProgressBar::clicked, this,
                 &BitcoinGUI::showModalOverlay);
     }
 #endif
 }
 
 BitcoinGUI::~BitcoinGUI() {
     // Unsubscribe from notifications from core
     unsubscribeFromCoreSignals();
 
     QSettings settings;
     settings.setValue("MainWindowGeometry", saveGeometry());
     // Hide tray icon, as deleting will let it linger until quit (on Ubuntu)
     if (trayIcon) {
         trayIcon->hide();
     }
 #ifdef Q_OS_MAC
     delete appMenuBar;
     MacDockIconHandler::cleanup();
 #endif
 
     delete rpcConsole;
 }
 
 void BitcoinGUI::createActions() {
     QActionGroup *tabGroup = new QActionGroup(this);
 
     overviewAction =
         new QAction(platformStyle->SingleColorIcon(":/icons/overview"),
                     tr("&Overview"), this);
     overviewAction->setStatusTip(tr("Show general overview of wallet"));
     overviewAction->setToolTip(overviewAction->statusTip());
     overviewAction->setCheckable(true);
     overviewAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_1));
     tabGroup->addAction(overviewAction);
 
     sendCoinsAction = new QAction(
         platformStyle->SingleColorIcon(":/icons/send"), tr("&Send"), this);
     sendCoinsAction->setStatusTip(tr("Send coins to a Bitcoin address"));
     sendCoinsAction->setToolTip(sendCoinsAction->statusTip());
     sendCoinsAction->setCheckable(true);
     sendCoinsAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_2));
     tabGroup->addAction(sendCoinsAction);
 
     sendCoinsMenuAction =
         new QAction(platformStyle->TextColorIcon(":/icons/send"),
                     sendCoinsAction->text(), this);
     sendCoinsMenuAction->setStatusTip(sendCoinsAction->statusTip());
     sendCoinsMenuAction->setToolTip(sendCoinsMenuAction->statusTip());
 
     receiveCoinsAction = new QAction(
         platformStyle->SingleColorIcon(":/icons/receiving_addresses"),
         tr("&Receive"), this);
     receiveCoinsAction->setStatusTip(
         tr("Request payments (generates QR codes and %1: URIs)")
             .arg(QString::fromStdString(
                 config->GetChainParams().CashAddrPrefix())));
     receiveCoinsAction->setToolTip(receiveCoinsAction->statusTip());
     receiveCoinsAction->setCheckable(true);
     receiveCoinsAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_3));
     tabGroup->addAction(receiveCoinsAction);
 
     receiveCoinsMenuAction =
         new QAction(platformStyle->TextColorIcon(":/icons/receiving_addresses"),
                     receiveCoinsAction->text(), this);
     receiveCoinsMenuAction->setStatusTip(receiveCoinsAction->statusTip());
     receiveCoinsMenuAction->setToolTip(receiveCoinsMenuAction->statusTip());
 
     historyAction =
         new QAction(platformStyle->SingleColorIcon(":/icons/history"),
                     tr("&Transactions"), this);
     historyAction->setStatusTip(tr("Browse transaction history"));
     historyAction->setToolTip(historyAction->statusTip());
     historyAction->setCheckable(true);
     historyAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_4));
     tabGroup->addAction(historyAction);
 
 #ifdef ENABLE_WALLET
     // These showNormalIfMinimized are needed because Send Coins and Receive
     // Coins can be triggered from the tray menu, and need to show the GUI to be
     // useful.
     connect(overviewAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(overviewAction, &QAction::triggered, this,
             &BitcoinGUI::gotoOverviewPage);
     connect(sendCoinsAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(sendCoinsAction, &QAction::triggered,
             [this] { gotoSendCoinsPage(); });
     connect(sendCoinsMenuAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(sendCoinsMenuAction, &QAction::triggered,
             [this] { gotoSendCoinsPage(); });
     connect(receiveCoinsAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(receiveCoinsAction, &QAction::triggered, this,
             &BitcoinGUI::gotoReceiveCoinsPage);
     connect(receiveCoinsMenuAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(receiveCoinsMenuAction, &QAction::triggered, this,
             &BitcoinGUI::gotoReceiveCoinsPage);
     connect(historyAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(historyAction, &QAction::triggered, this,
             &BitcoinGUI::gotoHistoryPage);
 #endif // ENABLE_WALLET
 
     quitAction = new QAction(platformStyle->TextColorIcon(":/icons/quit"),
                              tr("E&xit"), this);
     quitAction->setStatusTip(tr("Quit application"));
     quitAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q));
     quitAction->setMenuRole(QAction::QuitRole);
     aboutAction = new QAction(platformStyle->TextColorIcon(":/icons/about"),
                               tr("&About %1").arg(tr(PACKAGE_NAME)), this);
     aboutAction->setStatusTip(
         tr("Show information about %1").arg(tr(PACKAGE_NAME)));
     aboutAction->setMenuRole(QAction::AboutRole);
     aboutAction->setEnabled(false);
     aboutQtAction =
         new QAction(platformStyle->TextColorIcon(":/icons/about_qt"),
                     tr("About &Qt"), this);
     aboutQtAction->setStatusTip(tr("Show information about Qt"));
     aboutQtAction->setMenuRole(QAction::AboutQtRole);
     optionsAction = new QAction(platformStyle->TextColorIcon(":/icons/options"),
                                 tr("&Options..."), this);
     optionsAction->setStatusTip(
         tr("Modify configuration options for %1").arg(tr(PACKAGE_NAME)));
     optionsAction->setMenuRole(QAction::PreferencesRole);
     optionsAction->setEnabled(false);
     toggleHideAction =
         new QAction(platformStyle->TextColorIcon(":/icons/about"),
                     tr("&Show / Hide"), this);
     toggleHideAction->setStatusTip(tr("Show or hide the main Window"));
 
     encryptWalletAction =
         new QAction(platformStyle->TextColorIcon(":/icons/lock_closed"),
                     tr("&Encrypt Wallet..."), this);
     encryptWalletAction->setStatusTip(
         tr("Encrypt the private keys that belong to your wallet"));
     encryptWalletAction->setCheckable(true);
     backupWalletAction =
         new QAction(platformStyle->TextColorIcon(":/icons/filesave"),
                     tr("&Backup Wallet..."), this);
     backupWalletAction->setStatusTip(tr("Backup wallet to another location"));
     changePassphraseAction =
         new QAction(platformStyle->TextColorIcon(":/icons/key"),
                     tr("&Change Passphrase..."), this);
     changePassphraseAction->setStatusTip(
         tr("Change the passphrase used for wallet encryption"));
     signMessageAction =
         new QAction(platformStyle->TextColorIcon(":/icons/edit"),
                     tr("Sign &message..."), this);
     signMessageAction->setStatusTip(
         tr("Sign messages with your Bitcoin addresses to prove you own them"));
     verifyMessageAction =
         new QAction(platformStyle->TextColorIcon(":/icons/verify"),
                     tr("&Verify message..."), this);
     verifyMessageAction->setStatusTip(
         tr("Verify messages to ensure they were signed with specified Bitcoin "
            "addresses"));
 
     openRPCConsoleAction =
         new QAction(platformStyle->TextColorIcon(":/icons/debugwindow"),
                     tr("&Debug window"), this);
     openRPCConsoleAction->setStatusTip(
         tr("Open debugging and diagnostic console"));
     // initially disable the debug window menu item
     openRPCConsoleAction->setEnabled(false);
     openRPCConsoleAction->setObjectName("openRPCConsoleAction");
 
     usedSendingAddressesAction =
         new QAction(platformStyle->TextColorIcon(":/icons/address-book"),
                     tr("&Sending addresses..."), this);
     usedSendingAddressesAction->setStatusTip(
         tr("Show the list of used sending addresses and labels"));
     usedReceivingAddressesAction =
         new QAction(platformStyle->TextColorIcon(":/icons/address-book"),
                     tr("&Receiving addresses..."), this);
     usedReceivingAddressesAction->setStatusTip(
         tr("Show the list of used receiving addresses and labels"));
 
     openAction = new QAction(platformStyle->TextColorIcon(":/icons/open"),
                              tr("Open &URI..."), this);
     openAction->setStatusTip(
         tr("Open a %1: URI or payment request")
             .arg(QString::fromStdString(
                 config->GetChainParams().CashAddrPrefix())));
 
     showHelpMessageAction =
         new QAction(platformStyle->TextColorIcon(":/icons/info"),
                     tr("&Command-line options"), this);
     showHelpMessageAction->setMenuRole(QAction::NoRole);
     showHelpMessageAction->setStatusTip(
         tr("Show the %1 help message to get a list with possible Bitcoin "
            "command-line options")
             .arg(tr(PACKAGE_NAME)));
 
     connect(quitAction, &QAction::triggered, qApp, QApplication::quit);
     connect(aboutAction, &QAction::triggered, this, &BitcoinGUI::aboutClicked);
     connect(aboutQtAction, &QAction::triggered, qApp, QApplication::aboutQt);
     connect(optionsAction, &QAction::triggered, this,
             &BitcoinGUI::optionsClicked);
     connect(toggleHideAction, &QAction::triggered, this,
             &BitcoinGUI::toggleHidden);
     connect(showHelpMessageAction, &QAction::triggered, this,
             &BitcoinGUI::showHelpMessageClicked);
     connect(openRPCConsoleAction, &QAction::triggered, this,
             &BitcoinGUI::showDebugWindow);
     // prevents an open debug window from becoming stuck/unusable on client
     // shutdown
     connect(quitAction, &QAction::triggered, rpcConsole, &QWidget::hide);
 
 #ifdef ENABLE_WALLET
     if (walletFrame) {
         connect(encryptWalletAction, &QAction::triggered, walletFrame,
                 &WalletFrame::encryptWallet);
         connect(backupWalletAction, &QAction::triggered, walletFrame,
                 &WalletFrame::backupWallet);
         connect(changePassphraseAction, &QAction::triggered, walletFrame,
                 &WalletFrame::changePassphrase);
         connect(signMessageAction, &QAction::triggered,
                 [this] { showNormalIfMinimized(); });
         connect(signMessageAction, &QAction::triggered,
                 [this] { gotoSignMessageTab(); });
         connect(verifyMessageAction, &QAction::triggered,
                 [this] { showNormalIfMinimized(); });
         connect(verifyMessageAction, &QAction::triggered,
                 [this] { gotoVerifyMessageTab(); });
         connect(usedSendingAddressesAction, &QAction::triggered, walletFrame,
                 &WalletFrame::usedSendingAddresses);
         connect(usedReceivingAddressesAction, &QAction::triggered, walletFrame,
                 &WalletFrame::usedReceivingAddresses);
         connect(openAction, &QAction::triggered, this,
                 &BitcoinGUI::openClicked);
     }
 #endif // ENABLE_WALLET
 
     connect(new QShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_C), this),
             &QShortcut::activated, this,
             &BitcoinGUI::showDebugWindowActivateConsole);
     connect(new QShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_D), this),
             &QShortcut::activated, this, &BitcoinGUI::showDebugWindow);
 }
 
 void BitcoinGUI::createMenuBar() {
 #ifdef Q_OS_MAC
     // Create a decoupled menu bar on Mac which stays even if the window is
     // closed
     appMenuBar = new QMenuBar();
 #else
     // Get the main window's menu bar on other platforms
     appMenuBar = menuBar();
 #endif
 
     // Configure the menus
     QMenu *file = appMenuBar->addMenu(tr("&File"));
     if (walletFrame) {
         file->addAction(openAction);
         file->addAction(backupWalletAction);
         file->addAction(signMessageAction);
         file->addAction(verifyMessageAction);
         file->addSeparator();
         file->addAction(usedSendingAddressesAction);
         file->addAction(usedReceivingAddressesAction);
         file->addSeparator();
     }
     file->addAction(quitAction);
 
     QMenu *settings = appMenuBar->addMenu(tr("&Settings"));
     if (walletFrame) {
         settings->addAction(encryptWalletAction);
         settings->addAction(changePassphraseAction);
         settings->addSeparator();
     }
     settings->addAction(optionsAction);
 
     QMenu *help = appMenuBar->addMenu(tr("&Help"));
     if (walletFrame) {
         help->addAction(openRPCConsoleAction);
     }
     help->addAction(showHelpMessageAction);
     help->addSeparator();
     help->addAction(aboutAction);
     help->addAction(aboutQtAction);
 }
 
 void BitcoinGUI::createToolBars() {
     if (walletFrame) {
         QToolBar *toolbar = addToolBar(tr("Tabs toolbar"));
         appToolBar = toolbar;
         toolbar->setContextMenuPolicy(Qt::PreventContextMenu);
         toolbar->setMovable(false);
         toolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
         toolbar->addAction(overviewAction);
         toolbar->addAction(sendCoinsAction);
         toolbar->addAction(receiveCoinsAction);
         toolbar->addAction(historyAction);
         overviewAction->setChecked(true);
 
 #ifdef ENABLE_WALLET
         QWidget *spacer = new QWidget();
         spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
         toolbar->addWidget(spacer);
 
         m_wallet_selector = new QComboBox();
         connect(m_wallet_selector,
                 static_cast<void (QComboBox::*)(int)>(
                     &QComboBox::currentIndexChanged),
                 this, &BitcoinGUI::setCurrentWalletBySelectorIndex);
 
         m_wallet_selector_label = new QLabel();
         m_wallet_selector_label->setText(tr("Wallet:") + " ");
         m_wallet_selector_label->setBuddy(m_wallet_selector);
 
         m_wallet_selector_label_action =
             appToolBar->addWidget(m_wallet_selector_label);
         m_wallet_selector_action = appToolBar->addWidget(m_wallet_selector);
 
         m_wallet_selector_label_action->setVisible(false);
         m_wallet_selector_action->setVisible(false);
 #endif
     }
 }
 
 void BitcoinGUI::setClientModel(ClientModel *_clientModel) {
     this->clientModel = _clientModel;
     if (_clientModel) {
         // Create system tray menu (or setup the dock menu) that late to prevent
         // users from calling actions, while the client has not yet fully loaded
         createTrayIconMenu();
 
         // Keep up to date with client
         updateNetworkState();
         connect(_clientModel, &ClientModel::numConnectionsChanged, this,
                 &BitcoinGUI::setNumConnections);
         connect(_clientModel, &ClientModel::networkActiveChanged, this,
                 &BitcoinGUI::setNetworkActive);
 
         modalOverlay->setKnownBestHeight(
             _clientModel->getHeaderTipHeight(),
             QDateTime::fromTime_t(_clientModel->getHeaderTipTime()));
         setNumBlocks(m_node.getNumBlocks(),
                      QDateTime::fromTime_t(m_node.getLastBlockTime()),
                      m_node.getVerificationProgress(), false);
         connect(_clientModel, &ClientModel::numBlocksChanged, this,
                 &BitcoinGUI::setNumBlocks);
 
         // Receive and report messages from client model
         connect(_clientModel, &ClientModel::message,
                 [this](const QString &title, const QString &message,
                        unsigned int style) {
                     this->message(title, message, style);
                 });
 
         // Show progress dialog
         connect(_clientModel, &ClientModel::showProgress, this,
                 &BitcoinGUI::showProgress);
 
         rpcConsole->setClientModel(_clientModel);
 
         updateProxyIcon();
 
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->setClientModel(_clientModel);
         }
 #endif // ENABLE_WALLET
         unitDisplayControl->setOptionsModel(_clientModel->getOptionsModel());
 
         OptionsModel *optionsModel = _clientModel->getOptionsModel();
         if (optionsModel && trayIcon) {
             // be aware of the tray icon disable state change reported by the
             // OptionsModel object.
             connect(optionsModel, &OptionsModel::hideTrayIconChanged, this,
                     &BitcoinGUI::setTrayIconVisible);
 
             // initialize the disable state of the tray icon with the current
             // value in the model.
             setTrayIconVisible(optionsModel->getHideTrayIcon());
         }
     } else {
         // Disable possibility to show main window via action
         toggleHideAction->setEnabled(false);
         if (trayIconMenu) {
             // Disable context menu on tray icon
             trayIconMenu->clear();
         }
         // Propagate cleared model to child objects
         rpcConsole->setClientModel(nullptr);
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->setClientModel(nullptr);
         }
 #endif // ENABLE_WALLET
         unitDisplayControl->setOptionsModel(nullptr);
     }
 }
 
 #ifdef ENABLE_WALLET
 void BitcoinGUI::setWalletController(WalletController *wallet_controller) {
     assert(!m_wallet_controller);
     assert(wallet_controller);
 
     m_wallet_controller = wallet_controller;
 
     connect(wallet_controller, &WalletController::walletAdded, this,
             &BitcoinGUI::addWallet);
     connect(wallet_controller, &WalletController::walletRemoved, this,
             &BitcoinGUI::removeWallet);
 
     for (WalletModel *wallet_model : m_wallet_controller->getWallets()) {
         addWallet(wallet_model);
     }
 }
 
 void BitcoinGUI::addWallet(WalletModel *walletModel) {
     if (!walletFrame) {
         return;
     }
     const QString display_name = walletModel->getDisplayName();
     setWalletActionsEnabled(true);
     rpcConsole->addWallet(walletModel);
     walletFrame->addWallet(walletModel);
     m_wallet_selector->addItem(display_name, QVariant::fromValue(walletModel));
     if (m_wallet_selector->count() == 2) {
         m_wallet_selector_label_action->setVisible(true);
         m_wallet_selector_action->setVisible(true);
     }
 }
 
 void BitcoinGUI::removeWallet(WalletModel *walletModel) {
     if (!walletFrame) {
         return;
     }
     int index = m_wallet_selector->findData(QVariant::fromValue(walletModel));
     m_wallet_selector->removeItem(index);
     if (m_wallet_selector->count() == 0) {
         setWalletActionsEnabled(false);
     } else if (m_wallet_selector->count() == 1) {
         m_wallet_selector_label_action->setVisible(false);
         m_wallet_selector_action->setVisible(false);
     }
     rpcConsole->removeWallet(walletModel);
     walletFrame->removeWallet(walletModel);
     updateWindowTitle();
 }
 
 void BitcoinGUI::setCurrentWallet(WalletModel *wallet_model) {
     if (!walletFrame) {
         return;
     }
     walletFrame->setCurrentWallet(wallet_model);
     for (int index = 0; index < m_wallet_selector->count(); ++index) {
         if (m_wallet_selector->itemData(index).value<WalletModel *>() ==
             wallet_model) {
             m_wallet_selector->setCurrentIndex(index);
             break;
         }
     }
     updateWindowTitle();
 }
 
 void BitcoinGUI::setCurrentWalletBySelectorIndex(int index) {
     WalletModel *wallet_model =
         m_wallet_selector->itemData(index).value<WalletModel *>();
     if (wallet_model) {
         setCurrentWallet(wallet_model);
     }
 }
 
 void BitcoinGUI::removeAllWallets() {
-    if (!walletFrame) return;
+    if (!walletFrame) {
+        return;
+    }
     setWalletActionsEnabled(false);
     walletFrame->removeAllWallets();
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::setWalletActionsEnabled(bool enabled) {
     overviewAction->setEnabled(enabled);
     sendCoinsAction->setEnabled(enabled);
     sendCoinsMenuAction->setEnabled(enabled);
     receiveCoinsAction->setEnabled(enabled);
     receiveCoinsMenuAction->setEnabled(enabled);
     historyAction->setEnabled(enabled);
     encryptWalletAction->setEnabled(enabled);
     backupWalletAction->setEnabled(enabled);
     changePassphraseAction->setEnabled(enabled);
     signMessageAction->setEnabled(enabled);
     verifyMessageAction->setEnabled(enabled);
     usedSendingAddressesAction->setEnabled(enabled);
     usedReceivingAddressesAction->setEnabled(enabled);
     openAction->setEnabled(enabled);
 }
 
 void BitcoinGUI::createTrayIcon() {
     assert(QSystemTrayIcon::isSystemTrayAvailable());
 
 #ifndef Q_OS_MAC
     if (QSystemTrayIcon::isSystemTrayAvailable()) {
         trayIcon =
             new QSystemTrayIcon(m_network_style->getTrayAndWindowIcon(), this);
         QString toolTip = tr("%1 client").arg(tr(PACKAGE_NAME)) + " " +
                           m_network_style->getTitleAddText();
         trayIcon->setToolTip(toolTip);
     }
 #endif
 }
 
 void BitcoinGUI::createTrayIconMenu() {
 #ifndef Q_OS_MAC
     // Return if trayIcon is unset (only on non-macOSes)
     if (!trayIcon) {
         return;
     }
 
     trayIconMenu = new QMenu(this);
     trayIcon->setContextMenu(trayIconMenu);
 
     connect(trayIcon, &QSystemTrayIcon::activated, this,
             &BitcoinGUI::trayIconActivated);
 #else
     // Note: On macOS, the Dock icon is used to provide the tray's
     // functionality.
     MacDockIconHandler *dockIconHandler = MacDockIconHandler::instance();
     connect(dockIconHandler, &MacDockIconHandler::dockIconClicked, this,
             &BitcoinGUI::macosDockIconActivated);
     trayIconMenu = new QMenu(this);
     trayIconMenu->setAsDockMenu();
 #endif
 
     // Configuration of the tray icon (or Dock icon) menu
 #ifndef Q_OS_MAC
     // Note: On macOS, the Dock icon's menu already has Show / Hide action.
     trayIconMenu->addAction(toggleHideAction);
     trayIconMenu->addSeparator();
 #endif
     trayIconMenu->addAction(sendCoinsMenuAction);
     trayIconMenu->addAction(receiveCoinsMenuAction);
     trayIconMenu->addSeparator();
     trayIconMenu->addAction(signMessageAction);
     trayIconMenu->addAction(verifyMessageAction);
     trayIconMenu->addSeparator();
     trayIconMenu->addAction(optionsAction);
     trayIconMenu->addAction(openRPCConsoleAction);
 #ifndef Q_OS_MAC
     // This is built-in on macOS
     trayIconMenu->addSeparator();
     trayIconMenu->addAction(quitAction);
 #endif
 }
 
 #ifndef Q_OS_MAC
 void BitcoinGUI::trayIconActivated(QSystemTrayIcon::ActivationReason reason) {
     if (reason == QSystemTrayIcon::Trigger) {
         // Click on system tray icon triggers show/hide of the main window
         toggleHidden();
     }
 }
 #else
 void BitcoinGUI::macosDockIconActivated() {
     show();
     activateWindow();
 }
 #endif
 
 void BitcoinGUI::optionsClicked() {
     openOptionsDialogWithTab(OptionsDialog::TAB_MAIN);
 }
 
 void BitcoinGUI::aboutClicked() {
-    if (!clientModel) return;
+    if (!clientModel) {
+        return;
+    }
 
     HelpMessageDialog dlg(m_node, this, true);
     dlg.exec();
 }
 
 void BitcoinGUI::showDebugWindow() {
     GUIUtil::bringToFront(rpcConsole);
     Q_EMIT consoleShown(rpcConsole);
 }
 
 void BitcoinGUI::showDebugWindowActivateConsole() {
     rpcConsole->setTabFocus(RPCConsole::TAB_CONSOLE);
     showDebugWindow();
 }
 
 void BitcoinGUI::showHelpMessageClicked() {
     helpMessageDialog->show();
 }
 
 #ifdef ENABLE_WALLET
 void BitcoinGUI::openClicked() {
     OpenURIDialog dlg(config->GetChainParams(), this);
     if (dlg.exec()) {
         Q_EMIT receivedURI(dlg.getURI());
     }
 }
 
 void BitcoinGUI::gotoOverviewPage() {
     overviewAction->setChecked(true);
-    if (walletFrame) walletFrame->gotoOverviewPage();
+    if (walletFrame) {
+        walletFrame->gotoOverviewPage();
+    }
 }
 
 void BitcoinGUI::gotoHistoryPage() {
     historyAction->setChecked(true);
-    if (walletFrame) walletFrame->gotoHistoryPage();
+    if (walletFrame) {
+        walletFrame->gotoHistoryPage();
+    }
 }
 
 void BitcoinGUI::gotoReceiveCoinsPage() {
     receiveCoinsAction->setChecked(true);
-    if (walletFrame) walletFrame->gotoReceiveCoinsPage();
+    if (walletFrame) {
+        walletFrame->gotoReceiveCoinsPage();
+    }
 }
 
 void BitcoinGUI::gotoSendCoinsPage(QString addr) {
     sendCoinsAction->setChecked(true);
-    if (walletFrame) walletFrame->gotoSendCoinsPage(addr);
+    if (walletFrame) {
+        walletFrame->gotoSendCoinsPage(addr);
+    }
 }
 
 void BitcoinGUI::gotoSignMessageTab(QString addr) {
-    if (walletFrame) walletFrame->gotoSignMessageTab(addr);
+    if (walletFrame) {
+        walletFrame->gotoSignMessageTab(addr);
+    }
 }
 
 void BitcoinGUI::gotoVerifyMessageTab(QString addr) {
-    if (walletFrame) walletFrame->gotoVerifyMessageTab(addr);
+    if (walletFrame) {
+        walletFrame->gotoVerifyMessageTab(addr);
+    }
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::updateNetworkState() {
     int count = clientModel->getNumConnections();
     QString icon;
     switch (count) {
         case 0:
             icon = ":/icons/connect_0";
             break;
         case 1:
         case 2:
         case 3:
             icon = ":/icons/connect_1";
             break;
         case 4:
         case 5:
         case 6:
             icon = ":/icons/connect_2";
             break;
         case 7:
         case 8:
         case 9:
             icon = ":/icons/connect_3";
             break;
         default:
             icon = ":/icons/connect_4";
             break;
     }
 
     QString tooltip;
 
     if (m_node.getNetworkActive()) {
         tooltip = tr("%n active connection(s) to Bitcoin network", "", count) +
                   QString(".<br>") + tr("Click to disable network activity.");
     } else {
         tooltip = tr("Network activity disabled.") + QString("<br>") +
                   tr("Click to enable network activity again.");
         icon = ":/icons/network_disabled";
     }
 
     // Don't word-wrap this (fixed-width) tooltip
     tooltip = QString("<nobr>") + tooltip + QString("</nobr>");
     connectionsControl->setToolTip(tooltip);
 
     connectionsControl->setPixmap(platformStyle->SingleColorIcon(icon).pixmap(
         STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
 }
 
 void BitcoinGUI::setNumConnections(int count) {
     updateNetworkState();
 }
 
 void BitcoinGUI::setNetworkActive(bool networkActive) {
     updateNetworkState();
 }
 
 void BitcoinGUI::updateHeadersSyncProgressLabel() {
     int64_t headersTipTime = clientModel->getHeaderTipTime();
     int headersTipHeight = clientModel->getHeaderTipHeight();
     int estHeadersLeft =
         (GetTime() - headersTipTime) /
         config->GetChainParams().GetConsensus().nPowTargetSpacing;
     if (estHeadersLeft > HEADER_HEIGHT_DELTA_SYNC) {
         progressBarLabel->setText(
             tr("Syncing Headers (%1%)...")
                 .arg(QString::number(100.0 /
                                          (headersTipHeight + estHeadersLeft) *
                                          headersTipHeight,
                                      'f', 1)));
     }
 }
 
 void BitcoinGUI::openOptionsDialogWithTab(OptionsDialog::Tab tab) {
     if (!clientModel || !clientModel->getOptionsModel()) {
         return;
     }
 
     OptionsDialog dlg(this, enableWallet);
     dlg.setCurrentTab(tab);
     dlg.setModel(clientModel->getOptionsModel());
     dlg.exec();
 }
 
 void BitcoinGUI::setNumBlocks(int count, const QDateTime &blockDate,
                               double nVerificationProgress, bool header) {
     if (modalOverlay) {
         if (header) {
             modalOverlay->setKnownBestHeight(count, blockDate);
         } else {
             modalOverlay->tipUpdate(count, blockDate, nVerificationProgress);
         }
     }
     if (!clientModel) {
         return;
     }
 
     // Prevent orphan statusbar messages (e.g. hover Quit in main menu, wait
     // until chain-sync starts -> garbled text)
     statusBar()->clearMessage();
 
     // Acquire current block source
     enum BlockSource blockSource = clientModel->getBlockSource();
     switch (blockSource) {
         case BlockSource::NETWORK:
             if (header) {
                 updateHeadersSyncProgressLabel();
                 return;
             }
             progressBarLabel->setText(tr("Synchronizing with network..."));
             updateHeadersSyncProgressLabel();
             break;
         case BlockSource::DISK:
             if (header) {
                 progressBarLabel->setText(tr("Indexing blocks on disk..."));
             } else {
                 progressBarLabel->setText(tr("Processing blocks on disk..."));
             }
             break;
         case BlockSource::REINDEX:
             progressBarLabel->setText(tr("Reindexing blocks on disk..."));
             break;
         case BlockSource::NONE:
             if (header) {
                 return;
             }
             progressBarLabel->setText(tr("Connecting to peers..."));
             break;
     }
 
     QString tooltip;
 
     QDateTime currentDate = QDateTime::currentDateTime();
     qint64 secs = blockDate.secsTo(currentDate);
 
     tooltip = tr("Processed %n block(s) of transaction history.", "", count);
 
     // Set icon state: spinning if catching up, tick otherwise
     if (secs < MAX_BLOCK_TIME_GAP) {
         tooltip = tr("Up to date") + QString(".<br>") + tooltip;
         labelBlocksIcon->setPixmap(
             platformStyle->SingleColorIcon(":/icons/synced")
                 .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
 
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->showOutOfSyncWarning(false);
             modalOverlay->showHide(true, true);
         }
 #endif // ENABLE_WALLET
 
         progressBarLabel->setVisible(false);
         progressBar->setVisible(false);
     } else {
         QString timeBehindText = GUIUtil::formatNiceTimeOffset(secs);
 
         progressBarLabel->setVisible(true);
         progressBar->setFormat(tr("%1 behind").arg(timeBehindText));
         progressBar->setMaximum(1000000000);
         progressBar->setValue(nVerificationProgress * 1000000000.0 + 0.5);
         progressBar->setVisible(true);
 
         tooltip = tr("Catching up...") + QString("<br>") + tooltip;
         if (count != prevBlocks) {
             labelBlocksIcon->setPixmap(
                 platformStyle
                     ->SingleColorIcon(QString(":/movies/spinner-%1")
                                           .arg(spinnerFrame, 3, 10, QChar('0')))
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES;
         }
         prevBlocks = count;
 
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->showOutOfSyncWarning(true);
             modalOverlay->showHide();
         }
 #endif // ENABLE_WALLET
 
         tooltip += QString("<br>");
         tooltip +=
             tr("Last received block was generated %1 ago.").arg(timeBehindText);
         tooltip += QString("<br>");
         tooltip += tr("Transactions after this will not yet be visible.");
     }
 
     // Don't word-wrap this (fixed-width) tooltip
     tooltip = QString("<nobr>") + tooltip + QString("</nobr>");
 
     labelBlocksIcon->setToolTip(tooltip);
     progressBarLabel->setToolTip(tooltip);
     progressBar->setToolTip(tooltip);
 }
 
 void BitcoinGUI::message(const QString &title, const QString &message,
                          unsigned int style, bool *ret) {
     // default title
     QString strTitle = tr("Bitcoin");
     // Default to information icon
     int nMBoxIcon = QMessageBox::Information;
     int nNotifyIcon = Notificator::Information;
 
     QString msgType;
 
     // Prefer supplied title over style based title
     if (!title.isEmpty()) {
         msgType = title;
     } else {
         switch (style) {
             case CClientUIInterface::MSG_ERROR:
                 msgType = tr("Error");
                 break;
             case CClientUIInterface::MSG_WARNING:
                 msgType = tr("Warning");
                 break;
             case CClientUIInterface::MSG_INFORMATION:
                 msgType = tr("Information");
                 break;
             default:
                 break;
         }
     }
     // Append title to "Bitcoin - "
     if (!msgType.isEmpty()) {
         strTitle += " - " + msgType;
     }
 
     // Check for error/warning icon
     if (style & CClientUIInterface::ICON_ERROR) {
         nMBoxIcon = QMessageBox::Critical;
         nNotifyIcon = Notificator::Critical;
     } else if (style & CClientUIInterface::ICON_WARNING) {
         nMBoxIcon = QMessageBox::Warning;
         nNotifyIcon = Notificator::Warning;
     }
 
     // Display message
     if (style & CClientUIInterface::MODAL) {
         // Check for buttons, use OK as default, if none was supplied
         QMessageBox::StandardButton buttons;
         if (!(buttons = (QMessageBox::StandardButton)(
-                  style & CClientUIInterface::BTN_MASK)))
+                  style & CClientUIInterface::BTN_MASK))) {
             buttons = QMessageBox::Ok;
+        }
 
         showNormalIfMinimized();
         QMessageBox mBox(static_cast<QMessageBox::Icon>(nMBoxIcon), strTitle,
                          message, buttons, this);
         mBox.setTextFormat(Qt::PlainText);
         int r = mBox.exec();
         if (ret != nullptr) {
             *ret = r == QMessageBox::Ok;
         }
-    } else
+    } else {
         notificator->notify(static_cast<Notificator::Class>(nNotifyIcon),
                             strTitle, message);
+    }
 }
 
 void BitcoinGUI::changeEvent(QEvent *e) {
     QMainWindow::changeEvent(e);
 #ifndef Q_OS_MAC // Ignored on Mac
     if (e->type() == QEvent::WindowStateChange) {
         if (clientModel && clientModel->getOptionsModel() &&
             clientModel->getOptionsModel()->getMinimizeToTray()) {
             QWindowStateChangeEvent *wsevt =
                 static_cast<QWindowStateChangeEvent *>(e);
             if (!(wsevt->oldState() & Qt::WindowMinimized) && isMinimized()) {
                 QTimer::singleShot(0, this, &BitcoinGUI::hide);
                 e->ignore();
             } else if ((wsevt->oldState() & Qt::WindowMinimized) &&
                        !isMinimized()) {
                 QTimer::singleShot(0, this, &BitcoinGUI::show);
                 e->ignore();
             }
         }
     }
 #endif
 }
 
 void BitcoinGUI::closeEvent(QCloseEvent *event) {
 #ifndef Q_OS_MAC // Ignored on Mac
     if (clientModel && clientModel->getOptionsModel()) {
         if (!clientModel->getOptionsModel()->getMinimizeOnClose()) {
             // close rpcConsole in case it was open to make some space for the
             // shutdown window
             rpcConsole->close();
 
             QApplication::quit();
         } else {
             QMainWindow::showMinimized();
             event->ignore();
         }
     }
 #else
     QMainWindow::closeEvent(event);
 #endif
 }
 
 void BitcoinGUI::showEvent(QShowEvent *event) {
     // enable the debug window when the main window shows up
     openRPCConsoleAction->setEnabled(true);
     aboutAction->setEnabled(true);
     optionsAction->setEnabled(true);
 }
 
 #ifdef ENABLE_WALLET
 void BitcoinGUI::incomingTransaction(const QString &date, int unit,
                                      const Amount amount, const QString &type,
                                      const QString &address,
                                      const QString &label,
                                      const QString &walletName) {
     // On new transaction, make an info balloon
     QString msg = tr("Date: %1\n").arg(date) +
                   tr("Amount: %1\n")
                       .arg(BitcoinUnits::formatWithUnit(unit, amount, true));
     if (m_node.getWallets().size() > 1 && !walletName.isEmpty()) {
         msg += tr("Wallet: %1\n").arg(walletName);
     }
     msg += tr("Type: %1\n").arg(type);
     if (!label.isEmpty()) {
         msg += tr("Label: %1\n").arg(label);
     } else if (!address.isEmpty()) {
         msg += tr("Address: %1\n").arg(address);
     }
     message(amount < Amount::zero() ? tr("Sent transaction")
                                     : tr("Incoming transaction"),
             msg, CClientUIInterface::MSG_INFORMATION);
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::dragEnterEvent(QDragEnterEvent *event) {
     // Accept only URIs
     if (event->mimeData()->hasUrls()) {
         event->acceptProposedAction();
     }
 }
 
 void BitcoinGUI::dropEvent(QDropEvent *event) {
     if (event->mimeData()->hasUrls()) {
         for (const QUrl &uri : event->mimeData()->urls()) {
             Q_EMIT receivedURI(uri.toString());
         }
     }
     event->acceptProposedAction();
 }
 
 bool BitcoinGUI::eventFilter(QObject *object, QEvent *event) {
     // Catch status tip events
     if (event->type() == QEvent::StatusTip) {
         // Prevent adding text from setStatusTip(), if we currently use the
         // status bar for displaying other stuff
         if (progressBarLabel->isVisible() || progressBar->isVisible()) {
             return true;
         }
     }
     return QMainWindow::eventFilter(object, event);
 }
 
 #ifdef ENABLE_WALLET
 bool BitcoinGUI::handlePaymentRequest(const SendCoinsRecipient &recipient) {
     // URI has to be valid
     if (walletFrame && walletFrame->handlePaymentRequest(recipient)) {
         showNormalIfMinimized();
         gotoSendCoinsPage();
         return true;
     }
     return false;
 }
 
 void BitcoinGUI::setHDStatus(int hdEnabled) {
     labelWalletHDStatusIcon->setPixmap(
         platformStyle
             ->SingleColorIcon(hdEnabled ? ":/icons/hd_enabled"
                                         : ":/icons/hd_disabled")
             .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
     labelWalletHDStatusIcon->setToolTip(
         hdEnabled ? tr("HD key generation is <b>enabled</b>")
                   : tr("HD key generation is <b>disabled</b>"));
 
     // eventually disable the QLabel to set its opacity to 50%
     labelWalletHDStatusIcon->setEnabled(hdEnabled);
 }
 
 void BitcoinGUI::setEncryptionStatus(int status) {
     switch (status) {
         case WalletModel::Unencrypted:
             labelWalletEncryptionIcon->hide();
             encryptWalletAction->setChecked(false);
             changePassphraseAction->setEnabled(false);
             encryptWalletAction->setEnabled(true);
             break;
         case WalletModel::Unlocked:
             labelWalletEncryptionIcon->show();
             labelWalletEncryptionIcon->setPixmap(
                 platformStyle->SingleColorIcon(":/icons/lock_open")
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             labelWalletEncryptionIcon->setToolTip(
                 tr("Wallet is <b>encrypted</b> and currently <b>unlocked</b>"));
             encryptWalletAction->setChecked(true);
             changePassphraseAction->setEnabled(true);
             encryptWalletAction->setEnabled(
                 false); // TODO: decrypt currently not supported
             break;
         case WalletModel::Locked:
             labelWalletEncryptionIcon->show();
             labelWalletEncryptionIcon->setPixmap(
                 platformStyle->SingleColorIcon(":/icons/lock_closed")
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             labelWalletEncryptionIcon->setToolTip(
                 tr("Wallet is <b>encrypted</b> and currently <b>locked</b>"));
             encryptWalletAction->setChecked(true);
             changePassphraseAction->setEnabled(true);
             encryptWalletAction->setEnabled(
                 false); // TODO: decrypt currently not supported
             break;
     }
 }
 
 void BitcoinGUI::updateWalletStatus() {
     if (!walletFrame) {
         return;
     }
     WalletView *const walletView = walletFrame->currentWalletView();
     if (!walletView) {
         return;
     }
     WalletModel *const walletModel = walletView->getWalletModel();
     setEncryptionStatus(walletModel->getEncryptionStatus());
     setHDStatus(walletModel->wallet().hdEnabled());
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::updateProxyIcon() {
     std::string ip_port;
     bool proxy_enabled = clientModel->getProxyInfo(ip_port);
 
     if (proxy_enabled) {
         if (labelProxyIcon->pixmap() == 0) {
             QString ip_port_q = QString::fromStdString(ip_port);
             labelProxyIcon->setPixmap(
                 platformStyle->SingleColorIcon(":/icons/proxy")
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             labelProxyIcon->setToolTip(
                 tr("Proxy is <b>enabled</b>: %1").arg(ip_port_q));
         } else {
             labelProxyIcon->show();
         }
     } else {
         labelProxyIcon->hide();
     }
 }
 
 void BitcoinGUI::updateWindowTitle() {
     QString window_title = tr(PACKAGE_NAME) + " - ";
 #ifdef ENABLE_WALLET
     if (walletFrame) {
         WalletModel *const wallet_model = walletFrame->currentWalletModel();
         if (wallet_model && !wallet_model->getWalletName().isEmpty()) {
             window_title += wallet_model->getDisplayName() + " - ";
         }
     }
 #endif
     window_title += m_network_style->getTitleAddText();
     setWindowTitle(window_title);
 }
 
 void BitcoinGUI::showNormalIfMinimized(bool fToggleHidden) {
     if (!clientModel) {
         return;
     }
 
     if (!isHidden() && !isMinimized() && !GUIUtil::isObscured(this) &&
         fToggleHidden) {
         hide();
     } else {
         GUIUtil::bringToFront(this);
     }
 }
 
 void BitcoinGUI::toggleHidden() {
     showNormalIfMinimized(true);
 }
 
 void BitcoinGUI::detectShutdown() {
     if (m_node.shutdownRequested()) {
         if (rpcConsole) {
             rpcConsole->hide();
         }
         qApp->quit();
     }
 }
 
 void BitcoinGUI::showProgress(const QString &title, int nProgress) {
     if (nProgress == 0) {
         progressDialog = new QProgressDialog(title, "", 0, 100);
         progressDialog->setWindowModality(Qt::ApplicationModal);
         progressDialog->setMinimumDuration(0);
         progressDialog->setCancelButton(0);
         progressDialog->setAutoClose(false);
         progressDialog->setValue(0);
     } else if (progressDialog) {
         if (nProgress == 100) {
             progressDialog->close();
             progressDialog->deleteLater();
         } else {
             progressDialog->setValue(nProgress);
         }
     }
 }
 
 void BitcoinGUI::setTrayIconVisible(bool fHideTrayIcon) {
     if (trayIcon) {
         trayIcon->setVisible(!fHideTrayIcon);
     }
 }
 
 void BitcoinGUI::showModalOverlay() {
     if (modalOverlay &&
         (progressBar->isVisible() || modalOverlay->isLayerVisible())) {
         modalOverlay->toggleVisibility();
     }
 }
 
 static bool ThreadSafeMessageBox(BitcoinGUI *gui, const std::string &message,
                                  const std::string &caption,
                                  unsigned int style) {
     // Redundantly log and print message in non-gui fashion
     noui_ThreadSafeMessageBox(message, caption, style);
 
     bool modal = (style & CClientUIInterface::MODAL);
     // The SECURE flag has no effect in the Qt GUI.
     // bool secure = (style & CClientUIInterface::SECURE);
     style &= ~CClientUIInterface::SECURE;
     bool ret = false;
     // In case of modal message, use blocking connection to wait for user to
     // click a button
     QMetaObject::invokeMethod(gui, "message",
                               modal ? GUIUtil::blockingGUIThreadConnection()
                                     : Qt::QueuedConnection,
                               Q_ARG(QString, QString::fromStdString(caption)),
                               Q_ARG(QString, QString::fromStdString(message)),
                               Q_ARG(unsigned int, style), Q_ARG(bool *, &ret));
     return ret;
 }
 
 void BitcoinGUI::subscribeToCoreSignals() {
     // Connect signals to client
     m_handler_message_box = m_node.handleMessageBox(
         std::bind(ThreadSafeMessageBox, this, std::placeholders::_1,
                   std::placeholders::_2, std::placeholders::_3));
     m_handler_question = m_node.handleQuestion(
         std::bind(ThreadSafeMessageBox, this, std::placeholders::_1,
                   std::placeholders::_3, std::placeholders::_4));
 }
 
 void BitcoinGUI::unsubscribeFromCoreSignals() {
     // Disconnect signals from client
     m_handler_message_box->disconnect();
     m_handler_question->disconnect();
 }
 
 UnitDisplayStatusBarControl::UnitDisplayStatusBarControl(
     const PlatformStyle *platformStyle)
     : optionsModel(0), menu(0) {
     createContextMenu();
     setToolTip(tr("Unit to show amounts in. Click to select another unit."));
     QList<BitcoinUnits::Unit> units = BitcoinUnits::availableUnits();
     int max_width = 0;
     const QFontMetrics fm(font());
     for (const BitcoinUnits::Unit unit : units) {
         max_width = qMax(max_width, fm.width(BitcoinUnits::name(unit)));
     }
     setMinimumSize(max_width, 0);
     setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     setStyleSheet(QString("QLabel { color : %1 }")
                       .arg(platformStyle->SingleColor().name()));
 }
 
 /** So that it responds to button clicks */
 void UnitDisplayStatusBarControl::mousePressEvent(QMouseEvent *event) {
     onDisplayUnitsClicked(event->pos());
 }
 
 /** Creates context menu, its actions, and wires up all the relevant signals for
  * mouse events. */
 void UnitDisplayStatusBarControl::createContextMenu() {
     menu = new QMenu(this);
     for (const BitcoinUnits::Unit u : BitcoinUnits::availableUnits()) {
         QAction *menuAction = new QAction(QString(BitcoinUnits::name(u)), this);
         menuAction->setData(QVariant(u));
         menu->addAction(menuAction);
     }
     connect(menu, &QMenu::triggered, this,
             &UnitDisplayStatusBarControl::onMenuSelection);
 }
 
 /** Lets the control know about the Options Model (and its signals) */
 void UnitDisplayStatusBarControl::setOptionsModel(OptionsModel *_optionsModel) {
     if (_optionsModel) {
         this->optionsModel = _optionsModel;
 
         // be aware of a display unit change reported by the OptionsModel
         // object.
         connect(_optionsModel, &OptionsModel::displayUnitChanged, this,
                 &UnitDisplayStatusBarControl::updateDisplayUnit);
 
         // initialize the display units label with the current value in the
         // model.
         updateDisplayUnit(_optionsModel->getDisplayUnit());
     }
 }
 
 /** When Display Units are changed on OptionsModel it will refresh the display
  * text of the control on the status bar */
 void UnitDisplayStatusBarControl::updateDisplayUnit(int newUnits) {
     setText(BitcoinUnits::name(newUnits));
 }
 
 /** Shows context menu with Display Unit options by the mouse coordinates */
 void UnitDisplayStatusBarControl::onDisplayUnitsClicked(const QPoint &point) {
     QPoint globalPos = mapToGlobal(point);
     menu->exec(globalPos);
 }
 
 /** Tells underlying optionsModel to update its current display unit. */
 void UnitDisplayStatusBarControl::onMenuSelection(QAction *action) {
     if (action) {
         optionsModel->setDisplayUnit(action->data());
     }
 }
diff --git a/src/qt/csvmodelwriter.cpp b/src/qt/csvmodelwriter.cpp
index 95e7154d1d..fe616a2aef 100644
--- a/src/qt/csvmodelwriter.cpp
+++ b/src/qt/csvmodelwriter.cpp
@@ -1,76 +1,78 @@
 // 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/csvmodelwriter.h>
 
 #include <QAbstractItemModel>
 #include <QFile>
 #include <QTextStream>
 
 CSVModelWriter::CSVModelWriter(const QString &_filename, QObject *parent)
     : QObject(parent), filename(_filename), model(0) {}
 
 void CSVModelWriter::setModel(const QAbstractItemModel *_model) {
     this->model = _model;
 }
 
 void CSVModelWriter::addColumn(const QString &title, int column, int role) {
     Column col;
     col.title = title;
     col.column = column;
     col.role = role;
 
     columns.append(col);
 }
 
 static void writeValue(QTextStream &f, const QString &value) {
     QString escaped = value;
     escaped.replace('"', "\"\"");
     f << "\"" << escaped << "\"";
 }
 
 static void writeSep(QTextStream &f) {
     f << ",";
 }
 
 static void writeNewline(QTextStream &f) {
     f << "\n";
 }
 
 bool CSVModelWriter::write() {
     QFile file(filename);
-    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) return false;
+    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+        return false;
+    }
     QTextStream out(&file);
 
     int numRows = 0;
     if (model) {
         numRows = model->rowCount();
     }
 
     // Header row
     for (int i = 0; i < columns.size(); ++i) {
         if (i != 0) {
             writeSep(out);
         }
         writeValue(out, columns[i].title);
     }
     writeNewline(out);
 
     // Data rows
     for (int j = 0; j < numRows; ++j) {
         for (int i = 0; i < columns.size(); ++i) {
             if (i != 0) {
                 writeSep(out);
             }
             QVariant data =
                 model->index(j, columns[i].column).data(columns[i].role);
             writeValue(out, data.toString());
         }
         writeNewline(out);
     }
 
     file.close();
 
     return file.error() == QFile::NoError;
 }
diff --git a/src/qt/modaloverlay.cpp b/src/qt/modaloverlay.cpp
index 2098395b9f..2cdee86752 100644
--- a/src/qt/modaloverlay.cpp
+++ b/src/qt/modaloverlay.cpp
@@ -1,173 +1,183 @@
 // Copyright (c) 2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/forms/ui_modaloverlay.h>
 #include <qt/modaloverlay.h>
 
 #include <chainparams.h>
 #include <qt/guiutil.h>
 
 #include <QPropertyAnimation>
 #include <QResizeEvent>
 
 ModalOverlay::ModalOverlay(QWidget *parent)
     : QWidget(parent), ui(new Ui::ModalOverlay), bestHeaderHeight(0),
       bestHeaderDate(QDateTime()), layerIsVisible(false), userClosed(false) {
     ui->setupUi(this);
     connect(ui->closeButton, &QPushButton::clicked, this,
             &ModalOverlay::closeClicked);
     if (parent) {
         parent->installEventFilter(this);
         raise();
     }
 
     blockProcessTime.clear();
     setVisible(false);
 }
 
 ModalOverlay::~ModalOverlay() {
     delete ui;
 }
 
 bool ModalOverlay::eventFilter(QObject *obj, QEvent *ev) {
     if (obj == parent()) {
         if (ev->type() == QEvent::Resize) {
             QResizeEvent *rev = static_cast<QResizeEvent *>(ev);
             resize(rev->size());
-            if (!layerIsVisible) setGeometry(0, height(), width(), height());
+            if (!layerIsVisible) {
+                setGeometry(0, height(), width(), height());
+            }
 
         } else if (ev->type() == QEvent::ChildAdded) {
             raise();
         }
     }
     return QWidget::eventFilter(obj, ev);
 }
 
 //! Tracks parent widget changes
 bool ModalOverlay::event(QEvent *ev) {
     if (ev->type() == QEvent::ParentAboutToChange) {
-        if (parent()) parent()->removeEventFilter(this);
+        if (parent()) {
+            parent()->removeEventFilter(this);
+        }
     } else if (ev->type() == QEvent::ParentChange) {
         if (parent()) {
             parent()->installEventFilter(this);
             raise();
         }
     }
     return QWidget::event(ev);
 }
 
 void ModalOverlay::setKnownBestHeight(int count, const QDateTime &blockDate) {
     if (count > bestHeaderHeight) {
         bestHeaderHeight = count;
         bestHeaderDate = blockDate;
     }
 }
 
 void ModalOverlay::tipUpdate(int count, const QDateTime &blockDate,
                              double nVerificationProgress) {
     QDateTime currentDate = QDateTime::currentDateTime();
 
     // keep a vector of samples of verification progress at height
     blockProcessTime.push_front(
         qMakePair(currentDate.toMSecsSinceEpoch(), nVerificationProgress));
 
     // show progress speed if we have more than one sample
     if (blockProcessTime.size() >= 2) {
         double progressDelta = 0;
         double progressPerHour = 0;
         qint64 timeDelta = 0;
         qint64 remainingMSecs = 0;
         double remainingProgress = 1.0 - nVerificationProgress;
         for (int i = 1; i < blockProcessTime.size(); i++) {
             QPair<qint64, double> sample = blockProcessTime[i];
 
             // take first sample after 500 seconds or last available one
             if (sample.first < (currentDate.toMSecsSinceEpoch() - 500 * 1000) ||
                 i == blockProcessTime.size() - 1) {
                 progressDelta = blockProcessTime[0].second - sample.second;
                 timeDelta = blockProcessTime[0].first - sample.first;
                 progressPerHour =
                     progressDelta / (double)timeDelta * 1000 * 3600;
                 remainingMSecs =
                     (progressDelta > 0)
                         ? remainingProgress / progressDelta * timeDelta
                         : -1;
                 break;
             }
         }
         // show progress increase per hour
         ui->progressIncreasePerH->setText(
             QString::number(progressPerHour * 100, 'f', 2) + "%");
 
         // show expected remaining time
         if (remainingMSecs >= 0) {
             ui->expectedTimeLeft->setText(
                 GUIUtil::formatNiceTimeOffset(remainingMSecs / 1000.0));
         } else {
             ui->expectedTimeLeft->setText(QObject::tr("unknown"));
         }
 
         static const int MAX_SAMPLES = 5000;
         if (blockProcessTime.count() > MAX_SAMPLES) {
             blockProcessTime.remove(MAX_SAMPLES,
                                     blockProcessTime.count() - MAX_SAMPLES);
         }
     }
 
     // show the last block date
     ui->newestBlockDate->setText(blockDate.toString());
 
     // show the percentage done according to nVerificationProgress
     ui->percentageProgress->setText(
         QString::number(nVerificationProgress * 100, 'f', 2) + "%");
     ui->progressBar->setValue(nVerificationProgress * 100);
 
-    if (!bestHeaderDate.isValid())
+    if (!bestHeaderDate.isValid()) {
         // not syncing
         return;
+    }
 
     // estimate the number of headers left based on nPowTargetSpacing
     // and check if the gui is not aware of the best header (happens rarely)
     int estimateNumHeadersLeft = bestHeaderDate.secsTo(currentDate) /
                                  Params().GetConsensus().nPowTargetSpacing;
     bool hasBestHeader = bestHeaderHeight >= count;
 
     // show remaining number of blocks
     if (estimateNumHeadersLeft < HEADER_HEIGHT_DELTA_SYNC && hasBestHeader) {
         ui->numberOfBlocksLeft->setText(
             QString::number(bestHeaderHeight - count));
     } else {
         ui->numberOfBlocksLeft->setText(
             tr("Unknown. Syncing Headers (%1)...").arg(bestHeaderHeight));
         ui->expectedTimeLeft->setText(tr("Unknown..."));
     }
 }
 
 void ModalOverlay::toggleVisibility() {
     showHide(layerIsVisible, true);
-    if (!layerIsVisible) userClosed = true;
+    if (!layerIsVisible) {
+        userClosed = true;
+    }
 }
 
 void ModalOverlay::showHide(bool hide, bool userRequested) {
     if ((layerIsVisible && !hide) || (!layerIsVisible && hide) ||
-        (!hide && userClosed && !userRequested))
+        (!hide && userClosed && !userRequested)) {
         return;
+    }
 
-    if (!isVisible() && !hide) setVisible(true);
+    if (!isVisible() && !hide) {
+        setVisible(true);
+    }
 
     setGeometry(0, hide ? 0 : height(), width(), height());
 
     QPropertyAnimation *animation = new QPropertyAnimation(this, "pos");
     animation->setDuration(300);
     animation->setStartValue(QPoint(0, hide ? 0 : this->height()));
     animation->setEndValue(QPoint(0, hide ? this->height() : 0));
     animation->setEasingCurve(QEasingCurve::OutQuad);
     animation->start(QAbstractAnimation::DeleteWhenStopped);
     layerIsVisible = !hide;
 }
 
 void ModalOverlay::closeClicked() {
     showHide(true);
     userClosed = true;
 }
diff --git a/src/qt/optionsdialog.cpp b/src/qt/optionsdialog.cpp
index e32417b9d3..62a77a5314 100644
--- a/src/qt/optionsdialog.cpp
+++ b/src/qt/optionsdialog.cpp
@@ -1,410 +1,418 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/forms/ui_optionsdialog.h>
 #include <qt/optionsdialog.h>
 
 #include <interfaces/node.h>
 #include <netbase.h>
 #include <qt/bitcoinunits.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 #include <txdb.h>       // for -dbcache defaults
 #include <validation.h> // for DEFAULT_SCRIPTCHECK_THREADS and MAX_SCRIPTCHECK_THREADS
 
 #include <QDataWidgetMapper>
 #include <QDir>
 #include <QIntValidator>
 #include <QLocale>
 #include <QMessageBox>
 #include <QSystemTrayIcon>
 #include <QTimer>
 
 OptionsDialog::OptionsDialog(QWidget *parent, bool enableWallet)
     : QDialog(parent), ui(new Ui::OptionsDialog), model(0), mapper(0) {
     ui->setupUi(this);
 
     /* Main elements init */
     ui->databaseCache->setMinimum(nMinDbCache);
     ui->databaseCache->setMaximum(nMaxDbCache);
     static const uint64_t GiB = 1024 * 1024 * 1024;
     static const uint64_t nMinDiskSpace =
         MIN_DISK_SPACE_FOR_BLOCK_FILES / GiB +
                 (MIN_DISK_SPACE_FOR_BLOCK_FILES % GiB)
             ? 1
             : 0;
     ui->pruneSize->setMinimum(nMinDiskSpace);
     ui->threadsScriptVerif->setMinimum(-GetNumCores());
     ui->threadsScriptVerif->setMaximum(MAX_SCRIPTCHECK_THREADS);
     ui->pruneWarning->setVisible(false);
     ui->pruneWarning->setStyleSheet("QLabel { color: red; }");
 
     ui->pruneSize->setEnabled(false);
     connect(ui->prune, &QPushButton::toggled, ui->pruneSize,
             &QWidget::setEnabled);
 
 /* Network elements init */
 #ifndef USE_UPNP
     ui->mapPortUpnp->setEnabled(false);
 #endif
 
     ui->proxyIp->setEnabled(false);
     ui->proxyPort->setEnabled(false);
     ui->proxyPort->setValidator(new QIntValidator(1, 65535, this));
 
     ui->proxyIpTor->setEnabled(false);
     ui->proxyPortTor->setEnabled(false);
     ui->proxyPortTor->setValidator(new QIntValidator(1, 65535, this));
 
     connect(ui->connectSocks, &QPushButton::toggled, ui->proxyIp,
             &QWidget::setEnabled);
     connect(ui->connectSocks, &QPushButton::toggled, ui->proxyPort,
             &QWidget::setEnabled);
     connect(ui->connectSocks, &QPushButton::toggled, this,
             &OptionsDialog::updateProxyValidationState);
 
     connect(ui->connectSocksTor, &QPushButton::toggled, ui->proxyIpTor,
             &QWidget::setEnabled);
     connect(ui->connectSocksTor, &QPushButton::toggled, ui->proxyPortTor,
             &QWidget::setEnabled);
     connect(ui->connectSocksTor, &QPushButton::toggled, this,
             &OptionsDialog::updateProxyValidationState);
 
     /* Window elements init */
 #ifdef Q_OS_MAC
     /* remove Window tab on Mac */
     ui->tabWidget->removeTab(ui->tabWidget->indexOf(ui->tabWindow));
 #endif
 
     /* remove Wallet tab in case of -disablewallet */
     if (!enableWallet) {
         ui->tabWidget->removeTab(ui->tabWidget->indexOf(ui->tabWallet));
     }
 
     /* Display elements init */
     QDir translations(":translations");
 
     ui->bitcoinAtStartup->setToolTip(
         ui->bitcoinAtStartup->toolTip().arg(tr(PACKAGE_NAME)));
     ui->bitcoinAtStartup->setText(
         ui->bitcoinAtStartup->text().arg(tr(PACKAGE_NAME)));
 
     ui->openBitcoinConfButton->setToolTip(
         ui->openBitcoinConfButton->toolTip().arg(tr(PACKAGE_NAME)));
 
     ui->lang->setToolTip(ui->lang->toolTip().arg(tr(PACKAGE_NAME)));
     ui->lang->addItem(QString("(") + tr("default") + QString(")"),
                       QVariant(""));
     for (const QString &langStr : translations.entryList()) {
         QLocale locale(langStr);
 
         /** check if the locale name consists of 2 parts (language_country) */
         if (langStr.contains("_")) {
             /** display language strings as "native language - native country
              * (locale name)", e.g. "Deutsch - Deutschland (de)" */
             ui->lang->addItem(locale.nativeLanguageName() + QString(" - ") +
                                   locale.nativeCountryName() + QString(" (") +
                                   langStr + QString(")"),
                               QVariant(langStr));
         } else {
             /** display language strings as "native language (locale name)",
              * e.g. "Deutsch (de)" */
             ui->lang->addItem(locale.nativeLanguageName() + QString(" (") +
                                   langStr + QString(")"),
                               QVariant(langStr));
         }
     }
     ui->thirdPartyTxUrls->setPlaceholderText("https://example.com/tx/%s");
 
     ui->unit->setModel(new BitcoinUnits(this));
 
     /* Widget-to-option mapper */
     mapper = new QDataWidgetMapper(this);
     mapper->setSubmitPolicy(QDataWidgetMapper::ManualSubmit);
     mapper->setOrientation(Qt::Vertical);
 
     GUIUtil::ItemDelegate *delegate = new GUIUtil::ItemDelegate(mapper);
     connect(delegate, &GUIUtil::ItemDelegate::keyEscapePressed, this,
             &OptionsDialog::reject);
     mapper->setItemDelegate(delegate);
 
     /* setup/change UI elements when proxy IPs are invalid/valid */
     ui->proxyIp->setCheckValidator(new ProxyAddressValidator(parent));
     ui->proxyIpTor->setCheckValidator(new ProxyAddressValidator(parent));
     connect(ui->proxyIp, &QValidatedLineEdit::validationDidChange, this,
             &OptionsDialog::updateProxyValidationState);
     connect(ui->proxyIpTor, &QValidatedLineEdit::validationDidChange, this,
             &OptionsDialog::updateProxyValidationState);
     connect(ui->proxyPort, &QLineEdit::textChanged, this,
             &OptionsDialog::updateProxyValidationState);
     connect(ui->proxyPortTor, &QLineEdit::textChanged, this,
             &OptionsDialog::updateProxyValidationState);
 
     if (!QSystemTrayIcon::isSystemTrayAvailable()) {
         ui->hideTrayIcon->setChecked(true);
         ui->hideTrayIcon->setEnabled(false);
         ui->minimizeToTray->setChecked(false);
         ui->minimizeToTray->setEnabled(false);
     }
 }
 
 OptionsDialog::~OptionsDialog() {
     delete ui;
 }
 
 void OptionsDialog::setModel(OptionsModel *_model) {
     this->model = _model;
 
     if (_model) {
         /* check if client restart is needed and show persistent message */
-        if (_model->isRestartRequired()) showRestartWarning(true);
+        if (_model->isRestartRequired()) {
+            showRestartWarning(true);
+        }
 
         QString strLabel = _model->getOverriddenByCommandLine();
-        if (strLabel.isEmpty()) strLabel = tr("none");
+        if (strLabel.isEmpty()) {
+            strLabel = tr("none");
+        }
         ui->overriddenByCommandLineLabel->setText(strLabel);
 
         mapper->setModel(_model);
         setMapper();
         mapper->toFirst();
 
         updateDefaultProxyNets();
     }
 
     /* warn when one of the following settings changes by user action (placed
      * here so init via mapper doesn't trigger them) */
 
     /* Main */
     connect(ui->prune, &QCheckBox::clicked, this,
             &OptionsDialog::showRestartWarning);
     connect(ui->prune, &QCheckBox::clicked, this,
             &OptionsDialog::togglePruneWarning);
     connect(ui->pruneSize,
             static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this,
             &OptionsDialog::showRestartWarning);
     connect(ui->databaseCache,
             static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this,
             &OptionsDialog::showRestartWarning);
     connect(ui->threadsScriptVerif,
             static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this,
             &OptionsDialog::showRestartWarning);
     /* Wallet */
     connect(ui->spendZeroConfChange, &QCheckBox::clicked, this,
             &OptionsDialog::showRestartWarning);
     /* Network */
     connect(ui->allowIncoming, &QCheckBox::clicked, this,
             &OptionsDialog::showRestartWarning);
     connect(ui->connectSocks, &QCheckBox::clicked, this,
             &OptionsDialog::showRestartWarning);
     connect(ui->connectSocksTor, &QCheckBox::clicked, this,
             &OptionsDialog::showRestartWarning);
     /* Display */
     connect(
         ui->lang,
         static_cast<void (QValueComboBox::*)()>(&QValueComboBox::valueChanged),
         [this] { showRestartWarning(); });
     connect(ui->thirdPartyTxUrls, &QLineEdit::textChanged,
             [this] { showRestartWarning(); });
 }
 
 void OptionsDialog::setCurrentTab(OptionsDialog::Tab tab) {
     QWidget *tab_widget = nullptr;
     if (tab == OptionsDialog::Tab::TAB_NETWORK) {
         tab_widget = ui->tabNetwork;
     }
     if (tab == OptionsDialog::Tab::TAB_MAIN) {
         tab_widget = ui->tabMain;
     }
     if (tab_widget && ui->tabWidget->currentWidget() != tab_widget) {
         ui->tabWidget->setCurrentWidget(tab_widget);
     }
 }
 
 void OptionsDialog::setMapper() {
     /* Main */
     mapper->addMapping(ui->bitcoinAtStartup, OptionsModel::StartAtStartup);
     mapper->addMapping(ui->threadsScriptVerif,
                        OptionsModel::ThreadsScriptVerif);
     mapper->addMapping(ui->databaseCache, OptionsModel::DatabaseCache);
     mapper->addMapping(ui->prune, OptionsModel::Prune);
     mapper->addMapping(ui->pruneSize, OptionsModel::PruneSize);
 
     /* Wallet */
     mapper->addMapping(ui->spendZeroConfChange,
                        OptionsModel::SpendZeroConfChange);
     mapper->addMapping(ui->coinControlFeatures,
                        OptionsModel::CoinControlFeatures);
 
     /* Network */
     mapper->addMapping(ui->mapPortUpnp, OptionsModel::MapPortUPnP);
     mapper->addMapping(ui->allowIncoming, OptionsModel::Listen);
 
     mapper->addMapping(ui->connectSocks, OptionsModel::ProxyUse);
     mapper->addMapping(ui->proxyIp, OptionsModel::ProxyIP);
     mapper->addMapping(ui->proxyPort, OptionsModel::ProxyPort);
 
     mapper->addMapping(ui->connectSocksTor, OptionsModel::ProxyUseTor);
     mapper->addMapping(ui->proxyIpTor, OptionsModel::ProxyIPTor);
     mapper->addMapping(ui->proxyPortTor, OptionsModel::ProxyPortTor);
 
 /* Window */
 #ifndef Q_OS_MAC
     if (QSystemTrayIcon::isSystemTrayAvailable()) {
         mapper->addMapping(ui->hideTrayIcon, OptionsModel::HideTrayIcon);
         mapper->addMapping(ui->minimizeToTray, OptionsModel::MinimizeToTray);
     }
     mapper->addMapping(ui->minimizeOnClose, OptionsModel::MinimizeOnClose);
 #endif
 
     /* Display */
     mapper->addMapping(ui->lang, OptionsModel::Language);
     mapper->addMapping(ui->unit, OptionsModel::DisplayUnit);
     mapper->addMapping(ui->thirdPartyTxUrls, OptionsModel::ThirdPartyTxUrls);
 }
 
 void OptionsDialog::setOkButtonState(bool fState) {
     ui->okButton->setEnabled(fState);
 }
 
 void OptionsDialog::on_resetButton_clicked() {
     if (model) {
         // confirmation dialog
         QMessageBox::StandardButton btnRetVal = QMessageBox::question(
             this, tr("Confirm options reset"),
             tr("Client restart required to activate changes.") + "<br><br>" +
                 tr("Client will be shut down. Do you want to proceed?"),
             QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Cancel);
 
-        if (btnRetVal == QMessageBox::Cancel) return;
+        if (btnRetVal == QMessageBox::Cancel) {
+            return;
+        }
 
         /* reset all options and close GUI */
         model->Reset();
         QApplication::quit();
     }
 }
 
 void OptionsDialog::on_openBitcoinConfButton_clicked() {
     /* explain the purpose of the config file */
     QMessageBox::information(
         this, tr("Configuration options"),
         tr("The configuration file is used to specify advanced user options "
            "which override GUI settings. Additionally, any command-line "
            "options will override this configuration file."));
 
     /* show an error if there was some problem opening the file */
     if (!GUIUtil::openBitcoinConf()) {
         QMessageBox::critical(
             this, tr("Error"),
             tr("The configuration file could not be opened."));
     }
 }
 
 void OptionsDialog::on_okButton_clicked() {
     mapper->submit();
     accept();
     updateDefaultProxyNets();
 }
 
 void OptionsDialog::on_cancelButton_clicked() {
     reject();
 }
 
 void OptionsDialog::on_hideTrayIcon_stateChanged(int fState) {
     if (fState) {
         ui->minimizeToTray->setChecked(false);
         ui->minimizeToTray->setEnabled(false);
     } else {
         ui->minimizeToTray->setEnabled(true);
     }
 }
 
 void OptionsDialog::togglePruneWarning(bool enabled) {
     ui->pruneWarning->setVisible(!ui->pruneWarning->isVisible());
 }
 
 void OptionsDialog::showRestartWarning(bool fPersistent) {
     ui->statusLabel->setStyleSheet("QLabel { color: red; }");
 
     if (fPersistent) {
         ui->statusLabel->setText(
             tr("Client restart required to activate changes."));
     } else {
         ui->statusLabel->setText(
             tr("This change would require a client restart."));
         // clear non-persistent status label after 10 seconds
         // TODO: should perhaps be a class attribute, if we extend the use of
         // statusLabel
         QTimer::singleShot(10000, this, &OptionsDialog::clearStatusLabel);
     }
 }
 
 void OptionsDialog::clearStatusLabel() {
     ui->statusLabel->clear();
     if (model && model->isRestartRequired()) {
         showRestartWarning(true);
     }
 }
 
 void OptionsDialog::updateProxyValidationState() {
     QValidatedLineEdit *pUiProxyIp = ui->proxyIp;
     QValidatedLineEdit *otherProxyWidget =
         (pUiProxyIp == ui->proxyIpTor) ? ui->proxyIp : ui->proxyIpTor;
     if (pUiProxyIp->isValid() &&
         (!ui->proxyPort->isEnabled() || ui->proxyPort->text().toInt() > 0) &&
         (!ui->proxyPortTor->isEnabled() ||
          ui->proxyPortTor->text().toInt() > 0)) {
         // Only enable ok button if both proxys are valid
         setOkButtonState(otherProxyWidget->isValid());
         clearStatusLabel();
     } else {
         setOkButtonState(false);
         ui->statusLabel->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel->setText(tr("The supplied proxy address is invalid."));
     }
 }
 
 void OptionsDialog::updateDefaultProxyNets() {
     proxyType proxy;
     std::string strProxy;
     QString strDefaultProxyGUI;
 
     model->node().getProxy(NET_IPV4, proxy);
     strProxy = proxy.proxy.ToStringIP() + ":" + proxy.proxy.ToStringPort();
     strDefaultProxyGUI = ui->proxyIp->text() + ":" + ui->proxyPort->text();
     (strProxy == strDefaultProxyGUI.toStdString())
         ? ui->proxyReachIPv4->setChecked(true)
         : ui->proxyReachIPv4->setChecked(false);
 
     model->node().getProxy(NET_IPV6, proxy);
     strProxy = proxy.proxy.ToStringIP() + ":" + proxy.proxy.ToStringPort();
     strDefaultProxyGUI = ui->proxyIp->text() + ":" + ui->proxyPort->text();
     (strProxy == strDefaultProxyGUI.toStdString())
         ? ui->proxyReachIPv6->setChecked(true)
         : ui->proxyReachIPv6->setChecked(false);
 
     model->node().getProxy(NET_ONION, proxy);
     strProxy = proxy.proxy.ToStringIP() + ":" + proxy.proxy.ToStringPort();
     strDefaultProxyGUI = ui->proxyIp->text() + ":" + ui->proxyPort->text();
     (strProxy == strDefaultProxyGUI.toStdString())
         ? ui->proxyReachTor->setChecked(true)
         : ui->proxyReachTor->setChecked(false);
 }
 
 ProxyAddressValidator::ProxyAddressValidator(QObject *parent)
     : QValidator(parent) {}
 
 QValidator::State ProxyAddressValidator::validate(QString &input,
                                                   int &pos) const {
     Q_UNUSED(pos);
     // Validate the proxy
     CService serv(
         LookupNumeric(input.toStdString().c_str(), DEFAULT_GUI_PROXY_PORT));
     proxyType addrProxy = proxyType(serv, true);
-    if (addrProxy.IsValid()) return QValidator::Acceptable;
+    if (addrProxy.IsValid()) {
+        return QValidator::Acceptable;
+    }
 
     return QValidator::Invalid;
 }
diff --git a/src/qt/optionsmodel.cpp b/src/qt/optionsmodel.cpp
index 39a3eb3120..15fb530fad 100644
--- a/src/qt/optionsmodel.cpp
+++ b/src/qt/optionsmodel.cpp
@@ -1,575 +1,577 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/optionsmodel.h>
 
 #include <amount.h>
 #include <interfaces/node.h>
 #include <net.h>
 #include <netbase.h>
 #include <qt/bitcoinunits.h>
 #include <qt/guiutil.h>
 #include <qt/intro.h>
 #include <txdb.h>       // for -dbcache defaults
 #include <validation.h> // For DEFAULT_SCRIPTCHECK_THREADS
 
 #include <QNetworkProxy>
 #include <QSettings>
 #include <QStringList>
 
 const char *DEFAULT_GUI_PROXY_HOST = "127.0.0.1";
 
 static const QString GetDefaultProxyAddress();
 
 OptionsModel::OptionsModel(interfaces::Node &node, QObject *parent,
                            bool resetSettings)
     : QAbstractListModel(parent), m_node(node) {
     Init(resetSettings);
 }
 
 void OptionsModel::addOverriddenOption(const std::string &option) {
     strOverriddenByCommandLine +=
         QString::fromStdString(option) + "=" +
         QString::fromStdString(gArgs.GetArg(option, "")) + " ";
 }
 
 // Writes all missing QSettings with their default values
 void OptionsModel::Init(bool resetSettings) {
     if (resetSettings) {
         Reset();
     }
 
     checkAndMigrate();
 
     QSettings settings;
 
     // Ensure restart flag is unset on client startup
     setRestartRequired(false);
 
     // These are Qt-only settings:
 
     // Window
     if (!settings.contains("fHideTrayIcon")) {
         settings.setValue("fHideTrayIcon", false);
     }
     fHideTrayIcon = settings.value("fHideTrayIcon").toBool();
     Q_EMIT hideTrayIconChanged(fHideTrayIcon);
 
     if (!settings.contains("fMinimizeToTray")) {
         settings.setValue("fMinimizeToTray", false);
     }
     fMinimizeToTray =
         settings.value("fMinimizeToTray").toBool() && !fHideTrayIcon;
 
     if (!settings.contains("fMinimizeOnClose")) {
         settings.setValue("fMinimizeOnClose", false);
     }
     fMinimizeOnClose = settings.value("fMinimizeOnClose").toBool();
 
     // Display
     if (!settings.contains("nDisplayUnit")) {
         settings.setValue("nDisplayUnit", BitcoinUnits::BCH);
     }
     nDisplayUnit = settings.value("nDisplayUnit").toInt();
 
     if (!settings.contains("strThirdPartyTxUrls")) {
         settings.setValue("strThirdPartyTxUrls", "");
     }
     strThirdPartyTxUrls = settings.value("strThirdPartyTxUrls", "").toString();
 
     if (!settings.contains("fCoinControlFeatures")) {
         settings.setValue("fCoinControlFeatures", false);
     }
     fCoinControlFeatures =
         settings.value("fCoinControlFeatures", false).toBool();
 
     // These are shared with the core or have a command-line parameter
     // and we want command-line parameters to overwrite the GUI settings.
     //
     // If setting doesn't exist create it with defaults.
     //
     // If gArgs.SoftSetArg() or gArgs.SoftSetBoolArg() return false we were
     // overridden
     // by command-line and show this in the UI.
 
     // Main
     if (!settings.contains("bPrune")) {
         settings.setValue("bPrune", false);
     }
     if (!settings.contains("nPruneSize")) {
         settings.setValue("nPruneSize", 2);
     }
     // Convert prune size to MB:
     const uint64_t nPruneSizeMB = settings.value("nPruneSize").toInt() * 1000;
     if (!m_node.softSetArg("-prune", settings.value("bPrune").toBool()
                                          ? std::to_string(nPruneSizeMB)
                                          : "0")) {
         addOverriddenOption("-prune");
     }
 
     if (!settings.contains("nDatabaseCache")) {
         settings.setValue("nDatabaseCache", (qint64)nDefaultDbCache);
     }
     if (!m_node.softSetArg(
             "-dbcache",
             settings.value("nDatabaseCache").toString().toStdString())) {
         addOverriddenOption("-dbcache");
     }
 
     if (!settings.contains("nThreadsScriptVerif")) {
         settings.setValue("nThreadsScriptVerif", DEFAULT_SCRIPTCHECK_THREADS);
     }
     if (!m_node.softSetArg(
             "-par",
             settings.value("nThreadsScriptVerif").toString().toStdString())) {
         addOverriddenOption("-par");
     }
 
     if (!settings.contains("strDataDir")) {
         settings.setValue("strDataDir", Intro::getDefaultDataDirectory());
     }
 
 // Wallet
 #ifdef ENABLE_WALLET
     if (!settings.contains("bSpendZeroConfChange")) {
         settings.setValue("bSpendZeroConfChange", true);
     }
     if (!m_node.softSetBoolArg(
             "-spendzeroconfchange",
             settings.value("bSpendZeroConfChange").toBool())) {
         addOverriddenOption("-spendzeroconfchange");
     }
 #endif
 
     // Network
     if (!settings.contains("fUseUPnP")) {
         settings.setValue("fUseUPnP", DEFAULT_UPNP);
     }
     if (!m_node.softSetBoolArg("-upnp", settings.value("fUseUPnP").toBool())) {
         addOverriddenOption("-upnp");
     }
 
     if (!settings.contains("fListen")) {
         settings.setValue("fListen", DEFAULT_LISTEN);
     }
     if (!m_node.softSetBoolArg("-listen", settings.value("fListen").toBool())) {
         addOverriddenOption("-listen");
     }
 
     if (!settings.contains("fUseProxy")) {
         settings.setValue("fUseProxy", false);
     }
     if (!settings.contains("addrProxy")) {
         settings.setValue("addrProxy", GetDefaultProxyAddress());
     }
     // Only try to set -proxy, if user has enabled fUseProxy
     if (settings.value("fUseProxy").toBool() &&
         !m_node.softSetArg(
             "-proxy", settings.value("addrProxy").toString().toStdString())) {
         addOverriddenOption("-proxy");
     } else if (!settings.value("fUseProxy").toBool() &&
                !gArgs.GetArg("-proxy", "").empty()) {
         addOverriddenOption("-proxy");
     }
 
     if (!settings.contains("fUseSeparateProxyTor")) {
         settings.setValue("fUseSeparateProxyTor", false);
     }
     if (!settings.contains("addrSeparateProxyTor")) {
         settings.setValue("addrSeparateProxyTor", GetDefaultProxyAddress());
     }
     // Only try to set -onion, if user has enabled fUseSeparateProxyTor
     if (settings.value("fUseSeparateProxyTor").toBool() &&
         !m_node.softSetArg(
             "-onion",
             settings.value("addrSeparateProxyTor").toString().toStdString())) {
         addOverriddenOption("-onion");
     } else if (!settings.value("fUseSeparateProxyTor").toBool() &&
                !gArgs.GetArg("-onion", "").empty()) {
         addOverriddenOption("-onion");
     }
 
     // Display
     if (!settings.contains("language")) {
         settings.setValue("language", "");
     }
     if (!m_node.softSetArg(
             "-lang", settings.value("language").toString().toStdString())) {
         addOverriddenOption("-lang");
     }
 
     language = settings.value("language").toString();
 }
 
 /**
  * Helper function to copy contents from one QSettings to another.
  * By using allKeys this also covers nested settings in a hierarchy.
  */
 static void CopySettings(QSettings &dst, const QSettings &src) {
     for (const QString &key : src.allKeys()) {
         dst.setValue(key, src.value(key));
     }
 }
 
 /** Back up a QSettings to an ini-formatted file. */
 static void BackupSettings(const fs::path &filename, const QSettings &src) {
     qWarning() << "Backing up GUI settings to"
                << GUIUtil::boostPathToQString(filename);
     QSettings dst(GUIUtil::boostPathToQString(filename), QSettings::IniFormat);
     dst.clear();
     CopySettings(dst, src);
 }
 
 void OptionsModel::Reset() {
     QSettings settings;
 
     // Backup old settings to chain-specific datadir for troubleshooting
     BackupSettings(GetDataDir(true) / "guisettings.ini.bak", settings);
 
     // Save the strDataDir setting
     QString dataDir = Intro::getDefaultDataDirectory();
     dataDir = settings.value("strDataDir", dataDir).toString();
 
     // Remove all entries from our QSettings object
     settings.clear();
 
     // Set strDataDir
     settings.setValue("strDataDir", dataDir);
 
     // Set that this was reset
     settings.setValue("fReset", true);
 
     // default setting for OptionsModel::StartAtStartup - disabled
     if (GUIUtil::GetStartOnSystemStartup()) {
         GUIUtil::SetStartOnSystemStartup(false);
     }
 }
 
 int OptionsModel::rowCount(const QModelIndex &parent) const {
     return OptionIDRowCount;
 }
 
 struct ProxySetting {
     bool is_set;
     QString ip;
     QString port;
 };
 
 static ProxySetting GetProxySetting(QSettings &settings, const QString &name) {
     static const ProxySetting default_val = {
         false, DEFAULT_GUI_PROXY_HOST,
         QString("%1").arg(DEFAULT_GUI_PROXY_PORT)};
     // Handle the case that the setting is not set at all
     if (!settings.contains(name)) {
         return default_val;
     }
     // contains IP at index 0 and port at index 1
     QStringList ip_port =
         settings.value(name).toString().split(":", QString::SkipEmptyParts);
     if (ip_port.size() == 2) {
         return {true, ip_port.at(0), ip_port.at(1)};
     } else { // Invalid: return default
         return default_val;
     }
 }
 
 static void SetProxySetting(QSettings &settings, const QString &name,
                             const ProxySetting &ip_port) {
     settings.setValue(name, ip_port.ip + ":" + ip_port.port);
 }
 
 static const QString GetDefaultProxyAddress() {
     return QString("%1:%2")
         .arg(DEFAULT_GUI_PROXY_HOST)
         .arg(DEFAULT_GUI_PROXY_PORT);
 }
 
 // read QSettings values and return them
 QVariant OptionsModel::data(const QModelIndex &index, int role) const {
     if (role == Qt::EditRole) {
         QSettings settings;
         switch (index.row()) {
             case StartAtStartup:
                 return GUIUtil::GetStartOnSystemStartup();
             case HideTrayIcon:
                 return fHideTrayIcon;
             case MinimizeToTray:
                 return fMinimizeToTray;
             case MapPortUPnP:
 #ifdef USE_UPNP
                 return settings.value("fUseUPnP");
 #else
                 return false;
 #endif
             case MinimizeOnClose:
                 return fMinimizeOnClose;
 
             // default proxy
             case ProxyUse:
                 return settings.value("fUseProxy", false);
             case ProxyIP:
                 return GetProxySetting(settings, "addrProxy").ip;
             case ProxyPort:
                 return GetProxySetting(settings, "addrProxy").port;
 
             // separate Tor proxy
             case ProxyUseTor:
                 return settings.value("fUseSeparateProxyTor", false);
             case ProxyIPTor:
                 return GetProxySetting(settings, "addrSeparateProxyTor").ip;
             case ProxyPortTor:
                 return GetProxySetting(settings, "addrSeparateProxyTor").port;
 
 #ifdef ENABLE_WALLET
             case SpendZeroConfChange:
                 return settings.value("bSpendZeroConfChange");
 #endif
             case DisplayUnit:
                 return nDisplayUnit;
             case ThirdPartyTxUrls:
                 return strThirdPartyTxUrls;
             case Language:
                 return settings.value("language");
             case CoinControlFeatures:
                 return fCoinControlFeatures;
             case Prune:
                 return settings.value("bPrune");
             case PruneSize:
                 return settings.value("nPruneSize");
             case DatabaseCache:
                 return settings.value("nDatabaseCache");
             case ThreadsScriptVerif:
                 return settings.value("nThreadsScriptVerif");
             case Listen:
                 return settings.value("fListen");
             default:
                 return QVariant();
         }
     }
     return QVariant();
 }
 
 // write QSettings values
 bool OptionsModel::setData(const QModelIndex &index, const QVariant &value,
                            int role) {
     bool successful = true; /* set to false on parse error */
     if (role == Qt::EditRole) {
         QSettings settings;
         switch (index.row()) {
             case StartAtStartup:
                 successful = GUIUtil::SetStartOnSystemStartup(value.toBool());
                 break;
             case HideTrayIcon:
                 fHideTrayIcon = value.toBool();
                 settings.setValue("fHideTrayIcon", fHideTrayIcon);
                 Q_EMIT hideTrayIconChanged(fHideTrayIcon);
                 break;
             case MinimizeToTray:
                 fMinimizeToTray = value.toBool();
                 settings.setValue("fMinimizeToTray", fMinimizeToTray);
                 break;
             case MapPortUPnP: // core option - can be changed on-the-fly
                 settings.setValue("fUseUPnP", value.toBool());
                 m_node.mapPort(value.toBool());
                 break;
             case MinimizeOnClose:
                 fMinimizeOnClose = value.toBool();
                 settings.setValue("fMinimizeOnClose", fMinimizeOnClose);
                 break;
 
             // default proxy
             case ProxyUse:
                 if (settings.value("fUseProxy") != value) {
                     settings.setValue("fUseProxy", value.toBool());
                     setRestartRequired(true);
                 }
                 break;
             case ProxyIP: {
                 auto ip_port = GetProxySetting(settings, "addrProxy");
                 if (!ip_port.is_set || ip_port.ip != value.toString()) {
                     ip_port.ip = value.toString();
                     SetProxySetting(settings, "addrProxy", ip_port);
                     setRestartRequired(true);
                 }
             } break;
             case ProxyPort: {
                 auto ip_port = GetProxySetting(settings, "addrProxy");
                 if (!ip_port.is_set || ip_port.port != value.toString()) {
                     ip_port.port = value.toString();
                     SetProxySetting(settings, "addrProxy", ip_port);
                     setRestartRequired(true);
                 }
             } break;
 
             // separate Tor proxy
             case ProxyUseTor:
                 if (settings.value("fUseSeparateProxyTor") != value) {
                     settings.setValue("fUseSeparateProxyTor", value.toBool());
                     setRestartRequired(true);
                 }
                 break;
             case ProxyIPTor: {
                 auto ip_port =
                     GetProxySetting(settings, "addrSeparateProxyTor");
                 if (!ip_port.is_set || ip_port.ip != value.toString()) {
                     ip_port.ip = value.toString();
                     SetProxySetting(settings, "addrSeparateProxyTor", ip_port);
                     setRestartRequired(true);
                 }
             } break;
             case ProxyPortTor: {
                 auto ip_port =
                     GetProxySetting(settings, "addrSeparateProxyTor");
                 if (!ip_port.is_set || ip_port.port != value.toString()) {
                     ip_port.port = value.toString();
                     SetProxySetting(settings, "addrSeparateProxyTor", ip_port);
                     setRestartRequired(true);
                 }
             } break;
 
 #ifdef ENABLE_WALLET
             case SpendZeroConfChange:
                 if (settings.value("bSpendZeroConfChange") != value) {
                     settings.setValue("bSpendZeroConfChange", value);
                     setRestartRequired(true);
                 }
                 break;
 #endif
             case DisplayUnit:
                 setDisplayUnit(value);
                 break;
             case ThirdPartyTxUrls:
                 if (strThirdPartyTxUrls != value.toString()) {
                     strThirdPartyTxUrls = value.toString();
                     settings.setValue("strThirdPartyTxUrls",
                                       strThirdPartyTxUrls);
                     setRestartRequired(true);
                 }
                 break;
             case Language:
                 if (settings.value("language") != value) {
                     settings.setValue("language", value);
                     setRestartRequired(true);
                 }
                 break;
             case CoinControlFeatures:
                 fCoinControlFeatures = value.toBool();
                 settings.setValue("fCoinControlFeatures", fCoinControlFeatures);
                 Q_EMIT coinControlFeaturesChanged(fCoinControlFeatures);
                 break;
             case Prune:
                 if (settings.value("bPrune") != value) {
                     settings.setValue("bPrune", value);
                     setRestartRequired(true);
                 }
                 break;
             case PruneSize:
                 if (settings.value("nPruneSize") != value) {
                     settings.setValue("nPruneSize", value);
                     setRestartRequired(true);
                 }
                 break;
             case DatabaseCache:
                 if (settings.value("nDatabaseCache") != value) {
                     settings.setValue("nDatabaseCache", value);
                     setRestartRequired(true);
                 }
                 break;
             case ThreadsScriptVerif:
                 if (settings.value("nThreadsScriptVerif") != value) {
                     settings.setValue("nThreadsScriptVerif", value);
                     setRestartRequired(true);
                 }
                 break;
             case Listen:
                 if (settings.value("fListen") != value) {
                     settings.setValue("fListen", value);
                     setRestartRequired(true);
                 }
                 break;
             default:
                 break;
         }
     }
 
     Q_EMIT dataChanged(index, index);
 
     return successful;
 }
 
 /** Updates current unit in memory, settings and emits
  * displayUnitChanged(newUnit) signal */
 void OptionsModel::setDisplayUnit(const QVariant &value) {
     if (!value.isNull()) {
         QSettings settings;
         nDisplayUnit = value.toInt();
         settings.setValue("nDisplayUnit", nDisplayUnit);
         Q_EMIT displayUnitChanged(nDisplayUnit);
     }
 }
 
 bool OptionsModel::getProxySettings(QNetworkProxy &proxy) const {
     // Directly query current base proxy, because
     // GUI settings can be overridden with -proxy.
     proxyType curProxy;
     if (m_node.getProxy(NET_IPV4, curProxy)) {
         proxy.setType(QNetworkProxy::Socks5Proxy);
         proxy.setHostName(QString::fromStdString(curProxy.proxy.ToStringIP()));
         proxy.setPort(curProxy.proxy.GetPort());
 
         return true;
-    } else
+    } else {
         proxy.setType(QNetworkProxy::NoProxy);
+    }
 
     return false;
 }
 
 void OptionsModel::setRestartRequired(bool fRequired) {
     QSettings settings;
     return settings.setValue("fRestartRequired", fRequired);
 }
 
 bool OptionsModel::isRestartRequired() const {
     QSettings settings;
     return settings.value("fRestartRequired", false).toBool();
 }
 
 void OptionsModel::checkAndMigrate() {
     // Migration of default values
     // Check if the QSettings container was already loaded with this client
     // version
     QSettings settings;
     static const char strSettingsVersionKey[] = "nSettingsVersion";
     int settingsVersion = settings.contains(strSettingsVersionKey)
                               ? settings.value(strSettingsVersionKey).toInt()
                               : 0;
     if (settingsVersion < CLIENT_VERSION) {
         // -dbcache was bumped from 100 to 300 in 0.13
         // see https://github.com/bitcoin/bitcoin/pull/8273
         // force people to upgrade to the new value if they are using 100MB
         if (settingsVersion < 130000 && settings.contains("nDatabaseCache") &&
-            settings.value("nDatabaseCache").toLongLong() == 100)
+            settings.value("nDatabaseCache").toLongLong() == 100) {
             settings.setValue("nDatabaseCache", (qint64)nDefaultDbCache);
+        }
 
         settings.setValue(strSettingsVersionKey, CLIENT_VERSION);
     }
 
     // Overwrite the 'addrProxy' setting in case it has been set to an illegal
     // default value (see issue #12623; PR #12650).
     if (settings.contains("addrProxy") &&
         settings.value("addrProxy").toString().endsWith("%2")) {
         settings.setValue("addrProxy", GetDefaultProxyAddress());
     }
 
     // Overwrite the 'addrSeparateProxyTor' setting in case it has been set to
     // an illegal default value (see issue #12623; PR #12650).
     if (settings.contains("addrSeparateProxyTor") &&
         settings.value("addrSeparateProxyTor").toString().endsWith("%2")) {
         settings.setValue("addrSeparateProxyTor", GetDefaultProxyAddress());
     }
 }
diff --git a/src/qt/overviewpage.cpp b/src/qt/overviewpage.cpp
index f40596f912..704783c1e0 100644
--- a/src/qt/overviewpage.cpp
+++ b/src/qt/overviewpage.cpp
@@ -1,291 +1,293 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/forms/ui_overviewpage.h>
 #include <qt/overviewpage.h>
 
 #include <qt/bitcoinunits.h>
 #include <qt/clientmodel.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/transactionfilterproxy.h>
 #include <qt/transactiontablemodel.h>
 #include <qt/walletmodel.h>
 
 #include <QAbstractItemDelegate>
 #include <QPainter>
 
 #define DECORATION_SIZE 54
 #define NUM_ITEMS 5
 
 Q_DECLARE_METATYPE(interfaces::WalletBalances)
 
 class TxViewDelegate : public QAbstractItemDelegate {
     Q_OBJECT
 public:
     explicit TxViewDelegate(const PlatformStyle *_platformStyle,
                             QObject *parent = nullptr)
         : QAbstractItemDelegate(parent), unit(BitcoinUnits::BCH),
           platformStyle(_platformStyle) {}
 
     inline void paint(QPainter *painter, const QStyleOptionViewItem &option,
                       const QModelIndex &index) const {
         painter->save();
 
         QIcon icon = qvariant_cast<QIcon>(
             index.data(TransactionTableModel::RawDecorationRole));
         QRect mainRect = option.rect;
         QRect decorationRect(mainRect.topLeft(),
                              QSize(DECORATION_SIZE, DECORATION_SIZE));
         int xspace = DECORATION_SIZE + 8;
         int ypad = 6;
         int halfheight = (mainRect.height() - 2 * ypad) / 2;
         QRect amountRect(mainRect.left() + xspace, mainRect.top() + ypad,
                          mainRect.width() - xspace, halfheight);
         QRect addressRect(mainRect.left() + xspace,
                           mainRect.top() + ypad + halfheight,
                           mainRect.width() - xspace, halfheight);
         icon = platformStyle->SingleColorIcon(icon);
         icon.paint(painter, decorationRect);
 
         QDateTime date =
             index.data(TransactionTableModel::DateRole).toDateTime();
         QString address = index.data(Qt::DisplayRole).toString();
         Amount amount(
             int64_t(
                 index.data(TransactionTableModel::AmountRole).toLongLong()) *
             SATOSHI);
         bool confirmed =
             index.data(TransactionTableModel::ConfirmedRole).toBool();
         QVariant value = index.data(Qt::ForegroundRole);
         QColor foreground = option.palette.color(QPalette::Text);
         if (value.canConvert<QBrush>()) {
             QBrush brush = qvariant_cast<QBrush>(value);
             foreground = brush.color();
         }
 
         painter->setPen(foreground);
         QRect boundingRect;
         painter->drawText(addressRect, Qt::AlignLeft | Qt::AlignVCenter,
                           address, &boundingRect);
 
         if (index.data(TransactionTableModel::WatchonlyRole).toBool()) {
             QIcon iconWatchonly = qvariant_cast<QIcon>(
                 index.data(TransactionTableModel::WatchonlyDecorationRole));
             QRect watchonlyRect(boundingRect.right() + 5,
                                 mainRect.top() + ypad + halfheight, 16,
                                 halfheight);
             iconWatchonly.paint(painter, watchonlyRect);
         }
 
         if (amount < Amount::zero()) {
             foreground = COLOR_NEGATIVE;
         } else if (!confirmed) {
             foreground = COLOR_UNCONFIRMED;
         } else {
             foreground = option.palette.color(QPalette::Text);
         }
         painter->setPen(foreground);
         QString amountText = BitcoinUnits::formatWithUnit(
             unit, amount, true, BitcoinUnits::separatorAlways);
         if (!confirmed) {
             amountText = QString("[") + amountText + QString("]");
         }
         painter->drawText(amountRect, Qt::AlignRight | Qt::AlignVCenter,
                           amountText);
 
         painter->setPen(option.palette.color(QPalette::Text));
         painter->drawText(amountRect, Qt::AlignLeft | Qt::AlignVCenter,
                           GUIUtil::dateTimeStr(date));
 
         painter->restore();
     }
 
     inline QSize sizeHint(const QStyleOptionViewItem &option,
                           const QModelIndex &index) const {
         return QSize(DECORATION_SIZE, DECORATION_SIZE);
     }
 
     int unit;
     const PlatformStyle *platformStyle;
 };
 #include <qt/overviewpage.moc>
 
 OverviewPage::OverviewPage(const PlatformStyle *platformStyle, QWidget *parent)
     : QWidget(parent), ui(new Ui::OverviewPage), clientModel(0), walletModel(0),
       txdelegate(new TxViewDelegate(platformStyle, this)) {
     ui->setupUi(this);
 
     m_balances.balance = -SATOSHI;
 
     // use a SingleColorIcon for the "out of sync warning" icon
     QIcon icon = platformStyle->SingleColorIcon(":/icons/warning");
     // also set the disabled icon because we are using a disabled QPushButton to
     // work around missing HiDPI support of QLabel
     // (https://bugreports.qt.io/browse/QTBUG-42503)
     icon.addPixmap(icon.pixmap(QSize(64, 64), QIcon::Normal), QIcon::Disabled);
     ui->labelTransactionsStatus->setIcon(icon);
     ui->labelWalletStatus->setIcon(icon);
 
     // Recent transactions
     ui->listTransactions->setItemDelegate(txdelegate);
     ui->listTransactions->setIconSize(QSize(DECORATION_SIZE, DECORATION_SIZE));
     ui->listTransactions->setMinimumHeight(NUM_ITEMS * (DECORATION_SIZE + 2));
     ui->listTransactions->setAttribute(Qt::WA_MacShowFocusRect, false);
 
     connect(ui->listTransactions, &QListView::clicked, this,
             &OverviewPage::handleTransactionClicked);
 
     // start with displaying the "out of sync" warnings
     showOutOfSyncWarning(true);
     connect(ui->labelWalletStatus, &QPushButton::clicked, this,
             &OverviewPage::handleOutOfSyncWarningClicks);
     connect(ui->labelTransactionsStatus, &QPushButton::clicked, this,
             &OverviewPage::handleOutOfSyncWarningClicks);
 }
 
 void OverviewPage::handleTransactionClicked(const QModelIndex &index) {
-    if (filter) Q_EMIT transactionClicked(filter->mapToSource(index));
+    if (filter) {
+        Q_EMIT transactionClicked(filter->mapToSource(index));
+    }
 }
 
 void OverviewPage::handleOutOfSyncWarningClicks() {
     Q_EMIT outOfSyncWarningClicked();
 }
 
 OverviewPage::~OverviewPage() {
     delete ui;
 }
 
 void OverviewPage::setBalance(const interfaces::WalletBalances &balances) {
     int unit = walletModel->getOptionsModel()->getDisplayUnit();
     m_balances = balances;
     ui->labelBalance->setText(BitcoinUnits::formatWithUnit(
         unit, balances.balance, false, BitcoinUnits::separatorAlways));
     ui->labelUnconfirmed->setText(
         BitcoinUnits::formatWithUnit(unit, balances.unconfirmed_balance, false,
                                      BitcoinUnits::separatorAlways));
     ui->labelImmature->setText(BitcoinUnits::formatWithUnit(
         unit, balances.immature_balance, false, BitcoinUnits::separatorAlways));
     ui->labelTotal->setText(BitcoinUnits::formatWithUnit(
         unit,
         balances.balance + balances.unconfirmed_balance +
             balances.immature_balance,
         false, BitcoinUnits::separatorAlways));
     ui->labelWatchAvailable->setText(
         BitcoinUnits::formatWithUnit(unit, balances.watch_only_balance, false,
                                      BitcoinUnits::separatorAlways));
     ui->labelWatchPending->setText(BitcoinUnits::formatWithUnit(
         unit, balances.unconfirmed_watch_only_balance, false,
         BitcoinUnits::separatorAlways));
     ui->labelWatchImmature->setText(
         BitcoinUnits::formatWithUnit(unit, balances.immature_watch_only_balance,
                                      false, BitcoinUnits::separatorAlways));
     ui->labelWatchTotal->setText(BitcoinUnits::formatWithUnit(
         unit,
         balances.watch_only_balance + balances.unconfirmed_watch_only_balance +
             balances.immature_watch_only_balance,
         false, BitcoinUnits::separatorAlways));
 
     // only show immature (newly mined) balance if it's non-zero, so as not to
     // complicate things for the non-mining users
     bool showImmature = balances.immature_balance != Amount::zero();
     bool showWatchOnlyImmature =
         balances.immature_watch_only_balance != Amount::zero();
 
     // for symmetry reasons also show immature label when the watch-only one is
     // shown
     ui->labelImmature->setVisible(showImmature || showWatchOnlyImmature);
     ui->labelImmatureText->setVisible(showImmature || showWatchOnlyImmature);
     ui->labelWatchImmature->setVisible(
         showWatchOnlyImmature); // show watch-only immature balance
 }
 
 // show/hide watch-only labels
 void OverviewPage::updateWatchOnlyLabels(bool showWatchOnly) {
     // show spendable label (only when watch-only is active)
     ui->labelSpendable->setVisible(showWatchOnly);
     // show watch-only label
     ui->labelWatchonly->setVisible(showWatchOnly);
     // show watch-only balance separator line
     ui->lineWatchBalance->setVisible(showWatchOnly);
     // show watch-only available balance
     ui->labelWatchAvailable->setVisible(showWatchOnly);
     // show watch-only pending balance
     ui->labelWatchPending->setVisible(showWatchOnly);
     // show watch-only total balance
     ui->labelWatchTotal->setVisible(showWatchOnly);
 
     if (!showWatchOnly) {
         ui->labelWatchImmature->hide();
     }
 }
 
 void OverviewPage::setClientModel(ClientModel *model) {
     this->clientModel = model;
     if (model) {
         // Show warning if this is a prerelease version
         connect(model, &ClientModel::alertsChanged, this,
                 &OverviewPage::updateAlerts);
         updateAlerts(model->getStatusBarWarnings());
     }
 }
 
 void OverviewPage::setWalletModel(WalletModel *model) {
     this->walletModel = model;
     if (model && model->getOptionsModel()) {
         // Set up transaction list
         filter.reset(new TransactionFilterProxy());
         filter->setSourceModel(model->getTransactionTableModel());
         filter->setLimit(NUM_ITEMS);
         filter->setDynamicSortFilter(true);
         filter->setSortRole(Qt::EditRole);
         filter->setShowInactive(false);
         filter->sort(TransactionTableModel::Date, Qt::DescendingOrder);
 
         ui->listTransactions->setModel(filter.get());
         ui->listTransactions->setModelColumn(TransactionTableModel::ToAddress);
 
         // Keep up to date with wallet
         interfaces::Wallet &wallet = model->wallet();
         interfaces::WalletBalances balances = wallet.getBalances();
         setBalance(balances);
         connect(model, &WalletModel::balanceChanged, this,
                 &OverviewPage::setBalance);
 
         connect(model->getOptionsModel(), &OptionsModel::displayUnitChanged,
                 this, &OverviewPage::updateDisplayUnit);
 
         updateWatchOnlyLabels(wallet.haveWatchOnly());
         connect(model, &WalletModel::notifyWatchonlyChanged, this,
                 &OverviewPage::updateWatchOnlyLabels);
     }
 
     // update the display unit, to not use the default ("BCH")
     updateDisplayUnit();
 }
 
 void OverviewPage::updateDisplayUnit() {
     if (walletModel && walletModel->getOptionsModel()) {
         if (m_balances.balance != -SATOSHI) {
             setBalance(m_balances);
         }
 
         // Update txdelegate->unit with the current unit
         txdelegate->unit = walletModel->getOptionsModel()->getDisplayUnit();
 
         ui->listTransactions->update();
     }
 }
 
 void OverviewPage::updateAlerts(const QString &warnings) {
     this->ui->labelAlerts->setVisible(!warnings.isEmpty());
     this->ui->labelAlerts->setText(warnings);
 }
 
 void OverviewPage::showOutOfSyncWarning(bool fShow) {
     ui->labelWalletStatus->setVisible(fShow);
     ui->labelTransactionsStatus->setVisible(fShow);
 }
diff --git a/src/qt/paymentrequestplus.cpp b/src/qt/paymentrequestplus.cpp
index fc3e4e64d5..f19a391f70 100644
--- a/src/qt/paymentrequestplus.cpp
+++ b/src/qt/paymentrequestplus.cpp
@@ -1,236 +1,242 @@
 // 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.
 
 //
 // Wraps dumb protocol buffer paymentRequest with some extra methods
 //
 
 #include <qt/paymentrequestplus.h>
 
 #include <script/script.h>
 #include <util/system.h>
 
 #include <openssl/x509_vfy.h>
 
 #include <QDateTime>
 #include <QDebug>
 #include <QSslCertificate>
 
 #include <stdexcept>
 
 class SSLVerifyError : public std::runtime_error {
 public:
     explicit SSLVerifyError(std::string err) : std::runtime_error(err) {}
 };
 
 bool PaymentRequestPlus::parse(const QByteArray &data) {
     bool parseOK = paymentRequest.ParseFromArray(data.data(), data.size());
     if (!parseOK) {
         qWarning()
             << "PaymentRequestPlus::parse: Error parsing payment request";
         return false;
     }
     if (paymentRequest.payment_details_version() > 1) {
         qWarning() << "PaymentRequestPlus::parse: Received up-version payment "
                       "details, version="
                    << paymentRequest.payment_details_version();
         return false;
     }
 
     parseOK =
         details.ParseFromString(paymentRequest.serialized_payment_details());
     if (!parseOK) {
         qWarning()
             << "PaymentRequestPlus::parse: Error parsing payment details";
         paymentRequest.Clear();
         return false;
     }
     return true;
 }
 
 bool PaymentRequestPlus::SerializeToString(std::string *output) const {
     return paymentRequest.SerializeToString(output);
 }
 
 bool PaymentRequestPlus::IsInitialized() const {
     return paymentRequest.IsInitialized();
 }
 
 bool PaymentRequestPlus::getMerchant(X509_STORE *certStore,
                                      QString &merchant) const {
     merchant.clear();
 
-    if (!IsInitialized()) return false;
+    if (!IsInitialized()) {
+        return false;
+    }
 
     // One day we'll support more PKI types, but just x509 for now:
     const EVP_MD *digestAlgorithm = nullptr;
     if (paymentRequest.pki_type() == "x509+sha256") {
         digestAlgorithm = EVP_sha256();
     } else if (paymentRequest.pki_type() == "x509+sha1") {
         digestAlgorithm = EVP_sha1();
     } else if (paymentRequest.pki_type() == "none") {
         qWarning() << "PaymentRequestPlus::getMerchant: Payment request: "
                       "pki_type == none";
         return false;
     } else {
         qWarning() << "PaymentRequestPlus::getMerchant: Payment request: "
                       "unknown pki_type "
                    << QString::fromStdString(paymentRequest.pki_type());
         return false;
     }
 
     payments::X509Certificates certChain;
     if (!certChain.ParseFromString(paymentRequest.pki_data())) {
         qWarning() << "PaymentRequestPlus::getMerchant: Payment request: error "
                       "parsing pki_data";
         return false;
     }
 
     std::vector<X509 *> certs;
     const QDateTime currentTime = QDateTime::currentDateTime();
     for (int i = 0; i < certChain.certificate_size(); i++) {
         QByteArray certData(certChain.certificate(i).data(),
                             certChain.certificate(i).size());
         QSslCertificate qCert(certData, QSsl::Der);
         if (currentTime < qCert.effectiveDate() ||
             currentTime > qCert.expiryDate()) {
             qWarning() << "PaymentRequestPlus::getMerchant: Payment request: "
                           "certificate expired or not yet active: "
                        << qCert;
             return false;
         }
         if (qCert.isBlacklisted()) {
             qWarning() << "PaymentRequestPlus::getMerchant: Payment request: "
                           "certificate blacklisted: "
                        << qCert;
             return false;
         }
         const uint8_t *data = (const uint8_t *)certChain.certificate(i).data();
         X509 *cert = d2i_X509(nullptr, &data, certChain.certificate(i).size());
-        if (cert) certs.push_back(cert);
+        if (cert) {
+            certs.push_back(cert);
+        }
     }
     if (certs.empty()) {
         qWarning() << "PaymentRequestPlus::getMerchant: Payment request: empty "
                       "certificate chain";
         return false;
     }
 
     // The first cert is the signing cert, the rest are untrusted certs that
     // chain to a valid root authority. OpenSSL needs them separately.
     STACK_OF(X509) *chain = sk_X509_new_null();
     for (int i = certs.size() - 1; i > 0; i--) {
         sk_X509_push(chain, certs[i]);
     }
     X509 *signing_cert = certs[0];
 
     // Now create a "store context", which is a single use object for checking,
     // load the signing cert into it and verify.
     X509_STORE_CTX *store_ctx = X509_STORE_CTX_new();
     if (!store_ctx) {
         qWarning() << "PaymentRequestPlus::getMerchant: Payment request: error "
                       "creating X509_STORE_CTX";
         return false;
     }
 
     char *website = nullptr;
     bool fResult = true;
     try {
         if (!X509_STORE_CTX_init(store_ctx, certStore, signing_cert, chain)) {
             int error = X509_STORE_CTX_get_error(store_ctx);
             throw SSLVerifyError(X509_verify_cert_error_string(error));
         }
 
         // Now do the verification!
         int result = X509_verify_cert(store_ctx);
         if (result != 1) {
             int error = X509_STORE_CTX_get_error(store_ctx);
             // For testing payment requests, we allow self signed root certs!
             // This option is just shown in the UI options, if -help-debug is
             // enabled.
             if (!(error == X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT &&
                   gArgs.GetBoolArg("-allowselfsignedrootcertificates",
                                    DEFAULT_SELFSIGNED_ROOTCERTS))) {
                 throw SSLVerifyError(X509_verify_cert_error_string(error));
             } else {
                 qDebug() << "PaymentRequestPlus::getMerchant: Allowing self "
                             "signed root certificate, because "
                             "-allowselfsignedrootcertificates is true.";
             }
         }
         X509_NAME *certname = X509_get_subject_name(signing_cert);
 
         // Valid cert; check signature:
         // Copy
         payments::PaymentRequest rcopy(paymentRequest);
         rcopy.set_signature(std::string(""));
         // Everything but the signature
         std::string data_to_verify;
         rcopy.SerializeToString(&data_to_verify);
 
 #if HAVE_DECL_EVP_MD_CTX_NEW
         EVP_MD_CTX *ctx = EVP_MD_CTX_new();
-        if (!ctx) throw SSLVerifyError("Error allocating OpenSSL context.");
+        if (!ctx) {
+            throw SSLVerifyError("Error allocating OpenSSL context.");
+        }
 #else
         EVP_MD_CTX _ctx;
         EVP_MD_CTX *ctx;
         ctx = &_ctx;
 #endif
         EVP_PKEY *pubkey = X509_get_pubkey(signing_cert);
         EVP_MD_CTX_init(ctx);
         if (!EVP_VerifyInit_ex(ctx, digestAlgorithm, nullptr) ||
             !EVP_VerifyUpdate(ctx, data_to_verify.data(),
                               data_to_verify.size()) ||
             !EVP_VerifyFinal(
                 ctx, (const uint8_t *)paymentRequest.signature().data(),
                 (unsigned int)paymentRequest.signature().size(), pubkey)) {
             throw SSLVerifyError("Bad signature, invalid payment request.");
         }
 #if HAVE_DECL_EVP_MD_CTX_NEW
         EVP_MD_CTX_free(ctx);
 #endif
 
         // OpenSSL API for getting human printable strings from certs is
         // baroque.
         int textlen =
             X509_NAME_get_text_by_NID(certname, NID_commonName, nullptr, 0);
         website = new char[textlen + 1];
         if (X509_NAME_get_text_by_NID(certname, NID_commonName, website,
                                       textlen + 1) == textlen &&
             textlen > 0) {
             merchant = website;
         } else {
             throw SSLVerifyError("Bad certificate, missing common name.");
         }
         // TODO: detect EV certificates and set merchant = business name instead
         // of unfriendly NID_commonName ?
     } catch (const SSLVerifyError &err) {
         fResult = false;
         qWarning() << "PaymentRequestPlus::getMerchant: SSL error: "
                    << err.what();
     }
 
     if (website) {
         delete[] website;
     }
 
     X509_STORE_CTX_free(store_ctx);
     for (size_t i = 0; i < certs.size(); i++) {
         X509_free(certs[i]);
     }
 
     return fResult;
 }
 
 QList<std::pair<CScript, Amount>> PaymentRequestPlus::getPayTo() const {
     QList<std::pair<CScript, Amount>> result;
     for (int i = 0; i < details.outputs_size(); i++) {
         const uint8_t *scriptStr =
             (const uint8_t *)details.outputs(i).script().data();
         CScript s(scriptStr, scriptStr + details.outputs(i).script().size());
 
         result.append(
             std::make_pair(s, int64_t(details.outputs(i).amount()) * SATOSHI));
     }
     return result;
 }
diff --git a/src/qt/peertablemodel.cpp b/src/qt/peertablemodel.cpp
index 7561dc8a19..41d77f12c0 100644
--- a/src/qt/peertablemodel.cpp
+++ b/src/qt/peertablemodel.cpp
@@ -1,220 +1,231 @@
 // 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/peertablemodel.h>
 
 #include <qt/clientmodel.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 
 #include <interfaces/node.h>
 #include <sync.h>
 #include <validation.h> // for cs_main
 
 #include <algorithm>
 
 #include <QDebug>
 #include <QList>
 #include <QTimer>
 
 bool NodeLessThan::operator()(const CNodeCombinedStats &left,
                               const CNodeCombinedStats &right) const {
     const CNodeStats *pLeft = &(left.nodeStats);
     const CNodeStats *pRight = &(right.nodeStats);
 
-    if (order == Qt::DescendingOrder) std::swap(pLeft, pRight);
+    if (order == Qt::DescendingOrder) {
+        std::swap(pLeft, pRight);
+    }
 
     switch (column) {
         case PeerTableModel::NetNodeId:
             return pLeft->nodeid < pRight->nodeid;
         case PeerTableModel::Address:
             return pLeft->addrName.compare(pRight->addrName) < 0;
         case PeerTableModel::Subversion:
             return pLeft->cleanSubVer.compare(pRight->cleanSubVer) < 0;
         case PeerTableModel::Ping:
             return pLeft->dMinPing < pRight->dMinPing;
         case PeerTableModel::Sent:
             return pLeft->nSendBytes < pRight->nSendBytes;
         case PeerTableModel::Received:
             return pLeft->nRecvBytes < pRight->nRecvBytes;
     }
 
     return false;
 }
 
 // private implementation
 class PeerTablePriv {
 public:
     /** Local cache of peer information */
     QList<CNodeCombinedStats> cachedNodeStats;
     /** Column to sort nodes by (default to unsorted) */
     int sortColumn{-1};
     /** Order (ascending or descending) to sort nodes by */
     Qt::SortOrder sortOrder;
     /** Index of rows by node ID */
     std::map<NodeId, int> mapNodeRows;
 
     /** Pull a full list of peers from vNodes into our cache */
     void refreshPeers(interfaces::Node &node) {
         {
             cachedNodeStats.clear();
 
             interfaces::Node::NodesStats nodes_stats;
             node.getNodesStats(nodes_stats);
             cachedNodeStats.reserve(nodes_stats.size());
             for (const auto &node_stats : nodes_stats) {
                 CNodeCombinedStats stats;
                 stats.nodeStats = std::get<0>(node_stats);
                 stats.fNodeStateStatsAvailable = std::get<1>(node_stats);
                 stats.nodeStateStats = std::get<2>(node_stats);
                 cachedNodeStats.append(stats);
             }
         }
 
         if (sortColumn >= 0) {
             // sort cacheNodeStats (use stable sort to prevent rows jumping
             // around unnecessarily)
             std::stable_sort(cachedNodeStats.begin(), cachedNodeStats.end(),
                              NodeLessThan(sortColumn, sortOrder));
         }
 
         // build index map
         mapNodeRows.clear();
         int row = 0;
         for (const CNodeCombinedStats &stats : cachedNodeStats) {
             mapNodeRows.insert(
                 std::pair<NodeId, int>(stats.nodeStats.nodeid, row++));
         }
     }
 
     int size() const { return cachedNodeStats.size(); }
 
     CNodeCombinedStats *index(int idx) {
-        if (idx >= 0 && idx < cachedNodeStats.size())
+        if (idx >= 0 && idx < cachedNodeStats.size()) {
             return &cachedNodeStats[idx];
+        }
 
         return 0;
     }
 };
 
 PeerTableModel::PeerTableModel(interfaces::Node &node, ClientModel *parent)
     : QAbstractTableModel(parent), m_node(node), clientModel(parent), timer(0) {
     columns << tr("NodeId") << tr("Node/Service") << tr("Ping") << tr("Sent")
             << tr("Received") << tr("User Agent");
     priv.reset(new PeerTablePriv());
 
     // set up timer for auto refresh
     timer = new QTimer(this);
     connect(timer, &QTimer::timeout, this, &PeerTableModel::refresh);
     timer->setInterval(MODEL_UPDATE_DELAY);
 
     // load initial data
     refresh();
 }
 
 PeerTableModel::~PeerTableModel() {
     // Intentionally left empty
 }
 
 void PeerTableModel::startAutoRefresh() {
     timer->start();
 }
 
 void PeerTableModel::stopAutoRefresh() {
     timer->stop();
 }
 
 int PeerTableModel::rowCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return priv->size();
 }
 
 int PeerTableModel::columnCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return columns.length();
 }
 
 QVariant PeerTableModel::data(const QModelIndex &index, int role) const {
-    if (!index.isValid()) return QVariant();
+    if (!index.isValid()) {
+        return QVariant();
+    }
 
     CNodeCombinedStats *rec =
         static_cast<CNodeCombinedStats *>(index.internalPointer());
 
     if (role == Qt::DisplayRole) {
         switch (index.column()) {
             case NetNodeId:
                 return (qint64)rec->nodeStats.nodeid;
             case Address:
                 return QString::fromStdString(rec->nodeStats.addrName);
             case Subversion:
                 return QString::fromStdString(rec->nodeStats.cleanSubVer);
             case Ping:
                 return GUIUtil::formatPingTime(rec->nodeStats.dMinPing);
             case Sent:
                 return GUIUtil::formatBytes(rec->nodeStats.nSendBytes);
             case Received:
                 return GUIUtil::formatBytes(rec->nodeStats.nRecvBytes);
         }
     } else if (role == Qt::TextAlignmentRole) {
         switch (index.column()) {
             case Ping:
             case Sent:
             case Received:
                 return QVariant(Qt::AlignRight | Qt::AlignVCenter);
             default:
                 return QVariant();
         }
     }
 
     return QVariant();
 }
 
 QVariant PeerTableModel::headerData(int section, Qt::Orientation orientation,
                                     int role) const {
     if (orientation == Qt::Horizontal) {
         if (role == Qt::DisplayRole && section < columns.size()) {
             return columns[section];
         }
     }
     return QVariant();
 }
 
 Qt::ItemFlags PeerTableModel::flags(const QModelIndex &index) const {
-    if (!index.isValid()) return 0;
+    if (!index.isValid()) {
+        return 0;
+    }
 
     Qt::ItemFlags retval = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
     return retval;
 }
 
 QModelIndex PeerTableModel::index(int row, int column,
                                   const QModelIndex &parent) const {
     Q_UNUSED(parent);
     CNodeCombinedStats *data = priv->index(row);
 
-    if (data) return createIndex(row, column, data);
+    if (data) {
+        return createIndex(row, column, data);
+    }
     return QModelIndex();
 }
 
 const CNodeCombinedStats *PeerTableModel::getNodeStats(int idx) {
     return priv->index(idx);
 }
 
 void PeerTableModel::refresh() {
     Q_EMIT layoutAboutToBeChanged();
     priv->refreshPeers(m_node);
     Q_EMIT layoutChanged();
 }
 
 int PeerTableModel::getRowByNodeId(NodeId nodeid) {
     std::map<NodeId, int>::iterator it = priv->mapNodeRows.find(nodeid);
-    if (it == priv->mapNodeRows.end()) return -1;
+    if (it == priv->mapNodeRows.end()) {
+        return -1;
+    }
 
     return it->second;
 }
 
 void PeerTableModel::sort(int column, Qt::SortOrder order) {
     priv->sortColumn = column;
     priv->sortOrder = order;
     refresh();
 }
diff --git a/src/qt/platformstyle.cpp b/src/qt/platformstyle.cpp
index ac398d998e..edfdf7a518 100644
--- a/src/qt/platformstyle.cpp
+++ b/src/qt/platformstyle.cpp
@@ -1,126 +1,133 @@
 // Copyright (c) 2015-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/platformstyle.h>
 
 #include <qt/guiconstants.h>
 
 #include <QApplication>
 #include <QColor>
 #include <QIcon>
 #include <QImage>
 #include <QPalette>
 #include <QPixmap>
 
 static const struct {
     const char *platformId;
     /** Show images on push buttons */
     const bool imagesOnButtons;
     /** Colorize single-color icons */
     const bool colorizeIcons;
     /** Extra padding/spacing in transactionview */
     const bool useExtraSpacing;
 } platform_styles[] = {{"macosx", false, false, true},
                        {"windows", true, false, false},
                        /* Other: linux, unix, ... */
                        {"other", true, true, false}};
 static const unsigned platform_styles_count =
     sizeof(platform_styles) / sizeof(*platform_styles);
 
 namespace {
 
 /* Local functions for colorizing single-color images */
 void MakeSingleColorImage(QImage &img, const QColor &colorbase) {
     img = img.convertToFormat(QImage::Format_ARGB32);
     for (int x = img.width(); x--;) {
         for (int y = img.height(); y--;) {
             const QRgb rgb = img.pixel(x, y);
             img.setPixel(x, y,
                          qRgba(colorbase.red(), colorbase.green(),
                                colorbase.blue(), qAlpha(rgb)));
         }
     }
 }
 
 QIcon ColorizeIcon(const QIcon &ico, const QColor &colorbase) {
     QIcon new_ico;
     for (const QSize &sz : ico.availableSizes()) {
         QImage img(ico.pixmap(sz).toImage());
         MakeSingleColorImage(img, colorbase);
         new_ico.addPixmap(QPixmap::fromImage(img));
     }
     return new_ico;
 }
 
 QImage ColorizeImage(const QString &filename, const QColor &colorbase) {
     QImage img(filename);
     MakeSingleColorImage(img, colorbase);
     return img;
 }
 
 QIcon ColorizeIcon(const QString &filename, const QColor &colorbase) {
     return QIcon(QPixmap::fromImage(ColorizeImage(filename, colorbase)));
 }
 } // namespace
 
 PlatformStyle::PlatformStyle(const QString &_name, bool _imagesOnButtons,
                              bool _colorizeIcons, bool _useExtraSpacing)
     : name(_name), imagesOnButtons(_imagesOnButtons),
       colorizeIcons(_colorizeIcons), useExtraSpacing(_useExtraSpacing),
       singleColor(0, 0, 0), textColor(0, 0, 0) {
     // Determine icon highlighting color
     if (colorizeIcons) {
         const QColor colorHighlightBg(
             QApplication::palette().color(QPalette::Highlight));
         const QColor colorHighlightFg(
             QApplication::palette().color(QPalette::HighlightedText));
         const QColor colorText(
             QApplication::palette().color(QPalette::WindowText));
         const int colorTextLightness = colorText.lightness();
         QColor colorbase;
         if (abs(colorHighlightBg.lightness() - colorTextLightness) <
-            abs(colorHighlightFg.lightness() - colorTextLightness))
+            abs(colorHighlightFg.lightness() - colorTextLightness)) {
             colorbase = colorHighlightBg;
-        else
+        } else {
             colorbase = colorHighlightFg;
+        }
         singleColor = colorbase;
     }
     // Determine text color
     textColor = QColor(QApplication::palette().color(QPalette::WindowText));
 }
 
 QImage PlatformStyle::SingleColorImage(const QString &filename) const {
-    if (!colorizeIcons) return QImage(filename);
+    if (!colorizeIcons) {
+        return QImage(filename);
+    }
     return ColorizeImage(filename, SingleColor());
 }
 
 QIcon PlatformStyle::SingleColorIcon(const QString &filename) const {
-    if (!colorizeIcons) return QIcon(filename);
+    if (!colorizeIcons) {
+        return QIcon(filename);
+    }
     return ColorizeIcon(filename, SingleColor());
 }
 
 QIcon PlatformStyle::SingleColorIcon(const QIcon &icon) const {
-    if (!colorizeIcons) return icon;
+    if (!colorizeIcons) {
+        return icon;
+    }
     return ColorizeIcon(icon, SingleColor());
 }
 
 QIcon PlatformStyle::TextColorIcon(const QString &filename) const {
     return ColorizeIcon(filename, TextColor());
 }
 
 QIcon PlatformStyle::TextColorIcon(const QIcon &icon) const {
     return ColorizeIcon(icon, TextColor());
 }
 
 const PlatformStyle *PlatformStyle::instantiate(const QString &platformId) {
     for (unsigned x = 0; x < platform_styles_count; ++x) {
         if (platformId == platform_styles[x].platformId) {
             return new PlatformStyle(platform_styles[x].platformId,
                                      platform_styles[x].imagesOnButtons,
                                      platform_styles[x].colorizeIcons,
                                      platform_styles[x].useExtraSpacing);
         }
     }
     return 0;
 }
diff --git a/src/qt/qvalidatedlineedit.cpp b/src/qt/qvalidatedlineedit.cpp
index b9967612f0..1f15e23d51 100644
--- a/src/qt/qvalidatedlineedit.cpp
+++ b/src/qt/qvalidatedlineedit.cpp
@@ -1,100 +1,103 @@
 // 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/qvalidatedlineedit.h>
 
 #include <qt/bitcoinaddressvalidator.h>
 #include <qt/guiconstants.h>
 
 QValidatedLineEdit::QValidatedLineEdit(QWidget *parent)
     : QLineEdit(parent), valid(true), checkValidator(0) {
     connect(this, &QValidatedLineEdit::textChanged, this,
             &QValidatedLineEdit::markValid);
 }
 
 void QValidatedLineEdit::setValid(bool _valid) {
     if (_valid == this->valid) {
         return;
     }
 
     if (_valid) {
         setStyleSheet("");
     } else {
         setStyleSheet(STYLE_INVALID);
     }
     this->valid = _valid;
 }
 
 void QValidatedLineEdit::focusInEvent(QFocusEvent *evt) {
     // Clear invalid flag on focus
     setValid(true);
 
     QLineEdit::focusInEvent(evt);
 }
 
 void QValidatedLineEdit::focusOutEvent(QFocusEvent *evt) {
     checkValidity();
 
     QLineEdit::focusOutEvent(evt);
 }
 
 void QValidatedLineEdit::markValid() {
     // As long as a user is typing ensure we display state as valid
     setValid(true);
 }
 
 void QValidatedLineEdit::clear() {
     setValid(true);
     QLineEdit::clear();
 }
 
 void QValidatedLineEdit::setEnabled(bool enabled) {
     if (!enabled) {
         // A disabled QValidatedLineEdit should be marked valid
         setValid(true);
     } else {
         // Recheck validity when QValidatedLineEdit gets enabled
         checkValidity();
     }
 
     QLineEdit::setEnabled(enabled);
 }
 
 void QValidatedLineEdit::checkValidity() {
     if (text().isEmpty()) {
         setValid(true);
     } else if (hasAcceptableInput()) {
         setValid(true);
 
         // Check contents on focus out
         if (checkValidator) {
             QString address = text();
             int pos = 0;
             if (checkValidator->validate(address, pos) ==
-                QValidator::Acceptable)
+                QValidator::Acceptable) {
                 setValid(true);
-            else
+            } else {
                 setValid(false);
+            }
         }
-    } else
+    } else {
         setValid(false);
+    }
 
     Q_EMIT validationDidChange(this);
 }
 
 void QValidatedLineEdit::setCheckValidator(const QValidator *v) {
     checkValidator = v;
 }
 
 bool QValidatedLineEdit::isValid() {
     // use checkValidator in case the QValidatedLineEdit is disabled
     if (checkValidator) {
         QString address = text();
         int pos = 0;
-        if (checkValidator->validate(address, pos) == QValidator::Acceptable)
+        if (checkValidator->validate(address, pos) == QValidator::Acceptable) {
             return true;
+        }
     }
 
     return valid;
 }
diff --git a/src/qt/recentrequeststablemodel.cpp b/src/qt/recentrequeststablemodel.cpp
index 15e38665a6..4e02488165 100644
--- a/src/qt/recentrequeststablemodel.cpp
+++ b/src/qt/recentrequeststablemodel.cpp
@@ -1,228 +1,239 @@
 // 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/recentrequeststablemodel.h>
 
 #include <qt/bitcoinunits.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 
 #include <algorithm>
 #include <clientversion.h>
 #include <streams.h>
 
 RecentRequestsTableModel::RecentRequestsTableModel(WalletModel *parent)
     : QAbstractTableModel(parent), walletModel(parent) {
     // Load entries from wallet
     std::vector<std::string> vReceiveRequests;
     parent->loadReceiveRequests(vReceiveRequests);
     for (const std::string &request : vReceiveRequests) {
         addNewRequest(request);
     }
 
     /* These columns must match the indices in the ColumnIndex enumeration */
     columns << tr("Date") << tr("Label") << tr("Message") << getAmountTitle();
 
     connect(walletModel->getOptionsModel(), &OptionsModel::displayUnitChanged,
             this, &RecentRequestsTableModel::updateDisplayUnit);
 }
 
 RecentRequestsTableModel::~RecentRequestsTableModel() {
     /* Intentionally left empty */
 }
 
 int RecentRequestsTableModel::rowCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
 
     return list.length();
 }
 
 int RecentRequestsTableModel::columnCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
 
     return columns.length();
 }
 
 QVariant RecentRequestsTableModel::data(const QModelIndex &index,
                                         int role) const {
-    if (!index.isValid() || index.row() >= list.length()) return QVariant();
+    if (!index.isValid() || index.row() >= list.length()) {
+        return QVariant();
+    }
 
     if (role == Qt::DisplayRole || role == Qt::EditRole) {
         const RecentRequestEntry *rec = &list[index.row()];
         switch (index.column()) {
             case Date:
                 return GUIUtil::dateTimeStr(rec->date);
             case Label:
                 if (rec->recipient.label.isEmpty() && role == Qt::DisplayRole) {
                     return tr("(no label)");
                 } else {
                     return rec->recipient.label;
                 }
             case Message:
                 if (rec->recipient.message.isEmpty() &&
                     role == Qt::DisplayRole) {
                     return tr("(no message)");
                 } else {
                     return rec->recipient.message;
                 }
             case Amount:
                 if (rec->recipient.amount == ::Amount::zero() &&
-                    role == Qt::DisplayRole)
+                    role == Qt::DisplayRole) {
                     return tr("(no amount requested)");
-                else if (role == Qt::EditRole)
+                } else if (role == Qt::EditRole) {
                     return BitcoinUnits::format(
                         walletModel->getOptionsModel()->getDisplayUnit(),
                         rec->recipient.amount, false,
                         BitcoinUnits::separatorNever);
-                else
+                } else {
                     return BitcoinUnits::format(
                         walletModel->getOptionsModel()->getDisplayUnit(),
                         rec->recipient.amount);
+                }
         }
     } else if (role == Qt::TextAlignmentRole) {
-        if (index.column() == Amount)
+        if (index.column() == Amount) {
             return (int)(Qt::AlignRight | Qt::AlignVCenter);
+        }
     }
     return QVariant();
 }
 
 bool RecentRequestsTableModel::setData(const QModelIndex &index,
                                        const QVariant &value, int role) {
     return true;
 }
 
 QVariant RecentRequestsTableModel::headerData(int section,
                                               Qt::Orientation orientation,
                                               int role) const {
     if (orientation == Qt::Horizontal) {
         if (role == Qt::DisplayRole && section < columns.size()) {
             return columns[section];
         }
     }
     return QVariant();
 }
 
 /** Updates the column title to "Amount (DisplayUnit)" and emits
  * headerDataChanged() signal for table headers to react. */
 void RecentRequestsTableModel::updateAmountColumnTitle() {
     columns[Amount] = getAmountTitle();
     Q_EMIT headerDataChanged(Qt::Horizontal, Amount, Amount);
 }
 
 /** Gets title for amount column including current display unit if optionsModel
  * reference available. */
 QString RecentRequestsTableModel::getAmountTitle() {
     return (this->walletModel->getOptionsModel() != nullptr)
                ? tr("Requested") + " (" +
                      BitcoinUnits::name(this->walletModel->getOptionsModel()
                                             ->getDisplayUnit()) +
                      ")"
                : "";
 }
 
 QModelIndex RecentRequestsTableModel::index(int row, int column,
                                             const QModelIndex &parent) const {
     Q_UNUSED(parent);
 
     return createIndex(row, column);
 }
 
 bool RecentRequestsTableModel::removeRows(int row, int count,
                                           const QModelIndex &parent) {
     Q_UNUSED(parent);
 
     if (count > 0 && row >= 0 && (row + count) <= list.size()) {
         for (int i = 0; i < count; ++i) {
             const RecentRequestEntry *rec = &list[row + i];
             if (!walletModel->saveReceiveRequest(
                     rec->recipient.address.toStdString(), rec->id, "")) {
                 return false;
             }
         }
 
         beginRemoveRows(parent, row, row + count - 1);
         list.erase(list.begin() + row, list.begin() + row + count);
         endRemoveRows();
         return true;
     } else {
         return false;
     }
 }
 
 Qt::ItemFlags RecentRequestsTableModel::flags(const QModelIndex &index) const {
     return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
 }
 
 // called when adding a request from the GUI
 void RecentRequestsTableModel::addNewRequest(
     const SendCoinsRecipient &recipient) {
     RecentRequestEntry newEntry;
     newEntry.id = ++nReceiveRequestsMaxId;
     newEntry.date = QDateTime::currentDateTime();
     newEntry.recipient = recipient;
 
     CDataStream ss(SER_DISK, CLIENT_VERSION);
     ss << newEntry;
 
     if (!walletModel->saveReceiveRequest(recipient.address.toStdString(),
-                                         newEntry.id, ss.str()))
+                                         newEntry.id, ss.str())) {
         return;
+    }
 
     addNewRequest(newEntry);
 }
 
 // called from ctor when loading from wallet
 void RecentRequestsTableModel::addNewRequest(const std::string &recipient) {
     std::vector<char> data(recipient.begin(), recipient.end());
     CDataStream ss(data, SER_DISK, CLIENT_VERSION);
 
     RecentRequestEntry entry;
     ss >> entry;
 
     // should not happen
-    if (entry.id == 0) return;
+    if (entry.id == 0) {
+        return;
+    }
 
-    if (entry.id > nReceiveRequestsMaxId) nReceiveRequestsMaxId = entry.id;
+    if (entry.id > nReceiveRequestsMaxId) {
+        nReceiveRequestsMaxId = entry.id;
+    }
 
     addNewRequest(entry);
 }
 
 // actually add to table in GUI
 void RecentRequestsTableModel::addNewRequest(RecentRequestEntry &recipient) {
     beginInsertRows(QModelIndex(), 0, 0);
     list.prepend(recipient);
     endInsertRows();
 }
 
 void RecentRequestsTableModel::sort(int column, Qt::SortOrder order) {
     std::sort(list.begin(), list.end(),
               RecentRequestEntryLessThan(column, order));
     Q_EMIT dataChanged(
         index(0, 0, QModelIndex()),
         index(list.size() - 1, NUMBER_OF_COLUMNS - 1, QModelIndex()));
 }
 
 void RecentRequestsTableModel::updateDisplayUnit() {
     updateAmountColumnTitle();
 }
 
 bool RecentRequestEntryLessThan::operator()(RecentRequestEntry &left,
                                             RecentRequestEntry &right) const {
     RecentRequestEntry *pLeft = &left;
     RecentRequestEntry *pRight = &right;
-    if (order == Qt::DescendingOrder) std::swap(pLeft, pRight);
+    if (order == Qt::DescendingOrder) {
+        std::swap(pLeft, pRight);
+    }
 
     switch (column) {
         case RecentRequestsTableModel::Date:
             return pLeft->date.toTime_t() < pRight->date.toTime_t();
         case RecentRequestsTableModel::Label:
             return pLeft->recipient.label < pRight->recipient.label;
         case RecentRequestsTableModel::Message:
             return pLeft->recipient.message < pRight->recipient.message;
         case RecentRequestsTableModel::Amount:
             return pLeft->recipient.amount < pRight->recipient.amount;
         default:
             return pLeft->id < pRight->id;
     }
 }
diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
index c0f334ef41..5ad1036e95 100644
--- a/src/qt/rpcconsole.cpp
+++ b/src/qt/rpcconsole.cpp
@@ -1,1452 +1,1468 @@
 // 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.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/rpcconsole.h>
 
 #include <chainparams.h>
 #include <config.h>
 #include <interfaces/node.h>
 #include <netbase.h>
 #include <qt/bantablemodel.h>
 #include <qt/clientmodel.h>
 #include <qt/forms/ui_debugwindow.h>
 #include <qt/guiutil.h>
 #include <qt/platformstyle.h>
 #include <qt/walletmodel.h>
 #include <rpc/client.h>
 #include <rpc/server.h>
 #include <util/system.h>
 
 #ifdef ENABLE_WALLET
 #include <wallet/wallet.h>
 
 #include <db_cxx.h>
 #endif
 
 #include <QDesktopWidget>
 #include <QKeyEvent>
 #include <QMenu>
 #include <QMessageBox>
 #include <QScrollBar>
 #include <QSettings>
 #include <QSignalMapper>
 #include <QStringList>
 #include <QThread>
 #include <QTime>
 #include <QTimer>
 
 #include <univalue.h>
 
 // TODO: add a scrollback limit, as there is currently none
 // TODO: make it possible to filter out categories (esp debug messages when
 // implemented)
 // TODO: receive errors and debug messages through ClientModel
 
 const int CONSOLE_HISTORY = 50;
 const int INITIAL_TRAFFIC_GRAPH_MINS = 30;
 const QSize FONT_RANGE(4, 40);
 const char fontSizeSettingsKey[] = "consoleFontSize";
 
 const struct {
     const char *url;
     const char *source;
 } ICON_MAPPING[] = {{"cmd-request", ":/icons/tx_input"},
                     {"cmd-reply", ":/icons/tx_output"},
                     {"cmd-error", ":/icons/tx_output"},
                     {"misc", ":/icons/tx_inout"},
                     {nullptr, nullptr}};
 
 namespace {
 
 // don't add private key handling cmd's to the history
 const QStringList historyFilter = QStringList() << "importprivkey"
                                                 << "importmulti"
                                                 << "sethdseed"
                                                 << "signmessagewithprivkey"
                                                 << "signrawtransactionwithkey"
                                                 << "walletpassphrase"
                                                 << "walletpassphrasechange"
                                                 << "encryptwallet";
 } // namespace
 
 /* Object for executing console RPC commands in a separate thread.
  */
 class RPCExecutor : public QObject {
     Q_OBJECT
 public:
     RPCExecutor(interfaces::Node &node) : m_node(node) {}
 
 public Q_SLOTS:
     void request(const QString &command, const WalletModel *wallet_model);
 
 Q_SIGNALS:
     void reply(int category, const QString &command);
 
 private:
     interfaces::Node &m_node;
 };
 
 /** Class for handling RPC timers
  * (used for e.g. re-locking the wallet after a timeout)
  */
 class QtRPCTimerBase : public QObject, public RPCTimerBase {
     Q_OBJECT
 public:
     QtRPCTimerBase(std::function<void()> &_func, int64_t millis) : func(_func) {
         timer.setSingleShot(true);
         connect(&timer, &QTimer::timeout, [this] { func(); });
         timer.start(millis);
     }
     ~QtRPCTimerBase() {}
 
 private:
     QTimer timer;
     std::function<void()> func;
 };
 
 class QtRPCTimerInterface : public RPCTimerInterface {
 public:
     ~QtRPCTimerInterface() {}
     const char *Name() override { return "Qt"; }
     RPCTimerBase *NewTimer(std::function<void()> &func,
                            int64_t millis) override {
         return new QtRPCTimerBase(func, millis);
     }
 };
 
 #include <qt/rpcconsole.moc>
 
 /**
  * Split shell command line into a list of arguments and optionally execute the
  * command(s).
  * Aims to emulate \c bash and friends.
  *
  * - Command nesting is possible with parenthesis; for example:
  * validateaddress(getnewaddress())
  * - Arguments are delimited with whitespace or comma
  * - Extra whitespace at the beginning and end and between arguments will be
  * ignored
  * - Text can be "double" or 'single' quoted
  * - The backslash \c \ is used as escape character
  *   - Outside quotes, any character can be escaped
  *   - Within double quotes, only escape \c " and backslashes before a \c " or
  * another backslash
  *   - Within single quotes, no escaping is possible and no special
  * interpretation takes place
  *
  * @param[in]    node    optional node to execute command on
  * @param[out]   result      stringified Result from the executed command(chain)
  * @param[in]    strCommand  Command line to split
  * @param[in]    fExecute    set true if you want the command to be executed
  * @param[out]   pstrFilteredOut  Command line, filtered to remove any sensitive
  * data
  */
 
 bool RPCConsole::RPCParseCommandLine(interfaces::Node *node,
                                      std::string &strResult,
                                      const std::string &strCommand,
                                      const bool fExecute,
                                      std::string *const pstrFilteredOut,
                                      const WalletModel *wallet_model) {
     std::vector<std::vector<std::string>> stack;
     stack.push_back(std::vector<std::string>());
 
     enum CmdParseState {
         STATE_EATING_SPACES,
         STATE_EATING_SPACES_IN_ARG,
         STATE_EATING_SPACES_IN_BRACKETS,
         STATE_ARGUMENT,
         STATE_SINGLEQUOTED,
         STATE_DOUBLEQUOTED,
         STATE_ESCAPE_OUTER,
         STATE_ESCAPE_DOUBLEQUOTED,
         STATE_COMMAND_EXECUTED,
         STATE_COMMAND_EXECUTED_INNER
     } state = STATE_EATING_SPACES;
     std::string curarg;
     UniValue lastResult;
     unsigned nDepthInsideSensitive = 0;
     size_t filter_begin_pos = 0, chpos;
     std::vector<std::pair<size_t, size_t>> filter_ranges;
 
     auto add_to_current_stack = [&](const std::string &strArg) {
         if (stack.back().empty() && (!nDepthInsideSensitive) &&
             historyFilter.contains(QString::fromStdString(strArg),
                                    Qt::CaseInsensitive)) {
             nDepthInsideSensitive = 1;
             filter_begin_pos = chpos;
         }
         // Make sure stack is not empty before adding something
         if (stack.empty()) {
             stack.push_back(std::vector<std::string>());
         }
         stack.back().push_back(strArg);
     };
 
     auto close_out_params = [&]() {
         if (nDepthInsideSensitive) {
             if (!--nDepthInsideSensitive) {
                 assert(filter_begin_pos);
                 filter_ranges.push_back(
                     std::make_pair(filter_begin_pos, chpos));
                 filter_begin_pos = 0;
             }
         }
         stack.pop_back();
     };
 
     std::string strCommandTerminated = strCommand;
-    if (strCommandTerminated.back() != '\n') strCommandTerminated += "\n";
+    if (strCommandTerminated.back() != '\n') {
+        strCommandTerminated += "\n";
+    }
     for (chpos = 0; chpos < strCommandTerminated.size(); ++chpos) {
         char ch = strCommandTerminated[chpos];
         switch (state) {
             case STATE_COMMAND_EXECUTED_INNER:
             case STATE_COMMAND_EXECUTED: {
                 bool breakParsing = true;
                 switch (ch) {
                     case '[':
                         curarg.clear();
                         state = STATE_COMMAND_EXECUTED_INNER;
                         break;
                     default:
                         if (state == STATE_COMMAND_EXECUTED_INNER) {
                             if (ch != ']') {
                                 // append char to the current argument (which is
                                 // also used for the query command)
                                 curarg += ch;
                                 break;
                             }
                             if (curarg.size() && fExecute) {
                                 // if we have a value query, query arrays with
                                 // index and objects with a string key
                                 UniValue subelement;
                                 if (lastResult.isArray()) {
                                     for (char argch : curarg) {
                                         if (!std::isdigit(argch)) {
                                             throw std::runtime_error(
                                                 "Invalid result query");
                                         }
                                     }
                                     subelement =
                                         lastResult[atoi(curarg.c_str())];
                                 } else if (lastResult.isObject()) {
                                     subelement = find_value(lastResult, curarg);
                                 } else {
                                     // no array or object: abort
                                     throw std::runtime_error(
                                         "Invalid result query");
                                 }
                                 lastResult = subelement;
                             }
 
                             state = STATE_COMMAND_EXECUTED;
                             break;
                         }
                         // don't break parsing when the char is required for the
                         // next argument
                         breakParsing = false;
 
                         // pop the stack and return the result to the current
                         // command arguments
                         close_out_params();
 
                         // don't stringify the json in case of a string to avoid
                         // doublequotes
                         if (lastResult.isStr()) {
                             curarg = lastResult.get_str();
                         } else {
                             curarg = lastResult.write(2);
                         }
 
                         // if we have a non empty result, use it as stack
                         // argument otherwise as general result
                         if (curarg.size()) {
                             if (stack.size()) {
                                 add_to_current_stack(curarg);
                             } else {
                                 strResult = curarg;
                             }
                         }
                         curarg.clear();
                         // assume eating space state
                         state = STATE_EATING_SPACES;
                 }
 
                 if (breakParsing) {
                     break;
                 }
             }
             // FALLTHROUGH
             case STATE_ARGUMENT: // In or after argument
             case STATE_EATING_SPACES_IN_ARG:
             case STATE_EATING_SPACES_IN_BRACKETS:
             case STATE_EATING_SPACES: // Handle runs of whitespace
                 switch (ch) {
                     case '"':
                         state = STATE_DOUBLEQUOTED;
                         break;
                     case '\'':
                         state = STATE_SINGLEQUOTED;
                         break;
                     case '\\':
                         state = STATE_ESCAPE_OUTER;
                         break;
                     case '(':
                     case ')':
                     case '\n':
                         if (state == STATE_EATING_SPACES_IN_ARG) {
                             throw std::runtime_error("Invalid Syntax");
                         }
                         if (state == STATE_ARGUMENT) {
                             if (ch == '(' && stack.size() &&
                                 stack.back().size() > 0) {
                                 if (nDepthInsideSensitive) {
                                     ++nDepthInsideSensitive;
                                 }
                                 stack.push_back(std::vector<std::string>());
                             }
 
                             // don't allow commands after executed commands on
                             // baselevel
                             if (!stack.size()) {
                                 throw std::runtime_error("Invalid Syntax");
                             }
 
                             add_to_current_stack(curarg);
                             curarg.clear();
                             state = STATE_EATING_SPACES_IN_BRACKETS;
                         }
                         if ((ch == ')' || ch == '\n') && stack.size() > 0) {
                             if (fExecute) {
                                 // Convert argument list to JSON objects in
                                 // method-dependent way, and pass it along with
                                 // the method name to the dispatcher.
                                 UniValue params = RPCConvertValues(
                                     stack.back()[0],
                                     std::vector<std::string>(
                                         stack.back().begin() + 1,
                                         stack.back().end()));
                                 std::string method = stack.back()[0];
                                 std::string uri;
 
 #ifdef ENABLE_WALLET
                                 if (wallet_model) {
                                     QByteArray encodedName =
                                         QUrl::toPercentEncoding(
                                             wallet_model->getWalletName());
                                     uri = "/wallet/" +
                                           std::string(encodedName.constData(),
                                                       encodedName.length());
                                 }
 #endif
 
                                 GlobalConfig config;
                                 assert(node);
                                 lastResult = node->executeRpc(config, method,
                                                               params, uri);
                             }
 
                             state = STATE_COMMAND_EXECUTED;
                             curarg.clear();
                         }
                         break;
                     case ' ':
                     case ',':
                     case '\t':
                         if (state == STATE_EATING_SPACES_IN_ARG &&
                             curarg.empty() && ch == ',') {
                             throw std::runtime_error("Invalid Syntax");
                         } else if (state == STATE_ARGUMENT) {
                             // Space ends argument
                             add_to_current_stack(curarg);
                             curarg.clear();
                         }
                         if ((state == STATE_EATING_SPACES_IN_BRACKETS ||
                              state == STATE_ARGUMENT) &&
                             ch == ',') {
                             state = STATE_EATING_SPACES_IN_ARG;
                             break;
                         }
                         state = STATE_EATING_SPACES;
                         break;
                     default:
                         curarg += ch;
                         state = STATE_ARGUMENT;
                 }
                 break;
             case STATE_SINGLEQUOTED: // Single-quoted string
                 switch (ch) {
                     case '\'':
                         state = STATE_ARGUMENT;
                         break;
                     default:
                         curarg += ch;
                 }
                 break;
             case STATE_DOUBLEQUOTED: // Double-quoted string
                 switch (ch) {
                     case '"':
                         state = STATE_ARGUMENT;
                         break;
                     case '\\':
                         state = STATE_ESCAPE_DOUBLEQUOTED;
                         break;
                     default:
                         curarg += ch;
                 }
                 break;
             case STATE_ESCAPE_OUTER: // '\' outside quotes
                 curarg += ch;
                 state = STATE_ARGUMENT;
                 break;
             case STATE_ESCAPE_DOUBLEQUOTED: // '\' in double-quoted text
                 if (ch != '"' && ch != '\\') {
                     // keep '\' for everything but the quote and '\' itself
                     curarg += '\\';
                 }
                 curarg += ch;
                 state = STATE_DOUBLEQUOTED;
                 break;
         }
     }
     if (pstrFilteredOut) {
         if (STATE_COMMAND_EXECUTED == state) {
             assert(!stack.empty());
             close_out_params();
         }
         *pstrFilteredOut = strCommand;
         for (auto i = filter_ranges.rbegin(); i != filter_ranges.rend(); ++i) {
             pstrFilteredOut->replace(i->first, i->second - i->first, "(…)");
         }
     }
 
     // final state
     switch (state) {
         case STATE_COMMAND_EXECUTED:
             if (lastResult.isStr()) {
                 strResult = lastResult.get_str();
             } else {
                 strResult = lastResult.write(2);
             }
         // FALLTHROUGH
         case STATE_ARGUMENT:
         case STATE_EATING_SPACES:
             return true;
         default: // ERROR to end in one of the other states
             return false;
     }
 }
 
 void RPCExecutor::request(const QString &command,
                           const WalletModel *wallet_model) {
     try {
         std::string result;
         std::string executableCommand = command.toStdString() + "\n";
 
         // Catch the console-only-help command before RPC call is executed and
         // reply with help text as-if a RPC reply.
         if (executableCommand == "help-console\n") {
             Q_EMIT reply(
                 RPCConsole::CMD_REPLY,
                 QString(("\n"
                          "This console accepts RPC commands using the standard "
                          "syntax.\n"
                          "   example:    getblockhash 0\n\n"
 
                          "This console can also accept RPC commands using "
                          "parenthesized syntax.\n"
                          "   example:    getblockhash(0)\n\n"
 
                          "Commands may be nested when specified with the "
                          "parenthesized syntax.\n"
                          "   example:    getblock(getblockhash(0) 1)\n\n"
 
                          "A space or a comma can be used to delimit arguments "
                          "for either syntax.\n"
                          "   example:    getblockhash 0\n"
                          "               getblockhash,0\n\n"
 
                          "Named results can be queried with a non-quoted key "
                          "string in brackets.\n"
                          "   example:    getblock(getblockhash(0) true)[tx]\n\n"
 
                          "Results without keys can be queried using an integer "
                          "in brackets.\n"
                          "   example:    "
                          "getblock(getblockhash(0),true)[tx][0]\n\n")));
             return;
         }
         if (!RPCConsole::RPCExecuteCommandLine(
                 m_node, result, executableCommand, nullptr, wallet_model)) {
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString("Parse error: unbalanced ' or \""));
             return;
         }
 
         Q_EMIT reply(RPCConsole::CMD_REPLY, QString::fromStdString(result));
     } catch (UniValue &objError) {
         // Nice formatting for standard-format error
         try {
             int code = find_value(objError, "code").get_int();
             std::string message = find_value(objError, "message").get_str();
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString::fromStdString(message) + " (code " +
                              QString::number(code) + ")");
         } catch (const std::runtime_error &) {
             // raised when converting to invalid type, i.e. missing code or
             // message. Show raw JSON object.
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString::fromStdString(objError.write()));
         }
     } catch (const std::exception &e) {
         Q_EMIT reply(RPCConsole::CMD_ERROR,
                      QString("Error: ") + QString::fromStdString(e.what()));
     }
 }
 
 RPCConsole::RPCConsole(interfaces::Node &node,
                        const PlatformStyle *_platformStyle, QWidget *parent)
     : QWidget(parent), m_node(node), ui(new Ui::RPCConsole),
       platformStyle(_platformStyle) {
     ui->setupUi(this);
     QSettings settings;
     if (!restoreGeometry(
             settings.value("RPCConsoleWindowGeometry").toByteArray())) {
         // Restore failed (perhaps missing setting), center the window
         move(QApplication::desktop()->availableGeometry().center() -
              frameGeometry().center());
     }
 
     QChar nonbreaking_hyphen(8209);
     ui->dataDir->setToolTip(
         ui->dataDir->toolTip().arg(QString(nonbreaking_hyphen) + "datadir"));
     ui->blocksDir->setToolTip(ui->blocksDir->toolTip().arg(
         QString(nonbreaking_hyphen) + "blocksdir"));
     ui->openDebugLogfileButton->setToolTip(
         ui->openDebugLogfileButton->toolTip().arg(tr(PACKAGE_NAME)));
 
     if (platformStyle->getImagesOnButtons()) {
         ui->openDebugLogfileButton->setIcon(
             platformStyle->SingleColorIcon(":/icons/export"));
     }
     ui->clearButton->setIcon(platformStyle->SingleColorIcon(":/icons/remove"));
     ui->fontBiggerButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/fontbigger"));
     ui->fontSmallerButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/fontsmaller"));
 
     // Install event filter for up and down arrow
     ui->lineEdit->installEventFilter(this);
     ui->messagesWidget->installEventFilter(this);
 
     connect(ui->clearButton, &QPushButton::clicked, this, &RPCConsole::clear);
     connect(ui->fontBiggerButton, &QPushButton::clicked, this,
             &RPCConsole::fontBigger);
     connect(ui->fontSmallerButton, &QPushButton::clicked, this,
             &RPCConsole::fontSmaller);
     connect(ui->btnClearTrafficGraph, &QPushButton::clicked, ui->trafficGraph,
             &TrafficGraphWidget::clear);
 
     // disable the wallet selector by default
     ui->WalletSelector->setVisible(false);
     ui->WalletSelectorLabel->setVisible(false);
 
 // set library version labels
 #ifdef ENABLE_WALLET
     ui->berkeleyDBVersion->setText(DbEnv::version(0, 0, 0));
 #else
     ui->label_berkeleyDBVersion->hide();
     ui->berkeleyDBVersion->hide();
 #endif
     // Register RPC timer interface
     rpcTimerInterface = new QtRPCTimerInterface();
     // avoid accidentally overwriting an existing, non QTThread
     // based timer interface
     m_node.rpcSetTimerInterfaceIfUnset(rpcTimerInterface);
 
     setTrafficGraphRange(INITIAL_TRAFFIC_GRAPH_MINS);
 
     ui->detailWidget->hide();
     ui->peerHeading->setText(tr("Select a peer to view detailed information."));
 
     consoleFontSize =
         settings.value(fontSizeSettingsKey, QFontInfo(QFont()).pointSize())
             .toInt();
     clear();
 }
 
 RPCConsole::~RPCConsole() {
     QSettings settings;
     settings.setValue("RPCConsoleWindowGeometry", saveGeometry());
     m_node.rpcUnsetTimerInterface(rpcTimerInterface);
     delete rpcTimerInterface;
     delete ui;
 }
 
 bool RPCConsole::eventFilter(QObject *obj, QEvent *event) {
     // Special key handling
     if (event->type() == QEvent::KeyPress) {
         QKeyEvent *keyevt = static_cast<QKeyEvent *>(event);
         int key = keyevt->key();
         Qt::KeyboardModifiers mod = keyevt->modifiers();
         switch (key) {
             case Qt::Key_Up:
                 if (obj == ui->lineEdit) {
                     browseHistory(-1);
                     return true;
                 }
                 break;
             case Qt::Key_Down:
                 if (obj == ui->lineEdit) {
                     browseHistory(1);
                     return true;
                 }
                 break;
             case Qt::Key_PageUp: /* pass paging keys to messages widget */
             case Qt::Key_PageDown:
                 if (obj == ui->lineEdit) {
                     QApplication::postEvent(ui->messagesWidget,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
                 break;
             case Qt::Key_Return:
             case Qt::Key_Enter:
                 // forward these events to lineEdit
                 if (obj == autoCompleter->popup()) {
                     QApplication::postEvent(ui->lineEdit,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
                 break;
             default:
                 // Typing in messages widget brings focus to line edit, and
                 // redirects key there. Exclude most combinations and keys that
                 // emit no text, except paste shortcuts.
                 if (obj == ui->messagesWidget &&
                     ((!mod && !keyevt->text().isEmpty() &&
                       key != Qt::Key_Tab) ||
                      ((mod & Qt::ControlModifier) && key == Qt::Key_V) ||
                      ((mod & Qt::ShiftModifier) && key == Qt::Key_Insert))) {
                     ui->lineEdit->setFocus();
                     QApplication::postEvent(ui->lineEdit,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
         }
     }
     return QWidget::eventFilter(obj, event);
 }
 
 void RPCConsole::setClientModel(ClientModel *model) {
     clientModel = model;
     ui->trafficGraph->setClientModel(model);
     if (model && clientModel->getPeerTableModel() &&
         clientModel->getBanTableModel()) {
         // Keep up to date with client
         setNumConnections(model->getNumConnections());
         connect(model, &ClientModel::numConnectionsChanged, this,
                 &RPCConsole::setNumConnections);
 
         interfaces::Node &node = clientModel->node();
         setNumBlocks(node.getNumBlocks(),
                      QDateTime::fromTime_t(node.getLastBlockTime()),
                      node.getVerificationProgress(), false);
         connect(model, &ClientModel::numBlocksChanged, this,
                 &RPCConsole::setNumBlocks);
 
         updateNetworkState();
         connect(model, &ClientModel::networkActiveChanged, this,
                 &RPCConsole::setNetworkActive);
 
         updateTrafficStats(node.getTotalBytesRecv(), node.getTotalBytesSent());
         connect(model, &ClientModel::bytesChanged, this,
                 &RPCConsole::updateTrafficStats);
 
         connect(model, &ClientModel::mempoolSizeChanged, this,
                 &RPCConsole::setMempoolSize);
 
         // set up peer table
         ui->peerWidget->setModel(model->getPeerTableModel());
         ui->peerWidget->verticalHeader()->hide();
         ui->peerWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
         ui->peerWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
         ui->peerWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
         ui->peerWidget->setContextMenuPolicy(Qt::CustomContextMenu);
         ui->peerWidget->setColumnWidth(PeerTableModel::Address,
                                        ADDRESS_COLUMN_WIDTH);
         ui->peerWidget->setColumnWidth(PeerTableModel::Subversion,
                                        SUBVERSION_COLUMN_WIDTH);
         ui->peerWidget->setColumnWidth(PeerTableModel::Ping, PING_COLUMN_WIDTH);
         ui->peerWidget->horizontalHeader()->setStretchLastSection(true);
 
         // create peer table context menu actions
         QAction *disconnectAction = new QAction(tr("&Disconnect"), this);
         QAction *banAction1h =
             new QAction(tr("Ban for") + " " + tr("1 &hour"), this);
         QAction *banAction24h =
             new QAction(tr("Ban for") + " " + tr("1 &day"), this);
         QAction *banAction7d =
             new QAction(tr("Ban for") + " " + tr("1 &week"), this);
         QAction *banAction365d =
             new QAction(tr("Ban for") + " " + tr("1 &year"), this);
 
         // create peer table context menu
         peersTableContextMenu = new QMenu(this);
         peersTableContextMenu->addAction(disconnectAction);
         peersTableContextMenu->addAction(banAction1h);
         peersTableContextMenu->addAction(banAction24h);
         peersTableContextMenu->addAction(banAction7d);
         peersTableContextMenu->addAction(banAction365d);
 
         // Add a signal mapping to allow dynamic context menu arguments. We need
         // to use int (instead of int64_t), because signal mapper only supports
         // int or objects, which is okay because max bantime (1 year) is <
         // int_max.
         QSignalMapper *signalMapper = new QSignalMapper(this);
         signalMapper->setMapping(banAction1h, 60 * 60);
         signalMapper->setMapping(banAction24h, 60 * 60 * 24);
         signalMapper->setMapping(banAction7d, 60 * 60 * 24 * 7);
         signalMapper->setMapping(banAction365d, 60 * 60 * 24 * 365);
         connect(banAction1h, &QAction::triggered, signalMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(banAction24h, &QAction::triggered, signalMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(banAction7d, &QAction::triggered, signalMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(banAction365d, &QAction::triggered, signalMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(
             signalMapper,
             static_cast<void (QSignalMapper::*)(int)>(&QSignalMapper::mapped),
             this, &RPCConsole::banSelectedNode);
 
         // peer table context menu signals
         connect(ui->peerWidget, &QTableView::customContextMenuRequested, this,
                 &RPCConsole::showPeersTableContextMenu);
         connect(disconnectAction, &QAction::triggered, this,
                 &RPCConsole::disconnectSelectedNode);
 
         // peer table signal handling - update peer details when selecting new
         // node
         connect(ui->peerWidget->selectionModel(),
                 &QItemSelectionModel::selectionChanged, this,
                 &RPCConsole::peerSelected);
         // peer table signal handling - update peer details when new nodes are
         // added to the model
         connect(model->getPeerTableModel(), &PeerTableModel::layoutChanged,
                 this, &RPCConsole::peerLayoutChanged);
         // peer table signal handling - cache selected node ids
         connect(model->getPeerTableModel(),
                 &PeerTableModel::layoutAboutToBeChanged, this,
                 &RPCConsole::peerLayoutAboutToChange);
 
         // set up ban table
         ui->banlistWidget->setModel(model->getBanTableModel());
         ui->banlistWidget->verticalHeader()->hide();
         ui->banlistWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
         ui->banlistWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
         ui->banlistWidget->setSelectionMode(QAbstractItemView::SingleSelection);
         ui->banlistWidget->setContextMenuPolicy(Qt::CustomContextMenu);
         ui->banlistWidget->setColumnWidth(BanTableModel::Address,
                                           BANSUBNET_COLUMN_WIDTH);
         ui->banlistWidget->setColumnWidth(BanTableModel::Bantime,
                                           BANTIME_COLUMN_WIDTH);
         ui->banlistWidget->horizontalHeader()->setStretchLastSection(true);
 
         // create ban table context menu action
         QAction *unbanAction = new QAction(tr("&Unban"), this);
 
         // create ban table context menu
         banTableContextMenu = new QMenu(this);
         banTableContextMenu->addAction(unbanAction);
 
         // ban table context menu signals
         connect(ui->banlistWidget, &QTableView::customContextMenuRequested,
                 this, &RPCConsole::showBanTableContextMenu);
         connect(unbanAction, &QAction::triggered, this,
                 &RPCConsole::unbanSelectedNode);
 
         // ban table signal handling - clear peer details when clicking a peer
         // in the ban table
         connect(ui->banlistWidget, &QTableView::clicked, this,
                 &RPCConsole::clearSelectedNode);
         // ban table signal handling - ensure ban table is shown or hidden (if
         // empty)
         connect(model->getBanTableModel(), &BanTableModel::layoutChanged, this,
                 &RPCConsole::showOrHideBanTableIfRequired);
         showOrHideBanTableIfRequired();
 
         // Provide initial values
         ui->clientVersion->setText(model->formatFullVersion());
         ui->clientUserAgent->setText(model->formatSubVersion());
         ui->dataDir->setText(model->dataDir());
         ui->blocksDir->setText(model->blocksDir());
         ui->startupTime->setText(model->formatClientStartupTime());
         ui->networkName->setText(
             QString::fromStdString(Params().NetworkIDString()));
 
         // Setup autocomplete and attach it
         QStringList wordList;
         std::vector<std::string> commandList = m_node.listRpcCommands();
         for (size_t i = 0; i < commandList.size(); ++i) {
             wordList << commandList[i].c_str();
             wordList << ("help " + commandList[i]).c_str();
         }
 
         wordList << "help-console";
         wordList.sort();
         autoCompleter = new QCompleter(wordList, this);
         autoCompleter->setModelSorting(QCompleter::CaseSensitivelySortedModel);
         ui->lineEdit->setCompleter(autoCompleter);
         autoCompleter->popup()->installEventFilter(this);
         // Start thread to execute RPC commands.
         startExecutor();
     }
     if (!model) {
         // Client model is being set to 0, this means shutdown() is about to be
         // called. Make sure we clean up the executor thread
         Q_EMIT stopExecutor();
         thread.wait();
     }
 }
 
 #ifdef ENABLE_WALLET
 void RPCConsole::addWallet(WalletModel *const walletModel) {
     // use name for text and wallet model for internal data object (to allow to
     // move to a wallet id later)
     ui->WalletSelector->addItem(walletModel->getDisplayName(),
                                 QVariant::fromValue(walletModel));
     if (ui->WalletSelector->count() == 2 && !isVisible()) {
         // First wallet added, set to default so long as the window isn't
         // presently visible (and potentially in use)
         ui->WalletSelector->setCurrentIndex(1);
     }
     if (ui->WalletSelector->count() > 2) {
         ui->WalletSelector->setVisible(true);
         ui->WalletSelectorLabel->setVisible(true);
     }
 }
 
 void RPCConsole::removeWallet(WalletModel *const walletModel) {
     ui->WalletSelector->removeItem(
         ui->WalletSelector->findData(QVariant::fromValue(walletModel)));
     if (ui->WalletSelector->count() == 2) {
         ui->WalletSelector->setVisible(false);
         ui->WalletSelectorLabel->setVisible(false);
     }
 }
 #endif
 
 static QString categoryClass(int category) {
     switch (category) {
         case RPCConsole::CMD_REQUEST:
             return "cmd-request";
             break;
         case RPCConsole::CMD_REPLY:
             return "cmd-reply";
             break;
         case RPCConsole::CMD_ERROR:
             return "cmd-error";
             break;
         default:
             return "misc";
     }
 }
 
 void RPCConsole::fontBigger() {
     setFontSize(consoleFontSize + 1);
 }
 
 void RPCConsole::fontSmaller() {
     setFontSize(consoleFontSize - 1);
 }
 
 void RPCConsole::setFontSize(int newSize) {
     QSettings settings;
 
     // don't allow an insane font size
-    if (newSize < FONT_RANGE.width() || newSize > FONT_RANGE.height()) return;
+    if (newSize < FONT_RANGE.width() || newSize > FONT_RANGE.height()) {
+        return;
+    }
 
     // temp. store the console content
     QString str = ui->messagesWidget->toHtml();
 
     // replace font tags size in current content
     str.replace(QString("font-size:%1pt").arg(consoleFontSize),
                 QString("font-size:%1pt").arg(newSize));
 
     // store the new font size
     consoleFontSize = newSize;
     settings.setValue(fontSizeSettingsKey, consoleFontSize);
 
     // clear console (reset icon sizes, default stylesheet) and re-add the
     // content
     float oldPosFactor = 1.0 /
                          ui->messagesWidget->verticalScrollBar()->maximum() *
                          ui->messagesWidget->verticalScrollBar()->value();
     clear(false);
     ui->messagesWidget->setHtml(str);
     ui->messagesWidget->verticalScrollBar()->setValue(
         oldPosFactor * ui->messagesWidget->verticalScrollBar()->maximum());
 }
 
 void RPCConsole::clear(bool clearHistory) {
     ui->messagesWidget->clear();
     if (clearHistory) {
         history.clear();
         historyPtr = 0;
     }
     ui->lineEdit->clear();
     ui->lineEdit->setFocus();
 
     // Add smoothly scaled icon images.
     // (when using width/height on an img, Qt uses nearest instead of linear
     // interpolation)
     for (int i = 0; ICON_MAPPING[i].url; ++i) {
         ui->messagesWidget->document()->addResource(
             QTextDocument::ImageResource, QUrl(ICON_MAPPING[i].url),
             platformStyle->SingleColorImage(ICON_MAPPING[i].source)
                 .scaled(QSize(consoleFontSize * 2, consoleFontSize * 2),
                         Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
     }
 
     // Set default style sheet
     QFontInfo fixedFontInfo(GUIUtil::fixedPitchFont());
     ui->messagesWidget->document()->setDefaultStyleSheet(
         QString("table { }"
                 "td.time { color: #808080; font-size: %2; padding-top: 3px; } "
                 "td.message { font-family: %1; font-size: %2; "
                 "white-space:pre-wrap; } "
                 "td.cmd-request { color: #006060; } "
                 "td.cmd-error { color: red; } "
                 ".secwarning { color: red; }"
                 "b { color: #006060; } ")
             .arg(fixedFontInfo.family(), QString("%1pt").arg(consoleFontSize)));
 
 #ifdef Q_OS_MAC
     QString clsKey = "(⌘)-L";
 #else
     QString clsKey = "Ctrl-L";
 #endif
 
     message(CMD_REPLY,
             (tr("Welcome to the %1 RPC console.").arg(tr(PACKAGE_NAME)) +
              "<br>" +
              tr("Use up and down arrows to navigate history, and "
                 "%1 to clear screen.")
                  .arg("<b>" + clsKey + "</b>") +
              "<br>" +
              tr("Type %1 for an overview of available commands.")
                  .arg("<b>help</b>") +
              "<br>" +
              tr("For more information on using this console type %1.")
                  .arg("<b>help-console</b>") +
              "<br><span class=\"secwarning\"><br>" +
              tr("WARNING: Scammers have been active, telling users to type "
                 "commands here, stealing their wallet contents. Do not use "
                 "this console without fully understanding the ramifications "
                 "of a command.") +
              "</span>"),
             true);
 }
 
 void RPCConsole::keyPressEvent(QKeyEvent *event) {
     if (windowType() != Qt::Widget && event->key() == Qt::Key_Escape) {
         close();
     }
 }
 
 void RPCConsole::message(int category, const QString &message, bool html) {
     QTime time = QTime::currentTime();
     QString timeString = time.toString();
     QString out;
     out += "<table><tr><td class=\"time\" width=\"65\">" + timeString + "</td>";
     out += "<td class=\"icon\" width=\"32\"><img src=\"" +
            categoryClass(category) + "\"></td>";
     out += "<td class=\"message " + categoryClass(category) +
            "\" valign=\"middle\">";
     if (html) {
         out += message;
     } else {
         out += GUIUtil::HtmlEscape(message, false);
     }
     out += "</td></tr></table>";
     ui->messagesWidget->append(out);
 }
 
 void RPCConsole::updateNetworkState() {
     QString connections =
         QString::number(clientModel->getNumConnections()) + " (";
     connections += tr("In:") + " " +
                    QString::number(clientModel->getNumConnections(
                        ClientModel::CONNECTIONS_IN)) +
                    " / ";
     connections += tr("Out:") + " " +
                    QString::number(clientModel->getNumConnections(
                        ClientModel::CONNECTIONS_OUT)) +
                    ")";
 
     if (!clientModel->node().getNetworkActive()) {
         connections += " (" + tr("Network activity disabled") + ")";
     }
 
     ui->numberOfConnections->setText(connections);
 }
 
 void RPCConsole::setNumConnections(int count) {
     if (!clientModel) {
         return;
     }
 
     updateNetworkState();
 }
 
 void RPCConsole::setNetworkActive(bool networkActive) {
     updateNetworkState();
 }
 
 void RPCConsole::setNumBlocks(int count, const QDateTime &blockDate,
                               double nVerificationProgress, bool headers) {
     if (!headers) {
         ui->numberOfBlocks->setText(QString::number(count));
         ui->lastBlockTime->setText(blockDate.toString());
     }
 }
 
 void RPCConsole::setMempoolSize(long numberOfTxs, size_t dynUsage) {
     ui->mempoolNumberTxs->setText(QString::number(numberOfTxs));
 
     if (dynUsage < 1000000) {
         ui->mempoolSize->setText(QString::number(dynUsage / 1000.0, 'f', 2) +
                                  " KB");
     } else {
         ui->mempoolSize->setText(QString::number(dynUsage / 1000000.0, 'f', 2) +
                                  " MB");
     }
 }
 
 void RPCConsole::on_lineEdit_returnPressed() {
     QString cmd = ui->lineEdit->text();
 
     if (!cmd.isEmpty()) {
         std::string strFilteredCmd;
         try {
             std::string dummy;
             if (!RPCParseCommandLine(nullptr, dummy, cmd.toStdString(), false,
                                      &strFilteredCmd)) {
                 // Failed to parse command, so we cannot even filter it for the
                 // history
                 throw std::runtime_error("Invalid command line");
             }
         } catch (const std::exception &e) {
             QMessageBox::critical(this, "Error",
                                   QString("Error: ") +
                                       QString::fromStdString(e.what()));
             return;
         }
 
         ui->lineEdit->clear();
 
         cmdBeforeBrowsing = QString();
 
 #ifdef ENABLE_WALLET
         WalletModel *wallet_model{nullptr};
         const int wallet_index = ui->WalletSelector->currentIndex();
         if (wallet_index > 0) {
             wallet_model = ui->WalletSelector->itemData(wallet_index)
                                .value<WalletModel *>();
         }
 
         if (m_last_wallet_model != wallet_model) {
             if (wallet_model) {
                 message(CMD_REQUEST, tr("Executing command using \"%1\" wallet")
                                          .arg(wallet_model->getWalletName()));
             } else {
                 message(CMD_REQUEST,
                         tr("Executing command without any wallet"));
             }
             m_last_wallet_model = wallet_model;
         }
 #endif
 
         message(CMD_REQUEST, QString::fromStdString(strFilteredCmd));
         Q_EMIT cmdRequest(cmd, m_last_wallet_model);
 
         cmd = QString::fromStdString(strFilteredCmd);
 
         // Remove command, if already in history
         history.removeOne(cmd);
         // Append command to history
         history.append(cmd);
         // Enforce maximum history size
-        while (history.size() > CONSOLE_HISTORY)
+        while (history.size() > CONSOLE_HISTORY) {
             history.removeFirst();
+        }
         // Set pointer to end of history
         historyPtr = history.size();
 
         // Scroll console view to end
         scrollToEnd();
     }
 }
 
 void RPCConsole::browseHistory(int offset) {
     // store current text when start browsing through the history
     if (historyPtr == history.size()) {
         cmdBeforeBrowsing = ui->lineEdit->text();
     }
 
     historyPtr += offset;
     if (historyPtr < 0) {
         historyPtr = 0;
     }
     if (historyPtr > history.size()) {
         historyPtr = history.size();
     }
     QString cmd;
     if (historyPtr < history.size()) {
         cmd = history.at(historyPtr);
     } else if (!cmdBeforeBrowsing.isNull()) {
         cmd = cmdBeforeBrowsing;
     }
     ui->lineEdit->setText(cmd);
 }
 
 void RPCConsole::startExecutor() {
     RPCExecutor *executor = new RPCExecutor(m_node);
     executor->moveToThread(&thread);
 
     // Replies from executor object must go to this object
     connect(executor, &RPCExecutor::reply, this,
             static_cast<void (RPCConsole::*)(int, const QString &)>(
                 &RPCConsole::message));
 
     // Requests from this object must go to executor
     connect(this, &RPCConsole::cmdRequest, executor, &RPCExecutor::request);
 
     // On stopExecutor signal
     // - quit the Qt event loop in the execution thread
     connect(this, &RPCConsole::stopExecutor, &thread, &QThread::quit);
     // - queue executor for deletion (in execution thread)
     connect(&thread, &QThread::finished, executor, &RPCExecutor::deleteLater,
             Qt::DirectConnection);
 
     // Default implementation of QThread::run() simply spins up an event loop in
     // the thread, which is what we want.
     thread.start();
 }
 
 void RPCConsole::on_tabWidget_currentChanged(int index) {
     if (ui->tabWidget->widget(index) == ui->tab_console) {
         ui->lineEdit->setFocus();
     } else if (ui->tabWidget->widget(index) != ui->tab_peers) {
         clearSelectedNode();
     }
 }
 
 void RPCConsole::on_openDebugLogfileButton_clicked() {
     GUIUtil::openDebugLogfile();
 }
 
 void RPCConsole::scrollToEnd() {
     QScrollBar *scrollbar = ui->messagesWidget->verticalScrollBar();
     scrollbar->setValue(scrollbar->maximum());
 }
 
 void RPCConsole::on_sldGraphRange_valueChanged(int value) {
     const int multiplier = 5; // each position on the slider represents 5 min
     int mins = value * multiplier;
     setTrafficGraphRange(mins);
 }
 
 void RPCConsole::setTrafficGraphRange(int mins) {
     ui->trafficGraph->setGraphRangeMins(mins);
     ui->lblGraphRange->setText(GUIUtil::formatDurationStr(mins * 60));
 }
 
 void RPCConsole::updateTrafficStats(quint64 totalBytesIn,
                                     quint64 totalBytesOut) {
     ui->lblBytesIn->setText(GUIUtil::formatBytes(totalBytesIn));
     ui->lblBytesOut->setText(GUIUtil::formatBytes(totalBytesOut));
 }
 
 void RPCConsole::peerSelected(const QItemSelection &selected,
                               const QItemSelection &deselected) {
     Q_UNUSED(deselected);
 
     if (!clientModel || !clientModel->getPeerTableModel() ||
-        selected.indexes().isEmpty())
+        selected.indexes().isEmpty()) {
         return;
+    }
 
     const CNodeCombinedStats *stats =
         clientModel->getPeerTableModel()->getNodeStats(
             selected.indexes().first().row());
-    if (stats) updateNodeDetail(stats);
+    if (stats) {
+        updateNodeDetail(stats);
+    }
 }
 
 void RPCConsole::peerLayoutAboutToChange() {
     QModelIndexList selected =
         ui->peerWidget->selectionModel()->selectedIndexes();
     cachedNodeids.clear();
     for (int i = 0; i < selected.size(); i++) {
         const CNodeCombinedStats *stats =
             clientModel->getPeerTableModel()->getNodeStats(
                 selected.at(i).row());
         cachedNodeids.append(stats->nodeStats.nodeid);
     }
 }
 
 void RPCConsole::peerLayoutChanged() {
     if (!clientModel || !clientModel->getPeerTableModel()) {
         return;
     }
 
     const CNodeCombinedStats *stats = nullptr;
     bool fUnselect = false;
     bool fReselect = false;
 
-    if (cachedNodeids.empty()) // no node selected yet
+    // no node selected yet
+    if (cachedNodeids.empty()) {
         return;
+    }
 
     // find the currently selected row
     int selectedRow = -1;
     QModelIndexList selectedModelIndex =
         ui->peerWidget->selectionModel()->selectedIndexes();
     if (!selectedModelIndex.isEmpty()) {
         selectedRow = selectedModelIndex.first().row();
     }
 
     // check if our detail node has a row in the table (it may not necessarily
     // be at selectedRow since its position can change after a layout change)
     int detailNodeRow =
         clientModel->getPeerTableModel()->getRowByNodeId(cachedNodeids.first());
 
     if (detailNodeRow < 0) {
         // detail node disappeared from table (node disconnected)
         fUnselect = true;
     } else {
         if (detailNodeRow != selectedRow) {
             // detail node moved position
             fUnselect = true;
             fReselect = true;
         }
 
         // get fresh stats on the detail node.
         stats = clientModel->getPeerTableModel()->getNodeStats(detailNodeRow);
     }
 
     if (fUnselect && selectedRow >= 0) {
         clearSelectedNode();
     }
 
     if (fReselect) {
         for (int i = 0; i < cachedNodeids.size(); i++) {
             ui->peerWidget->selectRow(
                 clientModel->getPeerTableModel()->getRowByNodeId(
                     cachedNodeids.at(i)));
         }
     }
 
-    if (stats) updateNodeDetail(stats);
+    if (stats) {
+        updateNodeDetail(stats);
+    }
 }
 
 void RPCConsole::updateNodeDetail(const CNodeCombinedStats *stats) {
     // update the detail ui with latest node information
     QString peerAddrDetails(QString::fromStdString(stats->nodeStats.addrName) +
                             " ");
     peerAddrDetails +=
         tr("(node id: %1)").arg(QString::number(stats->nodeStats.nodeid));
     if (!stats->nodeStats.addrLocal.empty()) {
         peerAddrDetails += "<br />" + tr("via %1").arg(QString::fromStdString(
                                           stats->nodeStats.addrLocal));
     }
     ui->peerHeading->setText(peerAddrDetails);
     ui->peerServices->setText(
         GUIUtil::formatServicesStr(stats->nodeStats.nServices));
     ui->peerLastSend->setText(
         stats->nodeStats.nLastSend
             ? GUIUtil::formatDurationStr(GetSystemTimeInSeconds() -
                                          stats->nodeStats.nLastSend)
             : tr("never"));
     ui->peerLastRecv->setText(
         stats->nodeStats.nLastRecv
             ? GUIUtil::formatDurationStr(GetSystemTimeInSeconds() -
                                          stats->nodeStats.nLastRecv)
             : tr("never"));
     ui->peerBytesSent->setText(
         GUIUtil::formatBytes(stats->nodeStats.nSendBytes));
     ui->peerBytesRecv->setText(
         GUIUtil::formatBytes(stats->nodeStats.nRecvBytes));
     ui->peerConnTime->setText(GUIUtil::formatDurationStr(
         GetSystemTimeInSeconds() - stats->nodeStats.nTimeConnected));
     ui->peerPingTime->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dPingTime));
     ui->peerPingWait->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dPingWait));
     ui->peerMinPing->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dMinPing));
     ui->timeoffset->setText(
         GUIUtil::formatTimeOffset(stats->nodeStats.nTimeOffset));
     ui->peerVersion->setText(
         QString("%1").arg(QString::number(stats->nodeStats.nVersion)));
     ui->peerSubversion->setText(
         QString::fromStdString(stats->nodeStats.cleanSubVer));
     ui->peerDirection->setText(stats->nodeStats.fInbound ? tr("Inbound")
                                                          : tr("Outbound"));
     ui->peerHeight->setText(
         QString("%1").arg(QString::number(stats->nodeStats.nStartingHeight)));
     ui->peerWhitelisted->setText(stats->nodeStats.fWhitelisted ? tr("Yes")
                                                                : tr("No"));
 
     // This check fails for example if the lock was busy and
     // nodeStateStats couldn't be fetched.
     if (stats->fNodeStateStatsAvailable) {
         // Ban score is init to 0
         ui->peerBanScore->setText(
             QString("%1").arg(stats->nodeStateStats.nMisbehavior));
 
         // Sync height is init to -1
         if (stats->nodeStateStats.nSyncHeight > -1) {
             ui->peerSyncHeight->setText(
                 QString("%1").arg(stats->nodeStateStats.nSyncHeight));
         } else {
             ui->peerSyncHeight->setText(tr("Unknown"));
         }
 
         // Common height is init to -1
         if (stats->nodeStateStats.nCommonHeight > -1) {
             ui->peerCommonHeight->setText(
                 QString("%1").arg(stats->nodeStateStats.nCommonHeight));
         } else {
             ui->peerCommonHeight->setText(tr("Unknown"));
         }
     }
 
     ui->detailWidget->show();
 }
 
 void RPCConsole::resizeEvent(QResizeEvent *event) {
     QWidget::resizeEvent(event);
 }
 
 void RPCConsole::showEvent(QShowEvent *event) {
     QWidget::showEvent(event);
 
     if (!clientModel || !clientModel->getPeerTableModel()) {
         return;
     }
 
     // start PeerTableModel auto refresh
     clientModel->getPeerTableModel()->startAutoRefresh();
 }
 
 void RPCConsole::hideEvent(QHideEvent *event) {
     QWidget::hideEvent(event);
 
     if (!clientModel || !clientModel->getPeerTableModel()) {
         return;
     }
 
     // stop PeerTableModel auto refresh
     clientModel->getPeerTableModel()->stopAutoRefresh();
 }
 
 void RPCConsole::showPeersTableContextMenu(const QPoint &point) {
     QModelIndex index = ui->peerWidget->indexAt(point);
-    if (index.isValid()) peersTableContextMenu->exec(QCursor::pos());
+    if (index.isValid()) {
+        peersTableContextMenu->exec(QCursor::pos());
+    }
 }
 
 void RPCConsole::showBanTableContextMenu(const QPoint &point) {
     QModelIndex index = ui->banlistWidget->indexAt(point);
-    if (index.isValid()) banTableContextMenu->exec(QCursor::pos());
+    if (index.isValid()) {
+        banTableContextMenu->exec(QCursor::pos());
+    }
 }
 
 void RPCConsole::disconnectSelectedNode() {
     // Get selected peer addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected peer address
         NodeId id = nodes.at(i).data().toLongLong();
         // Find the node, disconnect it and clear the selected node
         if (m_node.disconnect(id)) {
             clearSelectedNode();
         }
     }
 }
 
 void RPCConsole::banSelectedNode(int bantime) {
     if (!clientModel) {
         return;
     }
 
     // Get selected peer addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected peer address
         NodeId id = nodes.at(i).data().toLongLong();
 
         // Get currently selected peer address
         int detailNodeRow =
             clientModel->getPeerTableModel()->getRowByNodeId(id);
         if (detailNodeRow < 0) {
             return;
         }
 
         // Find possible nodes, ban it and clear the selected node
         const CNodeCombinedStats *stats =
             clientModel->getPeerTableModel()->getNodeStats(detailNodeRow);
         if (stats) {
             m_node.ban(stats->nodeStats.addr, BanReasonManuallyAdded, bantime);
             m_node.disconnect(stats->nodeStats.addr);
         }
     }
     clearSelectedNode();
     clientModel->getBanTableModel()->refresh();
 }
 
 void RPCConsole::unbanSelectedNode() {
     if (!clientModel) {
         return;
     }
 
     // Get selected ban addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->banlistWidget, BanTableModel::Address);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected ban address
         QString strNode = nodes.at(i).data().toString();
         CSubNet possibleSubnet;
 
         LookupSubNet(strNode.toStdString().c_str(), possibleSubnet);
         if (possibleSubnet.IsValid() && m_node.unban(possibleSubnet)) {
             clientModel->getBanTableModel()->refresh();
         }
     }
 }
 
 void RPCConsole::clearSelectedNode() {
     ui->peerWidget->selectionModel()->clearSelection();
     cachedNodeids.clear();
     ui->detailWidget->hide();
     ui->peerHeading->setText(tr("Select a peer to view detailed information."));
 }
 
 void RPCConsole::showOrHideBanTableIfRequired() {
     if (!clientModel) {
         return;
     }
 
     bool visible = clientModel->getBanTableModel()->shouldShow();
     ui->banlistWidget->setVisible(visible);
     ui->banHeading->setVisible(visible);
 }
 
 void RPCConsole::setTabFocus(enum TabTypes tabType) {
     ui->tabWidget->setCurrentIndex(tabType);
 }
diff --git a/src/qt/signverifymessagedialog.cpp b/src/qt/signverifymessagedialog.cpp
index 7d273f7183..9c1ada42fe 100644
--- a/src/qt/signverifymessagedialog.cpp
+++ b/src/qt/signverifymessagedialog.cpp
@@ -1,276 +1,282 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/forms/ui_signverifymessagedialog.h>
 #include <qt/signverifymessagedialog.h>
 
 #include <key_io.h>
 #include <qt/addressbookpage.h>
 #include <qt/guiutil.h>
 #include <qt/platformstyle.h>
 #include <qt/walletmodel.h>
 #include <validation.h> // For strMessageMagic
 #include <wallet/wallet.h>
 
 #include <QClipboard>
 
 #include <string>
 #include <vector>
 
 SignVerifyMessageDialog::SignVerifyMessageDialog(
     const PlatformStyle *_platformStyle, QWidget *parent)
     : QDialog(parent), ui(new Ui::SignVerifyMessageDialog), model(0),
       platformStyle(_platformStyle) {
     ui->setupUi(this);
 
     ui->addressBookButton_SM->setIcon(
         platformStyle->SingleColorIcon(":/icons/address-book"));
     ui->pasteButton_SM->setIcon(
         platformStyle->SingleColorIcon(":/icons/editpaste"));
     ui->copySignatureButton_SM->setIcon(
         platformStyle->SingleColorIcon(":/icons/editcopy"));
     ui->signMessageButton_SM->setIcon(
         platformStyle->SingleColorIcon(":/icons/edit"));
     ui->clearButton_SM->setIcon(
         platformStyle->SingleColorIcon(":/icons/remove"));
     ui->addressBookButton_VM->setIcon(
         platformStyle->SingleColorIcon(":/icons/address-book"));
     ui->verifyMessageButton_VM->setIcon(
         platformStyle->SingleColorIcon(":/icons/transaction_0"));
     ui->clearButton_VM->setIcon(
         platformStyle->SingleColorIcon(":/icons/remove"));
 
     ui->signatureOut_SM->setPlaceholderText(
         tr("Click \"Sign Message\" to generate signature"));
 
     GUIUtil::setupAddressWidget(ui->addressIn_SM, this);
     GUIUtil::setupAddressWidget(ui->addressIn_VM, this);
 
     ui->addressIn_SM->installEventFilter(this);
     ui->messageIn_SM->installEventFilter(this);
     ui->signatureOut_SM->installEventFilter(this);
     ui->addressIn_VM->installEventFilter(this);
     ui->messageIn_VM->installEventFilter(this);
     ui->signatureIn_VM->installEventFilter(this);
 
     ui->signatureOut_SM->setFont(GUIUtil::fixedPitchFont());
     ui->signatureIn_VM->setFont(GUIUtil::fixedPitchFont());
 }
 
 SignVerifyMessageDialog::~SignVerifyMessageDialog() {
     delete ui;
 }
 
 void SignVerifyMessageDialog::setModel(WalletModel *_model) {
     this->model = _model;
 }
 
 void SignVerifyMessageDialog::setAddress_SM(const QString &address) {
     ui->addressIn_SM->setText(address);
     ui->messageIn_SM->setFocus();
 }
 
 void SignVerifyMessageDialog::setAddress_VM(const QString &address) {
     ui->addressIn_VM->setText(address);
     ui->messageIn_VM->setFocus();
 }
 
 void SignVerifyMessageDialog::showTab_SM(bool fShow) {
     ui->tabWidget->setCurrentIndex(0);
-    if (fShow) this->show();
+    if (fShow) {
+        this->show();
+    }
 }
 
 void SignVerifyMessageDialog::showTab_VM(bool fShow) {
     ui->tabWidget->setCurrentIndex(1);
-    if (fShow) this->show();
+    if (fShow) {
+        this->show();
+    }
 }
 
 void SignVerifyMessageDialog::on_addressBookButton_SM_clicked() {
     if (model && model->getAddressTableModel()) {
         AddressBookPage dlg(platformStyle, AddressBookPage::ForSelection,
                             AddressBookPage::ReceivingTab, this);
         dlg.setModel(model->getAddressTableModel());
         if (dlg.exec()) {
             setAddress_SM(dlg.getReturnValue());
         }
     }
 }
 
 void SignVerifyMessageDialog::on_pasteButton_SM_clicked() {
     setAddress_SM(QApplication::clipboard()->text());
 }
 
 void SignVerifyMessageDialog::on_signMessageButton_SM_clicked() {
-    if (!model) return;
+    if (!model) {
+        return;
+    }
 
     /* Clear old signature to ensure users don't get confused on error with an
      * old signature displayed */
     ui->signatureOut_SM->clear();
 
     CTxDestination destination = DecodeDestination(
         ui->addressIn_SM->text().toStdString(), model->getChainParams());
     if (!IsValidDestination(destination)) {
         ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_SM->setText(
             tr("The entered address is invalid.") + QString(" ") +
             tr("Please check the address and try again."));
         return;
     }
     const CKeyID *keyID = boost::get<CKeyID>(&destination);
     if (!keyID) {
         ui->addressIn_SM->setValid(false);
         ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_SM->setText(
             tr("The entered address does not refer to a key.") + QString(" ") +
             tr("Please check the address and try again."));
         return;
     }
 
     WalletModel::UnlockContext ctx(model->requestUnlock());
     if (!ctx.isValid()) {
         ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_SM->setText(tr("Wallet unlock was cancelled."));
         return;
     }
 
     CKey key;
     if (!model->wallet().getPrivKey(*keyID, key)) {
         ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_SM->setText(
             tr("Private key for the entered address is not available."));
         return;
     }
 
     CHashWriter ss(SER_GETHASH, 0);
     ss << strMessageMagic;
     ss << ui->messageIn_SM->document()->toPlainText().toStdString();
 
     std::vector<uint8_t> vchSig;
     if (!key.SignCompact(ss.GetHash(), vchSig)) {
         ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_SM->setText(QString("<nobr>") +
                                     tr("Message signing failed.") +
                                     QString("</nobr>"));
         return;
     }
 
     ui->statusLabel_SM->setStyleSheet("QLabel { color: green; }");
     ui->statusLabel_SM->setText(QString("<nobr>") + tr("Message signed.") +
                                 QString("</nobr>"));
 
     ui->signatureOut_SM->setText(
         QString::fromStdString(EncodeBase64(vchSig.data(), vchSig.size())));
 }
 
 void SignVerifyMessageDialog::on_copySignatureButton_SM_clicked() {
     GUIUtil::setClipboard(ui->signatureOut_SM->text());
 }
 
 void SignVerifyMessageDialog::on_clearButton_SM_clicked() {
     ui->addressIn_SM->clear();
     ui->messageIn_SM->clear();
     ui->signatureOut_SM->clear();
     ui->statusLabel_SM->clear();
 
     ui->addressIn_SM->setFocus();
 }
 
 void SignVerifyMessageDialog::on_addressBookButton_VM_clicked() {
     if (model && model->getAddressTableModel()) {
         AddressBookPage dlg(platformStyle, AddressBookPage::ForSelection,
                             AddressBookPage::SendingTab, this);
         dlg.setModel(model->getAddressTableModel());
         if (dlg.exec()) {
             setAddress_VM(dlg.getReturnValue());
         }
     }
 }
 
 void SignVerifyMessageDialog::on_verifyMessageButton_VM_clicked() {
     CTxDestination destination = DecodeDestination(
         ui->addressIn_VM->text().toStdString(), model->getChainParams());
     if (!IsValidDestination(destination)) {
         ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_VM->setText(
             tr("The entered address is invalid.") + QString(" ") +
             tr("Please check the address and try again."));
         return;
     }
     if (!boost::get<CKeyID>(&destination)) {
         ui->addressIn_VM->setValid(false);
         ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_VM->setText(
             tr("The entered address does not refer to a key.") + QString(" ") +
             tr("Please check the address and try again."));
         return;
     }
 
     bool fInvalid = false;
     std::vector<uint8_t> vchSig = DecodeBase64(
         ui->signatureIn_VM->text().toStdString().c_str(), &fInvalid);
 
     if (fInvalid) {
         ui->signatureIn_VM->setValid(false);
         ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_VM->setText(
             tr("The signature could not be decoded.") + QString(" ") +
             tr("Please check the signature and try again."));
         return;
     }
 
     CHashWriter ss(SER_GETHASH, 0);
     ss << strMessageMagic;
     ss << ui->messageIn_VM->document()->toPlainText().toStdString();
 
     CPubKey pubkey;
     if (!pubkey.RecoverCompact(ss.GetHash(), vchSig)) {
         ui->signatureIn_VM->setValid(false);
         ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_VM->setText(
             tr("The signature did not match the message digest.") +
             QString(" ") + tr("Please check the signature and try again."));
         return;
     }
 
     if (!(CTxDestination(pubkey.GetID()) == destination)) {
         ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_VM->setText(QString("<nobr>") +
                                     tr("Message verification failed.") +
                                     QString("</nobr>"));
         return;
     }
 
     ui->statusLabel_VM->setStyleSheet("QLabel { color: green; }");
     ui->statusLabel_VM->setText(QString("<nobr>") + tr("Message verified.") +
                                 QString("</nobr>"));
 }
 
 void SignVerifyMessageDialog::on_clearButton_VM_clicked() {
     ui->addressIn_VM->clear();
     ui->signatureIn_VM->clear();
     ui->messageIn_VM->clear();
     ui->statusLabel_VM->clear();
 
     ui->addressIn_VM->setFocus();
 }
 
 bool SignVerifyMessageDialog::eventFilter(QObject *object, QEvent *event) {
     if (event->type() == QEvent::MouseButtonPress ||
         event->type() == QEvent::FocusIn) {
         if (ui->tabWidget->currentIndex() == 0) {
             /* Clear status message on focus change */
             ui->statusLabel_SM->clear();
 
             /* Select generated signature */
             if (object == ui->signatureOut_SM) {
                 ui->signatureOut_SM->selectAll();
                 return true;
             }
         } else if (ui->tabWidget->currentIndex() == 1) {
             /* Clear status message on focus change */
             ui->statusLabel_VM->clear();
         }
     }
     return QDialog::eventFilter(object, event);
 }
diff --git a/src/qt/splashscreen.cpp b/src/qt/splashscreen.cpp
index 765237c662..39725618f4 100644
--- a/src/qt/splashscreen.cpp
+++ b/src/qt/splashscreen.cpp
@@ -1,248 +1,251 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/splashscreen.h>
 
 #include <qt/networkstyle.h>
 
 #include <clientversion.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <interfaces/wallet.h>
 #include <ui_interface.h>
 #include <util/system.h>
 #include <version.h>
 
 #include <QApplication>
 #include <QCloseEvent>
 #include <QDesktopWidget>
 #include <QPainter>
 #include <QRadialGradient>
 
 #include <memory>
 
 SplashScreen::SplashScreen(interfaces::Node &node, Qt::WindowFlags f,
                            const NetworkStyle *networkStyle)
     : QWidget(0, f), curAlignment(0), m_node(node) {
     // set reference point, paddings
     int paddingRight = 50;
     int paddingTop = 50;
     int titleVersionVSpace = 17;
     int titleCopyrightVSpace = 40;
 
     float fontFactor = 1.0;
     float devicePixelRatio = 1.0;
 #if QT_VERSION > 0x050100
     devicePixelRatio =
         static_cast<QGuiApplication *>(QCoreApplication::instance())
             ->devicePixelRatio();
 #endif
 
     // define text to place
     QString titleText = tr(PACKAGE_NAME);
     QString versionText =
         QString("Version %1").arg(QString::fromStdString(FormatFullVersion()));
     QString copyrightText = QString::fromUtf8(
         CopyrightHolders(strprintf("\xc2\xA9 %u-%u ", 2009, COPYRIGHT_YEAR))
             .c_str());
     QString titleAddText = networkStyle->getTitleAddText();
 
     QString font = QApplication::font().toString();
 
     // create a bitmap according to device pixelratio
     QSize splashSize(634 * devicePixelRatio, 320 * devicePixelRatio);
     pixmap = QPixmap(splashSize);
 
 #if QT_VERSION > 0x050100
     // change to HiDPI if it makes sense
     pixmap.setDevicePixelRatio(devicePixelRatio);
 #endif
 
     QPainter pixPaint(&pixmap);
     pixPaint.setPen(QColor(100, 100, 100));
 
     // draw a slightly radial gradient
     QRadialGradient gradient(QPoint(0, 0),
                              splashSize.width() / devicePixelRatio);
     gradient.setColorAt(0, Qt::white);
     gradient.setColorAt(1, QColor(247, 247, 247));
     QRect rGradient(QPoint(0, 0), splashSize);
     pixPaint.fillRect(rGradient, gradient);
 
     // draw the bitcoin icon, expected size of PNG: 1024x1024
     QRect rectIcon(QPoint(-10, -100), QSize(430, 430));
 
     const QSize requiredSize(1024, 1024);
     QPixmap icon(networkStyle->getAppIcon().pixmap(requiredSize));
 
     pixPaint.drawPixmap(rectIcon, icon);
 
     // check font size and drawing with
     pixPaint.setFont(QFont(font, 33 * fontFactor));
     QFontMetrics fm = pixPaint.fontMetrics();
     int titleTextWidth = fm.width(titleText);
     if (titleTextWidth > 176) {
         fontFactor = fontFactor * 176 / titleTextWidth;
     }
 
     pixPaint.setFont(QFont(font, 33 * fontFactor));
     fm = pixPaint.fontMetrics();
     titleTextWidth = fm.width(titleText);
     pixPaint.drawText(pixmap.width() / devicePixelRatio - titleTextWidth -
                           paddingRight,
                       paddingTop, titleText);
 
     pixPaint.setFont(QFont(font, 15 * fontFactor));
 
     // if the version string is too long, reduce size
     fm = pixPaint.fontMetrics();
     int versionTextWidth = fm.width(versionText);
     if (versionTextWidth > titleTextWidth + paddingRight - 10) {
         pixPaint.setFont(QFont(font, 10 * fontFactor));
         titleVersionVSpace -= 5;
     }
     pixPaint.drawText(pixmap.width() / devicePixelRatio - titleTextWidth -
                           paddingRight + 2,
                       paddingTop + titleVersionVSpace, versionText);
 
     // draw copyright stuff
     {
         pixPaint.setFont(QFont(font, 10 * fontFactor));
         const int x =
             pixmap.width() / devicePixelRatio - titleTextWidth - paddingRight;
         const int y = paddingTop + titleCopyrightVSpace;
         QRect copyrightRect(x, y, pixmap.width() - x - paddingRight,
                             pixmap.height() - y);
         pixPaint.drawText(copyrightRect,
                           Qt::AlignLeft | Qt::AlignTop | Qt::TextWordWrap,
                           copyrightText);
     }
 
     // draw additional text if special network
     if (!titleAddText.isEmpty()) {
         QFont boldFont = QFont(font, 10 * fontFactor);
         boldFont.setWeight(QFont::Bold);
         pixPaint.setFont(boldFont);
         fm = pixPaint.fontMetrics();
         int titleAddTextWidth = fm.width(titleAddText);
         pixPaint.drawText(pixmap.width() / devicePixelRatio -
                               titleAddTextWidth - 10,
                           15, titleAddText);
     }
 
     pixPaint.end();
 
     // Set window title
     setWindowTitle(titleText + " " + titleAddText);
 
     // Resize window and move to center of desktop, disallow resizing
     QRect r(QPoint(), QSize(pixmap.size().width() / devicePixelRatio,
                             pixmap.size().height() / devicePixelRatio));
     resize(r.size());
     setFixedSize(r.size());
     move(QApplication::desktop()->screenGeometry().center() - r.center());
 
     subscribeToCoreSignals();
     installEventFilter(this);
 }
 
 SplashScreen::~SplashScreen() {
     unsubscribeFromCoreSignals();
 }
 
 bool SplashScreen::eventFilter(QObject *obj, QEvent *ev) {
     if (ev->type() == QEvent::KeyPress) {
         QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
         if (keyEvent->text()[0] == 'q') {
             m_node.startShutdown();
         }
     }
     return QObject::eventFilter(obj, ev);
 }
 
 void SplashScreen::slotFinish(QWidget *mainWin) {
     Q_UNUSED(mainWin);
 
     /* If the window is minimized, hide() will be ignored. */
     /* Make sure we de-minimize the splashscreen window before hiding */
-    if (isMinimized()) showNormal();
+    if (isMinimized()) {
+        showNormal();
+    }
     hide();
-    deleteLater(); // No more need for this
+    // No more need for this
+    deleteLater();
 }
 
 static void InitMessage(SplashScreen *splash, const std::string &message) {
     QMetaObject::invokeMethod(splash, "showMessage", Qt::QueuedConnection,
                               Q_ARG(QString, QString::fromStdString(message)),
                               Q_ARG(int, Qt::AlignBottom | Qt::AlignHCenter),
                               Q_ARG(QColor, QColor(55, 55, 55)));
 }
 
 static void ShowProgress(SplashScreen *splash, const std::string &title,
                          int nProgress, bool resume_possible) {
     InitMessage(splash, title + std::string("\n") +
                             (resume_possible
                                  ? _("(press q to shutdown and continue later)")
                                  : _("press q to shutdown")) +
                             strprintf("\n%d", nProgress) + "%");
 }
 #ifdef ENABLE_WALLET
 void SplashScreen::ConnectWallet(std::unique_ptr<interfaces::Wallet> wallet) {
     m_connected_wallet_handlers.emplace_back(wallet->handleShowProgress(
         std::bind(ShowProgress, this, std::placeholders::_1,
                   std::placeholders::_2, false)));
     m_connected_wallets.emplace_back(std::move(wallet));
 }
 #endif
 
 void SplashScreen::subscribeToCoreSignals() {
     // Connect signals to client
     m_handler_init_message = m_node.handleInitMessage(
         std::bind(InitMessage, this, std::placeholders::_1));
     m_handler_show_progress = m_node.handleShowProgress(
         std::bind(ShowProgress, this, std::placeholders::_1,
                   std::placeholders::_2, std::placeholders::_3));
 #ifdef ENABLE_WALLET
     m_handler_load_wallet = m_node.handleLoadWallet(
         [this](std::unique_ptr<interfaces::Wallet> wallet) {
             ConnectWallet(std::move(wallet));
         });
 #endif
 }
 
 void SplashScreen::unsubscribeFromCoreSignals() {
     // Disconnect signals from client
     m_handler_init_message->disconnect();
     m_handler_show_progress->disconnect();
     for (const auto &handler : m_connected_wallet_handlers) {
         handler->disconnect();
     }
     m_connected_wallet_handlers.clear();
     m_connected_wallets.clear();
 }
 
 void SplashScreen::showMessage(const QString &message, int alignment,
                                const QColor &color) {
     curMessage = message;
     curAlignment = alignment;
     curColor = color;
     update();
 }
 
 void SplashScreen::paintEvent(QPaintEvent *event) {
     QPainter painter(this);
     painter.drawPixmap(0, 0, pixmap);
     QRect r = rect().adjusted(5, 5, -5, -5);
     painter.setPen(curColor);
     painter.drawText(r, curAlignment, curMessage);
 }
 
 void SplashScreen::closeEvent(QCloseEvent *event) {
     // allows an "emergency" shutdown during startup
     m_node.startShutdown();
     event->ignore();
 }
diff --git a/src/qt/test/paymentservertests.cpp b/src/qt/test/paymentservertests.cpp
index 985a8dce54..f86b10a852 100644
--- a/src/qt/test/paymentservertests.cpp
+++ b/src/qt/test/paymentservertests.cpp
@@ -1,220 +1,221 @@
 // Copyright (c) 2009-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/test/paymentservertests.h>
 
 #include <amount.h>
 #include <interfaces/node.h>
 #include <qt/optionsmodel.h>
 #include <qt/test/paymentrequestdata.h>
 #include <random.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 
 #include <openssl/x509.h>
 #include <openssl/x509_vfy.h>
 
 #include <QFileOpenEvent>
 #include <QTemporaryFile>
 
 X509 *parse_b64der_cert(const char *cert_data) {
     std::vector<uint8_t> data = DecodeBase64(cert_data);
     assert(data.size() > 0);
     const uint8_t *dptr = data.data();
     X509 *cert = d2i_X509(nullptr, &dptr, data.size());
     assert(cert);
     return cert;
 }
 
 //
 // Test payment request handling
 //
 
 static SendCoinsRecipient handleRequest(PaymentServer *server,
                                         std::vector<uint8_t> &data) {
     RecipientCatcher sigCatcher;
     QObject::connect(server, &PaymentServer::receivedPaymentRequest,
                      &sigCatcher, &RecipientCatcher::getRecipient);
 
     // Write data to a temp file:
     QTemporaryFile f;
     f.open();
     f.write((const char *)data.data(), data.size());
     f.close();
 
     // Create a QObject, install event filter from PaymentServer and send a file
     // open event to the object
     QObject object;
     object.installEventFilter(server);
     QFileOpenEvent event(f.fileName());
     // If sending the event fails, this will cause sigCatcher to be empty, which
     // will lead to a test failure anyway.
     QCoreApplication::sendEvent(&object, &event);
 
     QObject::disconnect(server, &PaymentServer::receivedPaymentRequest,
                         &sigCatcher, &RecipientCatcher::getRecipient);
 
     // Return results from sigCatcher
     return sigCatcher.recipient;
 }
 
 void PaymentServerTests::paymentServerTests() {
     SelectParams(CBaseChainParams::MAIN);
     auto node = interfaces::MakeNode();
     OptionsModel optionsModel(*node);
     PaymentServer *server = new PaymentServer(nullptr, false);
     X509_STORE *caStore = X509_STORE_new();
     X509_STORE_add_cert(caStore, parse_b64der_cert(caCert1_BASE64));
     PaymentServer::LoadRootCAs(caStore);
     server->setOptionsModel(&optionsModel);
     server->uiReady();
 
     std::vector<uint8_t> data;
     SendCoinsRecipient r;
     QString merchant;
 
     // Now feed PaymentRequests to server, and observe signals it produces
 
     // This payment request validates directly against the caCert1 certificate
     // authority:
     data = DecodeBase64(paymentrequest1_cert1_BASE64);
     r = handleRequest(server, data);
     r.paymentRequest.getMerchant(caStore, merchant);
     QCOMPARE(merchant, QString("testmerchant.org"));
 
     // Signed, but expired, merchant cert in the request:
     data = DecodeBase64(paymentrequest2_cert1_BASE64);
     r = handleRequest(server, data);
     r.paymentRequest.getMerchant(caStore, merchant);
     QCOMPARE(merchant, QString(""));
 
     // 10-long certificate chain, all intermediates valid:
     data = DecodeBase64(paymentrequest3_cert1_BASE64);
     r = handleRequest(server, data);
     r.paymentRequest.getMerchant(caStore, merchant);
     QCOMPARE(merchant, QString("testmerchant8.org"));
 
     // Long certificate chain, with an expired certificate in the middle:
     data = DecodeBase64(paymentrequest4_cert1_BASE64);
     r = handleRequest(server, data);
     r.paymentRequest.getMerchant(caStore, merchant);
     QCOMPARE(merchant, QString(""));
 
     // Validly signed, but by a CA not in our root CA list:
     data = DecodeBase64(paymentrequest5_cert1_BASE64);
     r = handleRequest(server, data);
     r.paymentRequest.getMerchant(caStore, merchant);
     QCOMPARE(merchant, QString(""));
 
     // Try again with no root CA's, verifiedMerchant should be empty:
     caStore = X509_STORE_new();
     PaymentServer::LoadRootCAs(caStore);
     data = DecodeBase64(paymentrequest1_cert1_BASE64);
     r = handleRequest(server, data);
     r.paymentRequest.getMerchant(caStore, merchant);
     QCOMPARE(merchant, QString(""));
 
     // Load second root certificate
     caStore = X509_STORE_new();
     X509_STORE_add_cert(caStore, parse_b64der_cert(caCert2_BASE64));
     PaymentServer::LoadRootCAs(caStore);
 
     QByteArray byteArray;
 
     // For the tests below we just need the payment request data from
     // paymentrequestdata.h parsed + stored in r.paymentRequest.
     //
     // These tests require us to bypass the following normal client execution
     // flow shown below to be able to explicitly just trigger a certain
     // condition!
     //
     // handleRequest()
     // -> PaymentServer::eventFilter()
     //   -> PaymentServer::handleURIOrFile()
     //     -> PaymentServer::readPaymentRequestFromFile()
     //       -> PaymentServer::processPaymentRequest()
 
     // Contains a testnet paytoaddress, so payment request network doesn't match
     // client network:
     data = DecodeBase64(paymentrequest1_cert2_BASE64);
     byteArray = QByteArray((const char *)data.data(), data.size());
     r.paymentRequest.parse(byteArray);
     // Ensure the request is initialized, because network "main" is default,
     // even for uninitialized payment requests and that will fail our test here.
     QVERIFY(r.paymentRequest.IsInitialized());
     QCOMPARE(PaymentServer::verifyNetwork(*node, r.paymentRequest.getDetails()),
              false);
 
     // Expired payment request (expires is set to 1 = 1970-01-01 00:00:01):
     data = DecodeBase64(paymentrequest2_cert2_BASE64);
     byteArray = QByteArray((const char *)data.data(), data.size());
     r.paymentRequest.parse(byteArray);
     // Ensure the request is initialized
     QVERIFY(r.paymentRequest.IsInitialized());
     // compares 1 < GetTime() == false (treated as expired payment request)
     QCOMPARE(PaymentServer::verifyExpired(r.paymentRequest.getDetails()), true);
 
     // Unexpired payment request (expires is set to 0x7FFFFFFFFFFFFFFF = max.
     // int64_t):
     // 9223372036854775807 (uint64), 9223372036854775807 (int64_t) and -1
     // (int32_t)
     // -1 is 1969-12-31 23:59:59 (for a 32 bit time values)
     data = DecodeBase64(paymentrequest3_cert2_BASE64);
     byteArray = QByteArray((const char *)data.data(), data.size());
     r.paymentRequest.parse(byteArray);
     // Ensure the request is initialized
     QVERIFY(r.paymentRequest.IsInitialized());
     // compares 9223372036854775807 < GetTime() == false (treated as unexpired
     // payment request)
     QCOMPARE(PaymentServer::verifyExpired(r.paymentRequest.getDetails()),
              false);
 
     // Unexpired payment request (expires is set to 0x8000000000000000 > max.
     // int64_t, allowed uint64):
     // 9223372036854775808 (uint64), -9223372036854775808 (int64_t) and 0
     // (int32_t)
     // 0 is 1970-01-01 00:00:00 (for a 32 bit time values)
     data = DecodeBase64(paymentrequest4_cert2_BASE64);
     byteArray = QByteArray((const char *)data.data(), data.size());
     r.paymentRequest.parse(byteArray);
     // Ensure the request is initialized
     QVERIFY(r.paymentRequest.IsInitialized());
     // compares -9223372036854775808 < GetTime() == true (treated as expired
     // payment request)
     QCOMPARE(PaymentServer::verifyExpired(r.paymentRequest.getDetails()), true);
 
     // Test BIP70 DoS protection:
     auto randdata =
         FastRandomContext().randbytes(BIP70_MAX_PAYMENTREQUEST_SIZE + 1);
 
     // Write data to a temp file:
     QTemporaryFile tempFile;
     tempFile.open();
     tempFile.write((const char *)randdata.data(), randdata.size());
     tempFile.close();
     // compares 50001 <= BIP70_MAX_PAYMENTREQUEST_SIZE == false
     QCOMPARE(PaymentServer::verifySize(tempFile.size()), false);
 
     // Payment request with amount overflow (amount is set to 21000001 BCH):
     data = DecodeBase64(paymentrequest5_cert2_BASE64);
     byteArray = QByteArray((const char *)data.data(), data.size());
     r.paymentRequest.parse(byteArray);
     // Ensure the request is initialized
     QVERIFY(r.paymentRequest.IsInitialized());
     // Extract address and amount from the request
     QList<std::pair<CScript, Amount>> sendingTos = r.paymentRequest.getPayTo();
     for (const std::pair<CScript, Amount> &sendingTo : sendingTos) {
         CTxDestination dest;
-        if (ExtractDestination(sendingTo.first, dest))
+        if (ExtractDestination(sendingTo.first, dest)) {
             QCOMPARE(PaymentServer::verifyAmount(sendingTo.second), false);
+        }
     }
 
     delete server;
 }
 
 void RecipientCatcher::getRecipient(const SendCoinsRecipient &r) {
     recipient = r;
 }
diff --git a/src/qt/trafficgraphwidget.cpp b/src/qt/trafficgraphwidget.cpp
index bdabdd3a7a..17d0eff5ed 100644
--- a/src/qt/trafficgraphwidget.cpp
+++ b/src/qt/trafficgraphwidget.cpp
@@ -1,167 +1,177 @@
 // Copyright (c) 2011-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/trafficgraphwidget.h>
 
 #include <interfaces/node.h>
 #include <qt/clientmodel.h>
 
 #include <QColor>
 #include <QPainter>
 #include <QTimer>
 
 #include <cmath>
 
 #define DESIRED_SAMPLES 800
 
 #define XMARGIN 10
 #define YMARGIN 10
 
 TrafficGraphWidget::TrafficGraphWidget(QWidget *parent)
     : QWidget(parent), timer(0), fMax(0.0f), nMins(0), vSamplesIn(),
       vSamplesOut(), nLastBytesIn(0), nLastBytesOut(0), clientModel(0) {
     timer = new QTimer(this);
     connect(timer, &QTimer::timeout, this, &TrafficGraphWidget::updateRates);
 }
 
 void TrafficGraphWidget::setClientModel(ClientModel *model) {
     clientModel = model;
     if (model) {
         nLastBytesIn = model->node().getTotalBytesRecv();
         nLastBytesOut = model->node().getTotalBytesSent();
     }
 }
 
 int TrafficGraphWidget::getGraphRangeMins() const {
     return nMins;
 }
 
 void TrafficGraphWidget::paintPath(QPainterPath &path, QQueue<float> &samples) {
     int sampleCount = samples.size();
     if (sampleCount > 0) {
         int h = height() - YMARGIN * 2, w = width() - XMARGIN * 2;
         int x = XMARGIN + w;
         path.moveTo(x, YMARGIN + h);
         for (int i = 0; i < sampleCount; ++i) {
             x = XMARGIN + w - w * i / DESIRED_SAMPLES;
             int y = YMARGIN + h - (int)(h * samples.at(i) / fMax);
             path.lineTo(x, y);
         }
         path.lineTo(x, YMARGIN + h);
     }
 }
 
 void TrafficGraphWidget::paintEvent(QPaintEvent *) {
     QPainter painter(this);
     painter.fillRect(rect(), Qt::black);
 
-    if (fMax <= 0.0f) return;
+    if (fMax <= 0.0f) {
+        return;
+    }
 
     QColor axisCol(Qt::gray);
     int h = height() - YMARGIN * 2;
     painter.setPen(axisCol);
     painter.drawLine(XMARGIN, YMARGIN + h, width() - XMARGIN, YMARGIN + h);
 
     // decide what order of magnitude we are
     int base = floor(log10(fMax));
     float val = pow(10.0f, base);
 
     const QString units = tr("KB/s");
     const float yMarginText = 2.0;
 
     // draw lines
     painter.setPen(axisCol);
     painter.drawText(XMARGIN, YMARGIN + h - h * val / fMax - yMarginText,
                      QString("%1 %2").arg(val).arg(units));
     for (float y = val; y < fMax; y += val) {
         int yy = YMARGIN + h - h * y / fMax;
         painter.drawLine(XMARGIN, yy, width() - XMARGIN, yy);
     }
     // if we drew 3 or fewer lines, break them up at the next lower order of
     // magnitude
     if (fMax / val <= 3.0f) {
         axisCol = axisCol.darker();
         val = pow(10.0f, base - 1);
         painter.setPen(axisCol);
         painter.drawText(XMARGIN, YMARGIN + h - h * val / fMax - yMarginText,
                          QString("%1 %2").arg(val).arg(units));
         int count = 1;
         for (float y = val; y < fMax; y += val, count++) {
             // don't overwrite lines drawn above
-            if (count % 10 == 0) continue;
+            if (count % 10 == 0) {
+                continue;
+            }
             int yy = YMARGIN + h - h * y / fMax;
             painter.drawLine(XMARGIN, yy, width() - XMARGIN, yy);
         }
     }
 
     if (!vSamplesIn.empty()) {
         QPainterPath p;
         paintPath(p, vSamplesIn);
         painter.fillPath(p, QColor(0, 255, 0, 128));
         painter.setPen(Qt::green);
         painter.drawPath(p);
     }
     if (!vSamplesOut.empty()) {
         QPainterPath p;
         paintPath(p, vSamplesOut);
         painter.fillPath(p, QColor(255, 0, 0, 128));
         painter.setPen(Qt::red);
         painter.drawPath(p);
     }
 }
 
 void TrafficGraphWidget::updateRates() {
-    if (!clientModel) return;
+    if (!clientModel) {
+        return;
+    }
 
     quint64 bytesIn = clientModel->node().getTotalBytesRecv(),
             bytesOut = clientModel->node().getTotalBytesSent();
     float inRate =
         (bytesIn - nLastBytesIn) / 1024.0f * 1000 / timer->interval();
     float outRate =
         (bytesOut - nLastBytesOut) / 1024.0f * 1000 / timer->interval();
     vSamplesIn.push_front(inRate);
     vSamplesOut.push_front(outRate);
     nLastBytesIn = bytesIn;
     nLastBytesOut = bytesOut;
 
     while (vSamplesIn.size() > DESIRED_SAMPLES) {
         vSamplesIn.pop_back();
     }
     while (vSamplesOut.size() > DESIRED_SAMPLES) {
         vSamplesOut.pop_back();
     }
 
     float tmax = 0.0f;
     for (const float f : vSamplesIn) {
-        if (f > tmax) tmax = f;
+        if (f > tmax) {
+            tmax = f;
+        }
     }
     for (const float f : vSamplesOut) {
-        if (f > tmax) tmax = f;
+        if (f > tmax) {
+            tmax = f;
+        }
     }
     fMax = tmax;
     update();
 }
 
 void TrafficGraphWidget::setGraphRangeMins(int mins) {
     nMins = mins;
     int msecsPerSample = nMins * 60 * 1000 / DESIRED_SAMPLES;
     timer->stop();
     timer->setInterval(msecsPerSample);
 
     clear();
 }
 
 void TrafficGraphWidget::clear() {
     timer->stop();
 
     vSamplesOut.clear();
     vSamplesIn.clear();
     fMax = 0.0f;
 
     if (clientModel) {
         nLastBytesIn = clientModel->node().getTotalBytesRecv();
         nLastBytesOut = clientModel->node().getTotalBytesSent();
     }
     timer->start();
 }
diff --git a/src/qt/transactiontablemodel.cpp b/src/qt/transactiontablemodel.cpp
index 4c87c1d94d..67e508f02f 100644
--- a/src/qt/transactiontablemodel.cpp
+++ b/src/qt/transactiontablemodel.cpp
@@ -1,773 +1,775 @@
 // 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/transactiontablemodel.h>
 
 #include <core_io.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <qt/addresstablemodel.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/transactiondesc.h>
 #include <qt/transactionrecord.h>
 #include <qt/walletmodel.h>
 #include <sync.h>
 #include <uint256.h>
 #include <util/system.h>
 #include <validation.h>
 
 #include <algorithm>
 
 #include <QColor>
 #include <QDateTime>
 #include <QDebug>
 #include <QIcon>
 #include <QList>
 
 // Amount column is right-aligned it contains numbers
 static int column_alignments[] = {
     Qt::AlignLeft | Qt::AlignVCenter, /* status */
     Qt::AlignLeft | Qt::AlignVCenter, /* watchonly */
     Qt::AlignLeft | Qt::AlignVCenter, /* date */
     Qt::AlignLeft | Qt::AlignVCenter, /* type */
     Qt::AlignLeft | Qt::AlignVCenter, /* address */
     Qt::AlignRight | Qt::AlignVCenter /* amount */
 };
 
 // Comparison operator for sort/binary search of model tx list
 struct TxLessThan {
     bool operator()(const TransactionRecord &a,
                     const TransactionRecord &b) const {
         return a.txid < b.txid;
     }
     bool operator()(const TransactionRecord &a, const TxId &b) const {
         return a.txid < b;
     }
     bool operator()(const TxId &a, const TransactionRecord &b) const {
         return a < b.txid;
     }
 };
 
 // Private implementation
 class TransactionTablePriv {
 public:
     TransactionTablePriv(TransactionTableModel *_parent) : parent(_parent) {}
 
     TransactionTableModel *parent;
 
     /* Local cache of wallet.
      * As it is in the same order as the CWallet, by definition this is sorted
      * by sha256.
      */
     QList<TransactionRecord> cachedWallet;
 
     /**
      * Query entire wallet anew from core.
      */
     void refreshWallet(interfaces::Wallet &wallet) {
         qDebug() << "TransactionTablePriv::refreshWallet";
         cachedWallet.clear();
         for (const auto &wtx : wallet.getWalletTxs()) {
             if (TransactionRecord::showTransaction()) {
                 cachedWallet.append(
                     TransactionRecord::decomposeTransaction(wtx));
             }
         }
     }
 
     /**
      * Update our model of the wallet incrementally, to synchronize our model of
      * the wallet with that of the core.
      * Call with transaction that was added, removed or changed.
      */
     void updateWallet(interfaces::Wallet &wallet, const TxId &txid, int status,
                       bool showTransaction) {
         qDebug() << "TransactionTablePriv::updateWallet: " +
                         QString::fromStdString(txid.ToString()) + " " +
                         QString::number(status);
 
         // Find bounds of this transaction in model
         QList<TransactionRecord>::iterator lower = std::lower_bound(
             cachedWallet.begin(), cachedWallet.end(), txid, TxLessThan());
         QList<TransactionRecord>::iterator upper = std::upper_bound(
             cachedWallet.begin(), cachedWallet.end(), txid, TxLessThan());
         int lowerIndex = (lower - cachedWallet.begin());
         int upperIndex = (upper - cachedWallet.begin());
         bool inModel = (lower != upper);
 
         if (status == CT_UPDATED) {
             // Not in model, but want to show, treat as new.
             if (showTransaction && !inModel) {
                 status = CT_NEW;
             }
             // In model, but want to hide, treat as deleted.
             if (!showTransaction && inModel) {
                 status = CT_DELETED;
             }
         }
 
         qDebug() << "    inModel=" + QString::number(inModel) +
                         " Index=" + QString::number(lowerIndex) + "-" +
                         QString::number(upperIndex) +
                         " showTransaction=" + QString::number(showTransaction) +
                         " derivedStatus=" + QString::number(status);
 
         switch (status) {
             case CT_NEW:
                 if (inModel) {
                     qWarning() << "TransactionTablePriv::updateWallet: "
                                   "Warning: Got CT_NEW, but transaction is "
                                   "already in model";
                     break;
                 }
                 if (showTransaction) {
                     // Find transaction in wallet
                     interfaces::WalletTx wtx = wallet.getWalletTx(txid);
                     if (!wtx.tx) {
                         qWarning() << "TransactionTablePriv::updateWallet: "
                                       "Warning: Got CT_NEW, but transaction is "
                                       "not in wallet";
                         break;
                     }
                     // Added -- insert at the right position
                     QList<TransactionRecord> toInsert =
                         TransactionRecord::decomposeTransaction(wtx);
                     /* only if something to insert */
                     if (!toInsert.isEmpty()) {
                         parent->beginInsertRows(QModelIndex(), lowerIndex,
                                                 lowerIndex + toInsert.size() -
                                                     1);
                         int insert_idx = lowerIndex;
                         for (const TransactionRecord &rec : toInsert) {
                             cachedWallet.insert(insert_idx, rec);
                             insert_idx += 1;
                         }
                         parent->endInsertRows();
                     }
                 }
                 break;
             case CT_DELETED:
                 if (!inModel) {
                     qWarning() << "TransactionTablePriv::updateWallet: "
                                   "Warning: Got CT_DELETED, but transaction is "
                                   "not in model";
                     break;
                 }
                 // Removed -- remove entire transaction from table
                 parent->beginRemoveRows(QModelIndex(), lowerIndex,
                                         upperIndex - 1);
                 cachedWallet.erase(lower, upper);
                 parent->endRemoveRows();
                 break;
             case CT_UPDATED:
                 // Miscellaneous updates -- nothing to do, status update will
                 // take care of this, and is only computed for visible
                 // transactions.
                 break;
         }
     }
 
     int size() { return cachedWallet.size(); }
 
     TransactionRecord *index(interfaces::Wallet &wallet, int idx) {
         if (idx >= 0 && idx < cachedWallet.size()) {
             TransactionRecord *rec = &cachedWallet[idx];
 
             // Get required locks upfront. This avoids the GUI from getting
             // stuck if the core is holding the locks for a longer time - for
             // example, during a wallet rescan.
             //
             // If a status update is needed (blocks came in since last check),
             // update the status of this transaction from the wallet. Otherwise,
             // simply re-use the cached status.
             interfaces::WalletTxStatus wtx;
             int numBlocks;
             int64_t block_time;
             if (wallet.tryGetTxStatus(rec->txid, wtx, numBlocks, block_time) &&
                 rec->statusUpdateNeeded(numBlocks)) {
                 rec->updateStatus(wtx, numBlocks, block_time);
             }
             return rec;
         }
         return 0;
     }
 
     QString describe(interfaces::Node &node, interfaces::Wallet &wallet,
                      TransactionRecord *rec, int unit) {
         return TransactionDesc::toHTML(node, wallet, rec, unit);
     }
 
     QString getTxHex(interfaces::Wallet &wallet, TransactionRecord *rec) {
         auto tx = wallet.getTx(rec->txid);
         if (tx) {
             std::string strHex = EncodeHexTx(*tx);
             return QString::fromStdString(strHex);
         }
         return QString();
     }
 };
 
 TransactionTableModel::TransactionTableModel(
     const PlatformStyle *_platformStyle, WalletModel *parent)
     : QAbstractTableModel(parent), walletModel(parent),
       priv(new TransactionTablePriv(this)),
       fProcessingQueuedTransactions(false), platformStyle(_platformStyle) {
     columns << QString() << QString() << tr("Date") << tr("Type") << tr("Label")
             << BitcoinUnits::getAmountColumnTitle(
                    walletModel->getOptionsModel()->getDisplayUnit());
     priv->refreshWallet(walletModel->wallet());
 
     connect(walletModel->getOptionsModel(), &OptionsModel::displayUnitChanged,
             this, &TransactionTableModel::updateDisplayUnit);
 
     subscribeToCoreSignals();
 }
 
 TransactionTableModel::~TransactionTableModel() {
     unsubscribeFromCoreSignals();
     delete priv;
 }
 
 /** Updates the column title to "Amount (DisplayUnit)" and emits
  * headerDataChanged() signal for table headers to react. */
 void TransactionTableModel::updateAmountColumnTitle() {
     columns[Amount] = BitcoinUnits::getAmountColumnTitle(
         walletModel->getOptionsModel()->getDisplayUnit());
     Q_EMIT headerDataChanged(Qt::Horizontal, Amount, Amount);
 }
 
 void TransactionTableModel::updateTransaction(const QString &hash, int status,
                                               bool showTransaction) {
     TxId updated;
     updated.SetHex(hash.toStdString());
 
     priv->updateWallet(walletModel->wallet(), updated, status, showTransaction);
 }
 
 void TransactionTableModel::updateConfirmations() {
     // Blocks came in since last poll.
     // Invalidate status (number of confirmations) and (possibly) description
     // for all rows. Qt is smart enough to only actually request the data for
     // the visible rows.
     Q_EMIT dataChanged(index(0, Status), index(priv->size() - 1, Status));
     Q_EMIT dataChanged(index(0, ToAddress), index(priv->size() - 1, ToAddress));
 }
 
 int TransactionTableModel::rowCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return priv->size();
 }
 
 int TransactionTableModel::columnCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return columns.length();
 }
 
 QString
 TransactionTableModel::formatTxStatus(const TransactionRecord *wtx) const {
     QString status;
 
     switch (wtx->status.status) {
         case TransactionStatus::OpenUntilBlock:
             status = tr("Open for %n more block(s)", "", wtx->status.open_for);
             break;
         case TransactionStatus::OpenUntilDate:
             status = tr("Open until %1")
                          .arg(GUIUtil::dateTimeStr(wtx->status.open_for));
             break;
         case TransactionStatus::Unconfirmed:
             status = tr("Unconfirmed");
             break;
         case TransactionStatus::Abandoned:
             status = tr("Abandoned");
             break;
         case TransactionStatus::Confirming:
             status = tr("Confirming (%1 of %2 recommended confirmations)")
                          .arg(wtx->status.depth)
                          .arg(TransactionRecord::RecommendedNumConfirmations);
             break;
         case TransactionStatus::Confirmed:
             status = tr("Confirmed (%1 confirmations)").arg(wtx->status.depth);
             break;
         case TransactionStatus::Conflicted:
             status = tr("Conflicted");
             break;
         case TransactionStatus::Immature:
             status =
                 tr("Immature (%1 confirmations, will be available after %2)")
                     .arg(wtx->status.depth)
                     .arg(wtx->status.depth + wtx->status.matures_in);
             break;
         case TransactionStatus::NotAccepted:
             status = tr("Generated but not accepted");
             break;
     }
 
     return status;
 }
 
 QString
 TransactionTableModel::formatTxDate(const TransactionRecord *wtx) const {
     if (wtx->time) {
         return GUIUtil::dateTimeStr(wtx->time);
     }
     return QString();
 }
 
 /**
  * Look up address in address book, if found return label (address)  otherwise
  * just return (address)
  */
 QString TransactionTableModel::lookupAddress(const std::string &address,
                                              bool tooltip) const {
     QString label = walletModel->getAddressTableModel()->labelForAddress(
         QString::fromStdString(address));
     QString description;
     if (!label.isEmpty()) {
         description += label;
     }
     if (label.isEmpty() || tooltip) {
         description +=
             QString(" (") + QString::fromStdString(address) + QString(")");
     }
     return description;
 }
 
 QString
 TransactionTableModel::formatTxType(const TransactionRecord *wtx) const {
     switch (wtx->type) {
         case TransactionRecord::RecvWithAddress:
             return tr("Received with");
         case TransactionRecord::RecvFromOther:
             return tr("Received from");
         case TransactionRecord::SendToAddress:
         case TransactionRecord::SendToOther:
             return tr("Sent to");
         case TransactionRecord::SendToSelf:
             return tr("Payment to yourself");
         case TransactionRecord::Generated:
             return tr("Mined");
         default:
             return QString();
     }
 }
 
 QVariant
 TransactionTableModel::txAddressDecoration(const TransactionRecord *wtx) const {
     switch (wtx->type) {
         case TransactionRecord::Generated:
             return QIcon(":/icons/tx_mined");
         case TransactionRecord::RecvWithAddress:
         case TransactionRecord::RecvFromOther:
             return QIcon(":/icons/tx_input");
         case TransactionRecord::SendToAddress:
         case TransactionRecord::SendToOther:
             return QIcon(":/icons/tx_output");
         default:
             return QIcon(":/icons/tx_inout");
     }
 }
 
 QString TransactionTableModel::formatTxToAddress(const TransactionRecord *wtx,
                                                  bool tooltip) const {
     QString watchAddress;
     if (tooltip) {
         // Mark transactions involving watch-only addresses by adding "
         // (watch-only)"
         watchAddress = wtx->involvesWatchAddress
                            ? QString(" (") + tr("watch-only") + QString(")")
                            : "";
     }
 
     switch (wtx->type) {
         case TransactionRecord::RecvFromOther:
             return QString::fromStdString(wtx->address) + watchAddress;
         case TransactionRecord::RecvWithAddress:
         case TransactionRecord::SendToAddress:
         case TransactionRecord::Generated:
             return lookupAddress(wtx->address, tooltip) + watchAddress;
         case TransactionRecord::SendToOther:
             return QString::fromStdString(wtx->address) + watchAddress;
         case TransactionRecord::SendToSelf:
         default:
             return tr("(n/a)") + watchAddress;
     }
 }
 
 QVariant
 TransactionTableModel::addressColor(const TransactionRecord *wtx) const {
     // Show addresses without label in a less visible color
     switch (wtx->type) {
         case TransactionRecord::RecvWithAddress:
         case TransactionRecord::SendToAddress:
         case TransactionRecord::Generated: {
             QString label =
                 walletModel->getAddressTableModel()->labelForAddress(
                     QString::fromStdString(wtx->address));
-            if (label.isEmpty()) return COLOR_BAREADDRESS;
+            if (label.isEmpty()) {
+                return COLOR_BAREADDRESS;
+            }
         } break;
         case TransactionRecord::SendToSelf:
             return COLOR_BAREADDRESS;
         default:
             break;
     }
     return QVariant();
 }
 
 QString TransactionTableModel::formatTxAmount(
     const TransactionRecord *wtx, bool showUnconfirmed,
     BitcoinUnits::SeparatorStyle separators) const {
     QString str =
         BitcoinUnits::format(walletModel->getOptionsModel()->getDisplayUnit(),
                              wtx->credit + wtx->debit, false, separators);
     if (showUnconfirmed) {
         if (!wtx->status.countsForBalance) {
             str = QString("[") + str + QString("]");
         }
     }
     return QString(str);
 }
 
 QVariant
 TransactionTableModel::txStatusDecoration(const TransactionRecord *wtx) const {
     switch (wtx->status.status) {
         case TransactionStatus::OpenUntilBlock:
         case TransactionStatus::OpenUntilDate:
             return COLOR_TX_STATUS_OPENUNTILDATE;
         case TransactionStatus::Unconfirmed:
             return QIcon(":/icons/transaction_0");
         case TransactionStatus::Abandoned:
             return QIcon(":/icons/transaction_abandoned");
         case TransactionStatus::Confirming:
             switch (wtx->status.depth) {
                 case 1:
                     return QIcon(":/icons/transaction_1");
                 case 2:
                     return QIcon(":/icons/transaction_2");
                 case 3:
                     return QIcon(":/icons/transaction_3");
                 case 4:
                     return QIcon(":/icons/transaction_4");
                 default:
                     return QIcon(":/icons/transaction_5");
             };
         case TransactionStatus::Confirmed:
             return QIcon(":/icons/transaction_confirmed");
         case TransactionStatus::Conflicted:
             return QIcon(":/icons/transaction_conflicted");
         case TransactionStatus::Immature: {
             int total = wtx->status.depth + wtx->status.matures_in;
             int part = (wtx->status.depth * 4 / total) + 1;
             return QIcon(QString(":/icons/transaction_%1").arg(part));
         }
         case TransactionStatus::NotAccepted:
             return QIcon(":/icons/transaction_0");
         default:
             return COLOR_BLACK;
     }
 }
 
 QVariant TransactionTableModel::txWatchonlyDecoration(
     const TransactionRecord *wtx) const {
     if (wtx->involvesWatchAddress) {
         return QIcon(":/icons/eye");
     }
 
     return QVariant();
 }
 
 QString
 TransactionTableModel::formatTooltip(const TransactionRecord *rec) const {
     QString tooltip = formatTxStatus(rec) + QString("\n") + formatTxType(rec);
     if (rec->type == TransactionRecord::RecvFromOther ||
         rec->type == TransactionRecord::SendToOther ||
         rec->type == TransactionRecord::SendToAddress ||
         rec->type == TransactionRecord::RecvWithAddress) {
         tooltip += QString(" ") + formatTxToAddress(rec, true);
     }
     return tooltip;
 }
 
 QVariant TransactionTableModel::data(const QModelIndex &index, int role) const {
     if (!index.isValid()) {
         return QVariant();
     }
 
     TransactionRecord *rec =
         static_cast<TransactionRecord *>(index.internalPointer());
 
     switch (role) {
         case RawDecorationRole:
             switch (index.column()) {
                 case Status:
                     return txStatusDecoration(rec);
                 case Watchonly:
                     return txWatchonlyDecoration(rec);
                 case ToAddress:
                     return txAddressDecoration(rec);
             }
             break;
         case Qt::DecorationRole: {
             QIcon icon = qvariant_cast<QIcon>(index.data(RawDecorationRole));
             return platformStyle->TextColorIcon(icon);
         }
         case Qt::DisplayRole:
             switch (index.column()) {
                 case Date:
                     return formatTxDate(rec);
                 case Type:
                     return formatTxType(rec);
                 case ToAddress:
                     return formatTxToAddress(rec, false);
                 case Amount:
                     return formatTxAmount(rec, true,
                                           BitcoinUnits::separatorAlways);
             }
             break;
         case Qt::EditRole:
             // Edit role is used for sorting, so return the unformatted values
             switch (index.column()) {
                 case Status:
                     return QString::fromStdString(rec->status.sortKey);
                 case Date:
                     return rec->time;
                 case Type:
                     return formatTxType(rec);
                 case Watchonly:
                     return (rec->involvesWatchAddress ? 1 : 0);
                 case ToAddress:
                     return formatTxToAddress(rec, true);
                 case Amount:
                     return qint64((rec->credit + rec->debit) / SATOSHI);
             }
             break;
         case Qt::ToolTipRole:
             return formatTooltip(rec);
         case Qt::TextAlignmentRole:
             return column_alignments[index.column()];
         case Qt::ForegroundRole:
             // Use the "danger" color for abandoned transactions
             if (rec->status.status == TransactionStatus::Abandoned) {
                 return COLOR_TX_STATUS_DANGER;
             }
             // Non-confirmed (but not immature) as transactions are grey
             if (!rec->status.countsForBalance &&
                 rec->status.status != TransactionStatus::Immature) {
                 return COLOR_UNCONFIRMED;
             }
             if (index.column() == Amount &&
                 (rec->credit + rec->debit) < ::Amount::zero()) {
                 return COLOR_NEGATIVE;
             }
             if (index.column() == ToAddress) {
                 return addressColor(rec);
             }
             break;
         case TypeRole:
             return rec->type;
         case DateRole:
             return QDateTime::fromTime_t(static_cast<uint>(rec->time));
         case WatchonlyRole:
             return rec->involvesWatchAddress;
         case WatchonlyDecorationRole:
             return txWatchonlyDecoration(rec);
         case LongDescriptionRole:
             return priv->describe(
                 walletModel->node(), walletModel->wallet(), rec,
                 walletModel->getOptionsModel()->getDisplayUnit());
         case AddressRole:
             return QString::fromStdString(rec->address);
         case LabelRole:
             return walletModel->getAddressTableModel()->labelForAddress(
                 QString::fromStdString(rec->address));
         case AmountRole:
             return qint64((rec->credit + rec->debit) / SATOSHI);
         case TxIDRole:
             return rec->getTxID();
         case TxHashRole:
             return QString::fromStdString(rec->txid.ToString());
         case TxHexRole:
             return priv->getTxHex(walletModel->wallet(), rec);
         case TxPlainTextRole: {
             QString details;
             QDateTime date =
                 QDateTime::fromTime_t(static_cast<uint>(rec->time));
             QString txLabel =
                 walletModel->getAddressTableModel()->labelForAddress(
                     QString::fromStdString(rec->address));
 
             details.append(date.toString("M/d/yy HH:mm"));
             details.append(" ");
             details.append(formatTxStatus(rec));
             details.append(". ");
             if (!formatTxType(rec).isEmpty()) {
                 details.append(formatTxType(rec));
                 details.append(" ");
             }
             if (!rec->address.empty()) {
                 if (txLabel.isEmpty()) {
                     details.append(tr("(no label)") + " ");
                 } else {
                     details.append("(");
                     details.append(txLabel);
                     details.append(") ");
                 }
                 details.append(QString::fromStdString(rec->address));
                 details.append(" ");
             }
             details.append(
                 formatTxAmount(rec, false, BitcoinUnits::separatorNever));
             return details;
         }
         case ConfirmedRole:
             return rec->status.countsForBalance;
         case FormattedAmountRole:
             // Used for copy/export, so don't include separators
             return formatTxAmount(rec, false, BitcoinUnits::separatorNever);
         case StatusRole:
             return rec->status.status;
     }
     return QVariant();
 }
 
 QVariant TransactionTableModel::headerData(int section,
                                            Qt::Orientation orientation,
                                            int role) const {
     if (orientation == Qt::Horizontal) {
         if (role == Qt::DisplayRole) {
             return columns[section];
         } else if (role == Qt::TextAlignmentRole) {
             return column_alignments[section];
         } else if (role == Qt::ToolTipRole) {
             switch (section) {
                 case Status:
                     return tr("Transaction status. Hover over this field to "
                               "show number of confirmations.");
                 case Date:
                     return tr(
                         "Date and time that the transaction was received.");
                 case Type:
                     return tr("Type of transaction.");
                 case Watchonly:
                     return tr("Whether or not a watch-only address is involved "
                               "in this transaction.");
                 case ToAddress:
                     return tr(
                         "User-defined intent/purpose of the transaction.");
                 case Amount:
                     return tr("Amount removed from or added to balance.");
             }
         }
     }
     return QVariant();
 }
 
 QModelIndex TransactionTableModel::index(int row, int column,
                                          const QModelIndex &parent) const {
     Q_UNUSED(parent);
     TransactionRecord *data = priv->index(walletModel->wallet(), row);
     if (data) {
         return createIndex(row, column,
                            priv->index(walletModel->wallet(), row));
     }
     return QModelIndex();
 }
 
 void TransactionTableModel::updateDisplayUnit() {
     // emit dataChanged to update Amount column with the current unit
     updateAmountColumnTitle();
     Q_EMIT dataChanged(index(0, Amount), index(priv->size() - 1, Amount));
 }
 
 // queue notifications to show a non freezing progress dialog e.g. for rescan
 struct TransactionNotification {
 public:
     TransactionNotification() {}
     TransactionNotification(TxId _txid, ChangeType _status,
                             bool _showTransaction)
         : txid(_txid), status(_status), showTransaction(_showTransaction) {}
 
     void invoke(QObject *ttm) {
         QString strHash = QString::fromStdString(txid.GetHex());
         qDebug() << "NotifyTransactionChanged: " + strHash +
                         " status= " + QString::number(status);
         QMetaObject::invokeMethod(ttm, "updateTransaction",
                                   Qt::QueuedConnection, Q_ARG(QString, strHash),
                                   Q_ARG(int, status),
                                   Q_ARG(bool, showTransaction));
     }
 
 private:
     TxId txid;
     ChangeType status;
     bool showTransaction;
 };
 
 static bool fQueueNotifications = false;
 static std::vector<TransactionNotification> vQueueNotifications;
 
 static void NotifyTransactionChanged(TransactionTableModel *ttm,
                                      const TxId &txid, ChangeType status) {
     // Find transaction in wallet
     // Determine whether to show transaction or not (determine this here so that
     // no relocking is needed in GUI thread)
     bool showTransaction = TransactionRecord::showTransaction();
 
     TransactionNotification notification(txid, status, showTransaction);
 
     if (fQueueNotifications) {
         vQueueNotifications.push_back(notification);
         return;
     }
     notification.invoke(ttm);
 }
 
 static void ShowProgress(TransactionTableModel *ttm, const std::string &title,
                          int nProgress) {
     if (nProgress == 0) {
         fQueueNotifications = true;
     }
 
     if (nProgress == 100) {
         fQueueNotifications = false;
         if (vQueueNotifications.size() > 10) {
             // prevent balloon spam, show maximum 10 balloons
             QMetaObject::invokeMethod(ttm, "setProcessingQueuedTransactions",
                                       Qt::QueuedConnection, Q_ARG(bool, true));
         }
 
         for (size_t i = 0; i < vQueueNotifications.size(); ++i) {
             if (vQueueNotifications.size() - i <= 10) {
                 QMetaObject::invokeMethod(
                     ttm, "setProcessingQueuedTransactions",
                     Qt::QueuedConnection, Q_ARG(bool, false));
             }
 
             vQueueNotifications[i].invoke(ttm);
         }
 
         // clear
         std::vector<TransactionNotification>().swap(vQueueNotifications);
     }
 }
 
 void TransactionTableModel::subscribeToCoreSignals() {
     // Connect signals to wallet
     m_handler_transaction_changed =
         walletModel->wallet().handleTransactionChanged(
             std::bind(NotifyTransactionChanged, this, std::placeholders::_1,
                       std::placeholders::_2));
     m_handler_show_progress =
         walletModel->wallet().handleShowProgress(std::bind(
             ShowProgress, this, std::placeholders::_1, std::placeholders::_2));
 }
 
 void TransactionTableModel::unsubscribeFromCoreSignals() {
     // Disconnect signals from wallet
     m_handler_transaction_changed->disconnect();
     m_handler_show_progress->disconnect();
 }
diff --git a/src/qt/utilitydialog.cpp b/src/qt/utilitydialog.cpp
index de9acc2a6a..22ebeafb41 100644
--- a/src/qt/utilitydialog.cpp
+++ b/src/qt/utilitydialog.cpp
@@ -1,173 +1,177 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/utilitydialog.h>
 
 #include <clientversion.h>
 #include <init.h>
 #include <interfaces/node.h>
 #include <qt/bitcoingui.h>
 #include <qt/clientmodel.h>
 #include <qt/forms/ui_helpmessagedialog.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #include <qt/intro.h>
 #ifdef ENABLE_BIP70
 #include <qt/paymentrequestplus.h>
 #endif
 #include <util/system.h>
 
 #include <QCloseEvent>
 #include <QLabel>
 #include <QRegExp>
 #include <QTextCursor>
 #include <QTextTable>
 #include <QVBoxLayout>
 
 #include <cstdio>
 
 /** "Help message" or "About" dialog box */
 HelpMessageDialog::HelpMessageDialog(interfaces::Node &node, QWidget *parent,
                                      bool about)
     : QDialog(parent), ui(new Ui::HelpMessageDialog) {
     ui->setupUi(this);
 
     QString version = tr(PACKAGE_NAME) + " " + tr("version") + " " +
                       QString::fromStdString(FormatFullVersion());
 /**
  * On x86 add a bit specifier to the version so that users can distinguish
  * between 32 and 64 bit builds. On other architectures, 32/64 bit may be more
  * ambiguous.
  */
 #if defined(__x86_64__)
     version += " " + tr("(%1-bit)").arg(64);
 #elif defined(__i386__)
     version += " " + tr("(%1-bit)").arg(32);
 #endif
 
     if (about) {
         setWindowTitle(tr("About %1").arg(tr(PACKAGE_NAME)));
 
         /// HTML-format the license message from the core
         QString licenseInfo = QString::fromStdString(LicenseInfo());
         QString licenseInfoHTML = licenseInfo;
         // Make URLs clickable
         QRegExp uri("<(.*)>", Qt::CaseSensitive, QRegExp::RegExp2);
         uri.setMinimal(true); // use non-greedy matching
         licenseInfoHTML.replace(uri, "<a href=\"\\1\">\\1</a>");
         // Replace newlines with HTML breaks
         licenseInfoHTML.replace("\n", "<br>");
 
         ui->aboutMessage->setTextFormat(Qt::RichText);
         ui->scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
         text = version + "\n" + licenseInfo;
         ui->aboutMessage->setText(version + "<br><br>" + licenseInfoHTML);
         ui->aboutMessage->setWordWrap(true);
         ui->helpMessage->setVisible(false);
     } else {
         setWindowTitle(tr("Command-line options"));
         QString header =
             "Usage:  bitcoin-qt [command-line options]                     \n";
         QTextCursor cursor(ui->helpMessage->document());
         cursor.insertText(version);
         cursor.insertBlock();
         cursor.insertText(header);
         cursor.insertBlock();
 
         std::string strUsage = gArgs.GetHelpMessage();
         QString coreOptions = QString::fromStdString(strUsage);
         text = version + "\n\n" + header + "\n" + coreOptions;
 
         QTextTableFormat tf;
         tf.setBorderStyle(QTextFrameFormat::BorderStyle_None);
         tf.setCellPadding(2);
         QVector<QTextLength> widths;
         widths << QTextLength(QTextLength::PercentageLength, 35);
         widths << QTextLength(QTextLength::PercentageLength, 65);
         tf.setColumnWidthConstraints(widths);
 
         QTextCharFormat bold;
         bold.setFontWeight(QFont::Bold);
 
         for (const QString &line : coreOptions.split("\n")) {
             if (line.startsWith("  -")) {
                 cursor.currentTable()->appendRows(1);
                 cursor.movePosition(QTextCursor::PreviousCell);
                 cursor.movePosition(QTextCursor::NextRow);
                 cursor.insertText(line.trimmed());
                 cursor.movePosition(QTextCursor::NextCell);
             } else if (line.startsWith("   ")) {
                 cursor.insertText(line.trimmed() + ' ');
             } else if (line.size() > 0) {
                 // Title of a group
-                if (cursor.currentTable()) cursor.currentTable()->appendRows(1);
+                if (cursor.currentTable()) {
+                    cursor.currentTable()->appendRows(1);
+                }
                 cursor.movePosition(QTextCursor::Down);
                 cursor.insertText(line.trimmed(), bold);
                 cursor.insertTable(1, 2, tf);
             }
         }
 
         ui->helpMessage->moveCursor(QTextCursor::Start);
         ui->scrollArea->setVisible(false);
         ui->aboutLogo->setVisible(false);
     }
 }
 
 HelpMessageDialog::~HelpMessageDialog() {
     delete ui;
 }
 
 void HelpMessageDialog::printToConsole() {
     // On other operating systems, the expected action is to print the message
     // to the console.
     fprintf(stdout, "%s\n", qPrintable(text));
 }
 
 void HelpMessageDialog::showOrPrint() {
 #if defined(WIN32)
     // On Windows, show a message box, as there is no stderr/stdout in windowed
     // applications
     exec();
 #else
     // On other operating systems, print help text to console
     printToConsole();
 #endif
 }
 
 void HelpMessageDialog::on_okButton_accepted() {
     close();
 }
 
 /** "Shutdown" window */
 ShutdownWindow::ShutdownWindow(QWidget *parent, Qt::WindowFlags f)
     : QWidget(parent, f) {
     QVBoxLayout *layout = new QVBoxLayout();
     layout->addWidget(new QLabel(
         tr("%1 is shutting down...").arg(tr(PACKAGE_NAME)) + "<br /><br />" +
         tr("Do not shut down the computer until this window disappears.")));
     setLayout(layout);
 }
 
 QWidget *ShutdownWindow::showShutdownWindow(BitcoinGUI *window) {
-    if (!window) return nullptr;
+    if (!window) {
+        return nullptr;
+    }
 
     // Show a simple window indicating shutdown status
     QWidget *shutdownWindow = new ShutdownWindow();
     shutdownWindow->setWindowTitle(window->windowTitle());
 
     // Center shutdown window at where main window was
     const QPoint global = window->mapToGlobal(window->rect().center());
     shutdownWindow->move(global.x() - shutdownWindow->width() / 2,
                          global.y() - shutdownWindow->height() / 2);
     shutdownWindow->show();
     return shutdownWindow;
 }
 
 void ShutdownWindow::closeEvent(QCloseEvent *event) {
     event->ignore();
 }