qml: Add CoinsListModel to WalletQmlModel

The coins list model will be used to list out of the locked and
selectable coins in the coin selection form. A toggle method is
provided that will select or unselect the coin in the associated
WalletQmlModel.

Author: johnny9

src/Makefile.qt.include

@@ -39,6 +39,7 @@ QT_MOC_CPP = \
   qml/controls/moc_linegraph.cpp \
   qml/models/moc_activitylistmodel.cpp \
   qml/models/moc_chainmodel.cpp \
+  qml/models/moc_coinslistmodel.cpp \
   qml/models/moc_networktraffictower.cpp \
   qml/models/moc_nodemodel.cpp \
   qml/models/moc_options_model.cpp \
@@ -129,6 +130,7 @@ BITCOIN_QT_H = \
   qml/controls/linegraph.h \
   qml/models/activitylistmodel.h \
   qml/models/chainmodel.h \
+  qml/models/coinslistmodel.h \
   qml/models/networktraffictower.h \
   qml/models/nodemodel.h \
   qml/models/options_model.h \
@@ -328,6 +330,7 @@ BITCOIN_QML_BASE_CPP = \
   qml/controls/linegraph.cpp \
   qml/models/activitylistmodel.cpp \
   qml/models/chainmodel.cpp \
+  qml/models/coinslistmodel.cpp \
   qml/models/networktraffictower.cpp \
   qml/models/nodemodel.cpp \
   qml/models/options_model.cpp \

src/qml/models/coinslistmodel.cpp

@@ -0,0 +1,131 @@
+// Copyright (c) 2025 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 <qml/models/coinslistmodel.h>
+
+#include <consensus/amount.h>
+#include <interfaces/wallet.h>
+#include <key_io.h>
+#include <primitives/transaction.h>
+#include <qml/models/walletqmlmodel.h>
+#include <qt/bitcoinunits.h>
+#include <vector>
+
+CoinsListModel::CoinsListModel(WalletQmlModel* parent)
+    : QAbstractListModel(parent), m_wallet_model(parent)
+{
+}
+
+CoinsListModel::~CoinsListModel() = default;
+
+int CoinsListModel::rowCount(const QModelIndex& parent) const
+{
+    return m_coins.size();
+}
+
+QVariant CoinsListModel::data(const QModelIndex& index, int role) const
+{
+    if (!index.isValid() || index.row() < 0 || index.row() >= static_cast<int>(m_coins.size()))
+        return QVariant();
+
+    const auto& [destination, outpoint, coin] = m_coins.at(index.row());
+    switch (role) {
+    case AddressRole:
+        return QString::fromStdString(EncodeDestination(destination));
+    case AmountRole:
+        return BitcoinUnits::format(BitcoinUnits::Unit::BTC, coin.txout.nValue);
+    case LabelRole:
+        return QString::fromStdString("");
+    case LockedRole:
+        return m_wallet_model->isLockedCoin(outpoint);
+    case SelectedRole:
+        return m_wallet_model->isSelectedCoin(outpoint);
+    default:
+        return QVariant();
+    }
+}
+
+QHash<int, QByteArray> CoinsListModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles[AmountRole] = "amount";
+    roles[AddressRole] = "address";
+    roles[DateTimeRole] = "date";
+    roles[LabelRole] = "label";
+    roles[LockedRole] = "locked";
+    roles[SelectedRole] = "selected";
+    return roles;
+}
+
+void CoinsListModel::update()
+{
+    if (m_wallet_model == nullptr) {
+        return;
+    }
+    auto coins_map = m_wallet_model->listCoins();
+    beginResetModel();
+    m_coins.clear();
+    for (const auto& [destination, vec] : coins_map) {
+        for (const auto& [outpoint, tx_out] : vec) {
+            auto tuple = std::make_tuple(destination, outpoint, tx_out);
+            m_coins.push_back(tuple);
+        }
+    }
+    endResetModel();
+}
+
+void CoinsListModel::setSortBy(const QString& roleName)
+{
+    if (m_sort_by != roleName) {
+        m_sort_by = roleName;
+        // sort(RoleNameToIndex(roleName));
+        Q_EMIT sortByChanged(roleName);
+    }
+}
+
+void CoinsListModel::toggleCoinSelection(const int index)
+{
+    if (index < 0 || index >= static_cast<int>(m_coins.size())) {
+        return;
+    }
+    const auto& [destination, outpoint, coin] = m_coins.at(index);
+
+    if (m_wallet_model->isSelectedCoin(outpoint)) {
+        m_wallet_model->unselectCoin(outpoint);
+        m_total_amount -= coin.txout.nValue;
+    } else {
+        m_wallet_model->selectCoin(outpoint);
+        m_total_amount += coin.txout.nValue;
+    }
+    Q_EMIT selectedCoinsCountChanged();
+}
+
+unsigned int CoinsListModel::lockedCoinsCount() const
+{
+    std::vector<COutPoint> lockedCoins;
+    m_wallet_model->listLockedCoins(lockedCoins);
+    return lockedCoins.size();
+}
+
+unsigned int CoinsListModel::selectedCoinsCount() const
+{
+    return m_wallet_model->listSelectedCoins().size();
+}
+
+QString CoinsListModel::totalSelected() const
+{
+    return BitcoinUnits::format(BitcoinUnits::Unit::BTC, m_total_amount);
+}
+
+QString CoinsListModel::changeAmount() const
+{
+    CAmount change = m_total_amount - m_wallet_model->sendRecipient()->cAmount();
+    change = std::abs(change);
+    return BitcoinUnits::format(BitcoinUnits::Unit::BTC, change);
+}
+
+bool CoinsListModel::overRequiredAmount() const
+{
+    return m_total_amount > m_wallet_model->sendRecipient()->cAmount();
+}

src/qml/models/coinslistmodel.h

@@ -0,0 +1,67 @@
+// Copyright (c) 2025 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_QML_MODELS_COINSLISTMODEL_H
+#define BITCOIN_QML_MODELS_COINSLISTMODEL_H
+
+#include <consensus/amount.h>
+#include <interfaces/handler.h>
+#include <interfaces/wallet.h>
+#include <qml/models/transaction.h>
+
+#include <QAbstractListModel>
+#include <QString>
+
+class WalletQmlModel;
+
+class CoinsListModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int lockedCoinsCount READ lockedCoinsCount NOTIFY lockedCoinsCountChanged)
+    Q_PROPERTY(int selectedCoinsCount READ selectedCoinsCount NOTIFY selectedCoinsCountChanged)
+    Q_PROPERTY(QString totalSelected READ totalSelected NOTIFY selectedCoinsCountChanged)
+    Q_PROPERTY(QString changeAmount READ changeAmount NOTIFY selectedCoinsCountChanged)
+    Q_PROPERTY(bool overRequiredAmount READ overRequiredAmount NOTIFY selectedCoinsCountChanged)
+
+public:
+    explicit CoinsListModel(WalletQmlModel* parent = nullptr);
+    ~CoinsListModel();
+
+    enum CoinsRoles {
+        AddressRole = Qt::UserRole + 1,
+        AmountRole,
+        DateTimeRole,
+        LabelRole,
+        LockedRole,
+        SelectedRole
+    };
+
+    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
+    QHash<int, QByteArray> roleNames() const override;
+
+public Q_SLOTS:
+    void update();
+    void setSortBy(const QString& roleName);
+    void toggleCoinSelection(const int index);
+    unsigned int lockedCoinsCount() const;
+    unsigned int selectedCoinsCount() const;
+    QString totalSelected() const;
+    QString changeAmount() const;
+    bool overRequiredAmount() const;
+
+Q_SIGNALS:
+    void sortByChanged(const QString& roleName);
+    void lockedCoinsCountChanged();
+    void selectedCoinsCountChanged();
+
+private:
+    WalletQmlModel* m_wallet_model;
+    std::unique_ptr<interfaces::Handler> m_handler_transaction_changed;
+    std::vector<std::tuple<CTxDestination, COutPoint, interfaces::WalletTxOut>> m_coins;
+    QString m_sort_by;
+    CAmount m_total_amount;
+};
+
+#endif // BITCOIN_QML_MODELS_COINSLISTMODEL_H

src/qml/models/walletqmlmodel.cpp

@@ -4,14 +4,13 @@
 
 #include <qml/models/walletqmlmodel.h>
 
-#include <qml/models/activitylistmodel.h>
-
-#include <qml/models/sendrecipient.h>
-#include <qml/models/walletqmlmodeltransaction.h>
-
 #include <consensus/amount.h>
+#include <interfaces/wallet.h>
 #include <key_io.h>
 #include <outputtype.h>
+#include <qml/models/activitylistmodel.h>
+#include <qml/models/sendrecipient.h>
+#include <qml/models/walletqmlmodeltransaction.h>
 #include <qt/bitcoinunits.h>
 #include <wallet/coincontrol.h>
 #include <wallet/wallet.h>
@@ -23,16 +22,28 @@ WalletQmlModel::WalletQmlModel(std::unique_ptr<interfaces::Wallet> wallet, QObje
 {
     m_wallet = std::move(wallet);
     m_activity_list_model = new ActivityListModel(this);
+    m_coins_list_model = new CoinsListModel(this);
     m_current_recipient = new SendRecipient(this);
 }
 
 WalletQmlModel::WalletQmlModel(QObject* parent)
     : QObject(parent)
 {
     m_activity_list_model = new ActivityListModel(this);
+    m_coins_list_model = new CoinsListModel(this);
     m_current_recipient = new SendRecipient(this);
 }
 
+WalletQmlModel::~WalletQmlModel()
+{
+    delete m_activity_list_model;
+    delete m_coins_list_model;
+    delete m_current_recipient;
+    if (m_current_transaction) {
+        delete m_current_transaction;
+    }
+}
+
 QString WalletQmlModel::balance() const
 {
     if (!m_wallet) {
@@ -76,11 +87,6 @@ bool WalletQmlModel::tryGetTxStatus(const uint256& txid,
     return m_wallet->tryGetTxStatus(txid, tx_status, num_blocks, block_time);
 }
 
-WalletQmlModel::~WalletQmlModel()
-{
-    delete m_activity_list_model;
-}
-
 std::unique_ptr<interfaces::Handler> WalletQmlModel::handleTransactionChanged(TransactionChangedFn fn)
 {
     if (!m_wallet) {
@@ -97,8 +103,7 @@ bool WalletQmlModel::prepareTransaction()
 
     CScript scriptPubKey = GetScriptForDestination(DecodeDestination(m_current_recipient->address().toStdString()));
     wallet::CRecipient recipient = {scriptPubKey, m_current_recipient->cAmount(), m_current_recipient->subtractFeeFromAmount()};
-    wallet::CCoinControl coinControl;
-    coinControl.m_feerate = CFeeRate(1000);
+    m_coin_control.m_feerate = CFeeRate(1000);
 
     CAmount balance = m_wallet->getBalance();
     if (balance < recipient.nAmount) {
@@ -108,7 +113,7 @@ bool WalletQmlModel::prepareTransaction()
     std::vector<wallet::CRecipient> vecSend{recipient};
     int nChangePosRet = -1;
     CAmount nFeeRequired = 0;
-    const auto& res = m_wallet->createTransaction(vecSend, coinControl, true, nChangePosRet, nFeeRequired);
+    const auto& res = m_wallet->createTransaction(vecSend, m_coin_control, true, nChangePosRet, nFeeRequired);
     if (res) {
         if (m_current_transaction) {
             delete m_current_transaction;
@@ -139,3 +144,63 @@ void WalletQmlModel::sendTransaction()
     interfaces::WalletOrderForm order_form;
     m_wallet->commitTransaction(newTx, value_map, order_form);
 }
+
+interfaces::Wallet::CoinsList WalletQmlModel::listCoins() const
+{
+    if (!m_wallet) {
+        return {};
+    }
+    return m_wallet->listCoins();
+}
+
+bool WalletQmlModel::lockCoin(const COutPoint& output)
+{
+    if (!m_wallet) {
+        return false;
+    }
+    return m_wallet->lockCoin(output, true);
+}
+
+bool WalletQmlModel::unlockCoin(const COutPoint& output)
+{
+    if (!m_wallet) {
+        return false;
+    }
+    return m_wallet->unlockCoin(output);
+}
+
+bool WalletQmlModel::isLockedCoin(const COutPoint& output)
+{
+    if (!m_wallet) {
+        return false;
+    }
+    return m_wallet->isLockedCoin(output);
+}
+
+void WalletQmlModel::listLockedCoins(std::vector<COutPoint>& outputs)
+{
+    if (!m_wallet) {
+        return;
+    }
+    m_wallet->listLockedCoins(outputs);
+}
+
+void WalletQmlModel::selectCoin(const COutPoint& output)
+{
+    m_coin_control.Select(output);
+}
+
+void WalletQmlModel::unselectCoin(const COutPoint& output)
+{
+    m_coin_control.UnSelect(output);
+}
+
+bool WalletQmlModel::isSelectedCoin(const COutPoint& output)
+{
+    return m_coin_control.IsSelected(output);
+}
+
+std::vector<COutPoint> WalletQmlModel::listSelectedCoins() const
+{
+    return m_coin_control.ListSelected();
+}