diff --git a/src/qt/bitcoinunits.cpp b/src/qt/bitcoinunits.cpp
index 477f1f6f4..55f050e60 100644
--- a/src/qt/bitcoinunits.cpp
+++ b/src/qt/bitcoinunits.cpp
@@ -1,240 +1,259 @@
 // 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/bitcoinunits.h>
 
 #include <currencyunit.h>
 #include <network.h>
 #include <util/system.h>
 
 #include <QStringList>
 
+#include <cassert>
+
 // clang-format off
 using unitNameMap =
     std::map<
         BitcoinUnits::Unit,
         std::tuple<
             QString /* longname */,
             QString /* description */
         >
     >;
 static const unitNameMap xecUnits = {
     {BitcoinUnits::Unit::base,
         {"XEC",
         "eCash"}},
     {BitcoinUnits::Unit::sub,
         {"Satoshi (sat)",
         "Satoshi (sat) (1 / 100)"}},
 };
 static const unitNameMap bchUnits = {
     {BitcoinUnits::Unit::base,
         {"BCHA",
         "Bitcoins"}},
     {BitcoinUnits::Unit::sub,
         {"Satoshi (sat)",
         "Satoshi (sat) (1 / 100" THIN_SP_UTF8 "000" THIN_SP_UTF8 "000)"}},
 };
 // clang-format on
 
 static const unitNameMap &getUnitsAtRuntime() {
     return gArgs.GetBoolArg("-ecash", DEFAULT_ECASH) ? xecUnits : bchUnits;
 }
 
 BitcoinUnits::BitcoinUnits(QObject *parent)
     : QAbstractListModel(parent), unitlist(availableUnits()) {}
 
 QList<BitcoinUnits::Unit> BitcoinUnits::availableUnits() {
     QList<BitcoinUnits::Unit> unitlist;
     unitlist.append(base);
     unitlist.append(sub);
     return unitlist;
 }
 
 bool BitcoinUnits::valid(int unit) {
     switch (unit) {
         case base:
         case sub:
             return true;
         default:
             return false;
     }
 }
 
 QString BitcoinUnits::longName(int unit) {
     const auto &units = getUnitsAtRuntime();
     auto it = units.find(BitcoinUnits::Unit(unit));
     return it != units.end() ? std::get<0>(it->second) : "???";
 }
 
 QString BitcoinUnits::shortName(int unit) {
     if (unit == sub) {
         return QString("sat");
     }
     return longName(unit);
 }
 
 QString BitcoinUnits::description(int unit) {
     const auto &units = getUnitsAtRuntime();
     auto it = units.find(BitcoinUnits::Unit(unit));
     return it != units.end() ? std::get<1>(it->second) : "???";
 }
 
 Amount BitcoinUnits::factor(int unit) {
     const auto &currency = Currency::get();
     switch (unit) {
         case base:
             return currency.baseunit;
         case sub:
             return currency.subunit;
         default:
             assert(false && "non-existent BitcoinUnits::Unit");
     }
 }
 
 int BitcoinUnits::decimals(int unit) {
     switch (unit) {
         case base:
             return Currency::get().decimals;
         case sub:
             return 0;
         default:
             assert(false && "non-existent BitcoinUnits::Unit");
     }
 }
 
 QString BitcoinUnits::format(int unit, const Amount nIn, bool fPlus,
-                             SeparatorStyle separators) {
+                             SeparatorStyle separators, bool justify) {
     // Note: not using straight sprintf here because we do NOT want
     // localized number formatting.
     if (!valid(unit)) {
         // Refuse to format invalid unit
         return QString();
     }
     qint64 n = qint64(nIn / SATOSHI);
     qint64 coin = factor(unit) / SATOSHI;
     int num_decimals = decimals(unit);
     qint64 n_abs = (n > 0 ? n : -n);
     qint64 quotient = n_abs / coin;
     QString quotient_str = QString::number(quotient);
+    if (justify) {
+        quotient_str = quotient_str.rightJustified(16 - num_decimals, ' ');
+    }
 
     // Use SI-style thin space separators as these are locale independent and
     // can't be confused with the decimal marker.
     QChar thin_sp(THIN_SP_CP);
     int q_size = quotient_str.size();
     if (separators == separatorAlways ||
         (separators == separatorStandard && q_size > 4)) {
         for (int i = 3; i < q_size; i += 3) {
             quotient_str.insert(q_size - i, thin_sp);
         }
     }
 
     if (n < 0) {
         quotient_str.insert(0, '-');
     } else if (fPlus && n > 0) {
         quotient_str.insert(0, '+');
     }
 
     if (num_decimals > 0) {
         qint64 remainder = n_abs % coin;
         QString remainder_str =
             QString::number(remainder).rightJustified(num_decimals, '0');
         return quotient_str + QString(".") + remainder_str;
     } else {
         return quotient_str;
     }
 }
 
 // NOTE: Using formatWithUnit in an HTML context risks wrapping
 // quantities at the thousands separator. More subtly, it also results
 // in a standard space rather than a thin space, due to a bug in Qt's
 // XML whitespace canonicalisation
 //
 // Please take care to use formatHtmlWithUnit instead, when
 // appropriate.
 
 QString BitcoinUnits::formatWithUnit(int unit, const Amount amount,
                                      bool plussign, SeparatorStyle separators) {
     return format(unit, amount, plussign, separators) + QString(" ") +
            shortName(unit);
 }
 
 QString BitcoinUnits::formatHtmlWithUnit(int unit, const Amount amount,
                                          bool plussign,
                                          SeparatorStyle separators) {
     QString str(formatWithUnit(unit, amount, plussign, separators));
     str.replace(QChar(THIN_SP_CP), QString(THIN_SP_HTML));
     return QString("<span style='white-space: nowrap;'>%1</span>").arg(str);
 }
 
+QString BitcoinUnits::formatWithPrivacy(int unit, const Amount &amount,
+                                        SeparatorStyle separators,
+                                        bool privacy) {
+    assert(amount >= Amount::zero());
+    QString value;
+    if (privacy) {
+        value = format(unit, Amount::zero(), false, separators, true)
+                    .replace('0', '#');
+    } else {
+        value = format(unit, amount, false, separators, true);
+    }
+    return value + QString(" ") + shortName(unit);
+}
+
 bool BitcoinUnits::parse(int unit, const QString &value, Amount *val_out) {
     if (!valid(unit) || value.isEmpty()) {
         // Refuse to parse invalid unit or empty string
         return false;
     }
     int num_decimals = decimals(unit);
 
     // Ignore spaces and thin spaces when parsing
     QStringList parts = removeSpaces(value).split(".");
 
     if (parts.size() > 2) {
         // More than one dot
         return false;
     }
     QString whole = parts[0];
     QString decimals;
 
     if (parts.size() > 1) {
         decimals = parts[1];
     }
     if (decimals.size() > num_decimals) {
         // Exceeds max precision
         return false;
     }
     bool ok = false;
     QString str = whole + decimals.leftJustified(num_decimals, '0');
 
     if (str.size() > 18) {
         // Longer numbers will exceed 63 bits
         return false;
     }
     Amount retvalue(int64_t(str.toLongLong(&ok)) * SATOSHI);
     if (val_out) {
         *val_out = retvalue;
     }
     return ok;
 }
 
 QString BitcoinUnits::getAmountColumnTitle(int unit) {
     QString amountTitle = QObject::tr("Amount");
     if (BitcoinUnits::valid(unit)) {
         amountTitle += " (" + BitcoinUnits::shortName(unit) + ")";
     }
     return amountTitle;
 }
 
 int BitcoinUnits::rowCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return unitlist.size();
 }
 
 QVariant BitcoinUnits::data(const QModelIndex &index, int role) const {
     int row = index.row();
     if (row >= 0 && row < unitlist.size()) {
         Unit unit = unitlist.at(row);
         switch (role) {
             case Qt::EditRole:
             case Qt::DisplayRole:
                 return QVariant(longName(unit));
             case Qt::ToolTipRole:
                 return QVariant(description(unit));
             case UnitRole:
                 return QVariant(static_cast<int>(unit));
         }
     }
     return QVariant();
 }
 
 Amount BitcoinUnits::maxMoney() {
     return MAX_MONEY;
 }
diff --git a/src/qt/bitcoinunits.h b/src/qt/bitcoinunits.h
index 3025c90f6..e38570d31 100644
--- a/src/qt/bitcoinunits.h
+++ b/src/qt/bitcoinunits.h
@@ -1,106 +1,111 @@
 // 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_BITCOINUNITS_H
 #define BITCOIN_QT_BITCOINUNITS_H
 
 #include <amount.h>
 
 #include <QAbstractListModel>
 #include <QString>
 
 // U+2009 THIN SPACE = UTF-8 E2 80 89
 #define REAL_THIN_SP_CP 0x2009
 #define REAL_THIN_SP_UTF8 "\xE2\x80\x89"
 
 // QMessageBox seems to have a bug whereby it doesn't display thin/hair spaces
 // correctly. Workaround is to display a space in a small font. If you change
 // this, please test that it doesn't cause the parent span to start wrapping.
 #define HTML_HACK_SP                                                           \
     "<span style='white-space: nowrap; font-size: 6pt'> </span>"
 
 // Define THIN_SP_* variables to be our preferred type of thin space
 #define THIN_SP_CP REAL_THIN_SP_CP
 #define THIN_SP_UTF8 REAL_THIN_SP_UTF8
 #define THIN_SP_HTML HTML_HACK_SP
 
 /**
  * Bitcoin unit definitions. Encapsulates parsing and formatting and serves as
  * list model for drop-down selection boxes.
  */
 class BitcoinUnits : public QAbstractListModel {
     Q_OBJECT
 
 public:
     explicit BitcoinUnits(QObject *parent);
 
     /**
      * Currency units
      * Please add only sensible ones.
      */
     enum Unit { base, sub };
 
     enum SeparatorStyle { separatorNever, separatorStandard, separatorAlways };
 
     //! @name Static API
     //! Unit conversion and formatting
     ///@{
 
     //! Get list of units, for drop-down box
     static QList<Unit> availableUnits();
     //! Is unit ID valid?
     static bool valid(int unit);
     //! Long name
     static QString longName(int unit);
     //! Short name
     static QString shortName(int unit);
     //! Longer description
     static QString description(int unit);
     //! Number of Satoshis (1e-8) per unit
     static Amount factor(int unit);
     //! Number of decimals left
     static int decimals(int unit);
     //! Format as string
     static QString format(int unit, const Amount amount, bool plussign = false,
-                          SeparatorStyle separators = separatorStandard);
+                          SeparatorStyle separators = separatorStandard,
+                          bool justify = false);
     //! Format as string (with unit)
     static QString
     formatWithUnit(int unit, const Amount amount, bool plussign = false,
                    SeparatorStyle separators = separatorStandard);
     //! Format as HTML string (with unit)
     static QString
     formatHtmlWithUnit(int unit, const Amount amount, bool plussign = false,
                        SeparatorStyle separators = separatorStandard);
+    //! Format as string (with unit) of fixed length to preserve privacy, if it
+    //! is set.
+    static QString formatWithPrivacy(int unit, const Amount &amount,
+                                     SeparatorStyle separators, bool privacy);
     //! Parse string to coin amount
     static bool parse(int unit, const QString &value, Amount *val_out);
     //! Gets title for amount column including current display unit if
     //! optionsModel reference available */
     static QString getAmountColumnTitle(int unit);
     ///@}
 
     //! @name AbstractListModel implementation
     //! List model for unit drop-down selection box.
     ///@{
     enum RoleIndex {
         /** Unit identifier */
         UnitRole = Qt::UserRole
     };
     int rowCount(const QModelIndex &parent) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     ///@}
 
     static QString removeSpaces(QString text) {
         text.remove(' ');
         text.remove(QChar(THIN_SP_CP));
         return text;
     }
 
     //! Return maximum number of base units (Satoshis)
     static Amount maxMoney();
 
 private:
     QList<BitcoinUnits::Unit> unitlist;
 };
 
 #endif // BITCOIN_QT_BITCOINUNITS_H