sendcoinsdialog.cpp

Go to the documentation of this file.

// Copyright (c) 2011-2014 The Bitcoin developers
// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2015-2017 The DAPS Project developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#include "sendcoinsdialog.h"
#include "ui_sendcoinsdialog.h"
 
#include "addresstablemodel.h"
#include "askpassphrasedialog.h"
#include "bitcoinunits.h"
#include "chainparams.h"
#include "clientmodel.h"
#include "coincontroldialog.h"
#include "guiutil.h"
#include "optionsmodel.h"
#include "masternode-sync.h"
#include "sendcoinsentry.h"
#include "walletmodel.h"
 
#include "base58.h"
#include "coincontrol.h"
#include "guiinterface.h"
#include "utilmoneystr.h"
#include "wallet/wallet.h"
#include "2faconfirmdialog.h"
#include "timedata.h"
 
#include <regex>
#include <QMessageBox>
#include <QScrollBar>
#include <QSettings>
#include <QTextDocument>
#include <QDateTime>
#include <QDebug>
#include <QDesktopServices>
#include <QUrl>
 
 
SendCoinsDialog::SendCoinsDialog(QWidget* parent) : QDialog(parent, Qt::WindowSystemMenuHint | Qt::WindowTitleHint | Qt::WindowCloseButtonHint),
                                                    ui(new Ui::SendCoinsDialog),
                                                    clientModel(0),
                                                    // m_SizeGrip(this),
                                                    model(0),
                                                    fNewRecipientAllowed(true)
{
    ui->setupUi(this);
 
    addEntry();
 
    connect(ui->addButton, SIGNAL(clicked()), this, SLOT(addEntry()));
 
    // Coin Control
    connect(ui->pushButtonCoinControl, SIGNAL(clicked()), this, SLOT(coinControlButtonClicked()));
    connect(ui->checkBoxCoinControlChange, SIGNAL(stateChanged(int)), this, SLOT(coinControlChangeChecked(int)));
    connect(ui->lineEditCoinControlChange, SIGNAL(textEdited(const QString&)), this, SLOT(coinControlChangeEdited(const QString&)));
 
    // Coin Control: clipboard actions
    QAction* clipboardQuantityAction = new QAction(tr("Copy quantity"), this);
    QAction* clipboardAmountAction = new QAction(tr("Copy amount"), this);
    QAction* clipboardFeeAction = new QAction(tr("Copy fee"), this);
    QAction* clipboardAfterFeeAction = new QAction(tr("Copy after fee"), this);
    QAction* clipboardBytesAction = new QAction(tr("Copy bytes"), this);
    QAction* clipboardPriorityAction = new QAction(tr("Copy priority"), this);
    QAction* clipboardLowOutputAction = new QAction(tr("Copy dust"), this);
    QAction* clipboardChangeAction = new QAction(tr("Copy change"), this);
    connect(clipboardQuantityAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardQuantity()));
    connect(clipboardAmountAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardAmount()));
    connect(clipboardFeeAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardFee()));
    connect(clipboardAfterFeeAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardAfterFee()));
    connect(clipboardBytesAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardBytes()));
    connect(clipboardPriorityAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardPriority()));
    connect(clipboardLowOutputAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardLowOutput()));
    connect(clipboardChangeAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardChange()));
    ui->labelCoinControlQuantity->addAction(clipboardQuantityAction);
    ui->labelCoinControlAmount->addAction(clipboardAmountAction);
    ui->labelCoinControlFee->addAction(clipboardFeeAction);
    ui->labelCoinControlAfterFee->addAction(clipboardAfterFeeAction);
    ui->labelCoinControlBytes->addAction(clipboardBytesAction);
    ui->labelCoinControlPriority->addAction(clipboardPriorityAction);
    ui->labelCoinControlLowOutput->addAction(clipboardLowOutputAction);
    ui->labelCoinControlChange->addAction(clipboardChangeAction);
 
    // #HIDE multisend / unused items
    ui->addButton->setVisible(false);
    ui->checkBoxCoinControlChange->setVisible(false);
    ui->lineEditCoinControlChange->setVisible(false);
    ui->splitBlockCheckBox->setVisible(false);
    ui->splitBlockLineEdit->setVisible(false);
    ui->labelBlockSize->setVisible(false);
    ui->labelBlockSizeText->setVisible(false);
    ui->labelCoinControlInsuffFunds->setVisible(false);
 
    // hide coin control frame
    ui->frameCoinControl->hide();
}
 
void SendCoinsDialog::setClientModel(ClientModel* clientModel)
{
    this->clientModel = clientModel;
 
    if (clientModel) {
    }
}
 
void SendCoinsDialog::setModel(WalletModel* model)
{
    this->model = model;
 
    if (model && model->getOptionsModel()) {
        for (int i = 0; i < ui->entries->count(); ++i) {
            SendCoinsEntry* entry = qobject_cast<SendCoinsEntry*>(ui->entries->itemAt(i)->widget());
            if (entry) {
                entry->setModel(model);
            }
        }
 
        connect(model, SIGNAL(balanceChanged(CAmount, CAmount, CAmount, CAmount, CAmount, CAmount)), this,
            SLOT(setBalance(CAmount, CAmount, CAmount, CAmount, CAmount, CAmount)));
    }
}
 
void SendCoinsDialog::setBalance(const CAmount& balance, const CAmount& unconfirmedBalance, const CAmount& immatureBalance, 
                              const CAmount& watchOnlyBalance, const CAmount& watchUnconfBalance, const CAmount& watchImmatureBalance)
{
    int status = model->getEncryptionStatus();
    if (status == WalletModel::Locked || status == WalletModel::UnlockedForStakingOnly) {
        ui->labelBalance->setText("Locked; Hidden");
    } else if (settings.value("fHideBalance", false).toBool()) {
        ui->labelBalance->setText("Hidden");
    } else {
        ui->labelBalance->setText(BitcoinUnits::formatHtmlWithUnit(0, balance, false, BitcoinUnits::separatorAlways));
    }
}
 
SendCoinsDialog::~SendCoinsDialog(){
    delete ui;
}
 
void SendCoinsDialog::on_sendButton_clicked(){
    if (!masternodeSync.IsBlockchainSynced()) {
        QMessageBox msgBox;
        msgBox.setWindowTitle("Send Disabled - Syncing");
        msgBox.setText("Sending PRCY is disabled when you are still syncing the wallet. Please allow the wallet to fully sync before attempting to send a transaction.");
        msgBox.setStyleSheet(GUIUtil::loadStyleSheet());
        msgBox.setIcon(QMessageBox::Warning);
        msgBox.exec();
        return;
    }
    if (!ui->entries->count())
        return;
 
    SendCoinsEntry* form = qobject_cast<SendCoinsEntry*>(ui->entries->itemAt(0)->widget());
    SendCoinsRecipient recipient = form->getValue();
    QString address = recipient.address;
    CAmount balance = model->getBalance();
    send_address = recipient.address;
    send_amount = recipient.amount;
    bool isValidAddresss = (regex_match(address.toStdString(), std::regex("[a-zA-z0-9]+")))&&(address.length()==99||address.length()==110);
    bool isValidAmount = ((recipient.amount>0) && (recipient.amount<=balance));
    bool fAlwaysRequest2FA = settings.value("fAlwaysRequest2FA").toBool();
    bool fAlwaysRequestPassphrase = settings.value("fAlwaysRequestPassphrase").toBool();
 
    form->errorAddress(isValidAddresss);
    form->errorAmount(isValidAmount);
 
    if (!isValidAddresss) {
        QMessageBox msgBox;
        msgBox.setWindowTitle("Invalid Address");
        msgBox.setText("Invalid address entered. Please make sure you are sending to a Stealth Address.");
        msgBox.setStyleSheet(GUIUtil::loadStyleSheet());
        msgBox.setIcon(QMessageBox::Warning);
        msgBox.exec();
        return;
    }
 
    if (!isValidAmount) {
        QMessageBox msgBox;
        msgBox.setWindowTitle("Invalid Amount");
        msgBox.setText("Invalid amount entered. Please enter an amount less than your Spendable Balance.");
        msgBox.setStyleSheet(GUIUtil::loadStyleSheet());
        msgBox.setIcon(QMessageBox::Warning);
        msgBox.exec();
        return;
    }
 
    // request unlock only if was locked or unlocked for mixing:
    // this way we let users unlock by walletpassphrase or by menu
    // and make many transactions while unlocking through this dialog
    // will call relock
    WalletModel::EncryptionStatus encStatus = model->getEncryptionStatus();
    if (encStatus == model->Locked || encStatus == model->UnlockedForStakingOnly || fAlwaysRequestPassphrase) {
        WalletModel::UnlockContext ctx(model->requestUnlock(AskPassphraseDialog::Context::Send, true));
        if (!ctx.isValid()) {
            // Unlock wallet was cancelled
            return;
        }
    }
 
    // Format confirmation message
    QStringList formatted;
    formatted.append("<center>");
    QString amount = "<b>" + BitcoinUnits::formatHtmlWithUnit(model->getOptionsModel()->getDisplayUnit(), recipient.amount)+"</b>";
 
    QString recipientElement;
    recipientElement.append("<span class='h1 b'>"+amount+"</span><br/>");
    recipientElement.append("<br/>to<br/>");
    //if (rcp.label.length() > 0)
            //recipientElement.append("<br/><span class='h3'>"+tr("Description")+": <br/><b>"+GUIUtil::HtmlEscape(rcp.label)+"</b></span>");
    recipientElement.append("<br/><span class='h3'>"+tr("Destination")+": <br/><b>"+recipient.address+"</b></span><br/>");
 
    formatted.append(recipientElement);
    SetRingSize(0);
    QString strFee = BitcoinUnits::formatHtmlWithUnit(model->getOptionsModel()->getDisplayUnit(), (pwalletMain->ComputeFee(1, 1, MAX_RING_SIZE)));
    QString questionString = "<br/><span class='h2'><center><b>"+tr("Are you sure you want to send?")+"</b></center></span>";
    questionString.append("%1");
    questionString.append("<br/><span class='h3'>"+tr("Estimated Transaction fee")+": <br/><b>");
    questionString.append(strFee+"</b></span>");
    questionString.append("<br/><br/>");
 
    CAmount txFee = pwalletMain->ComputeFee(1, 1, MAX_RING_SIZE);
    CAmount totalAmount;
    if (recipient.amount == balance) {
        totalAmount = send_amount;
    } else {
        totalAmount = send_amount + txFee;
    }
 
    // Show total amount + all alternative units
    questionString.append(tr("<span class='h3'>Total Amount = <b>%1</b><br/></center>")
                              .arg(BitcoinUnits::formatHtmlWithUnit(model->getOptionsModel()->getDisplayUnit(), totalAmount)));
 
    if (fAlwaysRequest2FA) {
        questionString.append("<center><br/>Note: Request 2FA authentication code before sending any transactions is enabled.<br/>You will be asked for your 2FA code on the next screen.<br/><br/></center>");
    }
 
    // Display message box
    QMessageBox::StandardButton retval = QMessageBox::question(this, tr("Confirm Send Coins"),
        questionString.arg(formatted.join("<br />")),
        QMessageBox::Yes | QMessageBox::Cancel,
        QMessageBox::Cancel);
 
    if (retval != QMessageBox::Yes) {
        return;
    }
 
    bool nStaking = (nLastCoinStakeSearchInterval > 0);
 
    if (nStaking) {
        CAmount spendable = pwalletMain->GetSpendableBalance();
        if (!(recipient.amount <= nReserveBalance && recipient.amount <= spendable)) {
            if (recipient.amount > spendable) {
                QMessageBox msgBox;
                msgBox.setWindowTitle("Insufficient Spendable Funds!");
                msgBox.setText("Insufficient spendable funds. Send with smaller amount or wait for your coins become mature");
                msgBox.setStyleSheet(GUIUtil::loadStyleSheet());
                msgBox.setIcon(QMessageBox::Information);
                msgBox.exec();
            } else if (recipient.amount > nReserveBalance) {
                QMessageBox msgBox;
                msgBox.setWindowTitle("Insufficient Reserve Funds!");
                msgBox.setText("Insufficient reserve funds. Send with smaller amount or turn off staking mode.");
                msgBox.setStyleSheet(GUIUtil::loadStyleSheet());
                msgBox.setIcon(QMessageBox::Information);
                msgBox.exec();
            }
            return;
        }
    }
 
    bool status = pwalletMain->Read2FA();
    if (!status) {
        sendTx();
        return;
    }
    uint lastTime = pwalletMain->Read2FALastTime();
    uint period = pwalletMain->Read2FAPeriod();
    QDateTime current = QDateTime::currentDateTime();
    uint diffTime = current.toTime_t() - lastTime;
    if (diffTime <= period * 24 * 60 * 60 || !fAlwaysRequest2FA)
        sendTx();
    else {
        TwoFAConfirmDialog codedlg;
        codedlg.setWindowTitle("2FA Code Verification");
        codedlg.setStyleSheet(GUIUtil::loadStyleSheet());
        connect(&codedlg, SIGNAL(finished (int)), this, SLOT(dialogIsFinished(int)));
        codedlg.exec();
    }
}
 
void SendCoinsDialog::sendTx() {
    CWalletTx resultTx;
    bool success = false;
    std::string sendAddress = send_address.toStdString();
    CAmount spendable = model->getSpendableBalance();
    CAmount balance = model->getBalance();
    try {
        if (send_amount == spendable && spendable == balance) {
            // Send All
            success = pwalletMain->SendAll(
                sendAddress,
                resultTx,
                false
            );
        } else {
            // Send
            success = pwalletMain->SendToStealthAddress(
                sendAddress,
                send_amount,
                resultTx,
                false
            );
        }
 
    } catch (const std::exception& err) {
        std::string errMes(err.what());
        if (errMes.find("You have attempted to send more than 50 UTXOs in a single transaction") != std::string::npos) {
            QMessageBox::StandardButton reply;
            reply = QMessageBox::question(this, "Transaction Size Too Large", QString(err.what()) + QString("\n\nDo you want to combine small UTXOs into a larger one?"), QMessageBox::Yes|QMessageBox::No);
            if (reply == QMessageBox::Yes) {
                CAmount backupReserve = nReserveBalance;
                try {
                    uint32_t nTime = GetAdjustedTime();
                    nReserveBalance = 0;
                    success = model->getCWallet()->CreateSweepingTransaction(
                                    send_amount,
                                    send_amount, nTime);
                    nReserveBalance = backupReserve;
                    if (success) {
                        QString msg = "Consolidation transaction created!";
                        QMessageBox msgBox;
                        msgBox.setWindowTitle("Information");
                        msgBox.setIcon(QMessageBox::Information);
                        msgBox.setText(msg);
                        msgBox.setStyleSheet(GUIUtil::loadStyleSheet());
                        msgBox.exec();
                    } else {
                        QMessageBox msgBox;
                        msgBox.setWindowTitle("Sweeping Transaction Creation Error");
                        msgBox.setText(QString("Sweeping transaction creation failed due to an internal error. Please try again later."));
                        msgBox.setStyleSheet(GUIUtil::loadStyleSheet());
                        msgBox.setIcon(QMessageBox::Critical);
                        msgBox.exec();
                    }
                } catch (const std::exception& err1) {
                    nReserveBalance = backupReserve;
                    QMessageBox msgBox;
                    LogPrintf("ERROR:%s: %s\n", __func__, err1.what());
                    msgBox.setWindowTitle("Sweeping Transaction Creation Error");
                    msgBox.setText(QString("Sweeping transaction creation failed due to an internal error. Please try again later."));
                    msgBox.setStyleSheet(GUIUtil::loadStyleSheet());
                    msgBox.setIcon(QMessageBox::Critical);
                    msgBox.exec();
                }
                return;
            } else {
                return;
            }
        } else {
            QString msg = err.what();
            if (msg == "") {
                msg = "Unable to create transaction. Please try again later.";
            }
            QMessageBox msgBox;
            msgBox.setWindowTitle("Transaction Creation Error");
            msgBox.setText(msg);
            msgBox.setStyleSheet(GUIUtil::loadStyleSheet());
            msgBox.setIcon(QMessageBox::Critical);
            msgBox.exec();
        }
        return;
    }
 
    if (success){
        WalletUtil::getTx(pwalletMain, resultTx.GetHash());
        QString txhash = resultTx.GetHash().GetHex().c_str();
 
        std::string myAddress;
        pwalletMain->ComputeStealthPublicAddress("masteraccount", myAddress);
        bool showCheckBox = false;
        int indexOut = -1;
        if (sendAddress == myAddress) {
            for (int i=0; i < (int)resultTx.vout.size(); i++) {
                CTxOut& out = resultTx.vout[i];
                CAmount value = pwalletMain->getCTxOutValue(resultTx, out);
                if (value == Params().MNCollateralAmt()) {
                    showCheckBox = true;
                    indexOut = i;
                }
            }
        }
 
        QMessageBox msgBox;
        QCheckBox *cb = new QCheckBox("5000 PRCY transaction detected. Would you like to lock this transaction output?");
        if (showCheckBox) {
            msgBox.setCheckBox(cb);
        }
        QPushButton *viewButton = msgBox.addButton(tr("View on Explorer"), QMessageBox::ActionRole);
        QPushButton *copyButton = msgBox.addButton(tr("Copy"), QMessageBox::ActionRole);
        QPushButton *okButton = msgBox.addButton(tr("OK"), QMessageBox::ActionRole);
        msgBox.setWindowTitle("Transaction Initialized");
        msgBox.setText("Transaction initialized.\n\n" + txhash);
        msgBox.setStyleSheet(GUIUtil::loadStyleSheet());
        msgBox.setIcon(QMessageBox::Information);
        msgBox.exec();
 
        if (msgBox.clickedButton() == viewButton) {
            QString URL;
            // Adjust link depending on Network
            if (Params().NetworkID() == CBaseChainParams::MAIN) {
                URL = "https://explorer.prcycoin.com/tx/";
            } else if (Params().NetworkID() == CBaseChainParams::TESTNET){
                URL = "https://testnet.prcycoin.com/tx/";
            }
            // Open the link
            QDesktopServices::openUrl(QUrl(URL.append(txhash)));
        }
 
        if (msgBox.clickedButton() == copyButton) {
        //Copy txhash to clipboard
        GUIUtil::setClipboard(txhash);
        }
        if ((msgBox.clickedButton() == viewButton || msgBox.clickedButton() == copyButton || msgBox.clickedButton() == okButton) && cb->isChecked()) {
            // Lock collateral output
            COutPoint collateralOut(resultTx.GetHash(), indexOut);
            model->lockCoin(collateralOut);
            LogPrintf("Masternode transaction: %s:%i has been locked\n", resultTx.GetHash().GetHex().c_str(), indexOut);
        }
    }
}
 
void SendCoinsDialog::dialogIsFinished(int result) {
   if(result == QDialog::Accepted){
        sendTx();
   }
}
 
SendCoinsEntry* SendCoinsDialog::addEntry()
{
    SendCoinsEntry* entry = new SendCoinsEntry(this);
    entry->setModel(model);
    ui->entries->addWidget(entry);
 
    ui->scrollAreaWidgetContents->resize(ui->scrollAreaWidgetContents->sizeHint());
    qApp->processEvents();
    QScrollBar* bar = ui->scrollArea->verticalScrollBar();
    if (bar)
        bar->setSliderPosition(bar->maximum());
    return entry;
}
// Coin Control: copy label "Quantity" to clipboard
void SendCoinsDialog::coinControlClipboardQuantity()
{
    GUIUtil::setClipboard(ui->labelCoinControlQuantity->text());
}
 
// Coin Control: copy label "Amount" to clipboard
void SendCoinsDialog::coinControlClipboardAmount()
{
    GUIUtil::setClipboard(ui->labelCoinControlAmount->text().left(ui->labelCoinControlAmount->text().indexOf(" ")));
}
 
// Coin Control: copy label "Fee" to clipboard
void SendCoinsDialog::coinControlClipboardFee()
{
    GUIUtil::setClipboard(ui->labelCoinControlFee->text().left(ui->labelCoinControlFee->text().indexOf(" ")).replace("~", ""));
}
 
// Coin Control: copy label "After fee" to clipboard
void SendCoinsDialog::coinControlClipboardAfterFee()
{
    GUIUtil::setClipboard(ui->labelCoinControlAfterFee->text().left(ui->labelCoinControlAfterFee->text().indexOf(" ")).replace("~", ""));
}
 
// Coin Control: copy label "Bytes" to clipboard
void SendCoinsDialog::coinControlClipboardBytes()
{
    GUIUtil::setClipboard(ui->labelCoinControlBytes->text().replace("~", ""));
}
 
// Coin Control: copy label "Priority" to clipboard
void SendCoinsDialog::coinControlClipboardPriority()
{
    GUIUtil::setClipboard(ui->labelCoinControlPriority->text());
}
 
// Coin Control: copy label "Dust" to clipboard
void SendCoinsDialog::coinControlClipboardLowOutput()
{
    GUIUtil::setClipboard(ui->labelCoinControlLowOutput->text());
}
 
// Coin Control: copy label "Change" to clipboard
void SendCoinsDialog::coinControlClipboardChange()
{
    GUIUtil::setClipboard(ui->labelCoinControlChange->text().left(ui->labelCoinControlChange->text().indexOf(" ")).replace("~", ""));
}
 
// Coin Control: settings menu - coin control enabled/disabled by user
void SendCoinsDialog::coinControlFeatureChanged(bool checked)
{
    ui->frameCoinControl->setVisible(checked);
 
    if (!checked && model) // coin control features disabled
        CoinControlDialog::coinControl->SetNull();
 
    if (checked)
        coinControlUpdateLabels();
}
 
// Coin Control: button inputs -> show actual coin control dialog
void SendCoinsDialog::coinControlButtonClicked()
{
    CoinControlDialog dlg;
    dlg.setModel(model);
    dlg.exec();
    coinControlUpdateLabels();
}
 
// Coin Control: checkbox custom change address
void SendCoinsDialog::coinControlChangeChecked(int state)
{
    if (state == Qt::Unchecked) {
        CoinControlDialog::coinControl->destChange = CNoDestination();
        ui->labelCoinControlChangeLabel->clear();
    } else
        // use this to re-validate an already entered address
        coinControlChangeEdited(ui->lineEditCoinControlChange->text());
 
    ui->lineEditCoinControlChange->setEnabled((state == Qt::Checked));
}
 
// Coin Control: custom change address changed
void SendCoinsDialog::coinControlChangeEdited(const QString& text)
{
    if (model && model->getAddressTableModel()) {
        // Default to no change address until verified
        CoinControlDialog::coinControl->destChange = CNoDestination();
        ui->labelCoinControlChangeLabel->setStyleSheet("QLabel{color:red;}");
 
        CBitcoinAddress addr = CBitcoinAddress(text.toStdString());
 
        if (text.isEmpty()) // Nothing entered
        {
            ui->labelCoinControlChangeLabel->setText("");
        } else if (!addr.IsValid()) // Invalid address
        {
            ui->labelCoinControlChangeLabel->setText(tr("Warning: Invalid PIVX address"));
        } else // Valid address
        {
            CPubKey pubkey;
            CKeyID keyid;
            addr.GetKeyID(keyid);
            if (!model->getPubKey(keyid, pubkey)) // Unknown change address
            {
                ui->labelCoinControlChangeLabel->setText(tr("Warning: Unknown change address"));
            } else // Known change address
            {
                ui->labelCoinControlChangeLabel->setStyleSheet("QLabel{color:black;}");
 
                // Query label
                QString associatedLabel = model->getAddressTableModel()->labelForAddress(text);
                if (!associatedLabel.isEmpty())
                    ui->labelCoinControlChangeLabel->setText(associatedLabel);
                else
                    ui->labelCoinControlChangeLabel->setText(tr("(no label)"));
 
                CoinControlDialog::coinControl->destChange = addr.Get();
            }
        }
    }
}
 
// Coin Control: update labels
void SendCoinsDialog::coinControlUpdateLabels()
{
    if (!model || !model->getOptionsModel() || !model->getOptionsModel()->getCoinControlFeatures())
        return;
 
    // set pay amounts
    CoinControlDialog::payAmounts.clear();
    for (int i = 0; i < ui->entries->count(); ++i) {
        SendCoinsEntry* entry = qobject_cast<SendCoinsEntry*>(ui->entries->itemAt(i)->widget());
        if (entry)
            CoinControlDialog::payAmounts.append(entry->getValue().amount);
    }
 
    if (CoinControlDialog::coinControl->HasSelected()) {
        // actual coin control calculation
        CoinControlDialog::updateLabels(model, this);
 
        // show coin control stats
        ui->labelCoinControlAutomaticallySelected->hide();
        ui->widgetCoinControl->show();
    } else {
        // hide coin control stats
        ui->labelCoinControlAutomaticallySelected->show();
        ui->widgetCoinControl->hide();
        ui->labelCoinControlInsuffFunds->hide();
    }
}