diff --git a/src/qt/walletview.cpp b/src/qt/walletview.cpp
index 735a01523..51162a7c9 100644
--- a/src/qt/walletview.cpp
+++ b/src/qt/walletview.cpp
@@ -1,333 +1,355 @@
 // 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 "walletview.h"
 
 #include "addressbookpage.h"
 #include "askpassphrasedialog.h"
 #include "bitcoingui.h"
 #include "clientmodel.h"
 #include "guiutil.h"
 #include "optionsmodel.h"
 #include "overviewpage.h"
 #include "platformstyle.h"
 #include "receivecoinsdialog.h"
 #include "sendcoinsdialog.h"
 #include "signverifymessagedialog.h"
 #include "transactiontablemodel.h"
 #include "transactionview.h"
 #include "walletmodel.h"
 
 #include "ui_interface.h"
 
 #include <QAction>
 #include <QActionGroup>
 #include <QFileDialog>
 #include <QHBoxLayout>
 #include <QProgressDialog>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 WalletView::WalletView(const PlatformStyle *_platformStyle, const Config *cfg,
                        QWidget *parent)
     : QStackedWidget(parent), clientModel(0), walletModel(0),
       platformStyle(_platformStyle) {
     // Create tabs
     overviewPage = new OverviewPage(platformStyle);
 
     transactionsPage = new QWidget(this);
     QVBoxLayout *vbox = new QVBoxLayout();
     QHBoxLayout *hbox_buttons = new QHBoxLayout();
     transactionView = new TransactionView(platformStyle, this);
     vbox->addWidget(transactionView);
     QPushButton *exportButton = new QPushButton(tr("&Export"), this);
     exportButton->setToolTip(
         tr("Export the data in the current tab to a file"));
     if (platformStyle->getImagesOnButtons()) {
         exportButton->setIcon(platformStyle->SingleColorIcon(":/icons/export"));
     }
     hbox_buttons->addStretch();
     hbox_buttons->addWidget(exportButton);
     vbox->addLayout(hbox_buttons);
     transactionsPage->setLayout(vbox);
 
     receiveCoinsPage = new ReceiveCoinsDialog(platformStyle, cfg);
     sendCoinsPage = new SendCoinsDialog(platformStyle);
 
     usedSendingAddressesPage =
         new AddressBookPage(platformStyle, AddressBookPage::ForEditing,
                             AddressBookPage::SendingTab, this);
     usedReceivingAddressesPage =
         new AddressBookPage(platformStyle, AddressBookPage::ForEditing,
                             AddressBookPage::ReceivingTab, this);
 
     addWidget(overviewPage);
     addWidget(transactionsPage);
     addWidget(receiveCoinsPage);
     addWidget(sendCoinsPage);
 
     // Clicking on a transaction on the overview pre-selects the transaction on
     // the transaction history page
     connect(overviewPage, SIGNAL(transactionClicked(QModelIndex)),
             transactionView, SLOT(focusTransaction(QModelIndex)));
     connect(overviewPage, SIGNAL(outOfSyncWarningClicked()), this,
             SLOT(requestedSyncWarningInfo()));
 
     // Double-clicking on a transaction on the transaction history page shows
     // details
     connect(transactionView, SIGNAL(doubleClicked(QModelIndex)),
             transactionView, SLOT(showDetails()));
 
     // Clicking on "Export" allows to export the transaction list
     connect(exportButton, SIGNAL(clicked()), transactionView,
             SLOT(exportClicked()));
 
     // Pass through messages from sendCoinsPage
     connect(sendCoinsPage, SIGNAL(message(QString, QString, unsigned int)),
             this, SIGNAL(message(QString, QString, unsigned int)));
     // Pass through messages from transactionView
     connect(transactionView, SIGNAL(message(QString, QString, unsigned int)),
             this, SIGNAL(message(QString, QString, unsigned int)));
 }
 
 WalletView::~WalletView() {}
 
 void WalletView::setBitcoinGUI(BitcoinGUI *gui) {
     if (gui) {
         // Clicking on a transaction on the overview page simply sends you to
         // transaction history page
         connect(overviewPage, SIGNAL(transactionClicked(QModelIndex)), gui,
                 SLOT(gotoHistoryPage()));
 
         // Receive and report messages
         connect(this, SIGNAL(message(QString, QString, unsigned int)), gui,
                 SLOT(message(QString, QString, unsigned int)));
 
         // Pass through encryption status changed signals
         connect(this, SIGNAL(encryptionStatusChanged(int)), gui,
                 SLOT(setEncryptionStatus(int)));
 
         // Pass through transaction notifications
         connect(this, SIGNAL(incomingTransaction(QString, int, Amount, QString,
                                                  QString, QString)),
                 gui, SLOT(incomingTransaction(QString, int, Amount, QString,
                                               QString, QString)));
 
         // Connect HD enabled state signal
         connect(this, SIGNAL(hdEnabledStatusChanged(int)), gui,
                 SLOT(setHDStatus(int)));
     }
 }
 
 void WalletView::setClientModel(ClientModel *_clientModel) {
     this->clientModel = _clientModel;
 
     overviewPage->setClientModel(_clientModel);
     sendCoinsPage->setClientModel(_clientModel);
 }
 
 void WalletView::setWalletModel(WalletModel *_walletModel) {
     this->walletModel = _walletModel;
 
     // Put transaction list in tabs
     transactionView->setModel(_walletModel);
     overviewPage->setWalletModel(_walletModel);
     receiveCoinsPage->setModel(_walletModel);
     sendCoinsPage->setModel(_walletModel);
     usedReceivingAddressesPage->setModel(_walletModel->getAddressTableModel());
     usedSendingAddressesPage->setModel(_walletModel->getAddressTableModel());
 
     if (_walletModel) {
         // Receive and pass through messages from wallet model
         connect(_walletModel, SIGNAL(message(QString, QString, unsigned int)),
                 this, SIGNAL(message(QString, QString, unsigned int)));
 
         // Handle changes in encryption status
         connect(_walletModel, SIGNAL(encryptionStatusChanged(int)), this,
                 SIGNAL(encryptionStatusChanged(int)));
         updateEncryptionStatus();
 
         // update HD status
         Q_EMIT hdEnabledStatusChanged(_walletModel->hdEnabled());
 
         // Balloon pop-up for new transaction
         connect(_walletModel->getTransactionTableModel(),
                 SIGNAL(rowsInserted(QModelIndex, int, int)), this,
                 SLOT(processNewTransaction(QModelIndex, int, int)));
 
         // Ask for passphrase if needed
         connect(_walletModel, SIGNAL(requireUnlock()), this,
                 SLOT(unlockWallet()));
 
         // Show progress dialog
         connect(_walletModel, SIGNAL(showProgress(QString, int)), this,
                 SLOT(showProgress(QString, int)));
     }
 }
 
 void WalletView::processNewTransaction(const QModelIndex &parent, int start,
-                                       int /*end*/) {
+                                       int end) {
     // Prevent balloon-spam when initial block download is in progress
-    if (!walletModel || !clientModel || clientModel->inInitialBlockDownload())
+    if (!walletModel || !clientModel || clientModel->inInitialBlockDownload()) {
         return;
+    }
 
     TransactionTableModel *ttm = walletModel->getTransactionTableModel();
-    if (!ttm || ttm->processingQueuedTransactions()) return;
+    if (!ttm || ttm->processingQueuedTransactions()) {
+        return;
+    }
 
     QString date = ttm->index(start, TransactionTableModel::Date, parent)
                        .data()
                        .toString();
     qint64 amount = ttm->index(start, TransactionTableModel::Amount, parent)
                         .data(Qt::EditRole)
                         .toULongLong();
     QString type = ttm->index(start, TransactionTableModel::Type, parent)
                        .data()
                        .toString();
     QModelIndex index = ttm->index(start, 0, parent);
     QString address =
         ttm->data(index, TransactionTableModel::AddressRole).toString();
     QString label =
         ttm->data(index, TransactionTableModel::LabelRole).toString();
 
     Q_EMIT incomingTransaction(date,
                                walletModel->getOptionsModel()->getDisplayUnit(),
-                               Amount(amount), type, address, label);
+                               int64_t(amount) * SATOSHI, type, address, label);
 }
 
 void WalletView::gotoOverviewPage() {
     setCurrentWidget(overviewPage);
 }
 
 void WalletView::gotoHistoryPage() {
     setCurrentWidget(transactionsPage);
 }
 
 void WalletView::gotoReceiveCoinsPage() {
     setCurrentWidget(receiveCoinsPage);
 }
 
 void WalletView::gotoSendCoinsPage(QString addr) {
     setCurrentWidget(sendCoinsPage);
 
-    if (!addr.isEmpty()) sendCoinsPage->setAddress(addr);
+    if (!addr.isEmpty()) {
+        sendCoinsPage->setAddress(addr);
+    }
 }
 
 void WalletView::gotoSignMessageTab(QString addr) {
     // calls show() in showTab_SM()
     SignVerifyMessageDialog *signVerifyMessageDialog =
         new SignVerifyMessageDialog(platformStyle, this);
     signVerifyMessageDialog->setAttribute(Qt::WA_DeleteOnClose);
     signVerifyMessageDialog->setModel(walletModel);
     signVerifyMessageDialog->showTab_SM(true);
 
-    if (!addr.isEmpty()) signVerifyMessageDialog->setAddress_SM(addr);
+    if (!addr.isEmpty()) {
+        signVerifyMessageDialog->setAddress_SM(addr);
+    }
 }
 
 void WalletView::gotoVerifyMessageTab(QString addr) {
     // calls show() in showTab_VM()
     SignVerifyMessageDialog *signVerifyMessageDialog =
         new SignVerifyMessageDialog(platformStyle, this);
     signVerifyMessageDialog->setAttribute(Qt::WA_DeleteOnClose);
     signVerifyMessageDialog->setModel(walletModel);
     signVerifyMessageDialog->showTab_VM(true);
 
-    if (!addr.isEmpty()) signVerifyMessageDialog->setAddress_VM(addr);
+    if (!addr.isEmpty()) {
+        signVerifyMessageDialog->setAddress_VM(addr);
+    }
 }
 
 bool WalletView::handlePaymentRequest(const SendCoinsRecipient &recipient) {
     return sendCoinsPage->handlePaymentRequest(recipient);
 }
 
 void WalletView::showOutOfSyncWarning(bool fShow) {
     overviewPage->showOutOfSyncWarning(fShow);
 }
 
 void WalletView::updateEncryptionStatus() {
     Q_EMIT encryptionStatusChanged(walletModel->getEncryptionStatus());
 }
 
 void WalletView::encryptWallet(bool status) {
-    if (!walletModel) return;
+    if (!walletModel) {
+        return;
+    }
+
     AskPassphraseDialog dlg(status ? AskPassphraseDialog::Encrypt
                                    : AskPassphraseDialog::Decrypt,
                             this);
     dlg.setModel(walletModel);
     dlg.exec();
 
     updateEncryptionStatus();
 }
 
 void WalletView::backupWallet() {
     QString filename =
         GUIUtil::getSaveFileName(this, tr("Backup Wallet"), QString(),
                                  tr("Wallet Data (*.dat)"), nullptr);
 
-    if (filename.isEmpty()) return;
+    if (filename.isEmpty()) {
+        return;
+    }
 
     if (!walletModel->backupWallet(filename)) {
         Q_EMIT message(
             tr("Backup Failed"),
             tr("There was an error trying to save the wallet data to %1.")
                 .arg(filename),
             CClientUIInterface::MSG_ERROR);
     } else {
         Q_EMIT message(
             tr("Backup Successful"),
             tr("The wallet data was successfully saved to %1.").arg(filename),
             CClientUIInterface::MSG_INFORMATION);
     }
 }
 
 void WalletView::changePassphrase() {
     AskPassphraseDialog dlg(AskPassphraseDialog::ChangePass, this);
     dlg.setModel(walletModel);
     dlg.exec();
 }
 
 void WalletView::unlockWallet() {
-    if (!walletModel) return;
+    if (!walletModel) {
+        return;
+    }
+
     // Unlock wallet when requested by wallet model
     if (walletModel->getEncryptionStatus() == WalletModel::Locked) {
         AskPassphraseDialog dlg(AskPassphraseDialog::Unlock, this);
         dlg.setModel(walletModel);
         dlg.exec();
     }
 }
 
 void WalletView::usedSendingAddresses() {
-    if (!walletModel) return;
+    if (!walletModel) {
+        return;
+    }
 
     usedSendingAddressesPage->show();
     usedSendingAddressesPage->raise();
     usedSendingAddressesPage->activateWindow();
 }
 
 void WalletView::usedReceivingAddresses() {
-    if (!walletModel) return;
+    if (!walletModel) {
+        return;
+    }
 
     usedReceivingAddressesPage->show();
     usedReceivingAddressesPage->raise();
     usedReceivingAddressesPage->activateWindow();
 }
 
 void WalletView::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 (nProgress == 100) {
         if (progressDialog) {
             progressDialog->close();
             progressDialog->deleteLater();
         }
-    } else if (progressDialog)
+    } else if (progressDialog) {
         progressDialog->setValue(nProgress);
+    }
 }
 
 void WalletView::requestedSyncWarningInfo() {
     Q_EMIT outOfSyncWarningClicked();
 }
diff --git a/src/qt/walletview.h b/src/qt/walletview.h
index 2721312d3..8f4ab1559 100644
--- a/src/qt/walletview.h
+++ b/src/qt/walletview.h
@@ -1,141 +1,141 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_QT_WALLETVIEW_H
 #define BITCOIN_QT_WALLETVIEW_H
 
 #include "amount.h"
 
 #include <QStackedWidget>
 
 class BitcoinGUI;
 class ClientModel;
 class OverviewPage;
 class PlatformStyle;
 class ReceiveCoinsDialog;
 class SendCoinsDialog;
 class SendCoinsRecipient;
 class TransactionView;
 class WalletModel;
 class AddressBookPage;
 class Config;
 
 QT_BEGIN_NAMESPACE
 class QModelIndex;
 class QProgressDialog;
 QT_END_NAMESPACE
 
-/*
-  WalletView class. This class represents the view to a single wallet.
-  It was added to support multiple wallet functionality. Each wallet gets its
-  own WalletView instance.
-  It communicates with both the client and the wallet models to give the user an
-  up-to-date view of the
-  current core state.
-*/
+/**
+ * WalletView class. This class represents the view to a single wallet.
+ * It was added to support multiple wallet functionality. Each wallet gets its
+ * own WalletView instance.
+ * It communicates with both the client and the wallet models to give the user
+ * an up-to-date view of the current core state.
+ */
 class WalletView : public QStackedWidget {
     Q_OBJECT
 
 public:
     explicit WalletView(const PlatformStyle *platformStyle, const Config *cfg,
                         QWidget *parent);
     ~WalletView();
 
     void setBitcoinGUI(BitcoinGUI *gui);
-    /** Set the client model.
-        The client model represents the part of the core that communicates with
-       the P2P network, and is wallet-agnostic.
-    */
+    /**
+     * Set the client model.
+     * The client model represents the part of the core that communicates with
+     * the P2P network, and is wallet-agnostic.
+     */
     void setClientModel(ClientModel *clientModel);
-    /** Set the wallet model.
-        The wallet model represents a bitcoin wallet, and offers access to the
-       list of transactions, address book and sending
-        functionality.
-    */
+    /**
+     * Set the wallet model.
+     * The wallet model represents a bitcoin wallet, and offers access to the
+     * list of transactions, address book and sending functionality.
+     */
     void setWalletModel(WalletModel *walletModel);
 
     bool handlePaymentRequest(const SendCoinsRecipient &recipient);
 
     void showOutOfSyncWarning(bool fShow);
 
 private:
     ClientModel *clientModel;
     WalletModel *walletModel;
 
     OverviewPage *overviewPage;
     QWidget *transactionsPage;
     ReceiveCoinsDialog *receiveCoinsPage;
     SendCoinsDialog *sendCoinsPage;
     AddressBookPage *usedSendingAddressesPage;
     AddressBookPage *usedReceivingAddressesPage;
 
     TransactionView *transactionView;
 
     QProgressDialog *progressDialog;
     const PlatformStyle *platformStyle;
 
 public Q_SLOTS:
     /** Switch to overview (home) page */
     void gotoOverviewPage();
     /** Switch to history (transactions) page */
     void gotoHistoryPage();
     /** Switch to receive coins page */
     void gotoReceiveCoinsPage();
     /** Switch to send coins page */
     void gotoSendCoinsPage(QString addr = "");
 
     /** Show Sign/Verify Message dialog and switch to sign message tab */
     void gotoSignMessageTab(QString addr = "");
     /** Show Sign/Verify Message dialog and switch to verify message tab */
     void gotoVerifyMessageTab(QString addr = "");
 
-    /** Show incoming transaction notification for new transactions.
-
-        The new items are those between start and end inclusive, under the given
-       parent item.
-    */
-    void processNewTransaction(const QModelIndex &parent, int start,
-                               int /*end*/);
+    /**
+     * Show incoming transaction notification for new transactions.
+     *
+     * The new items are those between start and end inclusive, under the given
+     * parent item.
+     */
+    void processNewTransaction(const QModelIndex &parent, int start, int end);
     /** Encrypt the wallet */
     void encryptWallet(bool status);
     /** Backup the wallet */
     void backupWallet();
     /** Change encrypted wallet passphrase */
     void changePassphrase();
     /** Ask for passphrase to unlock wallet temporarily */
     void unlockWallet();
 
     /** Show used sending addresses */
     void usedSendingAddresses();
     /** Show used receiving addresses */
     void usedReceivingAddresses();
 
     /** Re-emit encryption status signal */
     void updateEncryptionStatus();
 
     /** Show progress dialog e.g. for rescan */
     void showProgress(const QString &title, int nProgress);
 
     /** User has requested more information about the out of sync state */
     void requestedSyncWarningInfo();
 
 Q_SIGNALS:
     /** Signal that we want to show the main window */
     void showNormalIfMinimized();
     /**  Fired when a message should be reported to the user */
     void message(const QString &title, const QString &message,
                  unsigned int style);
     /** Encryption status of wallet changed */
     void encryptionStatusChanged(int status);
     /** HD-Enabled status of wallet changed (only possible during startup) */
     void hdEnabledStatusChanged(int hdEnabled);
     /** Notify that a new transaction appeared */
     void incomingTransaction(const QString &date, int unit, const Amount amount,
                              const QString &type, const QString &address,
                              const QString &label);
     /** Notify that the out of sync warning icon has been pressed */
     void outOfSyncWarningClicked();
 };
 
 #endif // BITCOIN_QT_WALLETVIEW_H