diff --git a/src/qt/bitcoinamountfield.cpp b/src/qt/bitcoinamountfield.cpp
index 3f5af2b69..d447e6181 100644
--- a/src/qt/bitcoinamountfield.cpp
+++ b/src/qt/bitcoinamountfield.cpp
@@ -1,300 +1,328 @@
 // 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/bitcoinamountfield.h>
 
 #include <qt/bitcoinunits.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #include <qt/qvaluecombobox.h>
 
 #include <QAbstractSpinBox>
 #include <QApplication>
 #include <QHBoxLayout>
 #include <QKeyEvent>
 #include <QLineEdit>
 
 /**
  * QSpinBox that uses fixed-point numbers internally and uses our own
  * formatting/parsing functions.
  */
 class AmountSpinBox : public QAbstractSpinBox {
     Q_OBJECT
 
 public:
-    explicit AmountSpinBox(QWidget *parent)
-        : QAbstractSpinBox(parent), currentUnit(BitcoinUnits::BCH),
-          singleStep(100000 * SATOSHI) {
+    explicit AmountSpinBox(QWidget *parent) {
         setAlignment(Qt::AlignRight);
 
         connect(lineEdit(), &QLineEdit::textEdited, this,
                 &AmountSpinBox::valueChanged);
     }
 
     QValidator::State validate(QString &text, int &pos) const override {
         if (text.isEmpty()) {
             return QValidator::Intermediate;
         }
         bool valid = false;
         parse(text, &valid);
         // Make sure we return Intermediate so that fixup() is called on
         // defocus.
         return valid ? QValidator::Intermediate : QValidator::Invalid;
     }
 
     void fixup(QString &input) const override {
-        bool valid = false;
-        Amount val = parse(input, &valid);
+        bool valid;
+        Amount val;
+
+        if (input.isEmpty() && !m_allow_empty) {
+            valid = true;
+            val = m_min_amount;
+        } else {
+            valid = false;
+            val = parse(input, &valid);
+        }
+
         if (valid) {
+            val = qBound(m_min_amount, val, m_max_amount);
             input = BitcoinUnits::format(currentUnit, val, false,
                                          BitcoinUnits::separatorAlways);
             lineEdit()->setText(input);
         }
     }
 
     Amount value(bool *valid_out = nullptr) const {
         return parse(text(), valid_out);
     }
 
     void setValue(const Amount value) {
         lineEdit()->setText(BitcoinUnits::format(
             currentUnit, value, false, BitcoinUnits::separatorAlways));
         Q_EMIT valueChanged();
     }
 
+    void SetAllowEmpty(bool allow) { m_allow_empty = allow; }
+
+    void SetMinValue(const Amount &value) { m_min_amount = value; }
+
+    void SetMaxValue(const Amount &value) { m_max_amount = value; }
+
     void stepBy(int steps) override {
         bool valid = false;
         Amount val = value(&valid);
         val = val + steps * singleStep;
-        val = qMin(qMax(val, Amount::zero()), BitcoinUnits::maxMoney());
+        val = qBound(m_min_amount, val, m_max_amount);
         setValue(val);
     }
 
     void setDisplayUnit(int unit) {
         bool valid = false;
         Amount val(value(&valid));
         currentUnit = unit;
 
         if (valid) {
             setValue(val);
         } else {
             clear();
         }
     }
 
     void setSingleStep(const Amount step) { singleStep = step; }
 
     QSize minimumSizeHint() const override {
         if (cachedMinimumSizeHint.isEmpty()) {
             ensurePolished();
 
             const QFontMetrics fm(fontMetrics());
             int h = lineEdit()->minimumSizeHint().height();
             int w = GUIUtil::TextWidth(
                 fm, BitcoinUnits::format(BitcoinUnits::BCH,
                                          BitcoinUnits::maxMoney(), false,
                                          BitcoinUnits::separatorAlways));
             // Cursor blinking space.
             w += 2;
 
             QStyleOptionSpinBox opt;
             initStyleOption(&opt);
             QSize hint(w, h);
             QSize extra(35, 6);
             opt.rect.setSize(hint + extra);
             extra +=
                 hint - style()
                            ->subControlRect(QStyle::CC_SpinBox, &opt,
                                             QStyle::SC_SpinBoxEditField, this)
                            .size();
             // Get closer to final result by repeating the calculation.
             opt.rect.setSize(hint + extra);
             extra +=
                 hint - style()
                            ->subControlRect(QStyle::CC_SpinBox, &opt,
                                             QStyle::SC_SpinBoxEditField, this)
                            .size();
             hint += extra;
             hint.setHeight(h);
 
             opt.rect = rect();
 
             cachedMinimumSizeHint =
                 style()
                     ->sizeFromContents(QStyle::CT_SpinBox, &opt, hint, this)
                     .expandedTo(QApplication::globalStrut());
         }
         return cachedMinimumSizeHint;
     }
 
 private:
-    int currentUnit;
-    Amount singleStep;
+    int currentUnit{BitcoinUnits::BCH};
+    Amount singleStep{100000 * SATOSHI};
     mutable QSize cachedMinimumSizeHint;
+    bool m_allow_empty{true};
+    Amount m_min_amount{Amount::zero()};
+    Amount m_max_amount{BitcoinUnits::maxMoney()};
 
     /**
      * Parse a string into a number of base monetary units and
      * return validity.
      * @note Must return 0 if !valid.
      */
     Amount parse(const QString &text, bool *valid_out = nullptr) const {
         Amount val = Amount::zero();
         bool valid = BitcoinUnits::parse(currentUnit, text, &val);
         if (valid) {
             if (val < Amount::zero() || val > BitcoinUnits::maxMoney()) {
                 valid = false;
             }
         }
         if (valid_out) {
             *valid_out = valid;
         }
         return valid ? val : Amount::zero();
     }
 
 protected:
     bool event(QEvent *event) override {
         if (event->type() == QEvent::KeyPress ||
             event->type() == QEvent::KeyRelease) {
             QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
             if (keyEvent->key() == Qt::Key_Comma) {
                 // Translate a comma into a period.
                 QKeyEvent periodKeyEvent(
                     event->type(), Qt::Key_Period, keyEvent->modifiers(), ".",
                     keyEvent->isAutoRepeat(), keyEvent->count());
                 return QAbstractSpinBox::event(&periodKeyEvent);
             }
         }
         return QAbstractSpinBox::event(event);
     }
 
     StepEnabled stepEnabled() const override {
         if (isReadOnly()) {
             // Disable steps when AmountSpinBox is read-only.
             return StepNone;
         }
         if (text().isEmpty()) {
             // Allow step-up with empty field.
             return StepUpEnabled;
         }
 
         StepEnabled rv = StepNone;
         bool valid = false;
         Amount val = value(&valid);
         if (valid) {
-            if (val > Amount::zero()) {
+            if (val > m_min_amount) {
                 rv |= StepDownEnabled;
             }
-            if (val < BitcoinUnits::maxMoney()) {
+            if (val < m_max_amount) {
                 rv |= StepUpEnabled;
             }
         }
         return rv;
     }
 
 Q_SIGNALS:
     void valueChanged();
 };
 
 #include <qt/bitcoinamountfield.moc>
 
 BitcoinAmountField::BitcoinAmountField(QWidget *parent)
     : QWidget(parent), amount(nullptr) {
     amount = new AmountSpinBox(this);
     amount->setLocale(QLocale::c());
     amount->installEventFilter(this);
     amount->setMaximumWidth(240);
 
     QHBoxLayout *layout = new QHBoxLayout(this);
     layout->addWidget(amount);
     unit = new QValueComboBox(this);
     unit->setModel(new BitcoinUnits(this));
     layout->addWidget(unit);
     layout->addStretch(1);
     layout->setContentsMargins(0, 0, 0, 0);
 
     setLayout(layout);
 
     setFocusPolicy(Qt::TabFocus);
     setFocusProxy(amount);
 
     // If one if the widgets changes, the combined content changes as well
     connect(amount, &AmountSpinBox::valueChanged, this,
             &BitcoinAmountField::valueChanged);
     connect(
         unit,
         static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
         this, &BitcoinAmountField::unitChanged);
 
     // Set default based on configuration
     unitChanged(unit->currentIndex());
 }
 
 void BitcoinAmountField::clear() {
     amount->clear();
     unit->setCurrentIndex(0);
 }
 
 void BitcoinAmountField::setEnabled(bool fEnabled) {
     amount->setEnabled(fEnabled);
     unit->setEnabled(fEnabled);
 }
 
 bool BitcoinAmountField::validate() {
     bool valid = false;
     value(&valid);
     setValid(valid);
     return valid;
 }
 
 void BitcoinAmountField::setValid(bool valid) {
     if (valid) {
         amount->setStyleSheet("");
     } else {
         amount->setStyleSheet(STYLE_INVALID);
     }
 }
 
 bool BitcoinAmountField::eventFilter(QObject *object, QEvent *event) {
     if (event->type() == QEvent::FocusIn) {
         // Clear invalid flag on focus
         setValid(true);
     }
     return QWidget::eventFilter(object, event);
 }
 
 QWidget *BitcoinAmountField::setupTabChain(QWidget *prev) {
     QWidget::setTabOrder(prev, amount);
     QWidget::setTabOrder(amount, unit);
     return unit;
 }
 
 Amount BitcoinAmountField::value(bool *valid_out) const {
     return amount->value(valid_out);
 }
 
 void BitcoinAmountField::setValue(const Amount value) {
     amount->setValue(value);
 }
 
+void BitcoinAmountField::SetAllowEmpty(bool allow) {
+    amount->SetAllowEmpty(allow);
+}
+
+void BitcoinAmountField::SetMinValue(const Amount &value) {
+    amount->SetMinValue(value);
+}
+
+void BitcoinAmountField::SetMaxValue(const Amount &value) {
+    amount->SetMaxValue(value);
+}
 void BitcoinAmountField::setReadOnly(bool fReadOnly) {
     amount->setReadOnly(fReadOnly);
 }
 
 void BitcoinAmountField::unitChanged(int idx) {
     // Use description tooltip for current unit for the combobox
     unit->setToolTip(unit->itemData(idx, Qt::ToolTipRole).toString());
 
     // Determine new unit ID
     int newUnit = unit->itemData(idx, BitcoinUnits::UnitRole).toInt();
 
     amount->setDisplayUnit(newUnit);
 }
 
 void BitcoinAmountField::setDisplayUnit(int newUnit) {
     unit->setValue(newUnit);
 }
 
 void BitcoinAmountField::setSingleStep(const Amount step) {
     amount->setSingleStep(step);
 }
diff --git a/src/qt/bitcoinamountfield.h b/src/qt/bitcoinamountfield.h
index e4535fa1a..1277d650b 100644
--- a/src/qt/bitcoinamountfield.h
+++ b/src/qt/bitcoinamountfield.h
@@ -1,74 +1,86 @@
 // Copyright (c) 2011-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_QT_BITCOINAMOUNTFIELD_H
 #define BITCOIN_QT_BITCOINAMOUNTFIELD_H
 
 #include <amount.h>
 
 #include <QWidget>
 
 class AmountSpinBox;
 
 QT_BEGIN_NAMESPACE
 class QValueComboBox;
 QT_END_NAMESPACE
 
 /** Widget for entering bitcoin amounts.
  */
 class BitcoinAmountField : public QWidget {
     Q_OBJECT
 
     Q_PROPERTY(
         Amount value READ value WRITE setValue NOTIFY valueChanged USER true)
 
 public:
     explicit BitcoinAmountField(QWidget *parent = nullptr);
 
     Amount value(bool *value = nullptr) const;
     void setValue(const Amount value);
 
+    /**
+     * If allow empty is set to false the field will be set to the minimum
+     * allowed value if left empty.
+     */
+    void SetAllowEmpty(bool allow);
+
+    /** Set the minimum value in satoshis **/
+    void SetMinValue(const Amount &value);
+
+    /** Set the maximum value in satoshis **/
+    void SetMaxValue(const Amount &value);
+
     /** Set single step in satoshis **/
     void setSingleStep(const Amount step);
 
     /** Make read-only **/
     void setReadOnly(bool fReadOnly);
 
     /** Mark current value as invalid in UI. */
     void setValid(bool valid);
     /** Perform input validation, mark field as invalid if entered value is not
      * valid. */
     bool validate();
 
     /** Change unit used to display amount. */
     void setDisplayUnit(int unit);
 
     /** Make field empty and ready for new input. */
     void clear();
 
     /** Enable/Disable. */
     void setEnabled(bool fEnabled);
 
     /** Qt messes up the tab chain by default in some cases (issue
        https://bugreports.qt-project.org/browse/QTBUG-10907),
         in these cases we have to set it up manually.
     */
     QWidget *setupTabChain(QWidget *prev);
 
 Q_SIGNALS:
     void valueChanged();
 
 protected:
     /** Intercept focus-in event and ',' key presses */
     bool eventFilter(QObject *object, QEvent *event) override;
 
 private:
     AmountSpinBox *amount;
     QValueComboBox *unit;
 
 private Q_SLOTS:
     void unitChanged(int idx);
 };
 
 #endif // BITCOIN_QT_BITCOINAMOUNTFIELD_H