Extend coin control to implement filter and consolidate functions

1. Changes the (un)select all button to a true select all/select none filp-flop.

2. Implements an input filter function to allow the selection of inputs either less than
or equal to or greater than or equal to a provided input value. This can be used for more
than just consolidations.

3. Implements a "Consolidate" button which limits the selected inputs to 600 to ensure
the consolidation transaction will be successful, presents a pick list to select the destination
address for the consolidation, and then automatically fills in the send transaction for
convenience.

Author: jamescowens

src/Makefile.qt.include

@@ -74,6 +74,7 @@ QT_TS = \
 QT_FORMS_UI = \
   qt/forms/aboutdialog.ui \
   qt/forms/coincontroldialog.ui \
+  qt/forms/consolidateunspentdialog.ui \
   qt/forms/diagnosticsdialog.ui \
   qt/forms/optionsdialog.ui \
   qt/forms/rpcconsole.ui \
@@ -111,6 +112,7 @@ QT_MOC_CPP = \
   qt/moc_clientmodel.cpp \
   qt/moc_coincontroldialog.cpp \
   qt/moc_coincontroltreewidget.cpp \
+  qt/moc_consolidateunspentdialog.cpp \
   qt/moc_csvmodelwriter.cpp \
   qt/moc_diagnosticsdialog.cpp \
   qt/moc_editaddressdialog.cpp \
@@ -181,6 +183,7 @@ GRIDCOINRESEARCH_QT_H = \
   qt/clientmodel.h \
   qt/coincontroldialog.h \
   qt/coincontroltreewidget.h \
+  qt/consolidateunspentdialog.h \
   qt/csvmodelwriter.h \
   qt/decoration.h \
   qt/diagnosticsdialog.h \
@@ -243,6 +246,7 @@ GRIDCOINRESEARCH_QT_CPP = \
   qt/clientmodel.cpp \
   qt/coincontroldialog.cpp \
   qt/coincontroltreewidget.cpp \
+  qt/consolidateunspentdialog.cpp \
   qt/csvmodelwriter.cpp \
   qt/decoration.cpp \
   qt/diagnosticsdialog.cpp \

src/qt/coincontroldialog.cpp

@@ -3,12 +3,12 @@
 
 #include "init.h"
 #include "bitcoinunits.h"
-#include "walletmodel.h"
 #include "addresstablemodel.h"
 #include "optionsmodel.h"
 #include "policy/fees.h"
 #include "validation.h"
 #include "wallet/coincontrol.h"
+#include "consolidateunspentdialog.h"
 
 #include <QApplication>
 #include <QCheckBox>
@@ -29,6 +29,7 @@ CCoinControl* CoinControlDialog::coinControl = new CCoinControl();
 
 CoinControlDialog::CoinControlDialog(QWidget *parent) :
     QDialog(parent),
+    m_inputSelectionLimit(600),
     ui(new Ui::CoinControlDialog),
     model(0)
 {
@@ -106,17 +107,38 @@ CoinControlDialog::CoinControlDialog(QWidget *parent) :
     // (un)select all
     connect(ui->selectAllPushButton, SIGNAL(clicked()), this, SLOT(buttonSelectAllClicked()));
 
-    ui->treeWidget->setColumnWidth(COLUMN_CHECKBOX, 84);
-    ui->treeWidget->setColumnWidth(COLUMN_AMOUNT, 100);
-    ui->treeWidget->setColumnWidth(COLUMN_LABEL, 170);
+    // filter/consolidate button interaction
+    connect(ui->maxMinOutputValue, SIGNAL(textChanged()), this, SLOT(maxMinOutputValueChanged()));
+
+    // filter mode
+    connect(ui->filterModePushButton, SIGNAL(clicked()), this, SLOT(buttonFilterModeClicked()));
+
+    // filter
+    connect(ui->filterPushButton, SIGNAL(clicked()), this, SLOT(buttonFilterClicked()));
+
+    // consolidate
+    connect(ui->consolidateButton, SIGNAL(clicked()), this, SLOT(buttonConsolidateClicked()));
+
+    ui->treeWidget->setColumnWidth(COLUMN_CHECKBOX, 150);
+    ui->treeWidget->setColumnWidth(COLUMN_AMOUNT, 170);
+    ui->treeWidget->setColumnWidth(COLUMN_LABEL, 200);
     ui->treeWidget->setColumnWidth(COLUMN_ADDRESS, 290);
     ui->treeWidget->setColumnWidth(COLUMN_DATE, 110);
     ui->treeWidget->setColumnWidth(COLUMN_CONFIRMATIONS, 100);
     ui->treeWidget->setColumnWidth(COLUMN_PRIORITY, 100);
-    ui->treeWidget->setColumnHidden(COLUMN_TXHASH, true);         // store transacton hash in this column, but dont show it
-    ui->treeWidget->setColumnHidden(COLUMN_VOUT_INDEX, true);     // store vout index in this column, but dont show it
-    ui->treeWidget->setColumnHidden(COLUMN_AMOUNT_INT64, true);   // store amount int64_t in this column, but dont show it
-    ui->treeWidget->setColumnHidden(COLUMN_PRIORITY_INT64, true); // store priority int64_t in this column, but dont show it
+    ui->treeWidget->setColumnHidden(COLUMN_TXHASH, true);         // store transacton hash in this column, but don't show it
+    ui->treeWidget->setColumnHidden(COLUMN_VOUT_INDEX, true);     // store vout index in this column, but don't show it
+    ui->treeWidget->setColumnHidden(COLUMN_AMOUNT_INT64, true);   // store amount int64_t in this column, but don't show it
+    ui->treeWidget->setColumnHidden(COLUMN_PRIORITY_INT64, true); // store priority int64_t in this column, but don't show it
+    ui->treeWidget->setColumnHidden(COLUMN_CHANGE_BOOL, true);    // store change flag but don't show it
+
+    ui->filterModePushButton->setToolTip(tr("Flips the filter mode between selecting inputs less than or equal to the "
+                                            "provided value (<=) and greater than or equal to the provided value (>=). "
+                                            "The filter also automatically limits the number of inputs to %1, in "
+                                            "ascending order for <= and descending order for >=."
+                                            ).arg(m_inputSelectionLimit));
+
+    ui->consolidateSendReadyLabel->hide();
 
     // default view is sorted by amount desc
     sortView(COLUMN_AMOUNT_INT64, Qt::DescendingOrder);
@@ -153,26 +175,222 @@ void CoinControlDialog::buttonBoxClicked(QAbstractButton* button)
 {
     if (ui->buttonBox->buttonRole(button) == QDialogButtonBox::AcceptRole)
         done(QDialog::Accepted); // closes the dialog
+
+    if (m_consolidationAddress.second.size())
+    {
+        SendCoinsRecipient consolidationRecipient;
+
+        qint64 amount = 0;
+        bool parse_status = false;
+
+        consolidationRecipient.label = m_consolidationAddress.first;
+        consolidationRecipient.address = m_consolidationAddress.second;
+        parse_status = BitcoinUnits::parse(model->getOptionsModel()->getDisplayUnit(),
+                                           ui->coinControlAfterFeeLabel->text()
+                                                .left(ui->coinControlAfterFeeLabel->text().indexOf(" ")),
+                                           &amount);
+
+        if (parse_status) consolidationRecipient.amount = amount;
+
+        emit selectedConsolidationRecipientSignal(consolidationRecipient);
+    }
+
+    showHideConsolidationReadyToSend();
 }
 
 // (un)select all
 void CoinControlDialog::buttonSelectAllClicked()
 {
-    Qt::CheckState state = Qt::Checked;
+    ui->treeWidget->setEnabled(false);
     for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++)
+            if (ui->treeWidget->topLevelItem(i)->checkState(COLUMN_CHECKBOX) != m_ToState)
+                ui->treeWidget->topLevelItem(i)->setCheckState(COLUMN_CHECKBOX, m_ToState);
+    ui->treeWidget->setEnabled(true);
+
+    if (m_ToState == Qt::Checked)
     {
-        if (ui->treeWidget->topLevelItem(i)->checkState(COLUMN_CHECKBOX) != Qt::Unchecked)
+        m_ToState = Qt::Unchecked;
+    }
+    else
+    {
+        m_ToState = Qt::Checked;
+    }
+
+    if (m_ToState == Qt::Checked)
+    {
+       ui->selectAllPushButton->setText("Select All");
+    }
+    else
+    {
+       ui->selectAllPushButton->setText("Select None");
+    }
+
+    CoinControlDialog::updateLabels(model, this);
+    showHideConsolidationReadyToSend();
+}
+
+void CoinControlDialog::maxMinOutputValueChanged()
+{
+
+    bool maxMinOutputValueValid = false;
+
+    ui->maxMinOutputValue->value(&maxMinOutputValueValid);
+
+    // If someone has put a value in the filter amount field, then consolidate should be disabled until the
+    // filter button is pressed to apply the filter. If the field is empty, then the consolidation can work
+    // without the filter application first, (i.e. consolidation is enabled), because the idea is to select
+    // up to the m_inputSelectionLimit number of inputs either from smallest upward or largest downward by
+    // following the <= or >= filter mode button. This shortcut is mainly for convenience.
+    if (maxMinOutputValueValid)
+    {
+        ui->consolidateButton->setEnabled(false);
+    }
+    else
+    {
+        ui->consolidateButton->setEnabled(true);
+    }
+
+    showHideConsolidationReadyToSend();
+}
+
+void CoinControlDialog::buttonFilterModeClicked()
+{
+    if (m_FilterMode)
+    {
+        m_FilterMode = false;
+        ui->filterModePushButton->setText(">=");
+    }
+    else
+    {
+        m_FilterMode = true;
+        ui->filterModePushButton->setText("<=");
+    }
+}
+
+void CoinControlDialog::buttonFilterClicked()
+{
+    // Don't limit the number of outputs for the filter only operation.
+    filterInputsByValue(m_FilterMode, ui->maxMinOutputValue->value(), std::numeric_limits<unsigned int>::max());
+
+    ui->consolidateButton->setEnabled(true);
+    showHideConsolidationReadyToSend();
+}
+
+bool CoinControlDialog::filterInputsByValue(const bool& less, const CAmount& inputFilterValue,
+                                            const unsigned int& inputSelectionLimit)
+{
+    // Disable generating update signals unnecessarily during this filter operation.
+    ui->treeWidget->setEnabled(false);
+
+    QTreeWidgetItemIterator iter(ui->treeWidget);
+
+    // If less is true, then we are choosing the smallest inputs upward, and so the map comparator needs to be "less than".
+    // If less is false, then we are choosing the largest inputs downward, and so the map comparator needs to be "greater
+    // than".
+    auto comp = [less](CAmount a, CAmount b)
+    {
+        if (less)
+        {
+            return (a < b);
+        }
+        else
         {
-            state = Qt::Unchecked;
-            break;
+            return (a > b);
         }
+    };
+
+    std::multimap<CAmount, std::pair<QTreeWidgetItem*, COutPoint>, decltype(comp)> input_map(comp);
+
+    bool culled_inputs = false;
+
+    while (*iter)
+    {
+        CAmount input_value = (*iter)->text(COLUMN_AMOUNT_INT64).toLongLong();
+        COutPoint outpoint(uint256S((*iter)->text(COLUMN_TXHASH).toStdString()), (*iter)->text(COLUMN_VOUT_INDEX).toUInt());
+
+        if ((*iter)->checkState(COLUMN_CHECKBOX) == Qt::Checked)
+        {
+            if ((*iter)->text(COLUMN_TXHASH).length() == 64)
+            {
+                if ((less && input_value <= inputFilterValue) || (!less && input_value >= inputFilterValue))
+                {
+                    input_map.insert(std::make_pair(input_value, std::make_pair(*iter, outpoint)));
+                }
+                else
+                {
+                    (*iter)->setCheckState(COLUMN_CHECKBOX, Qt::Unchecked);
+                    coinControl->UnSelect(outpoint);
+                }
+            }
+        }
+
+        ++iter;
     }
-    ui->treeWidget->setEnabled(false);
-    for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++)
-            if (ui->treeWidget->topLevelItem(i)->checkState(COLUMN_CHECKBOX) != state)
-                ui->treeWidget->topLevelItem(i)->setCheckState(COLUMN_CHECKBOX, state);
+
+    // The second loop is to limit the number of selected outputs to the inputCountLimit.
+    unsigned int input_count = 0;
+
+    for (auto& input : input_map)
+    {
+        if (input_count >= inputSelectionLimit)
+        {
+            LogPrint(BCLog::LogFlags::MISC, "INFO: %s: Culled input %u with value %f.",
+                     __func__, input_count, (double) input.first / COIN);
+
+            if (coinControl->IsSelected(input.second.second.hash, input.second.second.n))
+            {
+                input.second.first->setCheckState(COLUMN_CHECKBOX, Qt::Unchecked);
+
+                culled_inputs = true;
+                coinControl->UnSelect(input.second.second);
+            }
+        }
+
+        ++input_count;
+    }
+
+    // Reenable update signals.
     ui->treeWidget->setEnabled(true);
+
     CoinControlDialog::updateLabels(model, this);
+
+    // If the number of inputs selected was limited, then true is returned.
+    return culled_inputs;
+}
+
+void CoinControlDialog::buttonConsolidateClicked()
+{
+    ConsolidateUnspentDialog consolidateUnspentDialog(this, m_inputSelectionLimit);
+
+    std::map<QString, QString> addressList;
+
+    bool culled_inputs = false;
+
+    // Note that we are applying the filter here to limit the number of inputs only to ensure the m_inputSelectionLimit
+    // input maximum is not exceeded for the purpose of consolidation.
+    CAmount outputFilterValue = 0;
+
+    outputFilterValue = m_FilterMode ? MAX_MONEY: 0;
+
+    culled_inputs = filterInputsByValue(m_FilterMode, outputFilterValue, m_inputSelectionLimit);
+
+    for (int i = 0; i < ui->treeWidget->topLevelItemCount(); ++i)
+    {
+        QString label = ui->treeWidget->topLevelItem(i)->text(COLUMN_LABEL);
+        QString address = ui->treeWidget->topLevelItem(i)->text(COLUMN_ADDRESS);
+        QString change = ui->treeWidget-> topLevelItem(i)->text(COLUMN_CHANGE_BOOL);
+
+        if (!change.toInt()) addressList[address] = label;
+    }
+
+    if (!addressList.empty()) consolidateUnspentDialog.SetAddressList(addressList);
+
+    if (culled_inputs) consolidateUnspentDialog.SetOutputWarningVisible(true);
+
+    connect(&consolidateUnspentDialog, SIGNAL(selectedConsolidationAddressSignal(std::pair<QString, QString>)),
+            this, SLOT(selectedConsolidationAddressSlot(std::pair<QString, QString>)));
+
+    consolidateUnspentDialog.exec();
 }
 
 // context menu
@@ -379,6 +597,8 @@ void CoinControlDialog::viewItemChanged(QTreeWidgetItem* item, int column)
         if (ui->treeWidget->isEnabled()) // do not update on every click for (un)select all
             CoinControlDialog::updateLabels(model, this);
     }
+
+    showHideConsolidationReadyToSend();
 }
 
 // helper function, return human readable label for priority number
@@ -656,6 +876,7 @@ void CoinControlDialog::updateView()
                 // tooltip from where the change comes from
                 itemOutput->setToolTip(COLUMN_LABEL, tr("change from %1 (%2)").arg(sWalletLabel).arg(sWalletAddress));
                 itemOutput->setText(COLUMN_LABEL, tr("(change)"));
+                itemOutput->setText(COLUMN_CHANGE_BOOL, QString::number(1));
             }
             else if (!treeMode)
             {
@@ -740,3 +961,34 @@ void CoinControlDialog::updateView()
     sortView(sortColumn, sortOrder);
     ui->treeWidget->setEnabled(true);
 }
+
+void CoinControlDialog::selectedConsolidationAddressSlot(std::pair<QString, QString> address)
+{
+    m_consolidationAddress = address;
+    showHideConsolidationReadyToSend();
+}
+
+void CoinControlDialog::showHideConsolidationReadyToSend()
+{
+    if (m_consolidationAddress.second.size() && coinControl->HasSelected() && ui->consolidateButton->isEnabled())
+    {
+        // This is more expensive. Only do if it passes the first two conditions above. We want to check
+        // and make sure that the number of inputs is less than m_inputSelectionLimit for consolidation purposes.
+        std::vector<COutPoint> selectionList;
+
+        coinControl->ListSelected(selectionList);
+
+        if (selectionList.size() <= m_inputSelectionLimit)
+        {
+            ui->consolidateSendReadyLabel->show();
+        }
+        else
+        {
+            ui->consolidateSendReadyLabel->hide();
+        }
+    }
+    else
+    {
+        ui->consolidateSendReadyLabel->hide();
+    }
+}