Issue 15: add wallet-backed address book model and send label autofill

Author: johnny9

qml/models/addressbookmodel.cpp

@@ -0,0 +1,370 @@
+// Copyright (c) 2026 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/addressbookmodel.h>
+
+#include <key_io.h>
+#include <wallet/types.h>
+
+#include <algorithm>
+#include <vector>
+
+namespace {
+class WalletAddressBookDataSource final : public AddressBookDataSource
+{
+public:
+    explicit WalletAddressBookDataSource(interfaces::Wallet& wallet)
+        : m_wallet(wallet)
+    {
+    }
+
+    std::vector<interfaces::WalletAddress> getAddresses() override
+    {
+        return m_wallet.getAddresses();
+    }
+
+    bool setAddressBook(const CTxDestination& dest,
+                        const std::string& label,
+                        const std::optional<wallet::AddressPurpose>& purpose) override
+    {
+        return m_wallet.setAddressBook(dest, label, purpose);
+    }
+
+    bool delAddressBook(const CTxDestination& dest) override
+    {
+        return m_wallet.delAddressBook(dest);
+    }
+
+    bool getAddress(const CTxDestination& dest,
+                    std::string* label,
+                    wallet::AddressPurpose* purpose) override
+    {
+        return m_wallet.getAddress(dest, label, nullptr, purpose);
+    }
+
+private:
+    interfaces::Wallet& m_wallet;
+};
+} // namespace
+
+AddressBookModel::AddressBookModel(std::unique_ptr<AddressBookDataSource> source, QObject* parent)
+    : QAbstractListModel(parent), m_source(std::move(source))
+{
+    refresh();
+}
+
+AddressBookModel::AddressBookModel(interfaces::Wallet& wallet, QObject* parent)
+    : AddressBookModel(std::make_unique<WalletAddressBookDataSource>(wallet), parent)
+{
+}
+
+AddressBookModel::AddressBookModel(QObject* parent)
+    : QAbstractListModel(parent)
+{
+}
+
+int AddressBookModel::rowCount(const QModelIndex& parent) const
+{
+    if (parent.isValid()) {
+        return 0;
+    }
+
+    return static_cast<int>(m_entries.size());
+}
+
+QVariant AddressBookModel::data(const QModelIndex& index, int role) const
+{
+    if (!index.isValid() || index.row() < 0 || index.row() >= rowCount()) {
+        return {};
+    }
+
+    const Entry& entry = m_entries.at(index.row());
+    switch (role) {
+    case Address:
+        return entry.address;
+    case Label:
+        return entry.label;
+    case Purpose:
+        return PurposeName(entry.purpose);
+    case IsMine:
+        return entry.is_mine;
+    default:
+        return {};
+    }
+}
+
+QHash<int, QByteArray> AddressBookModel::roleNames() const
+{
+    return {
+        {Address, "address"},
+        {Label, "label"},
+        {Purpose, "purpose"},
+        {IsMine, "isMine"},
+    };
+}
+
+QString AddressBookModel::lastError() const
+{
+    return m_last_error;
+}
+
+void AddressBookModel::refresh()
+{
+    const int previous_count = rowCount();
+
+    if (!m_source) {
+        if (!m_entries.empty()) {
+            beginResetModel();
+            m_entries.clear();
+            endResetModel();
+        }
+        if (previous_count != 0) {
+            Q_EMIT countChanged();
+        }
+        return;
+    }
+
+    const std::vector<interfaces::WalletAddress> addresses = m_source->getAddresses();
+
+    std::vector<Entry> refreshed_entries;
+    refreshed_entries.reserve(addresses.size());
+
+    for (const auto& address : addresses) {
+        if (address.purpose == wallet::AddressPurpose::REFUND) {
+            continue;
+        }
+
+        const QString encoded = QString::fromStdString(EncodeDestination(address.dest));
+        if (encoded.isEmpty()) {
+            continue;
+        }
+
+        refreshed_entries.push_back(Entry{
+            encoded,
+            QString::fromStdString(address.name),
+            address.purpose,
+            address.is_mine != wallet::ISMINE_NO,
+        });
+    }
+
+    std::sort(refreshed_entries.begin(), refreshed_entries.end(), [](const Entry& lhs, const Entry& rhs) {
+        const int label_order = QString::compare(lhs.label, rhs.label, Qt::CaseInsensitive);
+        if (label_order != 0) {
+            return label_order < 0;
+        }
+        return lhs.address < rhs.address;
+    });
+
+    beginResetModel();
+    m_entries = std::move(refreshed_entries);
+    endResetModel();
+
+    if (previous_count != rowCount()) {
+        Q_EMIT countChanged();
+    }
+}
+
+bool AddressBookModel::addContact(const QString& address, const QString& label, const QString& purpose)
+{
+    CTxDestination destination;
+    if (!validateAddress(address, destination)) {
+        return false;
+    }
+
+    std::string existing_label;
+    wallet::AddressPurpose existing_purpose{wallet::AddressPurpose::SEND};
+    if (lookupAddress(destination, &existing_label, &existing_purpose)) {
+        setLastError(tr("The entered address is already in the address book with label \"%1\".")
+                         .arg(QString::fromStdString(existing_label)));
+        return false;
+    }
+
+    const auto parsed_purpose = ParsePurpose(purpose);
+    if (!parsed_purpose.has_value()) {
+        setLastError(tr("Unsupported address purpose: %1").arg(purpose));
+        return false;
+    }
+
+    if (!applyContact(destination,
+                      label,
+                      parsed_purpose.value(),
+                      tr("Failed to save the contact."))) {
+        return false;
+    }
+
+    setLastError(QString{});
+    return true;
+}
+
+bool AddressBookModel::editContact(const QString& old_address,
+                                   const QString& new_address,
+                                   const QString& label,
+                                   const QString& purpose)
+{
+    CTxDestination old_destination;
+    if (!validateAddress(old_address, old_destination)) {
+        return false;
+    }
+
+    CTxDestination new_destination;
+    if (!validateAddress(new_address, new_destination)) {
+        return false;
+    }
+
+    std::string old_label;
+    wallet::AddressPurpose old_purpose{wallet::AddressPurpose::SEND};
+    if (!lookupAddress(old_destination, &old_label, &old_purpose)) {
+        setLastError(tr("The selected contact does not exist."));
+        return false;
+    }
+
+    std::string existing_new_label;
+    wallet::AddressPurpose existing_new_purpose{wallet::AddressPurpose::SEND};
+    if (old_destination != new_destination
+        && lookupAddress(new_destination, &existing_new_label, &existing_new_purpose)) {
+        setLastError(tr("The entered address is already in the address book with label \"%1\".")
+                         .arg(QString::fromStdString(existing_new_label)));
+        return false;
+    }
+
+    const auto parsed_purpose = ParsePurpose(purpose);
+    if (!parsed_purpose.has_value()) {
+        setLastError(tr("Unsupported address purpose: %1").arg(purpose));
+        return false;
+    }
+
+    if (!applyContact(new_destination,
+                      label,
+                      parsed_purpose.value(),
+                      tr("Failed to update the contact."))) {
+        return false;
+    }
+
+    if (old_destination != new_destination && !m_source->delAddressBook(old_destination)) {
+        setLastError(tr("Updated the contact, but failed to remove the old address entry."));
+        refresh();
+        return false;
+    }
+
+    refresh();
+    setLastError(QString{});
+    return true;
+}
+
+bool AddressBookModel::deleteContact(const QString& address)
+{
+    CTxDestination destination;
+    if (!validateAddress(address, destination)) {
+        return false;
+    }
+
+    if (!m_source || !m_source->delAddressBook(destination)) {
+        setLastError(tr("Failed to delete the selected contact."));
+        return false;
+    }
+
+    refresh();
+    setLastError(QString{});
+    return true;
+}
+
+QString AddressBookModel::labelForAddress(const QString& address) const
+{
+    const auto it = std::find_if(m_entries.begin(), m_entries.end(), [&](const Entry& entry) {
+        return entry.address == address;
+    });
+
+    if (it == m_entries.end()) {
+        return {};
+    }
+
+    return it->label;
+}
+
+std::optional<wallet::AddressPurpose> AddressBookModel::ParsePurpose(const QString& purpose)
+{
+    const QString normalized = purpose.trimmed().toLower();
+    if (normalized == QStringLiteral("send")) {
+        return wallet::AddressPurpose::SEND;
+    }
+    if (normalized == QStringLiteral("receive")) {
+        return wallet::AddressPurpose::RECEIVE;
+    }
+    if (normalized == QStringLiteral("refund")) {
+        return wallet::AddressPurpose::REFUND;
+    }
+    return std::nullopt;
+}
+
+QString AddressBookModel::PurposeName(const wallet::AddressPurpose purpose)
+{
+    switch (purpose) {
+    case wallet::AddressPurpose::SEND:
+        return QStringLiteral("send");
+    case wallet::AddressPurpose::RECEIVE:
+        return QStringLiteral("receive");
+    case wallet::AddressPurpose::REFUND:
+        return QStringLiteral("refund");
+    }
+
+    return QStringLiteral("unknown");
+}
+
+bool AddressBookModel::validateAddress(const QString& address, CTxDestination& destination)
+{
+    const QString trimmed = address.trimmed();
+    if (trimmed.isEmpty()) {
+        setLastError(tr("Enter a Bitcoin address."));
+        return false;
+    }
+
+    destination = DecodeDestination(trimmed.toStdString());
+    if (!IsValidDestination(destination)) {
+        setLastError(tr("The entered address is not a valid Bitcoin address."));
+        return false;
+    }
+
+    return true;
+}
+
+bool AddressBookModel::lookupAddress(const CTxDestination& destination,
+                                     std::string* label,
+                                     wallet::AddressPurpose* purpose)
+{
+    if (!m_source) {
+        return false;
+    }
+
+    return m_source->getAddress(destination, label, purpose);
+}
+
+void AddressBookModel::setLastError(const QString& error)
+{
+    if (m_last_error == error) {
+        return;
+    }
+
+    m_last_error = error;
+    Q_EMIT lastErrorChanged();
+}
+
+bool AddressBookModel::applyContact(const CTxDestination& destination,
+                                    const QString& label,
+                                    const wallet::AddressPurpose purpose,
+                                    const QString& backend_error)
+{
+    if (!m_source) {
+        setLastError(tr("Contact storage is unavailable."));
+        return false;
+    }
+
+    if (!m_source->setAddressBook(destination, label.trimmed().toStdString(), purpose)) {
+        setLastError(backend_error);
+        return false;
+    }
+
+    refresh();
+    return true;
+}
+