diff --git a/src/amount.h b/src/amount.h
index 34ed52220..b579a1342 100644
--- a/src/amount.h
+++ b/src/amount.h
@@ -1,180 +1,180 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_AMOUNT_H
 #define BITCOIN_AMOUNT_H
 
 #include <serialize.h>
 
 #include <cstdlib>
 #include <ostream>
 #include <string>
 #include <type_traits>
 
 class UniValue;
 
 struct Amount {
 private:
     int64_t amount;
 
     explicit constexpr Amount(int64_t _amount) : amount(_amount) {}
 
 public:
     constexpr Amount() : amount(0) {}
     constexpr Amount(const Amount &other) : amount(other.amount) {}
 
     /**
      * Convenient implicit UniValue conversion operator
      */
     operator UniValue() const;
 
     /**
      * Assignement operator.
      */
     constexpr Amount &operator=(const Amount &other) {
         amount = other.amount;
         return *this;
     }
 
     static constexpr Amount zero() { return Amount(0); }
     static constexpr Amount satoshi() { return Amount(1); }
 
     /**
      * Implement standard operators
      */
     Amount &operator+=(const Amount a) {
         amount += a.amount;
         return *this;
     }
     Amount &operator-=(const Amount a) {
         amount -= a.amount;
         return *this;
     }
 
     /**
      * Equality
      */
     friend constexpr bool operator==(const Amount a, const Amount b) {
         return a.amount == b.amount;
     }
     friend constexpr bool operator!=(const Amount a, const Amount b) {
         return !(a == b);
     }
 
     /**
      * Comparison
      */
     friend constexpr bool operator<(const Amount a, const Amount b) {
         return a.amount < b.amount;
     }
     friend constexpr bool operator>(const Amount a, const Amount b) {
         return b < a;
     }
     friend constexpr bool operator<=(const Amount a, const Amount b) {
         return !(a > b);
     }
     friend constexpr bool operator>=(const Amount a, const Amount b) {
         return !(a < b);
     }
 
     /**
      * Unary minus
      */
     constexpr Amount operator-() const { return Amount(-amount); }
 
     /**
      * Addition and subtraction.
      */
     friend constexpr Amount operator+(const Amount a, const Amount b) {
         return Amount(a.amount + b.amount);
     }
     friend constexpr Amount operator-(const Amount a, const Amount b) {
         return a + -b;
     }
 
     /**
      * Multiplication
      */
     friend constexpr Amount operator*(const int64_t a, const Amount b) {
         return Amount(a * b.amount);
     }
     friend constexpr Amount operator*(const int a, const Amount b) {
         return Amount(a * b.amount);
     }
 
     /**
      * Division
      */
     constexpr int64_t operator/(const Amount b) const {
         return amount / b.amount;
     }
     constexpr Amount operator/(const int64_t b) const {
         return Amount(amount / b);
     }
     constexpr Amount operator/(const int b) const { return Amount(amount / b); }
     Amount &operator/=(const int64_t n) {
         amount /= n;
         return *this;
     }
 
     /**
      * Modulus
      */
     constexpr Amount operator%(const Amount b) const {
         return Amount(amount % b.amount);
     }
     constexpr Amount operator%(const int64_t b) const {
         return Amount(amount % b);
     }
     constexpr Amount operator%(const int b) const { return Amount(amount % b); }
 
     /**
      * Do not implement double ops to get an error with double and ensure
      * casting to integer is explicit.
      */
     friend constexpr Amount operator*(const double a, const Amount b) = delete;
     constexpr Amount operator/(const double b) const = delete;
     constexpr Amount operator%(const double b) const = delete;
 
     // ostream support
     friend std::ostream &operator<<(std::ostream &stream, const Amount &ca) {
         return stream << ca.amount;
     }
 
     std::string ToString() const;
 
     // serialization support
     SERIALIZE_METHODS(Amount, obj) { READWRITE(obj.amount); }
 };
 
 static constexpr Amount SATOSHI = Amount::satoshi();
 static constexpr Amount COIN = 100000000 * SATOSHI;
 
 struct Currency {
     Amount baseunit;
     Amount subunit;
     uint8_t decimals;
     std::string ticker;
 
     static const Currency &get();
 };
 
 /**
  * No amount larger than this (in satoshi) is valid.
  *
- * Note that this constant is *not* the total money supply, which in Bitcoin
- * currently happens to be less than 21,000,000 BCH for various reasons, but
- * rather a sanity check. As this sanity check is used by consensus-critical
+ * Note that this constant is *not* the total money supply, which in eCash
+ * currently happens to be less than 21,000,000 COIN for various reasons,
+ * but rather a sanity check. As this sanity check is used by consensus-critical
  * validation code, the exact value of the MAX_MONEY constant is consensus
  * critical; in unusual circumstances like a(nother) overflow bug that allowed
  * for the creation of coins out of thin air modification could lead to a fork.
  */
 static const Amount MAX_MONEY = 21000000 * COIN;
 inline bool MoneyRange(const Amount nValue) {
     return nValue >= Amount::zero() && nValue <= MAX_MONEY;
 }
 
 #endif // BITCOIN_AMOUNT_H
diff --git a/src/qt/overviewpage.cpp b/src/qt/overviewpage.cpp
index 75a7babd3..7d1c65bb1 100644
--- a/src/qt/overviewpage.cpp
+++ b/src/qt/overviewpage.cpp
@@ -1,336 +1,336 @@
 // 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::base),
           platformStyle(_platformStyle) {}
 
     inline void paint(QPainter *painter, const QStyleOptionViewItem &option,
                       const QModelIndex &index) const override {
         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 override {
         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(nullptr),
       walletModel(nullptr),
       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));
     }
 }
 
 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;
     if (walletModel->wallet().isLegacy()) {
         if (walletModel->wallet().privateKeysDisabled()) {
             ui->labelBalance->setText(BitcoinUnits::formatWithUnit(
                 unit, balances.watch_only_balance, false,
                 BitcoinUnits::separatorAlways));
             ui->labelUnconfirmed->setText(BitcoinUnits::formatWithUnit(
                 unit, balances.unconfirmed_watch_only_balance, false,
                 BitcoinUnits::separatorAlways));
             ui->labelImmature->setText(BitcoinUnits::formatWithUnit(
                 unit, balances.immature_watch_only_balance, false,
                 BitcoinUnits::separatorAlways));
             ui->labelTotal->setText(BitcoinUnits::formatWithUnit(
                 unit,
                 balances.watch_only_balance +
                     balances.unconfirmed_watch_only_balance +
                     balances.immature_watch_only_balance,
                 false, BitcoinUnits::separatorAlways));
         } else {
             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));
         }
     } else {
         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));
     }
 
     // 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);
     // show watch-only immature balance
     ui->labelWatchImmature->setVisible(
         !walletModel->wallet().privateKeysDisabled() && showWatchOnlyImmature);
 }
 
 // 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, for example 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() &&
                               !model->wallet().privateKeysDisabled());
         connect(model, &WalletModel::notifyWatchonlyChanged,
                 [this](bool showWatchOnly) {
                     updateWatchOnlyLabels(
                         showWatchOnly &&
                         !walletModel->wallet().privateKeysDisabled());
                 });
     }
 
-    // update the display unit, to not use the default ("BCH")
+    // update the display unit, to not use the default ("XEC")
     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/sendcoinsentry.cpp b/src/qt/sendcoinsentry.cpp
index b188c33d7..f8cb253e2 100644
--- a/src/qt/sendcoinsentry.cpp
+++ b/src/qt/sendcoinsentry.cpp
@@ -1,310 +1,310 @@
 // 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_sendcoinsentry.h>
 #include <qt/sendcoinsentry.h>
 
 #include <config.h>
 #include <qt/addressbookpage.h>
 #include <qt/addresstablemodel.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/walletmodel.h>
 
 #include <QApplication>
 #include <QClipboard>
 
 SendCoinsEntry::SendCoinsEntry(const PlatformStyle *_platformStyle,
                                WalletModel *_model, QWidget *parent)
     : QStackedWidget(parent), ui(new Ui::SendCoinsEntry), model(_model),
       platformStyle(_platformStyle) {
     ui->setupUi(this);
 
     ui->addressBookButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/address-book"));
     ui->pasteButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/editpaste"));
     ui->deleteButton->setIcon(platformStyle->SingleColorIcon(":/icons/remove"));
     ui->deleteButton_is->setIcon(
         platformStyle->SingleColorIcon(":/icons/remove"));
     ui->deleteButton_s->setIcon(
         platformStyle->SingleColorIcon(":/icons/remove"));
 
     setCurrentWidget(ui->SendCoins);
 
     if (platformStyle->getUseExtraSpacing()) {
         ui->payToLayout->setSpacing(4);
     }
 
     // normal bitcoin address field
     GUIUtil::setupAddressWidget(ui->payTo, this);
     // just a label for displaying bitcoin address(es)
     ui->payTo_is->setFont(GUIUtil::fixedPitchFont());
 
     // Connect signals
     connect(ui->payAmount, &BitcoinAmountField::valueChanged, this,
             &SendCoinsEntry::payAmountChanged);
     connect(ui->checkboxSubtractFeeFromAmount, &QCheckBox::toggled, this,
             &SendCoinsEntry::subtractFeeFromAmountChanged);
     connect(ui->deleteButton, &QPushButton::clicked, this,
             &SendCoinsEntry::deleteClicked);
     connect(ui->deleteButton_is, &QPushButton::clicked, this,
             &SendCoinsEntry::deleteClicked);
     connect(ui->deleteButton_s, &QPushButton::clicked, this,
             &SendCoinsEntry::deleteClicked);
     connect(ui->useAvailableBalanceButton, &QPushButton::clicked, this,
             &SendCoinsEntry::useAvailableBalanceClicked);
 
     // Set the model properly.
     setModel(model);
 }
 
 SendCoinsEntry::~SendCoinsEntry() {
     delete ui;
 }
 
 void SendCoinsEntry::on_pasteButton_clicked() {
     // Paste text from clipboard into recipient field
     ui->payTo->setText(QApplication::clipboard()->text());
 }
 
 void SendCoinsEntry::on_addressBookButton_clicked() {
     if (!model) {
         return;
     }
     AddressBookPage dlg(platformStyle, AddressBookPage::ForSelection,
                         AddressBookPage::SendingTab, this);
     dlg.setModel(model->getAddressTableModel());
     if (dlg.exec()) {
         ui->payTo->setText(dlg.getReturnValue());
         ui->payAmount->setFocus();
     }
 }
 
 void SendCoinsEntry::on_payTo_textChanged(const QString &address) {
     updateLabel(address);
 }
 
 void SendCoinsEntry::setModel(WalletModel *_model) {
     this->model = _model;
 
     if (_model) {
         ui->messageTextLabel->setToolTip(
             tr("A message that was attached to the %1 URI which will be stored "
                "with the transaction for your reference. Note: This message "
                "will not be sent over the Bitcoin network.")
                 .arg(QString::fromStdString(
                     _model->getChainParams().CashAddrPrefix())));
     }
 
     if (_model && _model->getOptionsModel()) {
         connect(_model->getOptionsModel(), &OptionsModel::displayUnitChanged,
                 this, &SendCoinsEntry::updateDisplayUnit);
     }
 
     clear();
 }
 
 void SendCoinsEntry::clear() {
     // clear UI elements for normal payment
     ui->payTo->clear();
     ui->addAsLabel->clear();
     ui->payAmount->clear();
     ui->checkboxSubtractFeeFromAmount->setCheckState(Qt::Unchecked);
     ui->messageTextLabel->clear();
     ui->messageTextLabel->hide();
     ui->messageLabel->hide();
     // clear UI elements for unauthenticated payment request
     ui->payTo_is->clear();
     ui->memoTextLabel_is->clear();
     ui->payAmount_is->clear();
     // clear UI elements for authenticated payment request
     ui->payTo_s->clear();
     ui->memoTextLabel_s->clear();
     ui->payAmount_s->clear();
 
-    // update the display unit, to not use the default ("BCH")
+    // update the display unit, to not use the default ("XEC")
     updateDisplayUnit();
 }
 
 void SendCoinsEntry::checkSubtractFeeFromAmount() {
     ui->checkboxSubtractFeeFromAmount->setChecked(true);
 }
 
 void SendCoinsEntry::deleteClicked() {
     Q_EMIT removeEntry(this);
 }
 
 void SendCoinsEntry::useAvailableBalanceClicked() {
     Q_EMIT useAvailableBalance(this);
 }
 
 bool SendCoinsEntry::validate(interfaces::Node &node) {
     if (!model) {
         return false;
     }
 
     // Check input validity
     bool retval = true;
 
 #ifdef ENABLE_BIP70
     // Skip checks for payment request
     if (recipient.paymentRequest.IsInitialized()) {
         return retval;
     }
 #endif
 
     if (!model->validateAddress(ui->payTo->text())) {
         ui->payTo->setValid(false);
         retval = false;
     }
 
     if (!ui->payAmount->validate()) {
         retval = false;
     }
 
     // Sending a zero amount is invalid
     if (ui->payAmount->value(nullptr) <= Amount::zero()) {
         ui->payAmount->setValid(false);
         retval = false;
     }
 
     // Reject dust outputs:
     if (retval &&
         GUIUtil::isDust(node, ui->payTo->text(), ui->payAmount->value(),
                         model->getChainParams())) {
         ui->payAmount->setValid(false);
         retval = false;
     }
 
     return retval;
 }
 
 SendCoinsRecipient SendCoinsEntry::getValue() {
 #ifdef ENABLE_BIP70
     // Payment request
     if (recipient.paymentRequest.IsInitialized()) {
         return recipient;
     }
 #endif
 
     // Normal payment
     recipient.address = ui->payTo->text();
     recipient.label = ui->addAsLabel->text();
     recipient.amount = ui->payAmount->value();
     recipient.message = ui->messageTextLabel->text();
     recipient.fSubtractFeeFromAmount =
         (ui->checkboxSubtractFeeFromAmount->checkState() == Qt::Checked);
 
     return recipient;
 }
 
 QWidget *SendCoinsEntry::setupTabChain(QWidget *prev) {
     QWidget::setTabOrder(prev, ui->payTo);
     QWidget::setTabOrder(ui->payTo, ui->addAsLabel);
     QWidget *w = ui->payAmount->setupTabChain(ui->addAsLabel);
     QWidget::setTabOrder(w, ui->checkboxSubtractFeeFromAmount);
     QWidget::setTabOrder(ui->checkboxSubtractFeeFromAmount,
                          ui->addressBookButton);
     QWidget::setTabOrder(ui->addressBookButton, ui->pasteButton);
     QWidget::setTabOrder(ui->pasteButton, ui->deleteButton);
     return ui->deleteButton;
 }
 
 void SendCoinsEntry::setValue(const SendCoinsRecipient &value) {
     recipient = value;
 
 #ifdef ENABLE_BIP70
     // payment request
     if (recipient.paymentRequest.IsInitialized()) {
         // unauthenticated
         if (recipient.authenticatedMerchant.isEmpty()) {
             ui->payTo_is->setText(recipient.address);
             ui->memoTextLabel_is->setText(recipient.message);
             ui->payAmount_is->setValue(recipient.amount);
             ui->payAmount_is->setReadOnly(true);
             setCurrentWidget(ui->SendCoins_UnauthenticatedPaymentRequest);
         }
 
         // authenticated
         else {
             ui->payTo_s->setText(recipient.authenticatedMerchant);
             ui->memoTextLabel_s->setText(recipient.message);
             ui->payAmount_s->setValue(recipient.amount);
             ui->payAmount_s->setReadOnly(true);
             setCurrentWidget(ui->SendCoins_AuthenticatedPaymentRequest);
         }
     }
 
     // normal payment
     else
 #endif
     {
         // message
         ui->messageTextLabel->setText(recipient.message);
         ui->messageTextLabel->setVisible(!recipient.message.isEmpty());
         ui->messageLabel->setVisible(!recipient.message.isEmpty());
 
         ui->addAsLabel->clear();
         // this may set a label from addressbook
         ui->payTo->setText(recipient.address);
         // if a label had been set from the addressbook, don't overwrite with an
         // empty label
         if (!recipient.label.isEmpty()) {
             ui->addAsLabel->setText(recipient.label);
         }
         ui->payAmount->setValue(recipient.amount);
     }
 }
 
 void SendCoinsEntry::setAddress(const QString &address) {
     ui->payTo->setText(address);
     ui->payAmount->setFocus();
 }
 
 void SendCoinsEntry::setAmount(const Amount amount) {
     ui->payAmount->setValue(amount);
 }
 
 bool SendCoinsEntry::isClear() {
     return ui->payTo->text().isEmpty() && ui->payTo_is->text().isEmpty() &&
            ui->payTo_s->text().isEmpty();
 }
 
 void SendCoinsEntry::setFocus() {
     ui->payTo->setFocus();
 }
 
 void SendCoinsEntry::updateDisplayUnit() {
     if (model && model->getOptionsModel()) {
         // Update payAmount with the current unit
         ui->payAmount->setDisplayUnit(
             model->getOptionsModel()->getDisplayUnit());
         ui->payAmount_is->setDisplayUnit(
             model->getOptionsModel()->getDisplayUnit());
         ui->payAmount_s->setDisplayUnit(
             model->getOptionsModel()->getDisplayUnit());
     }
 }
 
 bool SendCoinsEntry::updateLabel(const QString &address) {
     if (!model) {
         return false;
     }
 
     // Fill in label from address book, if address has an associated label
     QString associatedLabel =
         model->getAddressTableModel()->labelForAddress(address);
     if (!associatedLabel.isEmpty()) {
         ui->addAsLabel->setText(associatedLabel);
         return true;
     }
 
     return false;
 }
diff --git a/src/qt/test/paymentrequestdata.h b/src/qt/test/paymentrequestdata.h
index c5a850d22..b6435f77f 100644
--- a/src/qt/test/paymentrequestdata.h
+++ b/src/qt/test/paymentrequestdata.h
@@ -1,456 +1,457 @@
 // 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.
 
 #ifndef BITCOIN_QT_TEST_PAYMENTREQUESTDATA_H
 #define BITCOIN_QT_TEST_PAYMENTREQUESTDATA_H
 
 //
 // Data for paymentservertests.cpp
 //
 
 // Base64/DER-encoded fake certificate authority certificates.
 // Convert pem to base64/der with:
 // openssl x509 -in cert.pem -inform PEM -outform DER | openssl enc -base64
 
 // Serial Number: 10302349811211485352 (0x8ef94c91b112c0a8)
 // Issuer: CN=PaymentRequest Test CA
 // Subject: CN=PaymentRequest Test CA
 // Not Valid After : Dec  8 16:37:24 2022 GMT
 //
 const char *caCert1_BASE64 = "\
 MIIB0DCCATmgAwIBAgIJAI75TJGxEsCoMA0GCSqGSIb3DQEBCwUAMCExHzAdBgNV\
 BAMTFlBheW1lbnRSZXF1ZXN0IFRlc3QgQ0EwHhcNMTIxMjEwMTYzNzI0WhcNMjIx\
 MjA4MTYzNzI0WjAhMR8wHQYDVQQDExZQYXltZW50UmVxdWVzdCBUZXN0IENBMIGf\
 MA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCvua59nX9radoqDYyplcns5qdVDTN1\
 7tmcGixmMYOYU3UYMU55VSsJs0dWKnMm3COQDY+N63c0XSbRqarBcsLTkaNASuPX\
 FCv1VWuEKSyy5xe4zeoDU7CVSzlxtQD9wbZW/s3ISjgaXBpwn6eVmntb0JwYxxPc\
 M1u/hrMD8BDbSQIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUA\
 A4GBADSaRgK5xe47XxycXBhHhr0Wgl4pAsFsufqA9aB9r8KNEHJ0yUvvbD/jaJJM\
 RtQcf0AJ9olzUMY4syehxbzUJP6aeXhZEYiMvdvcv9D55clq6+WLLlNT3jBgAaVn\
 p3waRjPD4bUX3nv+ojz5s4puw7Qq5QUZlhGsMzPvwDGCmZkL\
 ";
 
 // Serial Number: f0:da:97:e4:38:d7:64:16
 // Issuer: CN=PaymentRequest Test CA
 // Subject: CN=PaymentRequest Test CA
 // Not Valid After : Jan  8 18:21:06 2025 GMT
 //
 const char *caCert2_BASE64 = "\
 MIIC1TCCAb2gAwIBAgIJAPDal+Q412QWMA0GCSqGSIb3DQEBCwUAMCExHzAdBgNV\
 BAMMFlBheW1lbnRSZXF1ZXN0IFRlc3QgQ0EwHhcNMTUwMTExMTgyMTA2WhcNMjUw\
 MTA4MTgyMTA2WjAhMR8wHQYDVQQDDBZQYXltZW50UmVxdWVzdCBUZXN0IENBMIIB\
 IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA1S9wVLfTplJuT/1OaaBgl/Mb\
 I392v8S9kHbzYz7B4OTMslaO7piz0v3SO3TKMh0dswjiRdHrIgpO7XdIUQiU/ugg\
 xDw0kuNehfz1ycaGedlFFtFHTNXqLyIUF3dlwHhQwaomM6RXoJmxLny5BhYHEcmk\
 yWwr3Cdjd9gAZpblugVJB9C1e40uyL8ao4PHdLzOqO27iSe6riP8SwwisJZEbMaz\
 AZpgNEEMbIXPJEFvm5HTRXSMtQCOTSZYMFF0M2yrtmlECnz7hWP19b9bcoDzZQB4\
 ylIsFG/7q2jV7MC/e2STZv+niJiHL08RUdoFpAgzaxMgqj63C7B55HgNDNHJYQID\
 AQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQBGejPxLxj9\
 +crv6gUeEBMZPiUx7pUgcI22Wm5yymP96B4fwI3Y0DBehq20d76vbWGPN17Z6pH3\
 ge7PVY1SYqXtS6hXTo4olCm/BZADli+2Bs2xCiaa+Ltve4ufVej+bKJXN/YnrhvO\
 Kq+klQkuuHywU+GJV/NQeBqToIrSOBgi477NgLFCCCmmx2QWsxHoCFGfuRCBVseT\
 z2k/tMuALCDXGeZBRPTsGHu1y4cj84swAeoDK5QSQcI+Ub7GKc+zkoj02sdDLiMo\
 3wokYPcIy47oclhmb4xubHc+y7nF610yZBoC/zgbhbawnZ65hDDWkdQ/SVAnWZD7\
 9PFfmNnYPTQH\
 ";
 
 //
 // This payment request validates directly against the
 // caCert1 certificate authority.
 //
 const char *paymentrequest1_cert1_BASE64 = "\
 Egt4NTA5K3NoYTI1NhrxAwruAzCCAeowggFToAMCAQICAQEwDQYJKoZIhvcNAQEL\
 BQAwITEfMB0GA1UEAxMWUGF5bWVudFJlcXVlc3QgVGVzdCBDQTAeFw0xMjEyMTAx\
 NjM3MjRaFw0yMjEyMDgxNjM3MjRaMEMxGTAXBgNVBAMMEHRlc3RtZXJjaGFudC5v\
 cmcxJjAkBgNVBAoMHVBheW1lbnQgUmVxdWVzdCBUZXN0IE1lcmNoYW50MIGfMA0G\
 CSqGSIb3DQEBAQUAA4GNADCBiQKBgQDHkMy8W1u6HsWlSqdWTmMKf54gICxNfxbY\
 +rcMtAftr62hCYx2d2QiSRd1pCUzmo12IiSX3WxSHwaTnT3MFD6jRx6+zM6XdGar\
 I2zpYle11ANzu4gAthN17uRQHV2O5QxVtzNaMdKeJLXT2L9tfEdyL++9ZUqoQmdA\
 YG9ix330hQIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4GB\
 AIkyO99KC68bi9PFRyQQ7nvn5GlQEb3Ca1bRG5+AKN9N5vc8rZ9G2hejtM8wEXni\
 eGBP+chVMsbTPEHKLrwREn7IvcyCcbAStaklPC3w0B/2idQSHskb6P3X13OR2bTH\
 a2+6wuhsOZRUrVNr24rM95DKx/eCC6JN1VW+qRPU6fqzIjQSHwiw2wYSGXapFJVg\
 igPI+6XpExtNLO/i1WFV8ZmoiKwYsuHFiwUqC1VuaXRUZXN0T25lKoABS0j59iMU\
 Uc9MdIfwsO1BskIET0eJSGNZ7eXb9N62u+qf831PMpEHkmlGpk8rHy92nPcgua/U\
 Yt8oZMn3QaTZ5A6HjJbc3A73eLylp1a0SwCl+KDMEvDQhqMn1jAVu2v92AH3uB7n\
 SiWVbw0tX/68iSQEGGfh9n6ee/8Myb3ICdw=\
 ";
 
 //
 // Signed, but expired, merchant cert in the request
 //
 const char *paymentrequest2_cert1_BASE64 = "\
 Egt4NTA5K3NoYTI1NhrsAwrpAzCCAeUwggFOoAMCAQICAQMwDQYJKoZIhvcNAQEL\
 BQAwITEfMB0GA1UEAxMWUGF5bWVudFJlcXVlc3QgVGVzdCBDQTAeFw0xMzAyMjMy\
 MTI2NDNaFw0xMzAyMjQyMTI2NDNaMD4xHDAaBgNVBAMME2V4cGlyZWRtZXJjaGFu\
 dC5vcmcxHjAcBgNVBAoMFUV4cGlyZWQgVGVzdCBNZXJjaGFudDCBnzANBgkqhkiG\
 9w0BAQEFAAOBjQAwgYkCgYEAx5DMvFtbuh7FpUqnVk5jCn+eICAsTX8W2Pq3DLQH\
 7a+toQmMdndkIkkXdaQlM5qNdiIkl91sUh8Gk509zBQ+o0cevszOl3RmqyNs6WJX\
 tdQDc7uIALYTde7kUB1djuUMVbczWjHSniS109i/bXxHci/vvWVKqEJnQGBvYsd9\
 9IUCAwEAAaMQMA4wDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOBgQAaU137\
 j53rvSjlmYZpZ4RWTP7EdD6fl5ZxBeXHytN6DQL33H0eD7OFHt+ofc7E6D7keubl\
 UfCu+jOvt/MvvPUmtCI9yXZ0dNC4sjyETv+wQpxO0UNZwOM4uegdCzlo6Bi3pD4/\
 KKLdMkWuUfuPBmoammny74lZaOVr5deKXztTuCI0Eh8IsNsGEhl2qRSVYIoDyPul\
 6RMbTSzv4tVhVfGZqIisGLLhxYsFKgtVbml0VGVzdFR3byqAAXHuo4nZEPniLpkd\
 y30TkwBxVgprWJ18a9z/7Py35Qss/JMbOXbnBhJtmJCdIowHRI0aa+zqt3KKKAXi\
 mm+V4seMgxTcxMS+eDDkiTcB/RtWWSyRcS2ANjFeY0T4SLMwiCL9qWPi03hr8j96\
 tejrSPOBNSJ3Mi/q5u2Yl4gJZY2b\
 ";
 
 //
 // 10-long certificate chain, all intermediates valid
 //
 const char *paymentrequest3_cert1_BASE64 = "\
 Egt4NTA5K3NoYTI1Nhq8JAr/AzCCAfswggFkoAMCAQICAQEwDQYJKoZIhvcNAQEL\
 BQAwPzEUMBIGA1UEAwwLdGVzdGNhOC5vcmcxJzAlBgNVBAoMHlBheW1lbnQgUmVx\
 dWVzdCBJbnRlcm1lZGlhdGUgODAeFw0xMzAyMjMyMjQyMzFaFw0yMzAyMjEyMjQy\
 MzFaMDYxGjAYBgNVBAMMEXRlc3RtZXJjaGFudDgub3JnMRgwFgYDVQQKDA9UZXN0\
 IE1lcmNoYW50IDgwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMMCHA3hiHbS\
 TKZ5K9jHRwE8NxkGp3IOx56PDB2diNkldG8XweTcRq7bBm7pdiBt4IVggtfs+6hE\
 hDYIOecyoAnVzPFTdvQ7KQdQ/fD9YLe6lk+o0edOqutPMyrxLFjSluXxEQyk7fdt\
 URloMMYfp3p1/hFCboA1rAsQ2RW38hR5AgMBAAGjEDAOMAwGA1UdEwQFMAMBAf8w\
 DQYJKoZIhvcNAQELBQADgYEAPsdFatnc2RJSpvZsw+nCiPVsllycw5ELglq9vfJz\
 nJJucRxgzmqI2iuas1ugwbXn0BEIRLK7vMF/qBzQR6M/nTxttah+KEu+okjps9vJ\
 cIyhfTyGPC5xkHaHZ7sG+UHOFhPw0/kXn0x+pbVgBZ5315axqcp1R+DTSj/whMAr\
 n0AKiAQwggIEMIIBbaADAgECAgECMA0GCSqGSIb3DQEBCwUAMD8xFDASBgNVBAMM\
 C3Rlc3RjYTcub3JnMScwJQYDVQQKDB5QYXltZW50IFJlcXVlc3QgSW50ZXJtZWRp\
 YXRlIDcwHhcNMTMwMjIzMjI0MjMxWhcNMjMwMjIxMjI0MjMxWjA/MRQwEgYDVQQD\
 DAt0ZXN0Y2E4Lm9yZzEnMCUGA1UECgweUGF5bWVudCBSZXF1ZXN0IEludGVybWVk\
 aWF0ZSA4MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDexUFfxb1sThvabp7u\
 dZz59ciThGmmAW0nP4tjrgEACgvWIInr2dZpTHbiQNF34ycsk0le1JD93D7Qb8rd\
 25OrpaO8XS2Li2zjR9cleixXjSLwV/zv8zJ8yPl/27XL++PDTKBXVpJ8/Syp+9Ty\
 plV1BqDhqtIHb/QSHEkTQXjeYQIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqG\
 SIb3DQEBCwUAA4GBACMooQVbkbIZ2DaPwHDc4ULwguG3VI2Kzj50UdExmHtzm2S4\
 MQei+n+HEPjtJAx5OY520+10nfuP+12H2DRLQmWmdvDpeQ/Cv0yavlw4ZRejRFo7\
 KS83C0wo5rd+qTvvOmAN4UTArWkzYcEUulPdiXnRamb0WQHTeVdIbHVkMormCogE\
 MIICBDCCAW2gAwIBAgIBAjANBgkqhkiG9w0BAQsFADA/MRQwEgYDVQQDDAt0ZXN0\
 Y2E2Lm9yZzEnMCUGA1UECgweUGF5bWVudCBSZXF1ZXN0IEludGVybWVkaWF0ZSA2\
 MB4XDTEzMDIyMzIyNDIzMVoXDTIzMDIyMTIyNDIzMVowPzEUMBIGA1UEAwwLdGVz\
 dGNhNy5vcmcxJzAlBgNVBAoMHlBheW1lbnQgUmVxdWVzdCBJbnRlcm1lZGlhdGUg\
 NzCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAtjBRazrkebXAhXsbjimrMIRm\
 W/f9SwAHwXfc042keNtl0t2z6XE6UPcR2v/KrssXuCZgodeYxz6IM6lWosCM1xot\
 C3ChKKFBfVO30reuKBRUxXfKAFqxaG0YOAEzdZkkY9AGhqWloeSmgxpIfhInU0EF\
 JjCwrJ6IkijBatGoAAECAwEAAaMQMA4wDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0B\
 AQsFAAOBgQDBRTi1MolmOA0niHYX0A2lN5QWHkCfX0A7GwyoMA3dvM45m/NYd4WB\
 X+HwfnfYcI6X9jOgNo5OWmc4GGsld0HlxwMYEKISBS9PbSHPBrb3TBOlw5ztQpXZ\
 91+bOhLux52Fr03sK7v9qExmBM12M8UR2ltpzAMiUgLLMHyPfiWkvQqIBDCCAgQw\
 ggFtoAMCAQICAQIwDQYJKoZIhvcNAQELBQAwPzEUMBIGA1UEAwwLdGVzdGNhNS5v\
 cmcxJzAlBgNVBAoMHlBheW1lbnQgUmVxdWVzdCBJbnRlcm1lZGlhdGUgNTAeFw0x\
 MzAyMjMyMjQyMzBaFw0yMzAyMjEyMjQyMzBaMD8xFDASBgNVBAMMC3Rlc3RjYTYu\
 b3JnMScwJQYDVQQKDB5QYXltZW50IFJlcXVlc3QgSW50ZXJtZWRpYXRlIDYwgZ8w\
 DQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANJSH3xivX1t9olIdHsznI1aE9SD7t9i\
 SZJsIB0otoETHZRVv9M9LvyzBNK98ZV+kTOlST7PJgC0d9BQM9sgYApSRq5oqKDM\
 9FXbOm/yaReAbU3mkFNFw5roTlJ5ThEy0yOGT/DS0YBRaGIvRPRj2DiqDVdCZZ+w\
 4jo1IYHkZt4FAgMBAAGjEDAOMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQELBQAD\
 gYEATm6+J1OmbrothO60xALKonWMBKr6hudb4amkFBqKbA9wMeM3jl+I/yKfz/Uf\
 xWuJ071IhiNv6Gxx5YwNvhUe1xMhUqHv0gpyK1Z47bD+kYS2se5sWNPNo3Y9qZDG\
 IXiGQxwHmrzaFk79Uy1xsmvsEz42w6hr25Yaw7HkIgrFveoKiAQwggIEMIIBbaAD\
 AgECAgECMA0GCSqGSIb3DQEBCwUAMD8xFDASBgNVBAMMC3Rlc3RjYTQub3JnMScw\
 JQYDVQQKDB5QYXltZW50IFJlcXVlc3QgSW50ZXJtZWRpYXRlIDQwHhcNMTMwMjIz\
 MjI0MjMwWhcNMjMwMjIxMjI0MjMwWjA/MRQwEgYDVQQDDAt0ZXN0Y2E1Lm9yZzEn\
 MCUGA1UECgweUGF5bWVudCBSZXF1ZXN0IEludGVybWVkaWF0ZSA1MIGfMA0GCSqG\
 SIb3DQEBAQUAA4GNADCBiQKBgQC7vVUFpxHzz2Tr/xij3k58s8d/BPA0R6D5RXTV\
 vmhAzc1Zuin4zUKRFs/aCj/0yED8Wu/COfNGF4tVlRNMdl9EcFsxa8XGEL4eAZa+\
 H/rOHH+7/1EINrrVWhZlUecyhilN8jmCZmqEM3ecuD0NAViqyMrgmaiFmsLoQZpE\
 GepDUQIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4GBAEdJ\
 Ss8jWiooja3WZzHXeF95QkBJNjIlpDLGcpl4opOYLSuEl9Uxp//LaQQiXuzpj4/I\
 pkWGQmMy5HOyH1lqDyiMgXpcG8PE0jEQAoEUGZ0QEqB1mZ6BCrYvmUuf/5aSVd8Y\
 6lKMR3WzFDYU9Zy0nzuHB/3nvp6MeDRQeRMtYvz4CogEMIICBDCCAW2gAwIBAgIB\
 AjANBgkqhkiG9w0BAQsFADA/MRQwEgYDVQQDDAt0ZXN0Y2EzLm9yZzEnMCUGA1UE\
 CgweUGF5bWVudCBSZXF1ZXN0IEludGVybWVkaWF0ZSAzMB4XDTEzMDIyMzIyNDIy\
 OVoXDTIzMDIyMTIyNDIyOVowPzEUMBIGA1UEAwwLdGVzdGNhNC5vcmcxJzAlBgNV\
 BAoMHlBheW1lbnQgUmVxdWVzdCBJbnRlcm1lZGlhdGUgNDCBnzANBgkqhkiG9w0B\
 AQEFAAOBjQAwgYkCgYEAxYYo3w2UXiYg6O8b4QgwN/vgreTkiW122Ep/z2TiDrhV\
 MhfOOiKdwYESPflfnXnVaQQzCGexYTQqsvqvzHSyna5hL0zPTRJxSKmTVrXRsWtp\
 dCRhjxCGipS3tlQBDi7vb+7SNRIBK4dBjjGzALNk7gMCpy+yM8f6I043jTlmGb0C\
 AwEAAaMQMA4wDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOBgQDU+IQxt3Oh\
 KqaUYWC23+cB2gekvWqwMBnrCNrX/Dp+kjoJKUoR2Fs3qw53raHES4SIhpGT9l9l\
 rppNQgFe/JMHeYqOZMZO+6kuU0olJanBJ14tPIc7zlMTQ9OfmZ6v07IpyFbsQDtR\
 hpe80DpuvSFPfJ4fh0WrQf6kn3KDVpGDnAqIBDCCAgQwggFtoAMCAQICAQIwDQYJ\
 KoZIhvcNAQELBQAwPzEUMBIGA1UEAwwLdGVzdGNhMi5vcmcxJzAlBgNVBAoMHlBh\
 eW1lbnQgUmVxdWVzdCBJbnRlcm1lZGlhdGUgMjAeFw0xMzAyMjMyMjQyMjlaFw0y\
 MzAyMjEyMjQyMjlaMD8xFDASBgNVBAMMC3Rlc3RjYTMub3JnMScwJQYDVQQKDB5Q\
 YXltZW50IFJlcXVlc3QgSW50ZXJtZWRpYXRlIDMwgZ8wDQYJKoZIhvcNAQEBBQAD\
 gY0AMIGJAoGBANzgVP99Qg98e6NsKEz1v5KqRB7NTBRRsYnBvb/TSWipvMQaCYuE\
 yk1xG57x++QuASKeR3QHRQJOoAhQaj9JLUhSSv9GQ5PrFLLsOFv7L1tpzXHh2dOB\
 IW92X2yFRW2s39q+Q21yvN+N8uoKdqXhzRA+dDoXh3cavaVeHX1G+IrlAgMBAAGj\
 EDAOMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQELBQADgYEASTwg84cX+1UhOG9s\
 ejFV3m34QuI1hPZ+qhqVJlRYUtego8Wng1BburDSwqVAv4ch2wi3c2s4e8J7AXyL\
 tzSbSQG4RN0oZi0mR8EtTTN+Mix/hBIk79dMZg85+I29uFA6Zj2d9oAhQv2qkHhc\
 6tcaheNvkQRlCyH68k3iF1Fqf+4KiAQwggIEMIIBbaADAgECAgECMA0GCSqGSIb3\
 DQEBCwUAMD8xFDASBgNVBAMMC3Rlc3RjYTEub3JnMScwJQYDVQQKDB5QYXltZW50\
 IFJlcXVlc3QgSW50ZXJtZWRpYXRlIDEwHhcNMTMwMjIzMjI0MjI5WhcNMjMwMjIx\
 MjI0MjI5WjA/MRQwEgYDVQQDDAt0ZXN0Y2EyLm9yZzEnMCUGA1UECgweUGF5bWVu\
 dCBSZXF1ZXN0IEludGVybWVkaWF0ZSAyMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB\
 iQKBgQDaV8zhfyQuSf/f+fauMfgs3g/RnWy9yxxUkvQneQQPH3uZzCyk3A6q72ip\
 TtwNqiibG9455L9A7SaUjGtnpUz0NKT/VWUdqbfCl1PqXjEZbDobbAQ5hxLGOTyL\
 RQhLIcgeq2/BnmeCqHsC4md04nUp+nBo1HwKyygvK+9sMbCp/wIDAQABoxAwDjAM\
 BgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4GBACvYyE+PPmWFkbjyRu9LAt8D\
 crtyYYLRClKSg6tVvutwukLG2l//kDOohYkJtgTqr6LnCIIIwYdXN+4wxugmw4cn\
 PIZmP6kovxjhhVM95okilor1zniTAo3RN7JDIfTGNgxLdGu1btt7DOFL4zTbeSJM\
 b8M1JpPftehH+x/VLyuUCuoDMIIB5jCCAU+gAwIBAgIBBTANBgkqhkiG9w0BAQsF\
 ADAhMR8wHQYDVQQDExZQYXltZW50UmVxdWVzdCBUZXN0IENBMB4XDTEzMDIyMzIy\
 NDIyOFoXDTIzMDIyMTIyNDIyOFowPzEUMBIGA1UEAwwLdGVzdGNhMS5vcmcxJzAl\
 BgNVBAoMHlBheW1lbnQgUmVxdWVzdCBJbnRlcm1lZGlhdGUgMTCBnzANBgkqhkiG\
 9w0BAQEFAAOBjQAwgYkCgYEAo5Vy9H3nA/OOkF5Ap89yfVNSiTay/LYCaB0eALpc\
 U690U75O9Q3w2M+2AN8wpbbHsJHZMIjEeBRoQfjlYXW1ucQTxWKyT+liu0D25mGX\
 X27CBXBd4iXTxVII/iX+u3lcjORjoHOBy7QgeIDIIS9y0vYu8eArpjh7m4thrVgI\
 RtMCAwEAAaMQMA4wDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOBgQB9LKcV\
 JK9sjASNzpQlpUp7nCiw5FSjVY+XMRIKK/kavzlKjZ+InsmmyRVGjDoZi9GrqG9P\
 VHgLBxi2VtVjmokZoNPqao3OfhqORAubC+JR/JLepM7aDaxDdTHVhSUk4lgNAvi2\
 6dGY7nZMsnHlPQ2tPp/HvRRiMq1oDjlylc8VTCI2Eh8IsNsGEhl2qRSVYIoDyPul\
 6RMbTSzv4tVhVfGZqIisGLLhxYsFKg1Vbml0VGVzdFRocmVlKoABn2HTsUQtMNI4\
 yNvkfkFNka3pRvTUTydJrvyfmEeLzImfM1BWddZjnywku9RToNFZZNgow5QnljmF\
 chhR/aHOuEMTxmc12K4rNlgYtHCsxLP9zd+6u0cva3TucZ6EzS8PKEib/+r12/52\
 664NuWA9WtsK7QCFrK2K95PnVCRmWl0=\
 ";
 
 //
 // Long certificate chain, with an expired certificate in the middle
 //
 const char *paymentrequest4_cert1_BASE64 = "\
 Egt4NTA5K3NoYTI1NhqeJAr/AzCCAfswggFkoAMCAQICAQEwDQYJKoZIhvcNAQEL\
 BQAwPzEUMBIGA1UEAwwLdGVzdGNhOC5vcmcxJzAlBgNVBAoMHlBheW1lbnQgUmVx\
 dWVzdCBJbnRlcm1lZGlhdGUgODAeFw0xMzAyMjMyMjQyMzFaFw0yMzAyMjEyMjQy\
 MzFaMDYxGjAYBgNVBAMMEXRlc3RtZXJjaGFudDgub3JnMRgwFgYDVQQKDA9UZXN0\
 IE1lcmNoYW50IDgwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMMCHA3hiHbS\
 TKZ5K9jHRwE8NxkGp3IOx56PDB2diNkldG8XweTcRq7bBm7pdiBt4IVggtfs+6hE\
 hDYIOecyoAnVzPFTdvQ7KQdQ/fD9YLe6lk+o0edOqutPMyrxLFjSluXxEQyk7fdt\
 URloMMYfp3p1/hFCboA1rAsQ2RW38hR5AgMBAAGjEDAOMAwGA1UdEwQFMAMBAf8w\
 DQYJKoZIhvcNAQELBQADgYEAPsdFatnc2RJSpvZsw+nCiPVsllycw5ELglq9vfJz\
 nJJucRxgzmqI2iuas1ugwbXn0BEIRLK7vMF/qBzQR6M/nTxttah+KEu+okjps9vJ\
 cIyhfTyGPC5xkHaHZ7sG+UHOFhPw0/kXn0x+pbVgBZ5315axqcp1R+DTSj/whMAr\
 n0AKiAQwggIEMIIBbaADAgECAgECMA0GCSqGSIb3DQEBCwUAMD8xFDASBgNVBAMM\
 C3Rlc3RjYTcub3JnMScwJQYDVQQKDB5QYXltZW50IFJlcXVlc3QgSW50ZXJtZWRp\
 YXRlIDcwHhcNMTMwMjIzMjI0MjMxWhcNMjMwMjIxMjI0MjMxWjA/MRQwEgYDVQQD\
 DAt0ZXN0Y2E4Lm9yZzEnMCUGA1UECgweUGF5bWVudCBSZXF1ZXN0IEludGVybWVk\
 aWF0ZSA4MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDexUFfxb1sThvabp7u\
 dZz59ciThGmmAW0nP4tjrgEACgvWIInr2dZpTHbiQNF34ycsk0le1JD93D7Qb8rd\
 25OrpaO8XS2Li2zjR9cleixXjSLwV/zv8zJ8yPl/27XL++PDTKBXVpJ8/Syp+9Ty\
 plV1BqDhqtIHb/QSHEkTQXjeYQIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqG\
 SIb3DQEBCwUAA4GBACMooQVbkbIZ2DaPwHDc4ULwguG3VI2Kzj50UdExmHtzm2S4\
 MQei+n+HEPjtJAx5OY520+10nfuP+12H2DRLQmWmdvDpeQ/Cv0yavlw4ZRejRFo7\
 KS83C0wo5rd+qTvvOmAN4UTArWkzYcEUulPdiXnRamb0WQHTeVdIbHVkMormCogE\
 MIICBDCCAW2gAwIBAgIBAjANBgkqhkiG9w0BAQsFADA/MRQwEgYDVQQDDAt0ZXN0\
 Y2E2Lm9yZzEnMCUGA1UECgweUGF5bWVudCBSZXF1ZXN0IEludGVybWVkaWF0ZSA2\
 MB4XDTEzMDIyMzIyNDIzMVoXDTIzMDIyMTIyNDIzMVowPzEUMBIGA1UEAwwLdGVz\
 dGNhNy5vcmcxJzAlBgNVBAoMHlBheW1lbnQgUmVxdWVzdCBJbnRlcm1lZGlhdGUg\
 NzCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAtjBRazrkebXAhXsbjimrMIRm\
 W/f9SwAHwXfc042keNtl0t2z6XE6UPcR2v/KrssXuCZgodeYxz6IM6lWosCM1xot\
 C3ChKKFBfVO30reuKBRUxXfKAFqxaG0YOAEzdZkkY9AGhqWloeSmgxpIfhInU0EF\
 JjCwrJ6IkijBatGoAAECAwEAAaMQMA4wDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0B\
 AQsFAAOBgQDBRTi1MolmOA0niHYX0A2lN5QWHkCfX0A7GwyoMA3dvM45m/NYd4WB\
 X+HwfnfYcI6X9jOgNo5OWmc4GGsld0HlxwMYEKISBS9PbSHPBrb3TBOlw5ztQpXZ\
 91+bOhLux52Fr03sK7v9qExmBM12M8UR2ltpzAMiUgLLMHyPfiWkvQqIBDCCAgQw\
 ggFtoAMCAQICAQIwDQYJKoZIhvcNAQELBQAwPzEUMBIGA1UEAwwLdGVzdGNhNS5v\
 cmcxJzAlBgNVBAoMHlBheW1lbnQgUmVxdWVzdCBJbnRlcm1lZGlhdGUgNTAeFw0x\
 MzAyMjMyMjQyMzBaFw0yMzAyMjEyMjQyMzBaMD8xFDASBgNVBAMMC3Rlc3RjYTYu\
 b3JnMScwJQYDVQQKDB5QYXltZW50IFJlcXVlc3QgSW50ZXJtZWRpYXRlIDYwgZ8w\
 DQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANJSH3xivX1t9olIdHsznI1aE9SD7t9i\
 SZJsIB0otoETHZRVv9M9LvyzBNK98ZV+kTOlST7PJgC0d9BQM9sgYApSRq5oqKDM\
 9FXbOm/yaReAbU3mkFNFw5roTlJ5ThEy0yOGT/DS0YBRaGIvRPRj2DiqDVdCZZ+w\
 4jo1IYHkZt4FAgMBAAGjEDAOMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQELBQAD\
 gYEATm6+J1OmbrothO60xALKonWMBKr6hudb4amkFBqKbA9wMeM3jl+I/yKfz/Uf\
 xWuJ071IhiNv6Gxx5YwNvhUe1xMhUqHv0gpyK1Z47bD+kYS2se5sWNPNo3Y9qZDG\
 IXiGQxwHmrzaFk79Uy1xsmvsEz42w6hr25Yaw7HkIgrFveoK6gMwggHmMIIBT6AD\
 AgECAgEGMA0GCSqGSIb3DQEBCwUAMCExHzAdBgNVBAMTFlBheW1lbnRSZXF1ZXN0\
 IFRlc3QgQ0EwHhcNMTMwMjIzMjI1OTUxWhcNMTMwMjI0MjI1OTUxWjA/MRQwEgYD\
 VQQDDAt0ZXN0Y2E1Lm9yZzEnMCUGA1UECgweUGF5bWVudCBSZXF1ZXN0IEludGVy\
 bWVkaWF0ZSA1MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC7vVUFpxHzz2Tr\
 /xij3k58s8d/BPA0R6D5RXTVvmhAzc1Zuin4zUKRFs/aCj/0yED8Wu/COfNGF4tV\
 lRNMdl9EcFsxa8XGEL4eAZa+H/rOHH+7/1EINrrVWhZlUecyhilN8jmCZmqEM3ec\
 uD0NAViqyMrgmaiFmsLoQZpEGepDUQIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0G\
 CSqGSIb3DQEBCwUAA4GBAEmcUEnhua/oiXy1fwScLgMqt+jk9mHRpE6SVsIop23Q\
 CY2JfpG6RxhMMzzzhGklEGN6cxG0HCi6B3HJx6PYrFEfTB0rW4K6m0Tvx3WpS9mN\
 uoEuJHLy18ausI/sYAPDHCL+SfBVcqorpaIG2sSpZouRBjRHAyqFAYlwlW87uq5n\
 CogEMIICBDCCAW2gAwIBAgIBAjANBgkqhkiG9w0BAQsFADA/MRQwEgYDVQQDDAt0\
 ZXN0Y2EzLm9yZzEnMCUGA1UECgweUGF5bWVudCBSZXF1ZXN0IEludGVybWVkaWF0\
 ZSAzMB4XDTEzMDIyMzIyNDIyOVoXDTIzMDIyMTIyNDIyOVowPzEUMBIGA1UEAwwL\
 dGVzdGNhNC5vcmcxJzAlBgNVBAoMHlBheW1lbnQgUmVxdWVzdCBJbnRlcm1lZGlh\
 dGUgNDCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAxYYo3w2UXiYg6O8b4Qgw\
 N/vgreTkiW122Ep/z2TiDrhVMhfOOiKdwYESPflfnXnVaQQzCGexYTQqsvqvzHSy\
 na5hL0zPTRJxSKmTVrXRsWtpdCRhjxCGipS3tlQBDi7vb+7SNRIBK4dBjjGzALNk\
 7gMCpy+yM8f6I043jTlmGb0CAwEAAaMQMA4wDAYDVR0TBAUwAwEB/zANBgkqhkiG\
 9w0BAQsFAAOBgQDU+IQxt3OhKqaUYWC23+cB2gekvWqwMBnrCNrX/Dp+kjoJKUoR\
 2Fs3qw53raHES4SIhpGT9l9lrppNQgFe/JMHeYqOZMZO+6kuU0olJanBJ14tPIc7\
 zlMTQ9OfmZ6v07IpyFbsQDtRhpe80DpuvSFPfJ4fh0WrQf6kn3KDVpGDnAqIBDCC\
 AgQwggFtoAMCAQICAQIwDQYJKoZIhvcNAQELBQAwPzEUMBIGA1UEAwwLdGVzdGNh\
 Mi5vcmcxJzAlBgNVBAoMHlBheW1lbnQgUmVxdWVzdCBJbnRlcm1lZGlhdGUgMjAe\
 Fw0xMzAyMjMyMjQyMjlaFw0yMzAyMjEyMjQyMjlaMD8xFDASBgNVBAMMC3Rlc3Rj\
 YTMub3JnMScwJQYDVQQKDB5QYXltZW50IFJlcXVlc3QgSW50ZXJtZWRpYXRlIDMw\
 gZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANzgVP99Qg98e6NsKEz1v5KqRB7N\
 TBRRsYnBvb/TSWipvMQaCYuEyk1xG57x++QuASKeR3QHRQJOoAhQaj9JLUhSSv9G\
 Q5PrFLLsOFv7L1tpzXHh2dOBIW92X2yFRW2s39q+Q21yvN+N8uoKdqXhzRA+dDoX\
 h3cavaVeHX1G+IrlAgMBAAGjEDAOMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEL\
 BQADgYEASTwg84cX+1UhOG9sejFV3m34QuI1hPZ+qhqVJlRYUtego8Wng1BburDS\
 wqVAv4ch2wi3c2s4e8J7AXyLtzSbSQG4RN0oZi0mR8EtTTN+Mix/hBIk79dMZg85\
 +I29uFA6Zj2d9oAhQv2qkHhc6tcaheNvkQRlCyH68k3iF1Fqf+4KiAQwggIEMIIB\
 baADAgECAgECMA0GCSqGSIb3DQEBCwUAMD8xFDASBgNVBAMMC3Rlc3RjYTEub3Jn\
 MScwJQYDVQQKDB5QYXltZW50IFJlcXVlc3QgSW50ZXJtZWRpYXRlIDEwHhcNMTMw\
 MjIzMjI0MjI5WhcNMjMwMjIxMjI0MjI5WjA/MRQwEgYDVQQDDAt0ZXN0Y2EyLm9y\
 ZzEnMCUGA1UECgweUGF5bWVudCBSZXF1ZXN0IEludGVybWVkaWF0ZSAyMIGfMA0G\
 CSqGSIb3DQEBAQUAA4GNADCBiQKBgQDaV8zhfyQuSf/f+fauMfgs3g/RnWy9yxxU\
 kvQneQQPH3uZzCyk3A6q72ipTtwNqiibG9455L9A7SaUjGtnpUz0NKT/VWUdqbfC\
 l1PqXjEZbDobbAQ5hxLGOTyLRQhLIcgeq2/BnmeCqHsC4md04nUp+nBo1HwKyygv\
 K+9sMbCp/wIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4GB\
 ACvYyE+PPmWFkbjyRu9LAt8DcrtyYYLRClKSg6tVvutwukLG2l//kDOohYkJtgTq\
 r6LnCIIIwYdXN+4wxugmw4cnPIZmP6kovxjhhVM95okilor1zniTAo3RN7JDIfTG\
 NgxLdGu1btt7DOFL4zTbeSJMb8M1JpPftehH+x/VLyuUCuoDMIIB5jCCAU+gAwIB\
 AgIBBTANBgkqhkiG9w0BAQsFADAhMR8wHQYDVQQDExZQYXltZW50UmVxdWVzdCBU\
 ZXN0IENBMB4XDTEzMDIyMzIyNDIyOFoXDTIzMDIyMTIyNDIyOFowPzEUMBIGA1UE\
 AwwLdGVzdGNhMS5vcmcxJzAlBgNVBAoMHlBheW1lbnQgUmVxdWVzdCBJbnRlcm1l\
 ZGlhdGUgMTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAo5Vy9H3nA/OOkF5A\
 p89yfVNSiTay/LYCaB0eALpcU690U75O9Q3w2M+2AN8wpbbHsJHZMIjEeBRoQfjl\
 YXW1ucQTxWKyT+liu0D25mGXX27CBXBd4iXTxVII/iX+u3lcjORjoHOBy7QgeIDI\
 IS9y0vYu8eArpjh7m4thrVgIRtMCAwEAAaMQMA4wDAYDVR0TBAUwAwEB/zANBgkq\
 hkiG9w0BAQsFAAOBgQB9LKcVJK9sjASNzpQlpUp7nCiw5FSjVY+XMRIKK/kavzlK\
 jZ+InsmmyRVGjDoZi9GrqG9PVHgLBxi2VtVjmokZoNPqao3OfhqORAubC+JR/JLe\
 pM7aDaxDdTHVhSUk4lgNAvi26dGY7nZMsnHlPQ2tPp/HvRRiMq1oDjlylc8VTCI1\
 Eh8IsNsGEhl2qRSVYIoDyPul6RMbTSzv4tVhVfGZqIisGLLhxYsFKgxVbml0VGVz\
 dEZvdXIqgAEBE1PP93Tkpif35F+dYmXn9kLA/1djcPjCs2o2rwRMM4Uk356O5dgu\
 HXQjsfdR58qZQS9CS5DAtRUf0R8+43/wijO/hb49VNaNXmY+/cPHMkahP2aV3tZi\
 FAyZblLik9A7ZvF+UsjeFQiHB5wzWQvbqk5wQ4yabHIXoYv/E0q+eQ==\
 ";
 
 //
 // Validly signed, but by a CA not in our root CA list
 //
 const char *paymentrequest5_cert1_BASE64 = "\
 Egt4NTA5K3NoYTI1NhrxAwruAzCCAeowggFToAMCAQICAQEwDQYJKoZIhvcNAQEL\
 BQAwITEfMB0GA1UEAxMWUGF5bWVudFJlcXVlc3QgVGVzdCBDQTAeFw0xMzA0MTkx\
 NzIwMDZaFw0yMzA0MTcxNzIwMDZaMEMxGTAXBgNVBAMMEHRlc3RtZXJjaGFudC5v\
 cmcxJjAkBgNVBAoMHVBheW1lbnQgUmVxdWVzdCBUZXN0IE1lcmNoYW50MIGfMA0G\
 CSqGSIb3DQEBAQUAA4GNADCBiQKBgQDhV6Yn47aEEmbl50YLvXoqGEJA51I/40wr\
 Z6VQGdXYaRqYktagrWDlgYY9h0JQ1bQhm8HgW7ju0R4NaDTXUqxg4HjprF0z3Mfm\
 /6mmebkLOOptfkVD7ceAteNI7cyuqWGIAZA7D9mV97mXoCAtTlBUycvkmoiClCCS\
 h0EpF/UTaQIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4GB\
 AGIRwW7I0QvLga+RnJoJSZNZQbtu4rQW3xmoz8WfZMBYXX3QBYg5ftycbdK+/IbP\
 qozfjGW2AS6DNArvpveSPDTK9+GJBNo1paiNtVqwXkC3Ddscv5AIms1eZGiIOQNC\
 mUvdLkpoXo48WAer3EGsZ3B15GyNEELc0q9W5yUebba1IjUSHwiw2wYSGXapFJVg\
 igPI+6XpExtNLO/i1WFV8ZmoiKwYuPvFiwUqDFVuaXRUZXN0Rml2ZSqAAXdsMgdG\
 ssymvca1S/1KeM3n8Ydi2fi1JUzAAr59xPvNJRUeqCLP9upHn5z7br3P12Oz9A20\
 5/4wL4ClPRPVnOHgij0bEg+y0tGESqmF1rfOfXDszlo2U92wCxS07kq79YAZJ1Zo\
 XYh860/Q4wvc7lfiTe+dXBzPKAKhMy91yETY\
 ";
 
 //
 // Contains a testnet paytoaddress, so payment request network doesn't match
 // client network
 //
 const char *paymentrequest1_cert2_BASE64 = "\
 Egt4NTA5K3NoYTI1NhrQBArNBDCCAkkwggExoAMCAQICAQEwDQYJKoZIhvcNAQEL\
 BQAwITEfMB0GA1UEAwwWUGF5bWVudFJlcXVlc3QgVGVzdCBDQTAeFw0xNTAxMTEx\
 ODIxMDhaFw0yNTAxMDgxODIxMDhaMCExHzAdBgNVBAMMFlBheW1lbnRSZXF1ZXN0\
 IFRlc3QgQ0EwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMsZqzkzeBGo+i2N\
 mUak3Ciodr1V7S062VOy7N0OQYNDQHYkgDFAUET7cEb5VJaHPv5m3ppTBpU9xBcf\
 wbHHUt4VjA+mhRmYrl1khjvZM+X8kEqvWn20BtcM9R6r0yIYec8UERDDHBleL/P8\
 RkxEnVLjYTV9zigCXfMsgYb3EQShAgMBAAGjEDAOMAwGA1UdEwQFMAMBAf8wDQYJ\
 KoZIhvcNAQELBQADggEBABUJpl3QCqsoDSxAsQdV6zKT4VGV76AzoGj7etQsQY+r\
 +S26VfWh/fMobEzuxFChr0USgLJ6FoK78hAtoZvt1lrye9yqFv/ig3WLWsJKWHHb\
 3RT6oR03CIwZXFSUasi08QDVLxafwsU5OMcPLucF3a1lRL1ccYrNgVCCx1+X7Bos\
 tIgDGRQQ4AyoHTcfVd2hEGeUv7k14mOxFsAp6851yosHq9Q2kwmdH+rHEJbjof87\
 yyKLagc4owyXBZYkQmkeHWCNqnuRmO5vUsfVb0UUrkD64o7Th/NjwooA7SCiUXl6\
 dfygT1b7ggpx7GC+sP2DsIM47IAZ55drjqX5u2f+Ba0iPQoEdGVzdBIhCIDWwowE\
 Ehl2qRQErGqUUwSsaMpDvWIaGnJGNQqi8oisGNeMy6UFKgxKdXN0IFRlc3Rpbmcq\
 gAFwThsozZxkZxzCn4R8WxNiLFV6m0ye9fEtSbolfaW+EjBMpO03lr/dwNnrclhg\
 ew+A05xfZztrAt16XKEY7qKJ/eY2nLd0fVAIu/nIt+7/VYVXT83zLrWc150aRS7W\
 AdJbL3JOJLs6Eyp5zrPbfI8faRttFAdONKDrJgIpuW1E3g==\
 ";
 
 //
 // Expired payment request (expires is set to 1 = 1970-01-01 00:00:01)
 //
 const char *paymentrequest2_cert2_BASE64 = "\
 Egt4NTA5K3NoYTI1NhrQBArNBDCCAkkwggExoAMCAQICAQEwDQYJKoZIhvcNAQEL\
 BQAwITEfMB0GA1UEAwwWUGF5bWVudFJlcXVlc3QgVGVzdCBDQTAeFw0xNTAxMTEx\
 ODIxMDhaFw0yNTAxMDgxODIxMDhaMCExHzAdBgNVBAMMFlBheW1lbnRSZXF1ZXN0\
 IFRlc3QgQ0EwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMsZqzkzeBGo+i2N\
 mUak3Ciodr1V7S062VOy7N0OQYNDQHYkgDFAUET7cEb5VJaHPv5m3ppTBpU9xBcf\
 wbHHUt4VjA+mhRmYrl1khjvZM+X8kEqvWn20BtcM9R6r0yIYec8UERDDHBleL/P8\
 RkxEnVLjYTV9zigCXfMsgYb3EQShAgMBAAGjEDAOMAwGA1UdEwQFMAMBAf8wDQYJ\
 KoZIhvcNAQELBQADggEBABUJpl3QCqsoDSxAsQdV6zKT4VGV76AzoGj7etQsQY+r\
 +S26VfWh/fMobEzuxFChr0USgLJ6FoK78hAtoZvt1lrye9yqFv/ig3WLWsJKWHHb\
 3RT6oR03CIwZXFSUasi08QDVLxafwsU5OMcPLucF3a1lRL1ccYrNgVCCx1+X7Bos\
 tIgDGRQQ4AyoHTcfVd2hEGeUv7k14mOxFsAp6851yosHq9Q2kwmdH+rHEJbjof87\
 yyKLagc4owyXBZYkQmkeHWCNqnuRmO5vUsfVb0UUrkD64o7Th/NjwooA7SCiUXl6\
 dfygT1b7ggpx7GC+sP2DsIM47IAZ55drjqX5u2f+Ba0iQgoEdGVzdBIgCICt4gQS\
 GXapFASsapRTBKxoykO9YhoackY1CqLyiKwYiNLUpQUgASoQVGVzdGluZyB0ZXN0\
 bmV0ISqAATXq9A5nmJgtmee/bQTeHeif4w1YYFPBlKghwx6qbVgXTWnwBJtOQhhV\
 sZdzbTl95ENR7/Y7VJupW9kDWobCK7zUUhLAzUlwmLlcx6itHw8LTUF5HK+AwsZm\
 Zs85lISGvOS0NZW/ENa6l+oQRnL87oqVZr/EDGiuqjz6T0ThQi0l\
 ";
 
 //
 // Unexpired payment request (expires is set to 0x7FFFFFFFFFFFFFFF = max.
 // int64_t)
 //
 const char *paymentrequest3_cert2_BASE64 = "\
 Egt4NTA5K3NoYTI1NhrQBArNBDCCAkkwggExoAMCAQICAQEwDQYJKoZIhvcNAQEL\
 BQAwITEfMB0GA1UEAwwWUGF5bWVudFJlcXVlc3QgVGVzdCBDQTAeFw0xNTAxMTEx\
 ODIxMDhaFw0yNTAxMDgxODIxMDhaMCExHzAdBgNVBAMMFlBheW1lbnRSZXF1ZXN0\
 IFRlc3QgQ0EwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMsZqzkzeBGo+i2N\
 mUak3Ciodr1V7S062VOy7N0OQYNDQHYkgDFAUET7cEb5VJaHPv5m3ppTBpU9xBcf\
 wbHHUt4VjA+mhRmYrl1khjvZM+X8kEqvWn20BtcM9R6r0yIYec8UERDDHBleL/P8\
 RkxEnVLjYTV9zigCXfMsgYb3EQShAgMBAAGjEDAOMAwGA1UdEwQFMAMBAf8wDQYJ\
 KoZIhvcNAQELBQADggEBABUJpl3QCqsoDSxAsQdV6zKT4VGV76AzoGj7etQsQY+r\
 +S26VfWh/fMobEzuxFChr0USgLJ6FoK78hAtoZvt1lrye9yqFv/ig3WLWsJKWHHb\
 3RT6oR03CIwZXFSUasi08QDVLxafwsU5OMcPLucF3a1lRL1ccYrNgVCCx1+X7Bos\
 tIgDGRQQ4AyoHTcfVd2hEGeUv7k14mOxFsAp6851yosHq9Q2kwmdH+rHEJbjof87\
 yyKLagc4owyXBZYkQmkeHWCNqnuRmO5vUsfVb0UUrkD64o7Th/NjwooA7SCiUXl6\
 dfygT1b7ggpx7GC+sP2DsIM47IAZ55drjqX5u2f+Ba0iSgoEdGVzdBIgCICt4gQS\
 GXapFASsapRTBKxoykO9YhoackY1CqLyiKwYyNfZpQUg//////////9/KhBUZXN0\
 aW5nIHRlc3RuZXQhKoABNwi8WnMW4aMvbmvorTiiWJLFhofLFnsoWCJnj3rWLnLh\
 n3w6q/fZ26p50ERL/noxdTUfeFsKnlECkUu/fOcOrqyYDiwvxI0SZ034DleVyFU1\
 Z3T+X0zcL8oe7bX01Yf+s2V+5JXQXarKnKBrZCGgv2ARjFNSZe7E7vGg5K4Q6Q8=\
 ";
 
 //
 // Unexpired payment request (expires is set to 0x8000000000000000 > max.
 // int64_t, allowed uint64)
 //
 const char *paymentrequest4_cert2_BASE64 = "\
 Egt4NTA5K3NoYTI1NhrQBArNBDCCAkkwggExoAMCAQICAQEwDQYJKoZIhvcNAQEL\
 BQAwITEfMB0GA1UEAwwWUGF5bWVudFJlcXVlc3QgVGVzdCBDQTAeFw0xNTAxMTEx\
 ODIxMDhaFw0yNTAxMDgxODIxMDhaMCExHzAdBgNVBAMMFlBheW1lbnRSZXF1ZXN0\
 IFRlc3QgQ0EwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMsZqzkzeBGo+i2N\
 mUak3Ciodr1V7S062VOy7N0OQYNDQHYkgDFAUET7cEb5VJaHPv5m3ppTBpU9xBcf\
 wbHHUt4VjA+mhRmYrl1khjvZM+X8kEqvWn20BtcM9R6r0yIYec8UERDDHBleL/P8\
 RkxEnVLjYTV9zigCXfMsgYb3EQShAgMBAAGjEDAOMAwGA1UdEwQFMAMBAf8wDQYJ\
 KoZIhvcNAQELBQADggEBABUJpl3QCqsoDSxAsQdV6zKT4VGV76AzoGj7etQsQY+r\
 +S26VfWh/fMobEzuxFChr0USgLJ6FoK78hAtoZvt1lrye9yqFv/ig3WLWsJKWHHb\
 3RT6oR03CIwZXFSUasi08QDVLxafwsU5OMcPLucF3a1lRL1ccYrNgVCCx1+X7Bos\
 tIgDGRQQ4AyoHTcfVd2hEGeUv7k14mOxFsAp6851yosHq9Q2kwmdH+rHEJbjof87\
 yyKLagc4owyXBZYkQmkeHWCNqnuRmO5vUsfVb0UUrkD64o7Th/NjwooA7SCiUXl6\
 dfygT1b7ggpx7GC+sP2DsIM47IAZ55drjqX5u2f+Ba0iSwoEdGVzdBIgCICt4gQS\
 GXapFASsapRTBKxoykO9YhoackY1CqLyiKwYt+HZpQUggICAgICAgICAASoQVGVz\
 dGluZyB0ZXN0bmV0ISqAAXSQG8+GFA18VaKarlYrOz293rNMIub0swKGcQm8jAGX\
 HSLaRgHfUDeEPr4hydy4dtfu59KNwe2xsHOHu/SpO4L8SrA4Dm9A7SlNBVWdcLbw\
 d2hj739GDLz0b5KuJ2SG6VknMRQM976w/m2qlq0ccVGaaZ2zMIGfpzL3p6adwx/5\
 ";
 
 //
-// Payment request with amount overflow (amount is set to 21000001 BCH)
+// Payment request with amount overflow (amount is set to
+// 21,000,001,000,000 XEC)
 //
 const char *paymentrequest5_cert2_BASE64 = "\
 Egt4NTA5K3NoYTI1NhrQBArNBDCCAkkwggExoAMCAQICAQEwDQYJKoZIhvcNAQEL\
 BQAwITEfMB0GA1UEAwwWUGF5bWVudFJlcXVlc3QgVGVzdCBDQTAeFw0xNTAxMTEx\
 ODIxMDhaFw0yNTAxMDgxODIxMDhaMCExHzAdBgNVBAMMFlBheW1lbnRSZXF1ZXN0\
 IFRlc3QgQ0EwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMsZqzkzeBGo+i2N\
 mUak3Ciodr1V7S062VOy7N0OQYNDQHYkgDFAUET7cEb5VJaHPv5m3ppTBpU9xBcf\
 wbHHUt4VjA+mhRmYrl1khjvZM+X8kEqvWn20BtcM9R6r0yIYec8UERDDHBleL/P8\
 RkxEnVLjYTV9zigCXfMsgYb3EQShAgMBAAGjEDAOMAwGA1UdEwQFMAMBAf8wDQYJ\
 KoZIhvcNAQELBQADggEBABUJpl3QCqsoDSxAsQdV6zKT4VGV76AzoGj7etQsQY+r\
 +S26VfWh/fMobEzuxFChr0USgLJ6FoK78hAtoZvt1lrye9yqFv/ig3WLWsJKWHHb\
 3RT6oR03CIwZXFSUasi08QDVLxafwsU5OMcPLucF3a1lRL1ccYrNgVCCx1+X7Bos\
 tIgDGRQQ4AyoHTcfVd2hEGeUv7k14mOxFsAp6851yosHq9Q2kwmdH+rHEJbjof87\
 yyKLagc4owyXBZYkQmkeHWCNqnuRmO5vUsfVb0UUrkD64o7Th/NjwooA7SCiUXl6\
 dfygT1b7ggpx7GC+sP2DsIM47IAZ55drjqX5u2f+Ba0iTAoEdGVzdBIkCIDC9P+F\
 vt0DEhl2qRQErGqUUwSsaMpDvWIaGnJGNQqi8oisGLzcrKYFKhhUZXN0aW5nIGFt\
 b3VudCBvdmVyZmxvdyEqgAG8S7WEDUC6tCL6q2CTBjop/AitgEy31RL9IqYruytR\
 iEBFUrBDJZU+UEezGwr7/zoECjo5ZY3PmtZcM2sILNjyweJF6XVzGqTxUw6pN6sW\
 XR2T3Gy2LzRvhVA25QgGqpz0/juS2BtmNbsZPkN9gMMwKimgzc+PuCzmEKwPK9cQ\
 YQ==\
 ";
 
 #endif // BITCOIN_QT_TEST_PAYMENTREQUESTDATA_H
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 12a9a037d..eeb4660b6 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -1,1171 +1,1171 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <amount.h>
 #include <blockvalidity.h>
 #include <cashaddrenc.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/activation.h>
 #include <consensus/consensus.h>
 #include <consensus/params.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <key_io.h>
 #include <miner.h>
 #include <minerfund.h>
 #include <net.h>
 #include <node/context.h>
 #include <policy/policy.h>
 #include <pow/pow.h>
 #include <rpc/blockchain.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <shutdown.h>
 #include <txmempool.h>
 #include <univalue.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <warnings.h>
 
 #include <cstdint>
 
 /**
  * Return average network hashes per second based on the last 'lookup' blocks,
  * or from the last difficulty change if 'lookup' is nonpositive. If 'height' is
  * nonnegative, compute the estimate at the time when a given block was found.
  */
 static UniValue GetNetworkHashPS(int lookup, int height) {
     CBlockIndex *pb = ::ChainActive().Tip();
 
     if (height >= 0 && height < ::ChainActive().Height()) {
         pb = ::ChainActive()[height];
     }
 
     if (pb == nullptr || !pb->nHeight) {
         return 0;
     }
 
     // If lookup is -1, then use blocks since last difficulty change.
     if (lookup <= 0) {
         lookup = pb->nHeight %
                      Params().GetConsensus().DifficultyAdjustmentInterval() +
                  1;
     }
 
     // If lookup is larger than chain, then set it to chain length.
     if (lookup > pb->nHeight) {
         lookup = pb->nHeight;
     }
 
     CBlockIndex *pb0 = pb;
     int64_t minTime = pb0->GetBlockTime();
     int64_t maxTime = minTime;
     for (int i = 0; i < lookup; i++) {
         pb0 = pb0->pprev;
         int64_t time = pb0->GetBlockTime();
         minTime = std::min(time, minTime);
         maxTime = std::max(time, maxTime);
     }
 
     // In case there's a situation where minTime == maxTime, we don't want a
     // divide by zero exception.
     if (minTime == maxTime) {
         return 0;
     }
 
     arith_uint256 workDiff = pb->nChainWork - pb0->nChainWork;
     int64_t timeDiff = maxTime - minTime;
 
     return workDiff.getdouble() / timeDiff;
 }
 
 static UniValue getnetworkhashps(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "getnetworkhashps",
         "Returns the estimated network hashes per second based on the last n "
         "blocks.\n"
         "Pass in [blocks] to override # of blocks, -1 specifies since last "
         "difficulty change.\n"
         "Pass in [height] to estimate the network speed at the time when a "
         "certain block was found.\n",
         {
             {"nblocks", RPCArg::Type::NUM, /* default */ "120",
              "The number of blocks, or -1 for blocks since last difficulty "
              "change."},
             {"height", RPCArg::Type::NUM, /* default */ "-1",
              "To estimate at the time of the given height."},
         },
         RPCResult{RPCResult::Type::NUM, "", "Hashes per second estimated"},
         RPCExamples{HelpExampleCli("getnetworkhashps", "") +
                     HelpExampleRpc("getnetworkhashps", "")},
     }
         .Check(request);
 
     LOCK(cs_main);
     return GetNetworkHashPS(
         !request.params[0].isNull() ? request.params[0].get_int() : 120,
         !request.params[1].isNull() ? request.params[1].get_int() : -1);
 }
 
 static bool GenerateBlock(const Config &config, ChainstateManager &chainman,
                           CBlock &block, uint64_t &max_tries,
                           unsigned int &extra_nonce, BlockHash &block_hash) {
     block_hash.SetNull();
     const uint64_t nExcessiveBlockSize = config.GetMaxBlockSize();
 
     {
         LOCK(cs_main);
         IncrementExtraNonce(&block, ::ChainActive().Tip(), nExcessiveBlockSize,
                             extra_nonce);
     }
 
     const Consensus::Params &params = config.GetChainParams().GetConsensus();
 
     while (max_tries > 0 &&
            block.nNonce < std::numeric_limits<uint32_t>::max() &&
            !CheckProofOfWork(block.GetHash(), block.nBits, params) &&
            !ShutdownRequested()) {
         ++block.nNonce;
         --max_tries;
     }
     if (max_tries == 0 || ShutdownRequested()) {
         return false;
     }
     if (block.nNonce == std::numeric_limits<uint32_t>::max()) {
         return true;
     }
 
     std::shared_ptr<const CBlock> shared_pblock =
         std::make_shared<const CBlock>(block);
     if (!chainman.ProcessNewBlock(config, shared_pblock, true, nullptr)) {
         throw JSONRPCError(RPC_INTERNAL_ERROR,
                            "ProcessNewBlock, block not accepted");
     }
 
     block_hash = block.GetHash();
     return true;
 }
 
 static UniValue generateBlocks(const Config &config,
                                ChainstateManager &chainman,
                                const CTxMemPool &mempool,
                                const CScript &coinbase_script, int nGenerate,
                                uint64_t nMaxTries) {
     int nHeightEnd = 0;
     int nHeight = 0;
 
     {
         // Don't keep cs_main locked.
         LOCK(cs_main);
         nHeight = ::ChainActive().Height();
         nHeightEnd = nHeight + nGenerate;
     }
 
     unsigned int nExtraNonce = 0;
     UniValue blockHashes(UniValue::VARR);
     while (nHeight < nHeightEnd && !ShutdownRequested()) {
         std::unique_ptr<CBlockTemplate> pblocktemplate(
             BlockAssembler(config, mempool).CreateNewBlock(coinbase_script));
 
         if (!pblocktemplate.get()) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
         }
 
         CBlock *pblock = &pblocktemplate->block;
 
         BlockHash block_hash;
         if (!GenerateBlock(config, chainman, *pblock, nMaxTries, nExtraNonce,
                            block_hash)) {
             break;
         }
 
         if (!block_hash.IsNull()) {
             ++nHeight;
             blockHashes.push_back(block_hash.GetHex());
         }
     }
     return blockHashes;
 }
 
 static bool getScriptFromDescriptor(const std::string &descriptor,
                                     CScript &script, std::string &error) {
     FlatSigningProvider key_provider;
     const auto desc =
         Parse(descriptor, key_provider, error, /* require_checksum = */ false);
     if (desc) {
         if (desc->IsRange()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Ranged descriptor not accepted. Maybe pass "
                                "through deriveaddresses first?");
         }
 
         FlatSigningProvider provider;
         std::vector<CScript> scripts;
         if (!desc->Expand(0, key_provider, scripts, provider)) {
             throw JSONRPCError(
                 RPC_INVALID_ADDRESS_OR_KEY,
                 strprintf("Cannot derive script without private keys"));
         }
 
         // Combo descriptors can have 2 scripts, so we can't just check
         // scripts.size() == 1
         CHECK_NONFATAL(scripts.size() > 0 && scripts.size() <= 2);
 
         if (scripts.size() == 1) {
             script = scripts.at(0);
         } else {
             // Else take the 2nd script, since it is p2pkh
             script = scripts.at(1);
         }
 
         return true;
     }
 
     return false;
 }
 
 static UniValue generatetodescriptor(const Config &config,
                                      const JSONRPCRequest &request) {
     RPCHelpMan{
         "generatetodescriptor",
         "\nMine blocks immediately to a specified descriptor (before the RPC "
         "call returns)\n",
         {
             {"num_blocks", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "How many blocks are generated immediately."},
             {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The descriptor to send the newly generated bitcoin to."},
             {"maxtries", RPCArg::Type::NUM, /* default */ "1000000",
              "How many iterations to try."},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "hashes of blocks generated",
                   {
                       {RPCResult::Type::STR_HEX, "", "blockhash"},
                   }},
         RPCExamples{"\nGenerate 11 blocks to mydesc\n" +
                     HelpExampleCli("generatetodescriptor", "11 \"mydesc\"")},
     }
         .Check(request);
 
     const int num_blocks{request.params[0].get_int()};
     const int64_t max_tries{
         request.params[2].isNull() ? 1000000 : request.params[2].get_int()};
 
     CScript coinbase_script;
     std::string error;
     if (!getScriptFromDescriptor(request.params[1].get_str(), coinbase_script,
                                  error)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
     }
 
     const CTxMemPool &mempool = EnsureMemPool(request.context);
     ChainstateManager &chainman = EnsureChainman(request.context);
 
     return generateBlocks(config, chainman, mempool, coinbase_script,
                           num_blocks, max_tries);
 }
 
 static UniValue generatetoaddress(const Config &config,
                                   const JSONRPCRequest &request) {
     RPCHelpMan{
         "generatetoaddress",
         "Mine blocks immediately to a specified address before the "
         "RPC call returns)\n",
         {
             {"nblocks", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "How many blocks are generated immediately."},
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The address to send the newly generated bitcoin to."},
             {"maxtries", RPCArg::Type::NUM, /* default */ "1000000",
              "How many iterations to try."},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "hashes of blocks generated",
                   {
                       {RPCResult::Type::STR_HEX, "", "blockhash"},
                   }},
         RPCExamples{
             "\nGenerate 11 blocks to myaddress\n" +
             HelpExampleCli("generatetoaddress", "11 \"myaddress\"") +
             "If you are using the " PACKAGE_NAME " wallet, you can "
             "get a new address to send the newly generated bitcoin to with:\n" +
             HelpExampleCli("getnewaddress", "")},
     }
         .Check(request);
 
     int nGenerate = request.params[0].get_int();
     uint64_t nMaxTries = 1000000;
     if (!request.params[2].isNull()) {
         nMaxTries = request.params[2].get_int64();
     }
 
     CTxDestination destination =
         DecodeDestination(request.params[1].get_str(), config.GetChainParams());
     if (!IsValidDestination(destination)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Error: Invalid address");
     }
 
     const CTxMemPool &mempool = EnsureMemPool(request.context);
     ChainstateManager &chainman = EnsureChainman(request.context);
 
     CScript coinbase_script = GetScriptForDestination(destination);
 
     return generateBlocks(config, chainman, mempool, coinbase_script, nGenerate,
                           nMaxTries);
 }
 
 static UniValue generateblock(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "generateblock",
         "\nMine a block with a set of ordered transactions immediately to a "
         "specified address or descriptor (before the RPC call returns)\n",
         {
             {"output", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The address or descriptor to send the newly generated bitcoin "
              "to."},
             {
                 "transactions",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "An array of hex strings which are either txids or raw "
                 "transactions.\n"
                 "Txids must reference transactions currently in the mempool.\n"
                 "All transactions must be valid and in valid order, otherwise "
                 "the block will be rejected.",
                 {
                     {"rawtx/txid", RPCArg::Type::STR_HEX,
                      RPCArg::Optional::OMITTED, ""},
                 },
             },
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR_HEX, "hash", "hash of generated block"},
             }},
         RPCExamples{
             "\nGenerate a block to myaddress, with txs rawtx and "
             "mempool_txid\n" +
             HelpExampleCli("generateblock",
                            R"("myaddress" '["rawtx", "mempool_txid"]')")},
     }
         .Check(request);
 
     const auto address_or_descriptor = request.params[0].get_str();
     CScript coinbase_script;
     std::string error;
 
     const CChainParams &chainparams = config.GetChainParams();
 
     if (!getScriptFromDescriptor(address_or_descriptor, coinbase_script,
                                  error)) {
         const auto destination =
             DecodeDestination(address_or_descriptor, chainparams);
         if (!IsValidDestination(destination)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Error: Invalid address or descriptor");
         }
 
         coinbase_script = GetScriptForDestination(destination);
     }
 
     const CTxMemPool &mempool = EnsureMemPool(request.context);
 
     std::vector<CTransactionRef> txs;
     const auto raw_txs_or_txids = request.params[1].get_array();
     for (size_t i = 0; i < raw_txs_or_txids.size(); i++) {
         const auto str(raw_txs_or_txids[i].get_str());
 
         uint256 hash;
         CMutableTransaction mtx;
         if (ParseHashStr(str, hash)) {
             const auto tx = mempool.get(TxId(hash));
             if (!tx) {
                 throw JSONRPCError(
                     RPC_INVALID_ADDRESS_OR_KEY,
                     strprintf("Transaction %s not in mempool.", str));
             }
 
             txs.emplace_back(tx);
 
         } else if (DecodeHexTx(mtx, str)) {
             txs.push_back(MakeTransactionRef(std::move(mtx)));
 
         } else {
             throw JSONRPCError(
                 RPC_DESERIALIZATION_ERROR,
                 strprintf("Transaction decode failed for %s", str));
         }
     }
 
     CBlock block;
 
     {
         LOCK(cs_main);
 
         CTxMemPool empty_mempool;
         std::unique_ptr<CBlockTemplate> blocktemplate(
             BlockAssembler(config, empty_mempool)
                 .CreateNewBlock(coinbase_script));
         if (!blocktemplate) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
         }
         block = blocktemplate->block;
     }
 
     CHECK_NONFATAL(block.vtx.size() == 1);
 
     // Add transactions
     block.vtx.insert(block.vtx.end(), txs.begin(), txs.end());
 
     {
         LOCK(cs_main);
 
         BlockValidationState state;
         if (!TestBlockValidity(state, chainparams, block,
                                LookupBlockIndex(block.hashPrevBlock),
                                BlockValidationOptions(config)
                                    .withCheckPoW(false)
                                    .withCheckMerkleRoot(false))) {
             throw JSONRPCError(
                 RPC_VERIFY_ERROR,
                 strprintf("TestBlockValidity failed: %s", state.ToString()));
         }
     }
 
     BlockHash block_hash;
     uint64_t max_tries{1000000};
     unsigned int extra_nonce{0};
 
     if (!GenerateBlock(config, EnsureChainman(request.context), block,
                        max_tries, extra_nonce, block_hash) ||
         block_hash.IsNull()) {
         throw JSONRPCError(RPC_MISC_ERROR, "Failed to make block.");
     }
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("hash", block_hash.GetHex());
     return obj;
 }
 
 static UniValue getmininginfo(const Config &config,
                               const JSONRPCRequest &request) {
     RPCHelpMan{
         "getmininginfo",
         "Returns a json object containing mining-related "
         "information.",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "blocks", "The current block"},
                 {RPCResult::Type::NUM, "currentblocksize", /* optional */ true,
                  "The block size of the last assembled block (only present if "
                  "a block was ever assembled)"},
                 {RPCResult::Type::NUM, "currentblocktx", /* optional */ true,
                  "The number of block transactions of the last assembled block "
                  "(only present if a block was ever assembled)"},
                 {RPCResult::Type::NUM, "difficulty", "The current difficulty"},
                 {RPCResult::Type::NUM, "networkhashps",
                  "The network hashes per second"},
                 {RPCResult::Type::NUM, "pooledtx", "The size of the mempool"},
                 {RPCResult::Type::STR, "chain",
                  "current network name (main, test, regtest)"},
                 {RPCResult::Type::STR, "warnings",
                  "any network and blockchain warnings"},
             }},
         RPCExamples{HelpExampleCli("getmininginfo", "") +
                     HelpExampleRpc("getmininginfo", "")},
     }
         .Check(request);
 
     LOCK(cs_main);
     const CTxMemPool &mempool = EnsureMemPool(request.context);
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("blocks", int(::ChainActive().Height()));
     if (BlockAssembler::m_last_block_size) {
         obj.pushKV("currentblocksize", *BlockAssembler::m_last_block_size);
     }
     if (BlockAssembler::m_last_block_num_txs) {
         obj.pushKV("currentblocktx", *BlockAssembler::m_last_block_num_txs);
     }
     obj.pushKV("difficulty", double(GetDifficulty(::ChainActive().Tip())));
     obj.pushKV("networkhashps", getnetworkhashps(config, request));
     obj.pushKV("pooledtx", uint64_t(mempool.size()));
     obj.pushKV("chain", config.GetChainParams().NetworkIDString());
     obj.pushKV("warnings", GetWarnings(false).original);
     return obj;
 }
 
-// NOTE: Unlike wallet RPC (which use BCH values), mining RPCs follow GBT (BIP
+// NOTE: Unlike wallet RPC (which use XEC values), mining RPCs follow GBT (BIP
 // 22) in using satoshi amounts
 static UniValue prioritisetransaction(const Config &config,
                                       const JSONRPCRequest &request) {
     RPCHelpMan{
         "prioritisetransaction",
         "Accepts the transaction into mined blocks at a higher "
         "(or lower) priority\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id."},
             {"dummy", RPCArg::Type::NUM, RPCArg::Optional::OMITTED_NAMED_ARG,
              "API-Compatibility for previous API. Must be zero or null.\n"
              "                  DEPRECATED. For forward compatibility "
              "use named arguments and omit this parameter."},
             {"fee_delta", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The fee value (in satoshis) to add (or subtract, if negative).\n"
              "                        The fee is not actually paid, only the "
              "algorithm for selecting transactions into a block\n"
              "                  considers the transaction as it would "
              "have paid a higher (or lower) fee."},
         },
         RPCResult{RPCResult::Type::BOOL, "", "Returns true"},
         RPCExamples{
             HelpExampleCli("prioritisetransaction", "\"txid\" 0.0 10000") +
             HelpExampleRpc("prioritisetransaction", "\"txid\", 0.0, 10000")},
     }
         .Check(request);
 
     LOCK(cs_main);
 
     TxId txid(ParseHashV(request.params[0], "txid"));
     Amount nAmount = request.params[2].get_int64() * SATOSHI;
 
     if (!(request.params[1].isNull() || request.params[1].get_real() == 0)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Priority is no longer supported, dummy argument to "
                            "prioritisetransaction must be 0.");
     }
 
     EnsureMemPool(request.context).PrioritiseTransaction(txid, nAmount);
     return true;
 }
 
 // NOTE: Assumes a conclusive result; if result is inconclusive, it must be
 // handled by caller
 static UniValue BIP22ValidationResult(const Config &config,
                                       const BlockValidationState &state) {
     if (state.IsValid()) {
         return NullUniValue;
     }
 
     if (state.IsError()) {
         throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
     }
 
     if (state.IsInvalid()) {
         std::string strRejectReason = state.GetRejectReason();
         if (strRejectReason.empty()) {
             return "rejected";
         }
         return strRejectReason;
     }
 
     // Should be impossible.
     return "valid?";
 }
 
 static UniValue getblocktemplate(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "getblocktemplate",
         "If the request parameters include a 'mode' key, that is used to "
         "explicitly select between the default 'template' request or a "
         "'proposal'.\n"
         "It returns data needed to construct a block to work on.\n"
         "For full specification, see BIPs 22, 23, 9, and 145:\n"
         "    "
         "https://github.com/bitcoin/bips/blob/master/"
         "bip-0022.mediawiki\n"
         "    "
         "https://github.com/bitcoin/bips/blob/master/"
         "bip-0023.mediawiki\n"
         "    "
         "https://github.com/bitcoin/bips/blob/master/"
         "bip-0009.mediawiki#getblocktemplate_changes\n"
         "    ",
         {
             {"template_request",
              RPCArg::Type::OBJ,
              "{}",
              "Format of the template",
              {
                  {"mode", RPCArg::Type::STR, /* treat as named arg */
                   RPCArg::Optional::OMITTED_NAMED_ARG,
                   "This must be set to \"template\", \"proposal\" (see BIP "
                   "23), or omitted"},
                  {
                      "capabilities",
                      RPCArg::Type::ARR,
                      /* treat as named arg */
                      RPCArg::Optional::OMITTED_NAMED_ARG,
                      "A list of strings",
                      {
                          {"support", RPCArg::Type::STR,
                           RPCArg::Optional::OMITTED,
                           "client side supported feature, 'longpoll', "
                           "'coinbasetxn', 'coinbasevalue', 'proposal', "
                           "'serverlist', 'workid'"},
                      },
                  },
              },
              "\"template_request\""},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "version",
                  "The preferred block version"},
                 {RPCResult::Type::STR, "previousblockhash",
                  "The hash of current highest block"},
                 {RPCResult::Type::ARR,
                  "transactions",
                  "contents of non-coinbase transactions that should be "
                  "included in the next block",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR_HEX, "data",
                            "transaction data encoded in hexadecimal "
                            "(byte-for-byte)"},
                           {RPCResult::Type::STR_HEX, "txid",
                            "transaction id encoded in little-endian "
                            "hexadecimal"},
                           {RPCResult::Type::STR_HEX, "hash",
                            "hash encoded in little-endian hexadecimal"},
                           {RPCResult::Type::ARR,
                            "depends",
                            "array of numbers",
                            {
                                {RPCResult::Type::NUM, "",
                                 "transactions before this one (by 1-based "
                                 "index in 'transactions' list) that must be "
                                 "present in the final block if this one is"},
                            }},
                           {RPCResult::Type::NUM, "fee",
                            "difference in value between transaction inputs and "
                            "outputs (in satoshis); for coinbase transactions, "
                            "this is a negative Number of the total collected "
                            "block fees (ie, not including the block subsidy); "
                            "if key is not present, fee is unknown and clients "
                            "MUST NOT assume there isn't one"},
                           {RPCResult::Type::NUM, "sigops",
                            "total SigOps cost, as counted for purposes of "
                            "block limits; if key is not present, sigop cost is "
                            "unknown and clients MUST NOT assume it is zero"},
                       }},
                  }},
                 {RPCResult::Type::OBJ,
                  "coinbaseaux",
                  "data that should be included in the coinbase's scriptSig "
                  "content",
                  {
                      {RPCResult::Type::ELISION, "", ""},
                  }},
                 {RPCResult::Type::NUM, "coinbasevalue",
                  "maximum allowable input to coinbase transaction, including "
                  "the generation award and transaction fees (in satoshis)"},
                 {RPCResult::Type::OBJ,
                  "coinbasetxn",
                  "information for coinbase transaction",
                  {
                      {RPCResult::Type::OBJ,
                       "minerfund",
                       "information related to the coinbase miner fund",
                       {
 
                           {RPCResult::Type::ARR,
                            "addresses",
                            "List of valid addresses for the miner fund output",
                            {
                                {RPCResult::Type::ELISION, "", ""},
                            }},
 
                           {RPCResult::Type::STR_AMOUNT, "minimumvalue",
                            "The minimum value the miner fund output must pay"},
 
                       }},
                      {RPCResult::Type::ELISION, "", ""},
                  }},
                 {RPCResult::Type::STR, "target", "The hash target"},
                 {RPCResult::Type::NUM_TIME, "mintime",
                  "The minimum timestamp appropriate for the next block time, "
                  "expressed in " +
                      UNIX_EPOCH_TIME},
                 {RPCResult::Type::ARR,
                  "mutable",
                  "list of ways the block template may be changed",
                  {
                      {RPCResult::Type::STR, "value",
                       "A way the block template may be changed, e.g. 'time', "
                       "'transactions', 'prevblock'"},
                  }},
                 {RPCResult::Type::STR_HEX, "noncerange",
                  "A range of valid nonces"},
                 {RPCResult::Type::NUM, "sigoplimit",
                  "limit of sigops in blocks"},
                 {RPCResult::Type::NUM, "sizelimit", "limit of block size"},
                 {RPCResult::Type::NUM_TIME, "curtime",
                  "current timestamp in " + UNIX_EPOCH_TIME},
                 {RPCResult::Type::STR, "bits",
                  "compressed target of next block"},
                 {RPCResult::Type::NUM, "height",
                  "The height of the next block"},
             }},
         RPCExamples{HelpExampleCli("getblocktemplate", "") +
                     HelpExampleRpc("getblocktemplate", "")},
     }
         .Check(request);
 
     LOCK(cs_main);
     const CChainParams &chainparams = config.GetChainParams();
 
     std::string strMode = "template";
     UniValue lpval = NullUniValue;
     std::set<std::string> setClientRules;
     if (!request.params[0].isNull()) {
         const UniValue &oparam = request.params[0].get_obj();
         const UniValue &modeval = find_value(oparam, "mode");
         if (modeval.isStr()) {
             strMode = modeval.get_str();
         } else if (modeval.isNull()) {
             /* Do nothing */
         } else {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
         }
         lpval = find_value(oparam, "longpollid");
 
         if (strMode == "proposal") {
             const UniValue &dataval = find_value(oparam, "data");
             if (!dataval.isStr()) {
                 throw JSONRPCError(RPC_TYPE_ERROR,
                                    "Missing data String key for proposal");
             }
 
             CBlock block;
             if (!DecodeHexBlk(block, dataval.get_str())) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    "Block decode failed");
             }
 
             const BlockHash hash = block.GetHash();
             const CBlockIndex *pindex = LookupBlockIndex(hash);
             if (pindex) {
                 if (pindex->IsValid(BlockValidity::SCRIPTS)) {
                     return "duplicate";
                 }
                 if (pindex->nStatus.isInvalid()) {
                     return "duplicate-invalid";
                 }
                 return "duplicate-inconclusive";
             }
 
             CBlockIndex *const pindexPrev = ::ChainActive().Tip();
             // TestBlockValidity only supports blocks built on the current Tip
             if (block.hashPrevBlock != pindexPrev->GetBlockHash()) {
                 return "inconclusive-not-best-prevblk";
             }
             BlockValidationState state;
             TestBlockValidity(state, chainparams, block, pindexPrev,
                               BlockValidationOptions(config)
                                   .withCheckPoW(false)
                                   .withCheckMerkleRoot(true));
             return BIP22ValidationResult(config, state);
         }
     }
 
     if (strMode != "template") {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
     }
 
     NodeContext &node = EnsureNodeContext(request.context);
     if (!node.connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     if (node.connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0) {
         throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED,
                            "Bitcoin is not connected!");
     }
 
     if (::ChainstateActive().IsInitialBlockDownload()) {
         throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, PACKAGE_NAME
                            " is in initial sync and waiting for blocks...");
     }
 
     static unsigned int nTransactionsUpdatedLast;
     const CTxMemPool &mempool = EnsureMemPool(request.context);
 
     if (!lpval.isNull()) {
         // Wait to respond until either the best block changes, OR a minute has
         // passed and there are more transactions
         uint256 hashWatchedChain;
         std::chrono::steady_clock::time_point checktxtime;
         unsigned int nTransactionsUpdatedLastLP;
 
         if (lpval.isStr()) {
             // Format: <hashBestChain><nTransactionsUpdatedLast>
             std::string lpstr = lpval.get_str();
 
             hashWatchedChain = ParseHashV(lpstr.substr(0, 64), "longpollid");
             nTransactionsUpdatedLastLP = atoi64(lpstr.substr(64));
         } else {
             // NOTE: Spec does not specify behaviour for non-string longpollid,
             // but this makes testing easier
             hashWatchedChain = ::ChainActive().Tip()->GetBlockHash();
             nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
         }
 
         // Release lock while waiting
         LEAVE_CRITICAL_SECTION(cs_main);
         {
             checktxtime =
                 std::chrono::steady_clock::now() + std::chrono::minutes(1);
 
             WAIT_LOCK(g_best_block_mutex, lock);
             while (g_best_block == hashWatchedChain && IsRPCRunning()) {
                 if (g_best_block_cv.wait_until(lock, checktxtime) ==
                     std::cv_status::timeout) {
                     // Timeout: Check transactions for update
                     // without holding the mempool look to avoid deadlocks
                     if (mempool.GetTransactionsUpdated() !=
                         nTransactionsUpdatedLastLP) {
                         break;
                     }
                     checktxtime += std::chrono::seconds(10);
                 }
             }
         }
         ENTER_CRITICAL_SECTION(cs_main);
 
         if (!IsRPCRunning()) {
             throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Shutting down");
         }
         // TODO: Maybe recheck connections/IBD and (if something wrong) send an
         // expires-immediately template to stop miners?
     }
 
     // Update block
     static CBlockIndex *pindexPrev;
     static int64_t nStart;
     static std::unique_ptr<CBlockTemplate> pblocktemplate;
     if (pindexPrev != ::ChainActive().Tip() ||
         (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast &&
          GetTime() - nStart > 5)) {
         // Clear pindexPrev so future calls make a new block, despite any
         // failures from here on
         pindexPrev = nullptr;
 
         // Store the pindexBest used before CreateNewBlock, to avoid races
         nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
         CBlockIndex *pindexPrevNew = ::ChainActive().Tip();
         nStart = GetTime();
 
         // Create new block
         CScript scriptDummy = CScript() << OP_TRUE;
         pblocktemplate =
             BlockAssembler(config, mempool).CreateNewBlock(scriptDummy);
         if (!pblocktemplate) {
             throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory");
         }
 
         // Need to update only after we know CreateNewBlock succeeded
         pindexPrev = pindexPrevNew;
     }
 
     CHECK_NONFATAL(pindexPrev);
     // pointer for convenience
     CBlock *pblock = &pblocktemplate->block;
 
     // Update nTime
     UpdateTime(pblock, chainparams, pindexPrev);
     pblock->nNonce = 0;
 
     UniValue aCaps(UniValue::VARR);
     aCaps.push_back("proposal");
 
     Amount coinbasevalue = Amount::zero();
 
     UniValue transactions(UniValue::VARR);
     transactions.reserve(pblock->vtx.size());
     int index_in_template = 0;
     for (const auto &it : pblock->vtx) {
         const CTransaction &tx = *it;
         const TxId txId = tx.GetId();
 
         if (tx.IsCoinBase()) {
             index_in_template++;
 
             for (const auto &o : pblock->vtx[0]->vout) {
                 coinbasevalue += o.nValue;
             }
 
             continue;
         }
 
         UniValue entry(UniValue::VOBJ);
         entry.reserve(5);
         entry.__pushKV("data", EncodeHexTx(tx));
         entry.__pushKV("txid", txId.GetHex());
         entry.__pushKV("hash", tx.GetHash().GetHex());
         entry.__pushKV("fee", pblocktemplate->entries[index_in_template].fees /
                                   SATOSHI);
         int64_t nTxSigOps =
             pblocktemplate->entries[index_in_template].sigOpCount;
         entry.__pushKV("sigops", nTxSigOps);
 
         transactions.push_back(entry);
         index_in_template++;
     }
 
     UniValue aux(UniValue::VOBJ);
 
     UniValue minerFundList(UniValue::VARR);
     const Consensus::Params &consensusParams = chainparams.GetConsensus();
     for (auto fundDestination :
          GetMinerFundWhitelist(consensusParams, pindexPrev)) {
         minerFundList.push_back(EncodeDestination(fundDestination, config));
     }
 
     int64_t minerFundMinValue = 0;
     if (IsAxionEnabled(consensusParams, pindexPrev)) {
         minerFundMinValue =
             int64_t(GetMinerFundAmount(coinbasevalue) / SATOSHI);
     }
 
     UniValue minerFund(UniValue::VOBJ);
     minerFund.pushKV("addresses", minerFundList);
     minerFund.pushKV("minimumvalue", minerFundMinValue);
 
     UniValue coinbasetxn(UniValue::VOBJ);
     coinbasetxn.pushKV("minerfund", minerFund);
 
     arith_uint256 hashTarget = arith_uint256().SetCompact(pblock->nBits);
 
     UniValue aMutable(UniValue::VARR);
     aMutable.push_back("time");
     aMutable.push_back("transactions");
     aMutable.push_back("prevblock");
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("capabilities", aCaps);
 
     result.pushKV("version", pblock->nVersion);
 
     result.pushKV("previousblockhash", pblock->hashPrevBlock.GetHex());
     result.pushKV("transactions", transactions);
     result.pushKV("coinbaseaux", aux);
     result.pushKV("coinbasetxn", coinbasetxn);
     result.pushKV("coinbasevalue", int64_t(coinbasevalue / SATOSHI));
     result.pushKV("longpollid", ::ChainActive().Tip()->GetBlockHash().GetHex() +
                                     ToString(nTransactionsUpdatedLast));
     result.pushKV("target", hashTarget.GetHex());
     result.pushKV("mintime", int64_t(pindexPrev->GetMedianTimePast()) + 1);
     result.pushKV("mutable", aMutable);
     result.pushKV("noncerange", "00000000ffffffff");
     result.pushKV("sigoplimit",
                   GetMaxBlockSigChecksCount(DEFAULT_MAX_BLOCK_SIZE));
     result.pushKV("sizelimit", DEFAULT_MAX_BLOCK_SIZE);
     result.pushKV("curtime", pblock->GetBlockTime());
     result.pushKV("bits", strprintf("%08x", pblock->nBits));
     result.pushKV("height", int64_t(pindexPrev->nHeight) + 1);
 
     return result;
 }
 
 class submitblock_StateCatcher final : public CValidationInterface {
 public:
     uint256 hash;
     bool found;
     BlockValidationState state;
 
     explicit submitblock_StateCatcher(const uint256 &hashIn)
         : hash(hashIn), found(false), state() {}
 
 protected:
     void BlockChecked(const CBlock &block,
                       const BlockValidationState &stateIn) override {
         if (block.GetHash() != hash) {
             return;
         }
 
         found = true;
         state = stateIn;
     }
 };
 
 static UniValue submitblock(const Config &config,
                             const JSONRPCRequest &request) {
     // We allow 2 arguments for compliance with BIP22. Argument 2 is ignored.
     RPCHelpMan{
         "submitblock",
         "Attempts to submit new block to network.\n"
         "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n",
         {
             {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hex-encoded block data to submit"},
             {"dummy", RPCArg::Type::STR, /* default */ "ignored",
              "dummy value, for compatibility with BIP22. This value is "
              "ignored."},
         },
         RPCResult{RPCResult::Type::NONE, "",
                   "Returns JSON Null when valid, a string according to BIP22 "
                   "otherwise"},
         RPCExamples{HelpExampleCli("submitblock", "\"mydata\"") +
                     HelpExampleRpc("submitblock", "\"mydata\"")},
     }
         .Check(request);
 
     std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
     CBlock &block = *blockptr;
     if (!DecodeHexBlk(block, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
     }
 
     if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            "Block does not start with a coinbase");
     }
 
     const BlockHash hash = block.GetHash();
     {
         LOCK(cs_main);
         const CBlockIndex *pindex = LookupBlockIndex(hash);
         if (pindex) {
             if (pindex->IsValid(BlockValidity::SCRIPTS)) {
                 return "duplicate";
             }
             if (pindex->nStatus.isInvalid()) {
                 return "duplicate-invalid";
             }
         }
     }
 
     bool new_block;
     auto sc = std::make_shared<submitblock_StateCatcher>(block.GetHash());
     RegisterSharedValidationInterface(sc);
     bool accepted =
         EnsureChainman(request.context)
             .ProcessNewBlock(config, blockptr, /* fForceProcessing */ true,
                              /* fNewBlock */ &new_block);
     UnregisterSharedValidationInterface(sc);
     if (!new_block && accepted) {
         return "duplicate";
     }
 
     if (!sc->found) {
         return "inconclusive";
     }
 
     return BIP22ValidationResult(config, sc->state);
 }
 
 static UniValue submitheader(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "submitheader",
         "Decode the given hexdata as a header and submit it as a candidate "
         "chain tip if valid."
         "\nThrows when the header is invalid.\n",
         {
             {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hex-encoded block header data"},
         },
         RPCResult{RPCResult::Type::NONE, "", "None"},
         RPCExamples{HelpExampleCli("submitheader", "\"aabbcc\"") +
                     HelpExampleRpc("submitheader", "\"aabbcc\"")},
     }
         .Check(request);
 
     CBlockHeader h;
     if (!DecodeHexBlockHeader(h, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                            "Block header decode failed");
     }
     {
         LOCK(cs_main);
         if (!LookupBlockIndex(h.hashPrevBlock)) {
             throw JSONRPCError(RPC_VERIFY_ERROR,
                                "Must submit previous header (" +
                                    h.hashPrevBlock.GetHex() + ") first");
         }
     }
 
     BlockValidationState state;
     EnsureChainman(request.context).ProcessNewBlockHeaders(config, {h}, state);
     if (state.IsValid()) {
         return NullUniValue;
     }
     if (state.IsError()) {
         throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
     }
     throw JSONRPCError(RPC_VERIFY_ERROR, state.GetRejectReason());
 }
 
 static UniValue estimatefee(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "estimatefee",
         "Estimates the approximate fee per kilobyte needed for a "
         "transaction\n",
         {},
         RPCResult{RPCResult::Type::NUM, "", "estimated fee-per-kilobyte"},
         RPCExamples{HelpExampleCli("estimatefee", "")},
     }
         .Check(request);
 
     const CTxMemPool &mempool = EnsureMemPool(request.context);
     return mempool.estimateFee().GetFeePerK();
 }
 
 void RegisterMiningRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category   name                     actor (function)       argNames
         //  ---------- ------------------------ ---------------------- ----------
         {"mining",     "getnetworkhashps",      getnetworkhashps,      {"nblocks", "height"}},
         {"mining",     "getmininginfo",         getmininginfo,         {}},
         {"mining",     "prioritisetransaction", prioritisetransaction, {"txid", "dummy", "fee_delta"}},
         {"mining",     "getblocktemplate",      getblocktemplate,      {"template_request"}},
         {"mining",     "submitblock",           submitblock,           {"hexdata", "dummy"}},
         {"mining",     "submitheader",          submitheader,          {"hexdata"}},
 
         {"generating", "generatetoaddress",     generatetoaddress,     {"nblocks", "address", "maxtries"}},
         {"generating", "generatetodescriptor",  generatetodescriptor,  {"num_blocks","descriptor","maxtries"}},
         {"generating", "generateblock",         generateblock,         {"output","transactions"}},
 
         {"util",       "estimatefee",           estimatefee,           {"nblocks"}},
     };
     // clang-format on
 
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/src/test/rpc_tests.cpp b/src/test/rpc_tests.cpp
index d8eb6084e..33088849d 100644
--- a/src/test/rpc_tests.cpp
+++ b/src/test/rpc_tests.cpp
@@ -1,508 +1,508 @@
 // Copyright (c) 2012-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <rpc/blockchain.h>
 #include <rpc/client.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 
 #include <config.h>
 #include <core_io.h>
 #include <interfaces/chain.h>
 #include <node/context.h>
 #include <util/ref.h>
 #include <util/time.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/test/unit_test.hpp>
 
 #include <univalue.h>
 
 UniValue CallRPC(const std::string &args, const util::Ref &context) {
     std::vector<std::string> vArgs;
     boost::split(vArgs, args, boost::is_any_of(" \t"));
     std::string strMethod = vArgs[0];
     vArgs.erase(vArgs.begin());
     GlobalConfig config;
     JSONRPCRequest request(context);
     request.strMethod = strMethod;
     request.params = RPCConvertValues(strMethod, vArgs);
     request.fHelp = false;
     if (RPCIsInWarmup(nullptr)) {
         SetRPCWarmupFinished();
     }
     try {
         UniValue result = tableRPC.execute(config, request);
         return result;
     } catch (const UniValue &objError) {
         throw std::runtime_error(find_value(objError, "message").get_str());
     }
 }
 
 class RPCTestingSetup : public TestingSetup {
 public:
     UniValue CallRPC(const std::string &args) {
         const util::Ref context{m_node};
         return ::CallRPC(args, context);
     }
 };
 
 BOOST_FIXTURE_TEST_SUITE(rpc_tests, RPCTestingSetup)
 
 BOOST_AUTO_TEST_CASE(rpc_rawparams) {
     // Test raw transaction API argument handling
     UniValue r;
 
     BOOST_CHECK_THROW(CallRPC("getrawtransaction"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("getrawtransaction not_hex"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("getrawtransaction "
                               "a3b807410df0b60fcb9736768df5823938b2f838694939ba"
                               "45f3c0a1bff150ed not_int"),
                       std::runtime_error);
 
     BOOST_CHECK_THROW(CallRPC("createrawtransaction"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("createrawtransaction null null"),
                       std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("createrawtransaction not_array"),
                       std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("createrawtransaction {} {}"),
                       std::runtime_error);
     BOOST_CHECK_NO_THROW(CallRPC("createrawtransaction [] {}"));
     BOOST_CHECK_THROW(CallRPC("createrawtransaction [] {} extra"),
                       std::runtime_error);
 
     BOOST_CHECK_THROW(CallRPC("decoderawtransaction"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("decoderawtransaction null"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("decoderawtransaction DEADBEEF"),
                       std::runtime_error);
     std::string rawtx =
         "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a9"
         "9ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0ef"
         "e71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b17"
         "36ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc31071"
         "1c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b383"
         "9e2bbf32d826a1e222031fd888ac00000000";
     BOOST_CHECK_NO_THROW(
         r = CallRPC(std::string("decoderawtransaction ") + rawtx));
     BOOST_CHECK_EQUAL(find_value(r.get_obj(), "size").get_int(), 193);
     BOOST_CHECK_EQUAL(find_value(r.get_obj(), "version").get_int(), 1);
     BOOST_CHECK_EQUAL(find_value(r.get_obj(), "locktime").get_int(), 0);
     BOOST_CHECK_THROW(
         r = CallRPC(std::string("decoderawtransaction ") + rawtx + " extra"),
         std::runtime_error);
 
     // Only check failure cases for sendrawtransaction, there's no network to
     // send to...
     BOOST_CHECK_THROW(CallRPC("sendrawtransaction"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("sendrawtransaction null"), std::runtime_error);
     BOOST_CHECK_THROW(CallRPC("sendrawtransaction DEADBEEF"),
                       std::runtime_error);
     BOOST_CHECK_THROW(
         CallRPC(std::string("sendrawtransaction ") + rawtx + " extra"),
         std::runtime_error);
 }
 
 BOOST_AUTO_TEST_CASE(rpc_togglenetwork) {
     UniValue r;
 
     r = CallRPC("getnetworkinfo");
     bool netState = find_value(r.get_obj(), "networkactive").get_bool();
     BOOST_CHECK_EQUAL(netState, true);
 
     BOOST_CHECK_NO_THROW(CallRPC("setnetworkactive false"));
     r = CallRPC("getnetworkinfo");
     int numConnection = find_value(r.get_obj(), "connections").get_int();
     BOOST_CHECK_EQUAL(numConnection, 0);
 
     netState = find_value(r.get_obj(), "networkactive").get_bool();
     BOOST_CHECK_EQUAL(netState, false);
 
     BOOST_CHECK_NO_THROW(CallRPC("setnetworkactive true"));
     r = CallRPC("getnetworkinfo");
     netState = find_value(r.get_obj(), "networkactive").get_bool();
     BOOST_CHECK_EQUAL(netState, true);
 }
 
 BOOST_AUTO_TEST_CASE(rpc_rawsign) {
     UniValue r;
     // input is a 1-of-2 multisig (so is output):
     std::string prevout = "[{\"txid\":"
                           "\"b4cc287e58f87cdae59417329f710f3ecd75a4ee1d2872b724"
                           "8f50977c8493f3\","
                           "\"vout\":1,\"scriptPubKey\":"
                           "\"a914b10c9df5f7edf436c697f02f1efdba4cf399615187\","
                           "\"amount\":3141590.00,"
                           "\"redeemScript\":"
                           "\"512103debedc17b3df2badbcdd86d5feb4562b86fe182e5998"
                           "abd8bcd4f122c6155b1b21027e940bb73ab8732bfdf7f9216ece"
                           "fca5b94d6df834e77e108f68e66f126044c052ae\"}]";
     r = CallRPC(std::string("createrawtransaction ") + prevout + " " +
                 "{\"3HqAe9LtNBjnsfM4CyYaWTnvCaUYT7v4oZ\":11}");
     std::string notsigned = r.get_str();
     std::string privkey1 =
         "\"KzsXybp9jX64P5ekX1KUxRQ79Jht9uzW7LorgwE65i5rWACL6LQe\"";
     std::string privkey2 =
         "\"Kyhdf5LuKTRx4ge69ybABsiUAWjVRK4XGxAKk2FQLp2HjGMy87Z4\"";
     r = CallRPC(std::string("signrawtransactionwithkey ") + notsigned + " [] " +
                 prevout);
     BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == false);
     r = CallRPC(std::string("signrawtransactionwithkey ") + notsigned + " [" +
                 privkey1 + "," + privkey2 + "] " + prevout);
     BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == true);
 }
 
 BOOST_AUTO_TEST_CASE(rpc_rawsign_missing_amount) {
     // Old format, missing amount parameter for prevout should generate
     // an RPC error.  This is because of new replay-protected tx's require
     // nonzero amount present in signed tx.
     // See: https://github.com/Bitcoin-ABC/bitcoin-abc/issues/63
     // (We will re-use the tx + keys from the above rpc_rawsign test for
     // simplicity.)
     UniValue r;
     std::string prevout = "[{\"txid\":"
                           "\"b4cc287e58f87cdae59417329f710f3ecd75a4ee1d2872b724"
                           "8f50977c8493f3\","
                           "\"vout\":1,\"scriptPubKey\":"
                           "\"a914b10c9df5f7edf436c697f02f1efdba4cf399615187\","
                           "\"redeemScript\":"
                           "\"512103debedc17b3df2badbcdd86d5feb4562b86fe182e5998"
                           "abd8bcd4f122c6155b1b21027e940bb73ab8732bfdf7f9216ece"
                           "fca5b94d6df834e77e108f68e66f126044c052ae\"}]";
     r = CallRPC(std::string("createrawtransaction ") + prevout + " " +
                 "{\"3HqAe9LtNBjnsfM4CyYaWTnvCaUYT7v4oZ\":11}");
     std::string notsigned = r.get_str();
     std::string privkey1 =
         "\"KzsXybp9jX64P5ekX1KUxRQ79Jht9uzW7LorgwE65i5rWACL6LQe\"";
     std::string privkey2 =
         "\"Kyhdf5LuKTRx4ge69ybABsiUAWjVRK4XGxAKk2FQLp2HjGMy87Z4\"";
 
     bool exceptionThrownDueToMissingAmount = false,
          errorWasMissingAmount = false;
 
     try {
         r = CallRPC(std::string("signrawtransactionwithkey ") + notsigned +
                     " [" + privkey1 + "," + privkey2 + "] " + prevout);
     } catch (const std::runtime_error &e) {
         exceptionThrownDueToMissingAmount = true;
         if (std::string(e.what()).find("amount") != std::string::npos) {
             errorWasMissingAmount = true;
         }
     }
     BOOST_CHECK(exceptionThrownDueToMissingAmount == true);
     BOOST_CHECK(errorWasMissingAmount == true);
 }
 
 BOOST_AUTO_TEST_CASE(rpc_createraw_op_return) {
     BOOST_CHECK_NO_THROW(
         CallRPC("createrawtransaction "
                 "[{\"txid\":"
                 "\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff1"
                 "50ed\",\"vout\":0}] {\"data\":\"68656c6c6f776f726c64\"}"));
 
     // Key not "data" (bad address)
     BOOST_CHECK_THROW(
         CallRPC("createrawtransaction "
                 "[{\"txid\":"
                 "\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff1"
                 "50ed\",\"vout\":0}] {\"somedata\":\"68656c6c6f776f726c64\"}"),
         std::runtime_error);
 
     // Bad hex encoding of data output
     BOOST_CHECK_THROW(
         CallRPC("createrawtransaction "
                 "[{\"txid\":"
                 "\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff1"
                 "50ed\",\"vout\":0}] {\"data\":\"12345\"}"),
         std::runtime_error);
     BOOST_CHECK_THROW(
         CallRPC("createrawtransaction "
                 "[{\"txid\":"
                 "\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff1"
                 "50ed\",\"vout\":0}] {\"data\":\"12345g\"}"),
         std::runtime_error);
 
     // Data 81 bytes long
     BOOST_CHECK_NO_THROW(
         CallRPC("createrawtransaction "
                 "[{\"txid\":"
                 "\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff1"
                 "50ed\",\"vout\":0}] "
                 "{\"data\":"
                 "\"010203040506070809101112131415161718192021222324252627282930"
                 "31323334353637383940414243444546474849505152535455565758596061"
                 "6263646566676869707172737475767778798081\"}"));
 }
 
 BOOST_AUTO_TEST_CASE(rpc_format_monetary_values) {
     BOOST_CHECK(UniValue(Amount::zero()).write() == "0.00");
     BOOST_CHECK(UniValue(SATOSHI).write() == "0.01");
     BOOST_CHECK(UniValue(17622195 * SATOSHI).write() == "176221.95");
     BOOST_CHECK(UniValue(50000000 * SATOSHI).write() == "500000.00");
     BOOST_CHECK(UniValue(89898989 * SATOSHI).write() == "898989.89");
     BOOST_CHECK(UniValue(100000000 * SATOSHI).write() == "1000000.00");
     BOOST_CHECK(UniValue(int64_t(2099999999999990) * SATOSHI).write() ==
                 "20999999999999.90");
     BOOST_CHECK(UniValue(int64_t(2099999999999999) * SATOSHI).write() ==
                 "20999999999999.99");
 
     BOOST_CHECK_EQUAL(UniValue(Amount::zero()).write(), "0.00");
     BOOST_CHECK_EQUAL(UniValue(123456789 * (COIN / 10000)).write(),
                       "12345678900.00");
     BOOST_CHECK_EQUAL(UniValue(-1 * COIN).write(), "-1000000.00");
     BOOST_CHECK_EQUAL(UniValue(-1 * COIN / 10).write(), "-100000.00");
 
     BOOST_CHECK_EQUAL(UniValue(100000000 * COIN).write(), "100000000000000.00");
     BOOST_CHECK_EQUAL(UniValue(10000000 * COIN).write(), "10000000000000.00");
     BOOST_CHECK_EQUAL(UniValue(1000000 * COIN).write(), "1000000000000.00");
     BOOST_CHECK_EQUAL(UniValue(100000 * COIN).write(), "100000000000.00");
     BOOST_CHECK_EQUAL(UniValue(10000 * COIN).write(), "10000000000.00");
     BOOST_CHECK_EQUAL(UniValue(1000 * COIN).write(), "1000000000.00");
     BOOST_CHECK_EQUAL(UniValue(100 * COIN).write(), "100000000.00");
     BOOST_CHECK_EQUAL(UniValue(10 * COIN).write(), "10000000.00");
     BOOST_CHECK_EQUAL(UniValue(COIN).write(), "1000000.00");
     BOOST_CHECK_EQUAL(UniValue(COIN / 10).write(), "100000.00");
     BOOST_CHECK_EQUAL(UniValue(COIN / 100).write(), "10000.00");
     BOOST_CHECK_EQUAL(UniValue(COIN / 1000).write(), "1000.00");
     BOOST_CHECK_EQUAL(UniValue(COIN / 10000).write(), "100.00");
     BOOST_CHECK_EQUAL(UniValue(COIN / 100000).write(), "10.00");
     BOOST_CHECK_EQUAL(UniValue(COIN / 1000000).write(), "1.00");
     BOOST_CHECK_EQUAL(UniValue(COIN / 10000000).write(), "0.10");
     BOOST_CHECK_EQUAL(UniValue(COIN / 100000000).write(), "0.01");
 }
 
 static UniValue ValueFromString(const std::string &str) {
     UniValue value;
     BOOST_CHECK(value.setNumStr(str));
     return value;
 }
 
 BOOST_AUTO_TEST_CASE(rpc_parse_monetary_values) {
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("-0.01")), UniValue);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0")), Amount::zero());
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.00")), Amount::zero());
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.01")), SATOSHI);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("176221.95")),
                       17622195 * SATOSHI);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("500000")),
                       50000000 * SATOSHI);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("500000.00")),
                       50000000 * SATOSHI);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("898989.89")),
                       89898989 * SATOSHI);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("1000000.00")),
                       100000000 * SATOSHI);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("20999999999999.9")),
                       int64_t(2099999999999990) * SATOSHI);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("20999999999999.99")),
                       int64_t(2099999999999999) * SATOSHI);
 
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("1e-2")),
                       COIN / 100000000);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.1e-1")),
                       COIN / 100000000);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.01e-0")),
                       COIN / 100000000);
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString(
                           "0."
                           "0000000000000000000000000000000000000000000000000000"
                           "000000000000000000000001e+74")),
                       COIN / 100000000);
     BOOST_CHECK_EQUAL(
         AmountFromValue(ValueFromString("10000000000000000000000000000000000000"
                                         "000000000000000000000000000e-58")),
         COIN);
     BOOST_CHECK_EQUAL(
         AmountFromValue(ValueFromString(
             "0."
             "000000000000000000000000000000000000000000000000000000000000000100"
             "000000000000000000000000000000000000000000000000000e70")),
         COIN);
 
     // should fail
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e-9")), UniValue);
     // should fail
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("0.000000019")),
                       UniValue);
     // should pass, cut trailing 0
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.01000000")), SATOSHI);
     // should fail
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("19e-9")), UniValue);
     // should pass, leading 0 is present
     BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.19e-0")),
                       19 * SATOSHI);
 
     // overflow error
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("92233720368.54775808")),
                       UniValue);
     // overflow error
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e+17")), UniValue);
     // overflow error signless
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e17")), UniValue);
     // overflow error
     BOOST_CHECK_THROW(AmountFromValue(ValueFromString("93e+15")), UniValue);
 }
 
 BOOST_AUTO_TEST_CASE(json_parse_errors) {
     // Valid
     BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0").get_real(), 1.0);
     // Valid, with leading or trailing whitespace
     BOOST_CHECK_EQUAL(ParseNonRFCJSONValue(" 1.0").get_real(), 1.0);
     BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0 ").get_real(), 1.0);
 
     // should fail, missing leading 0, therefore invalid JSON
     BOOST_CHECK_THROW(AmountFromValue(ParseNonRFCJSONValue(".19e-6")),
                       std::runtime_error);
     BOOST_CHECK_EQUAL(AmountFromValue(ParseNonRFCJSONValue(
                           "0.00000000000000000000000000000001e+30 ")),
                       SATOSHI);
     // Invalid, initial garbage
     BOOST_CHECK_THROW(ParseNonRFCJSONValue("[1.0"), std::runtime_error);
     BOOST_CHECK_THROW(ParseNonRFCJSONValue("a1.0"), std::runtime_error);
     // Invalid, trailing garbage
     BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0sds"), std::runtime_error);
     BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0]"), std::runtime_error);
-    // BCH addresses should fail parsing
+    // Legacy addresses should fail parsing
     BOOST_CHECK_THROW(
         ParseNonRFCJSONValue("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"),
         std::runtime_error);
     BOOST_CHECK_THROW(ParseNonRFCJSONValue("3J98t1WpEZ73CNmQviecrnyiWrnqRhWNL"),
                       std::runtime_error);
 }
 
 BOOST_AUTO_TEST_CASE(rpc_ban) {
     BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
 
     UniValue r;
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0 add")));
     // portnumber for setban not allowed
     BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.0.0:8334")),
                       std::runtime_error);
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     UniValue ar = r.get_array();
     UniValue o1 = ar[0].get_obj();
     UniValue adr = find_value(o1, "address");
     BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/32");
     BOOST_CHECK_NO_THROW(CallRPC(std::string("setban 127.0.0.0 remove")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     BOOST_CHECK_EQUAL(ar.size(), 0UL);
 
     // Set ban way in the future: 2283-12-18 19:33:20
     BOOST_CHECK_NO_THROW(
         r = CallRPC(std::string("setban 127.0.0.0/24 add 9907731200 true")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     o1 = ar[0].get_obj();
     adr = find_value(o1, "address");
     UniValue banned_until = find_value(o1, "banned_until");
     BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/24");
     // absolute time check
     BOOST_CHECK_EQUAL(banned_until.get_int64(), 9907731200);
 
     BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
 
     BOOST_CHECK_NO_THROW(
         r = CallRPC(std::string("setban 127.0.0.0/24 add 200")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     o1 = ar[0].get_obj();
     adr = find_value(o1, "address");
     banned_until = find_value(o1, "banned_until");
     BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/24");
     int64_t now = GetTime();
     BOOST_CHECK(banned_until.get_int64() > now);
     BOOST_CHECK(banned_until.get_int64() - now <= 200);
 
     // must throw an exception because 127.0.0.1 is in already banned subnet
     // range
     BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.0.1 add")),
                       std::runtime_error);
 
     BOOST_CHECK_NO_THROW(CallRPC(std::string("setban 127.0.0.0/24 remove")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     BOOST_CHECK_EQUAL(ar.size(), 0UL);
 
     BOOST_CHECK_NO_THROW(
         r = CallRPC(std::string("setban 127.0.0.0/255.255.0.0 add")));
     BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.1.1 add")),
                       std::runtime_error);
 
     BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     BOOST_CHECK_EQUAL(ar.size(), 0UL);
 
     // invalid IP
     BOOST_CHECK_THROW(r = CallRPC(std::string("setban test add")),
                       std::runtime_error);
 
     // IPv6 tests
     BOOST_CHECK_NO_THROW(
         r = CallRPC(
             std::string("setban FE80:0000:0000:0000:0202:B3FF:FE1E:8329 add")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     o1 = ar[0].get_obj();
     adr = find_value(o1, "address");
     BOOST_CHECK_EQUAL(adr.get_str(), "fe80::202:b3ff:fe1e:8329/128");
 
     BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string(
                              "setban 2001:db8::/ffff:fffc:0:0:0:0:0:0 add")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     o1 = ar[0].get_obj();
     adr = find_value(o1, "address");
     BOOST_CHECK_EQUAL(adr.get_str(), "2001:db8::/30");
 
     BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
     BOOST_CHECK_NO_THROW(
         r = CallRPC(std::string(
             "setban 2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/128 add")));
     BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
     ar = r.get_array();
     o1 = ar[0].get_obj();
     adr = find_value(o1, "address");
     BOOST_CHECK_EQUAL(adr.get_str(),
                       "2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/128");
 }
 
 BOOST_AUTO_TEST_CASE(rpc_convert_values_generatetoaddress) {
     UniValue result;
 
     BOOST_CHECK_NO_THROW(result = RPCConvertValues(
                              "generatetoaddress",
                              {"101", "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a"}));
     BOOST_CHECK_EQUAL(result[0].get_int(), 101);
     BOOST_CHECK_EQUAL(result[1].get_str(),
                       "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a");
 
     BOOST_CHECK_NO_THROW(result = RPCConvertValues(
                              "generatetoaddress",
                              {"101", "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU"}));
     BOOST_CHECK_EQUAL(result[0].get_int(), 101);
     BOOST_CHECK_EQUAL(result[1].get_str(),
                       "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU");
 
     BOOST_CHECK_NO_THROW(result = RPCConvertValues(
                              "generatetoaddress",
                              {"1", "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a", "9"}));
     BOOST_CHECK_EQUAL(result[0].get_int(), 1);
     BOOST_CHECK_EQUAL(result[1].get_str(),
                       "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a");
     BOOST_CHECK_EQUAL(result[2].get_int(), 9);
 
     BOOST_CHECK_NO_THROW(result = RPCConvertValues(
                              "generatetoaddress",
                              {"1", "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU", "9"}));
     BOOST_CHECK_EQUAL(result[0].get_int(), 1);
     BOOST_CHECK_EQUAL(result[1].get_str(),
                       "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU");
     BOOST_CHECK_EQUAL(result[2].get_int(), 9);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/test/coinselector_tests.cpp b/src/wallet/test/coinselector_tests.cpp
index 213d2b4fd..355c4ad20 100644
--- a/src/wallet/test/coinselector_tests.cpp
+++ b/src/wallet/test/coinselector_tests.cpp
@@ -1,827 +1,827 @@
 // Copyright (c) 2017 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 <amount.h>
 #include <chainparams.h> // For Params
 #include <node/context.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <wallet/coincontrol.h>
 #include <wallet/coinselection.h>
 #include <wallet/wallet.h>
 
 #include <test/util/setup_common.h>
 #include <wallet/test/wallet_test_fixture.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <memory>
 #include <random>
 
 BOOST_FIXTURE_TEST_SUITE(coinselector_tests, WalletTestingSetup)
 
 // how many times to run all the tests to have a chance to catch errors that
 // only show up with particular random shuffles
 #define RUN_TESTS 100
 
 // some tests fail 1% of the time due to bad luck.
 // we repeat those tests this many times and only complain if all iterations of
 // the test fail
 #define RANDOM_REPEATS 5
 
 typedef std::set<CInputCoin> CoinSet;
 
 static std::vector<COutput> vCoins;
 static NodeContext testNode;
 static Amount balance = Amount::zero();
 
 CoinEligibilityFilter filter_standard(1, 6, 0);
 CoinEligibilityFilter filter_confirmed(1, 1, 0);
 CoinEligibilityFilter filter_standard_extra(6, 6, 0);
 CoinSelectionParams coin_selection_params(false, 0, 0, CFeeRate(Amount::zero()),
                                           0);
 
 static void add_coin(const Amount nValue, int nInput,
                      std::vector<CInputCoin> &set) {
     CMutableTransaction tx;
     tx.vout.resize(nInput + 1);
     tx.vout[nInput].nValue = nValue;
     set.emplace_back(MakeTransactionRef(tx), nInput);
 }
 
 static void add_coin(const Amount nValue, int nInput, CoinSet &set) {
     CMutableTransaction tx;
     tx.vout.resize(nInput + 1);
     tx.vout[nInput].nValue = nValue;
     set.emplace(MakeTransactionRef(tx), nInput);
 }
 
 static void add_coin(CWallet &wallet, const Amount nValue, int nAge = 6 * 24,
                      bool fIsFromMe = false, int nInput = 0,
                      bool spendable = false) {
     balance += nValue;
     static int nextLockTime = 0;
     CMutableTransaction tx;
     // so all transactions get different hashes
     tx.nLockTime = nextLockTime++;
     tx.vout.resize(nInput + 1);
     tx.vout[nInput].nValue = nValue;
     if (spendable) {
         CTxDestination dest;
         std::string error;
         assert(wallet.GetNewDestination(OutputType::LEGACY, "", dest, error));
         tx.vout[nInput].scriptPubKey = GetScriptForDestination(dest);
     }
     if (fIsFromMe) {
         // IsFromMe() returns (GetDebit() > 0), and GetDebit() is 0 if
         // vin.empty(), so stop vin being empty, and cache a non-zero Debit to
         // fake out IsFromMe()
         tx.vin.resize(1);
     }
     CWalletTx *wtx = wallet.AddToWallet(MakeTransactionRef(std::move(tx)),
                                         /* confirm= */ {});
     if (fIsFromMe) {
         wtx->m_amounts[CWalletTx::DEBIT].Set(ISMINE_SPENDABLE, SATOSHI);
         wtx->m_is_cache_empty = false;
     }
     COutput output(wtx, nInput, nAge, true /* spendable */, true /* solvable */,
                    true /* safe */);
     vCoins.push_back(output);
 }
 
 static void empty_wallet() {
     vCoins.clear();
     balance = Amount::zero();
 }
 
 static bool equal_sets(CoinSet a, CoinSet b) {
     std::pair<CoinSet::iterator, CoinSet::iterator> ret =
         mismatch(a.begin(), a.end(), b.begin());
     return ret.first == a.end() && ret.second == b.end();
 }
 
 static Amount make_hard_case(int utxos, std::vector<CInputCoin> &utxo_pool) {
     utxo_pool.clear();
     Amount target = Amount::zero();
     for (int i = 0; i < utxos; ++i) {
         const Amount base = (int64_t(1) << (utxos + i)) * SATOSHI;
         target += base;
         add_coin(base, 2 * i, utxo_pool);
         add_coin(base + (int64_t(1) << (utxos - 1 - i)) * SATOSHI, 2 * i + 1,
                  utxo_pool);
     }
     return target;
 }
 
 inline std::vector<OutputGroup> &
 GroupCoins(const std::vector<CInputCoin> &coins) {
     static std::vector<OutputGroup> static_groups;
     static_groups.clear();
     for (auto &coin : coins) {
         static_groups.emplace_back(coin, 0, true, 0, 0);
     }
     return static_groups;
 }
 
 inline std::vector<OutputGroup> &GroupCoins(const std::vector<COutput> &coins) {
     static std::vector<OutputGroup> static_groups;
     static_groups.clear();
     for (auto &coin : coins) {
         // HACK: we can't figure out the is_me flag so we use the conditions
         // defined below; perhaps set safe to false for !fIsFromMe in add_coin()
         const bool is_me =
             coin.tx->m_amounts[CWalletTx::DEBIT].m_cached[ISMINE_SPENDABLE] &&
             coin.tx->m_amounts[CWalletTx::DEBIT].m_value[ISMINE_SPENDABLE] ==
                 SATOSHI;
         static_groups.emplace_back(coin.GetInputCoin(), coin.nDepth, is_me, 0,
                                    0);
     }
     return static_groups;
 }
 
 // Branch and bound coin selection tests
 BOOST_AUTO_TEST_CASE(bnb_search_test) {
     LOCK(m_wallet.cs_wallet);
     m_wallet.SetupLegacyScriptPubKeyMan();
 
     // Setup
     std::vector<CInputCoin> utxo_pool;
     CoinSet selection;
     CoinSet actual_selection;
     Amount value_ret = Amount::zero();
     Amount not_input_fees = Amount::zero();
 
     /////////////////////////
     // Known Outcome tests //
     /////////////////////////
 
     // Empty utxo pool
     BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 1 * CENT, CENT / 2,
                                 selection, value_ret, not_input_fees));
     selection.clear();
 
     // Add utxos
     add_coin(1 * CENT, 1, utxo_pool);
     add_coin(2 * CENT, 2, utxo_pool);
     add_coin(3 * CENT, 3, utxo_pool);
     add_coin(4 * CENT, 4, utxo_pool);
 
     // Select 1 Cent
     add_coin(1 * CENT, 1, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 1 * CENT, CENT / 2,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK(equal_sets(selection, actual_selection));
     BOOST_CHECK_EQUAL(value_ret, 1 * CENT);
     actual_selection.clear();
     selection.clear();
 
     // Select 2 Cent
     add_coin(2 * CENT, 2, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 2 * CENT, CENT / 2,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK(equal_sets(selection, actual_selection));
     BOOST_CHECK_EQUAL(value_ret, 2 * CENT);
     actual_selection.clear();
     selection.clear();
 
     // Select 5 Cent
     add_coin(4 * CENT, 4, actual_selection);
     add_coin(1 * CENT, 1, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 5 * CENT, CENT / 2,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK(equal_sets(selection, actual_selection));
     BOOST_CHECK_EQUAL(value_ret, 5 * CENT);
     actual_selection.clear();
     selection.clear();
 
     // Select 11 Cent, not possible
     BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 11 * CENT, CENT / 2,
                                 selection, value_ret, not_input_fees));
     actual_selection.clear();
     selection.clear();
 
     // Cost of change is greater than the difference between target value and
     // utxo sum
     add_coin(1 * CENT, 1, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 9 * CENT / 10,
                                5 * CENT / 10, selection, value_ret,
                                not_input_fees));
     BOOST_CHECK_EQUAL(value_ret, 1 * CENT);
     BOOST_CHECK(equal_sets(selection, actual_selection));
     actual_selection.clear();
     selection.clear();
 
     // Cost of change is less than the difference between target value and utxo
     // sum
     BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 9 * CENT / 10,
                                 Amount::zero(), selection, value_ret,
                                 not_input_fees));
     actual_selection.clear();
     selection.clear();
 
     // Select 10 Cent
     add_coin(5 * CENT, 5, utxo_pool);
     add_coin(5 * CENT, 5, actual_selection);
     add_coin(4 * CENT, 4, actual_selection);
     add_coin(1 * CENT, 1, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 10 * CENT, CENT / 2,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK(equal_sets(selection, actual_selection));
     BOOST_CHECK_EQUAL(value_ret, 10 * CENT);
     actual_selection.clear();
     selection.clear();
 
     // Negative effective value
     // Select 10 Cent but have 1 Cent not be possible because too small
     add_coin(5 * CENT, 5, actual_selection);
     add_coin(3 * CENT, 3, actual_selection);
     add_coin(2 * CENT, 2, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 10 * CENT, 5000 * SATOSHI,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK_EQUAL(value_ret, 10 * CENT);
     // FIXME: this test is redundant with the above, because 1 Cent is selected,
     // not "too small" BOOST_CHECK(equal_sets(selection, actual_selection));
 
     // Select 0.25 Cent, not possible
     BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), CENT / 4, CENT / 2,
                                 selection, value_ret, not_input_fees));
     actual_selection.clear();
     selection.clear();
 
     // Iteration exhaustion test
     Amount target = make_hard_case(17, utxo_pool);
     // Should exhaust
     BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), target, Amount::zero(),
                                 selection, value_ret, not_input_fees));
     target = make_hard_case(14, utxo_pool);
     // Should not exhaust
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), target, Amount::zero(),
                                selection, value_ret, not_input_fees));
 
     // Test same value early bailout optimization
     utxo_pool.clear();
     add_coin(7 * CENT, 7, actual_selection);
     add_coin(7 * CENT, 7, actual_selection);
     add_coin(7 * CENT, 7, actual_selection);
     add_coin(7 * CENT, 7, actual_selection);
     add_coin(2 * CENT, 7, actual_selection);
     add_coin(7 * CENT, 7, utxo_pool);
     add_coin(7 * CENT, 7, utxo_pool);
     add_coin(7 * CENT, 7, utxo_pool);
     add_coin(7 * CENT, 7, utxo_pool);
     add_coin(2 * CENT, 7, utxo_pool);
     for (int i = 0; i < 50000; ++i) {
         add_coin(5 * CENT, 7, utxo_pool);
     }
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 30 * CENT, 5000 * SATOSHI,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK_EQUAL(value_ret, 30 * CENT);
     BOOST_CHECK(equal_sets(selection, actual_selection));
 
     ////////////////////
     // Behavior tests //
     ////////////////////
     // Select 1 Cent with pool of only greater than 5 Cent
     utxo_pool.clear();
     for (int i = 5; i <= 20; ++i) {
         add_coin(i * CENT, i, utxo_pool);
     }
     // Run 100 times, to make sure it is never finding a solution
     for (int i = 0; i < 100; ++i) {
         BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 1 * CENT, 2 * CENT,
                                     selection, value_ret, not_input_fees));
     }
 
     // Make sure that effective value is working in SelectCoinsMinConf when BnB
     // is used
     CoinSelectionParams coin_selection_params_bnb(true, 0, 0,
                                                   CFeeRate(3000 * SATOSHI), 0);
     CoinSet setCoinsRet;
     Amount nValueRet;
     bool bnb_used;
     empty_wallet();
     add_coin(m_wallet, SATOSHI);
     // Make sure that it has a negative effective value. The next check should
     // assert if this somehow got through. Otherwise it will fail
     vCoins.at(0).nInputBytes = 40;
     BOOST_CHECK(!m_wallet.SelectCoinsMinConf(
         1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet,
         coin_selection_params_bnb, bnb_used));
 
     // Test fees subtracted from output:
     empty_wallet();
     add_coin(m_wallet, 1 * CENT);
     vCoins.at(0).nInputBytes = 40;
     BOOST_CHECK(!m_wallet.SelectCoinsMinConf(
         1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet,
         coin_selection_params_bnb, bnb_used));
     coin_selection_params_bnb.m_subtract_fee_outputs = true;
     BOOST_CHECK(m_wallet.SelectCoinsMinConf(
         1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet,
         coin_selection_params_bnb, bnb_used));
     BOOST_CHECK_EQUAL(nValueRet, 1 * CENT);
 
     // Make sure that can use BnB when there are preset inputs
     empty_wallet();
     {
         auto wallet = std::make_unique<CWallet>(m_chain.get(), WalletLocation(),
                                                 CreateMockWalletDatabase());
         bool firstRun;
         wallet->LoadWallet(firstRun);
         LOCK(wallet->cs_wallet);
         wallet->SetupLegacyScriptPubKeyMan();
         add_coin(*wallet, 5 * CENT, 6 * 24, false, 0, true);
         add_coin(*wallet, 3 * CENT, 6 * 24, false, 0, true);
         add_coin(*wallet, 2 * CENT, 6 * 24, false, 0, true);
         CCoinControl coin_control;
         coin_control.fAllowOtherInputs = true;
         coin_control.Select(
             COutPoint(vCoins.at(0).tx->GetId(), vCoins.at(0).i));
         coin_selection_params_bnb.effective_fee = CFeeRate(Amount::zero());
         BOOST_CHECK(wallet->SelectCoins(vCoins, 10 * CENT, setCoinsRet,
                                         nValueRet, coin_control,
                                         coin_selection_params_bnb, bnb_used));
         BOOST_CHECK(bnb_used);
         BOOST_CHECK(coin_selection_params_bnb.use_bnb);
     }
 }
 
 BOOST_AUTO_TEST_CASE(knapsack_solver_test) {
     auto testChain = interfaces::MakeChain(testNode, Params());
     CWallet testWallet(testChain.get(), WalletLocation(),
                        CreateDummyWalletDatabase());
 
     CoinSet setCoinsRet, setCoinsRet2;
     Amount nValueRet;
     bool bnb_used;
 
     LOCK(testWallet.cs_wallet);
     testWallet.SetupLegacyScriptPubKeyMan();
 
     // test multiple times to allow for differences in the shuffle order
     for (int i = 0; i < RUN_TESTS; i++) {
         empty_wallet();
 
         // with an empty wallet we can't even pay one cent
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
 
         // add a new 1 cent coin
         add_coin(testWallet, 1 * CENT, 4);
 
         // with a new 1 cent coin, we still can't find a mature 1 cent
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
 
         // but we can find a new 1 cent
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             1 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 1 * CENT);
         // add a mature 2 cent coin
         add_coin(testWallet, 2 * CENT);
 
         // we can't make 3 cents of mature coins
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             3 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
 
         // we can make 3 cents of new coins
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             3 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 3 * CENT);
 
         // add a mature 5 cent coin,
         add_coin(testWallet, 5 * CENT);
         // a new 10 cent coin sent from one of our own addresses
         add_coin(testWallet, 10 * CENT, 3, true);
         // and a mature 20 cent coin
         add_coin(testWallet, 20 * CENT);
 
         // now we have new: 1+10=11 (of which 10 was self-sent), and mature:
         // 2+5+20=27.  total = 38
 
         // we can't make 38 cents only if we disallow new coins:
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             38 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we can't even make 37 cents if we don't allow new coins even if
         // they're from us
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             38 * CENT, filter_standard_extra, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // but we can make 37 cents if we accept new coins from ourself
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             37 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 37 * CENT);
         // and we can make 38 cents if we accept all new coins
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             38 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 38 * CENT);
 
         // try making 34 cents from 1,2,5,10,20 - we can't do it exactly
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             34 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // but 35 cents is closest
         BOOST_CHECK_EQUAL(nValueRet, 35 * CENT);
         // the best should be 20+10+5.  it's incredibly unlikely the 1 or 2 got
         // included (but possible)
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         // when we try making 7 cents, the smaller coins (1,2,5) are enough.  We
         // should see just 2+5
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             7 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 7 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
         // when we try making 8 cents, the smaller coins (1,2,5) are exactly
         // enough.
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             8 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK(nValueRet == 8 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         // when we try making 9 cents, no subset of smaller coins is enough, and
         // we get the next bigger coin (10)
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             9 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 10 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // now clear out the wallet and start again to test choosing between
         // subsets of smaller coins and the next biggest coin
         empty_wallet();
 
         add_coin(testWallet, 6 * CENT);
         add_coin(testWallet, 7 * CENT);
         add_coin(testWallet, 8 * CENT);
         add_coin(testWallet, 20 * CENT);
         // now we have 6+7+8+20+30 = 71 cents total
         add_coin(testWallet, 30 * CENT);
 
         // check that we have 71 and not 72
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             71 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             72 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
 
         // now try making 16 cents.  the best smaller coins can do is 6+7+8 =
         // 21; not as good at the next biggest coin, 20
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get 20 in one coin
         BOOST_CHECK_EQUAL(nValueRet, 20 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // now we have 5+6+7+8+20+30 = 75 cents total
         add_coin(testWallet, 5 * CENT);
 
         // now if we try making 16 cents again, the smaller coins can make 5+6+7
         // = 18 cents, better than the next biggest coin, 20
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get 18 in 3 coins
         BOOST_CHECK_EQUAL(nValueRet, 18 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         // now we have 5+6+7+8+18+20+30
         add_coin(testWallet, 18 * CENT);
 
         // and now if we try making 16 cents again, the smaller coins can make
         // 5+6+7 = 18 cents, the same as the next biggest coin, 18
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get 18 in 1 coin
         BOOST_CHECK_EQUAL(nValueRet, 18 * CENT);
         // because in the event of a tie, the biggest coin wins
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // now try making 11 cents.  we should get 5+6
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             11 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 11 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
         // check that the smallest bigger coin is used
         add_coin(testWallet, 1 * COIN);
         add_coin(testWallet, 2 * COIN);
         add_coin(testWallet, 3 * COIN);
         // now we have 5+6+7+8+18+20+30+100+200+300+400 = 1094 cents
         add_coin(testWallet, 4 * COIN);
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             95 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
-        // we should get 1 BCH in 1 coin
+        // we should get 1,000,000 XEC in 1 coin
         BOOST_CHECK_EQUAL(nValueRet, 1 * COIN);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             195 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
-        // we should get 2 BCH in 1 coin
+        // we should get 2,000,000 XEC in 1 coin
         BOOST_CHECK_EQUAL(nValueRet, 2 * COIN);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // empty the wallet and start again, now with fractions of a cent, to
         // test small change avoidance
 
         empty_wallet();
         add_coin(testWallet, 1 * MIN_CHANGE / 10);
         add_coin(testWallet, 2 * MIN_CHANGE / 10);
         add_coin(testWallet, 3 * MIN_CHANGE / 10);
         add_coin(testWallet, 4 * MIN_CHANGE / 10);
         add_coin(testWallet, 5 * MIN_CHANGE / 10);
 
         // try making 1 * MIN_CHANGE from the 1.5 * MIN_CHANGE
         // we'll get change smaller than MIN_CHANGE whatever happens, so can
         // expect MIN_CHANGE exactly
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, MIN_CHANGE);
 
         // but if we add a bigger coin, small change is avoided
         add_coin(testWallet, 1111 * MIN_CHANGE);
 
         // try making 1 from 0.1 + 0.2 + 0.3 + 0.4 + 0.5 + 1111 = 1112.5
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get the exact amount
         BOOST_CHECK_EQUAL(nValueRet, 1 * MIN_CHANGE);
 
         // if we add more small coins:
         add_coin(testWallet, 6 * MIN_CHANGE / 10);
         add_coin(testWallet, 7 * MIN_CHANGE / 10);
 
         // and try again to make 1.0 * MIN_CHANGE
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get the exact amount
         BOOST_CHECK_EQUAL(nValueRet, 1 * MIN_CHANGE);
 
         // run the 'mtgox' test (see
         // http://blockexplorer.com/tx/29a3efd3ef04f9153d47a990bd7b048a4b2d213daaa5fb8ed670fb85f13bdbcf)
         // they tried to consolidate 10 50k coins into one 500k coin, and ended
         // up with 50k in change
         empty_wallet();
         for (int j = 0; j < 20; j++) {
             add_coin(testWallet, 50000 * COIN);
         }
 
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             500000 * COIN, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get the exact amount
         BOOST_CHECK_EQUAL(nValueRet, 500000 * COIN);
         // in ten coins
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 10U);
 
         // if there's not enough in the smaller coins to make at least 1 *
         // MIN_CHANGE change (0.5+0.6+0.7 < 1.0+1.0), we need to try finding an
         // exact subset anyway
 
         // sometimes it will fail, and so we use the next biggest coin:
         empty_wallet();
         add_coin(testWallet, 5 * MIN_CHANGE / 10);
         add_coin(testWallet, 6 * MIN_CHANGE / 10);
         add_coin(testWallet, 7 * MIN_CHANGE / 10);
         add_coin(testWallet, 1111 * MIN_CHANGE);
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we get the bigger coin
         BOOST_CHECK_EQUAL(nValueRet, 1111 * MIN_CHANGE);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // but sometimes it's possible, and we use an exact subset (0.4 + 0.6 =
         // 1.0)
         empty_wallet();
         add_coin(testWallet, 4 * MIN_CHANGE / 10);
         add_coin(testWallet, 6 * MIN_CHANGE / 10);
         add_coin(testWallet, 8 * MIN_CHANGE / 10);
         add_coin(testWallet, 1111 * MIN_CHANGE);
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get the exact amount
         BOOST_CHECK_EQUAL(nValueRet, MIN_CHANGE);
         // in two coins 0.4+0.6
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
         // test avoiding small change
         empty_wallet();
         add_coin(testWallet, 5 * MIN_CHANGE / 100);
         add_coin(testWallet, 1 * MIN_CHANGE);
         add_coin(testWallet, 100 * MIN_CHANGE);
 
         // trying to make 100.01 from these three coins
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             10001 * MIN_CHANGE / 100, filter_confirmed, GroupCoins(vCoins),
             setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         // we should get all coins
         BOOST_CHECK_EQUAL(nValueRet, 10105 * MIN_CHANGE / 100);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         // but if we try to make 99.9, we should take the bigger of the two
         // small coins to avoid small change
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             9990 * MIN_CHANGE / 100, filter_confirmed, GroupCoins(vCoins),
             setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 101 * MIN_CHANGE);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
     }
 
     // test with many inputs
     for (Amount amt = 1500 * SATOSHI; amt < COIN; amt = 10 * amt) {
         empty_wallet();
         // Create 676 inputs (=  (old MAX_STANDARD_TX_SIZE == 100000)  / 148
         // bytes per input)
         for (uint16_t j = 0; j < 676; j++) {
             add_coin(testWallet, amt);
         }
 
         // We only create the wallet once to save time, but we still run the
         // coin selection RUN_TESTS times.
         for (int i = 0; i < RUN_TESTS; i++) {
             BOOST_CHECK(testWallet.SelectCoinsMinConf(
                 2000 * SATOSHI, filter_confirmed, GroupCoins(vCoins),
                 setCoinsRet, nValueRet, coin_selection_params, bnb_used));
 
             if (amt - 2000 * SATOSHI < MIN_CHANGE) {
                 // needs more than one input:
                 uint16_t returnSize = std::ceil(
                     (2000.0 + (MIN_CHANGE / SATOSHI)) / (amt / SATOSHI));
                 Amount returnValue = returnSize * amt;
                 BOOST_CHECK_EQUAL(nValueRet, returnValue);
                 BOOST_CHECK_EQUAL(setCoinsRet.size(), returnSize);
             } else {
                 // one input is sufficient:
                 BOOST_CHECK_EQUAL(nValueRet, amt);
                 BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
             }
         }
     }
 
     // test randomness
     {
         empty_wallet();
         for (int i2 = 0; i2 < 100; i2++) {
             add_coin(testWallet, COIN);
         }
 
         // Again, we only create the wallet once to save time, but we still run
         // the coin selection RUN_TESTS times.
         for (int i = 0; i < RUN_TESTS; i++) {
             // picking 50 from 100 coins doesn't depend on the shuffle, but does
             // depend on randomness in the stochastic approximation code
             BOOST_CHECK(testWallet.SelectCoinsMinConf(
                 50 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet,
                 nValueRet, coin_selection_params, bnb_used));
             BOOST_CHECK(testWallet.SelectCoinsMinConf(
                 50 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet2,
                 nValueRet, coin_selection_params, bnb_used));
             BOOST_CHECK(!equal_sets(setCoinsRet, setCoinsRet2));
 
             int fails = 0;
             for (int j = 0; j < RANDOM_REPEATS; j++) {
                 // selecting 1 from 100 identical coins depends on the shuffle;
                 // this test will fail 1% of the time run the test
                 // RANDOM_REPEATS times and only complain if all of them fail
                 BOOST_CHECK(testWallet.SelectCoinsMinConf(
                     COIN, filter_standard, GroupCoins(vCoins), setCoinsRet,
                     nValueRet, coin_selection_params, bnb_used));
                 BOOST_CHECK(testWallet.SelectCoinsMinConf(
                     COIN, filter_standard, GroupCoins(vCoins), setCoinsRet2,
                     nValueRet, coin_selection_params, bnb_used));
                 if (equal_sets(setCoinsRet, setCoinsRet2)) {
                     fails++;
                 }
             }
             BOOST_CHECK_NE(fails, RANDOM_REPEATS);
         }
 
         // add 75 cents in small change.  not enough to make 90 cents, then
         // try making 90 cents.  there are multiple competing "smallest
         // bigger" coins, one of which should be picked at random
         add_coin(testWallet, 5 * CENT);
         add_coin(testWallet, 10 * CENT);
         add_coin(testWallet, 15 * CENT);
         add_coin(testWallet, 20 * CENT);
         add_coin(testWallet, 25 * CENT);
 
         for (int i = 0; i < RUN_TESTS; i++) {
             int fails = 0;
             for (int j = 0; j < RANDOM_REPEATS; j++) {
                 // selecting 1 from 100 identical coins depends on the shuffle;
                 // this test will fail 1% of the time run the test
                 // RANDOM_REPEATS times and only complain if all of them fail
                 BOOST_CHECK(testWallet.SelectCoinsMinConf(
                     90 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
                     nValueRet, coin_selection_params, bnb_used));
                 BOOST_CHECK(testWallet.SelectCoinsMinConf(
                     90 * CENT, filter_standard, GroupCoins(vCoins),
                     setCoinsRet2, nValueRet, coin_selection_params, bnb_used));
                 if (equal_sets(setCoinsRet, setCoinsRet2)) {
                     fails++;
                 }
             }
             BOOST_CHECK_NE(fails, RANDOM_REPEATS);
         }
     }
 
     empty_wallet();
 }
 
 BOOST_AUTO_TEST_CASE(ApproximateBestSubset) {
     CoinSet setCoinsRet;
     Amount nValueRet;
     bool bnb_used;
 
     LOCK(m_wallet.cs_wallet);
     m_wallet.SetupLegacyScriptPubKeyMan();
 
     empty_wallet();
 
     // Test vValue sort order
     for (int i = 0; i < 1000; i++) {
         add_coin(m_wallet, 1000 * COIN);
     }
     add_coin(m_wallet, 3 * COIN);
 
     BOOST_CHECK(m_wallet.SelectCoinsMinConf(
         1003 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet,
         nValueRet, coin_selection_params, bnb_used));
     BOOST_CHECK_EQUAL(nValueRet, 1003 * COIN);
     BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
     empty_wallet();
 }
 
 // Tests that with the ideal conditions, the coin selector will always be able
 // to find a solution that can pay the target value
 BOOST_AUTO_TEST_CASE(SelectCoins_test) {
     auto testChain = interfaces::MakeChain(testNode, Params());
     CWallet testWallet(testChain.get(), WalletLocation(),
                        CreateDummyWalletDatabase());
     testWallet.SetupLegacyScriptPubKeyMan();
 
     // Random generator stuff
     std::default_random_engine generator;
     std::exponential_distribution<double> distribution(100);
     FastRandomContext rand;
 
     // Run this test 100 times
     for (int i = 0; i < 100; ++i) {
         empty_wallet();
 
         // Make a wallet with 1000 exponentially distributed random inputs
         for (int j = 0; j < 1000; ++j) {
             add_coin(testWallet,
                      int64_t(10000000 * distribution(generator)) * SATOSHI);
         }
 
         // Generate a random fee rate in the range of 100 - 400
         CFeeRate rate(int64_t(rand.randrange(300) + 100) * SATOSHI);
 
         // Generate a random target value between 1000 and wallet balance
         Amount target =
             int64_t(rand.randrange(balance / SATOSHI - 1000) + 1000) * SATOSHI;
 
         // Perform selection
         CoinSelectionParams coin_selection_params_knapsack(
             false, 34, 148, CFeeRate(Amount::zero()), 0);
         CoinSelectionParams coin_selection_params_bnb(
             true, 34, 148, CFeeRate(Amount::zero()), 0);
         CoinSet out_set;
         Amount out_value = Amount::zero();
         bool bnb_used = false;
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
                         target, filter_standard, GroupCoins(vCoins), out_set,
                         out_value, coin_selection_params_bnb, bnb_used) ||
                     testWallet.SelectCoinsMinConf(
                         target, filter_standard, GroupCoins(vCoins), out_set,
                         out_value, coin_selection_params_knapsack, bnb_used));
         BOOST_CHECK_GE(out_value, target);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()