v31.1-roots.1 · Commit 6: [PATCH 06/17] feat(wallet): preserve Roots signing and spend controls on v31

src/qt/sweepdialog.cpp

Before: /dev/null · After: src/qt/sweepdialog.cpp

File metadata

new file mode 100644
index 0000000000000000000000000000000000000000..6bf558960f395dbeaa0094ef79a37067f4afee56

Download original patch · Release notes

Diff rows 1–273 of 273. Line numbers refer to the original before/after files.

+ Added− RemovedUnmarked lines are context.

Scroll the code area horizontally to read long lines. Before is on the left; after is on the right. Unified view fits narrow screens more easily.

src/qt/sweepdialog.cpp ADDED Viewed

	@@ -0,0 +1,273 @@

+// Copyright (c) 2026 The Bitcoin Roots developers
+// Distributed under the MIT software license, see the accompanying file COPYING or http://www.opensource.org/licenses/MIT.
+#include <qt/sweepdialog.h>
+#include <key_io.h>
+#include <qt/bitcoinunits.h>
+#include <qt/optionsmodel.h>
+#include <qt/walletmodel.h>
+#include <support/cleanse.h>
+#include <util/translation.h>
+#include <primitives/transaction_identifier.h>
+#include <QByteArray>
+#include <QCheckBox>
+#include <QDialogButtonBox>
+#include <QFormLayout>
+#include <QKeyEvent>
+#include <QKeySequence>
+#include <QLabel>
+#include <QLineEdit>
+#include <QMessageBox>
+#include <QPushButton>
+#include <QSignalBlocker>
+#include <QVBoxLayout>
+namespace {
+class SecureLineEdit final : public QLineEdit
+{
+public:
+    using QLineEdit::QLineEdit;
+    void ClearText()
+    {
+        setText(QString(text().size(), QChar{' '}));
+        clear();
+    }
+    SecureString TakeText()
+    {
+        QByteArray encoded{text().toLatin1()};
+        SecureString result{encoded.constData(), static_cast<size_t>(encoded.size())};
+        if (!encoded.isEmpty()) memory_cleanse(encoded.data(), encoded.size());
+        // QLineEdit does not expose its internal buffer for cleansing. Replace
+        // its visible contents before clearing; Qt does not guarantee physical
+        // erasure of every internal QString or undo-buffer copy.
+        ClearText();
+        return result;
+    }
+protected:
+    void keyPressEvent(QKeyEvent* event) override
+    {
+        if (event->matches(QKeySequence::Copy) || event->matches(QKeySequence::Cut)) {
+            event->accept();
+            return;
+        }
+        QLineEdit::keyPressEvent(event);
+    }
+};
+} // namespace
+SweepDialog::SweepDialog(WalletModel* wallet_model, QWidget* parent)
+    : QDialog(parent), m_wallet_model(wallet_model)
+{
+    setWindowTitle(tr("Sweep Private Key"));
+    setModal(true);
+    auto* layout = new QVBoxLayout(this);
+    auto* warning = new QLabel(tr("A private key is a bearer secret. It is used only for this sweep and is never saved in this wallet. Keep an independent backup until the transaction confirms."), this);
+    warning->setWordWrap(true);
+    layout->addWidget(warning);
+    auto* form = new QFormLayout;
+    m_private_key = new SecureLineEdit(this);
+    m_private_key->setObjectName("sweepPrivateKey");
+    m_private_key->setEchoMode(QLineEdit::Password);
+    m_private_key->setContextMenuPolicy(Qt::NoContextMenu);
+    m_private_key->setDragEnabled(false);
+    m_private_key->setAccessibleName(tr("Private key"));
+    m_private_key->setAccessibleDescription(tr("Masked private key. Copy, cut, and context-menu actions are disabled."));
+    auto* reveal = new QCheckBox(tr("Show private key"), this);
+    reveal->setObjectName("sweepReveal");
+    reveal->setAccessibleName(tr("Show private key"));
+    reveal->setAccessibleDescription(tr("Temporarily reveal the private key on screen. Copy and cut remain disabled."));
+    m_destination = new QLineEdit(this);
+    m_destination->setObjectName("sweepDestination");
+    m_destination->setAccessibleName(tr("Destination address"));
+    m_destination->setAccessibleDescription(tr("A spendable destination address controlled by the selected wallet. Watch-only and private-key-disabled wallets are not eligible."));
+    form->addRow(tr("Private key:"), m_private_key);
+    form->addRow(QString{}, reveal);
+    form->addRow(tr("Destination:"), m_destination);
+    layout->addLayout(form);
+    m_result = new QLabel(this);
+    m_result->setObjectName("sweepResult");
+    m_result->setWordWrap(true);
+    m_result->setAccessibleName(tr("Sweep preview"));
+    m_result->setAccessibleDescription(tr("Non-secret sweep preview, status, and error details."));
+    layout->addWidget(m_result);
+    auto* buttons = new QDialogButtonBox(QDialogButtonBox::Cancel, this);
+    m_preview = buttons->addButton(tr("Preview"), QDialogButtonBox::ActionRole);
+    m_broadcast = buttons->addButton(tr("Broadcast sweep"), QDialogButtonBox::AcceptRole);
+    m_preview->setObjectName("sweepPreview");
+    m_broadcast->setObjectName("sweepBroadcast");
+    m_broadcast->setEnabled(false);
+    m_preview->setAccessibleName(tr("Preview sweep"));
+    m_broadcast->setAccessibleName(tr("Broadcast sweep"));
+    m_preview->setAccessibleDescription(tr("Scan eligible supported coins and create a transaction preview without broadcasting. Review its fee, destination, and Replace-By-Fee state."));
+    m_broadcast->setAccessibleDescription(tr("Broadcast the currently displayed sweep transaction. This cannot be undone and may fail if chain state or fees changed."));
+    layout->addWidget(buttons);
+    setTabOrder(m_private_key, reveal);
+    setTabOrder(reveal, m_destination);
+    setTabOrder(m_destination, m_preview);
+    setTabOrder(m_preview, m_broadcast);
+    connect(m_preview, &QPushButton::clicked, this, &SweepDialog::preview);
+    connect(m_broadcast, &QPushButton::clicked, this, &SweepDialog::broadcast);
+    connect(buttons, &QDialogButtonBox::rejected, this, &SweepDialog::reject);
+    connect(m_private_key, &QLineEdit::textChanged, this, &SweepDialog::invalidate);
+    connect(m_destination, &QLineEdit::textChanged, this, &SweepDialog::invalidate);
+    connect(reveal, &QCheckBox::toggled, this, [this](bool checked) {
+        m_private_key->setEchoMode(checked ? QLineEdit::Normal : QLineEdit::Password);
+    });
+    connect(this, &QDialog::finished, this, &SweepDialog::clearSensitive);
+    connect(m_wallet_model, &WalletModel::unload, this, &SweepDialog::clearSensitive);
+    connect(m_wallet_model, &WalletModel::sweepRequestInvalidated, this, [this](uint64_t) {
+        m_request_generation = 0;
+        const QSignalBlocker block{m_private_key};
+        static_cast<SecureLineEdit*>(m_private_key)->ClearText();
+        clearPrivateKeyCache();
+        m_preview_txid.clear();
+        setBusy(false);
+        m_preview_current = false;
+        m_broadcast->setEnabled(false);
+        m_result->setText(tr("Sweep state changed. Enter the private key and create a fresh preview."));
+    });
+    connect(m_wallet_model, &WalletModel::sweepFinished, this, &SweepDialog::handleSweepFinished);
+}
+SweepDialog::~SweepDialog() { clearSensitive(); }
+void SweepDialog::clearPrivateKeyCache()
+{
+    // clear() alone retains storage, including the old secret beyond size().
+    // Wipe live bytes first, including short-string storage, then release any
+    // allocation through secure_allocator's cleansing deallocator.
+    if (!m_private_key_cache.empty()) memory_cleanse(m_private_key_cache.data(), m_private_key_cache.size());
+    SecureString{}.swap(m_private_key_cache);
+}
+void SweepDialog::invalidate()
+{
+    if (m_request_generation != 0 && !m_wallet_model->invalidateSweepRequests()) {
+        m_result->setText(tr("Sweep broadcast submission has started and can no longer be cancelled. Wait for its result."));
+        return;
+    }
+    m_request_generation = 0;
+    clearPrivateKeyCache();
+    m_preview_txid.clear();
+    m_preview_current = false;
+    m_broadcast->setEnabled(false);
+    m_result->setText(tr("A new preview is required before broadcasting."));
+}
+void SweepDialog::setBusy(bool busy)
+{
+    m_busy = busy;
+    m_private_key->setEnabled(!busy);
+    m_destination->setEnabled(!busy);
+    m_preview->setEnabled(!busy);
+    if (busy) m_broadcast->setEnabled(false);
+}
+void SweepDialog::setResult(const QString& text, bool can_broadcast)
+{
+    m_result->setText(text);
+    m_preview_current = can_broadcast;
+    m_broadcast->setEnabled(can_broadcast);
+}
+void SweepDialog::preview()
+{
+    clearPrivateKeyCache();
+    const CTxDestination destination{DecodeDestination(m_destination->text().toStdString())};
+    if (!IsValidDestination(destination)) { setResult(tr("Enter a valid destination address."), false); return; }
+    const QSignalBlocker block{m_private_key};
+    m_private_key_cache = static_cast<SecureLineEdit*>(m_private_key)->TakeText();
+    if (m_private_key_cache.empty()) { setResult(tr("Enter a private key."), false); return; }
+    setBusy(true);
+    m_result->setText(tr("Scanning for eligible coins and preparing a preview…"));
+    m_request_generation = m_wallet_model->requestSweep(m_private_key_cache, destination, false);
+    if (m_request_generation == 0) {
+        clearPrivateKeyCache();
+        setBusy(false);
+        setResult(tr("Another sweep broadcast is already being submitted."), false);
+    }
+}
+void SweepDialog::broadcast()
+{
+    if (!m_preview_current || m_private_key_cache.empty()) return;
+    const auto answer = QMessageBox::warning(this, tr("Broadcast sweep"),
+        tr("Broadcast this exact preview now? This action is irreversible and may fail if the chain state or fee conditions changed."),
+        QMessageBox::Cancel | QMessageBox::Yes, QMessageBox::Cancel);
+    if (answer != QMessageBox::Yes) return;
+    const CTxDestination destination{DecodeDestination(m_destination->text().toStdString())};
+    const auto expected_txid{Txid::FromHex(m_preview_txid.toStdString())};
+    if (!expected_txid) {
+        clearPrivateKeyCache();
+        setResult(tr("The preview is no longer valid. Create a fresh preview."), false);
+        return;
+    }
+    setBusy(true);
+    m_preview_current = false;
+    m_result->setText(tr("Rechecking the preview and broadcasting the sweep…"));
+    m_request_generation = m_wallet_model->requestSweep(m_private_key_cache, destination, true, expected_txid);
+    if (m_request_generation == 0) {
+        clearPrivateKeyCache();
+        setBusy(false);
+        setResult(tr("Sweep broadcast submission has already started. Wait for its result."), false);
+    }
+}
+void SweepDialog::reject()
+{
+    if (m_request_generation != 0 && !m_wallet_model->invalidateSweepRequests()) {
+        m_result->setText(tr("Sweep broadcast submission has started and can no longer be cancelled. Wait for its result."));
+        return;
+    }
+    m_request_generation = 0;
+    clearSensitive();
+    QDialog::reject();
+}
+void SweepDialog::handleSweepFinished(uint64_t generation, bool broadcast, bool success, const QString& error,
+                                      qint64 amount, qint64 fee, quint64 inputs, qint64 vsize, bool rbf, const QString& txid)
+{
+    if (generation != m_request_generation) return;
+    m_request_generation = 0;
+    setBusy(false);
+    if (!success) {
+        setResult(broadcast
+                ? tr("Broadcast failed: %1. Create a fresh preview before trying again.").arg(error)
+                : tr("Preview failed: %1").arg(error), false);
+        clearPrivateKeyCache();
+        m_preview_txid.clear();
+        return;
+    }
+    if (broadcast) {
+        setResult(tr("Sweep broadcast. Transaction %1 was submitted.").arg(txid), false);
+        clearSensitive();
+        return;
+    }
+    m_preview_txid = txid;
+    const qint64 fee_rate{vsize > 0 ? (fee + vsize - 1) / vsize : 0};
+    setResult(tr("Wallet: %1\nDestination: %2\n%3 input(s), total %4, fee %5, net received %6.\nFee rate: %7 sat/vB. Replace-By-Fee: %8. Review these facts before irreversible broadcast.")
+                  .arg(m_wallet_model->getDisplayName(), m_destination->text())
+                  .arg(inputs).arg(BitcoinUnits::formatWithUnit(m_wallet_model->getOptionsModel()->getDisplayUnit(), amount))
+                  .arg(BitcoinUnits::formatWithUnit(m_wallet_model->getOptionsModel()->getDisplayUnit(), fee))
+                  .arg(BitcoinUnits::formatWithUnit(m_wallet_model->getOptionsModel()->getDisplayUnit(), amount - fee))
+                  .arg(fee_rate)
+                  .arg(rbf ? tr("signaled") : tr("not signaled")), true);
+}
+void SweepDialog::clearSensitive()
+{
+    if (m_request_generation != 0 && !m_wallet_model->invalidateSweepRequests()) return;
+    m_request_generation = 0;
+    const QSignalBlocker block{m_private_key};
+    static_cast<SecureLineEdit*>(m_private_key)->ClearText();
+    clearPrivateKeyCache();
+    m_preview_txid.clear();
+    m_preview_current = false;
+    setBusy(false);
+    m_broadcast->setEnabled(false);
+}