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

src/qt/walletmodel.cpp

Before: src/qt/walletmodel.cpp · After: src/qt/walletmodel.cpp

File metadata

index 7a35f8e4d356fb603538a596ad237a8009f89c08..a08ed9d53d0ef3068f3f4d19ea237b842611ded1 100644

Download original patch · Release notes

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

+ Added− RemovedUnmarked lines are context.

Scroll the code area horizontally to read long lines. The two line-number columns refer to before and after.

src/qt/walletmodel.cpp CHANGED Viewed

@@ -2,6 +2,9 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#include <support/cleanse.h>
+#include <util/rbf.h>
+#include <util/threadnames.h>
 #include <qt/walletmodel.h>
 #include <qt/addresstablemodel.h>
@@ -52,14 +55,67 @@ WalletModel::WalletModel(std::unique_ptr<interfaces::Wallet> wallet, ClientModel
     transactionTableModel = new TransactionTableModel(platformStyle, this);
     recentRequestsTableModel = new RecentRequestsTableModel(this);
+    m_sweep_context.moveToThread(&m_sweep_thread);
+    m_sweep_thread.start();
+    QTimer::singleShot(0, &m_sweep_context, [] { util::ThreadRename("qt-sweep"); });
     subscribeToCoreSignals();
 }
 WalletModel::~WalletModel()
 {
+    invalidateSweepRequests();
+    m_sweep_thread.quit();
+    m_sweep_thread.wait();
     unsubscribeFromCoreSignals();
 }
+bool WalletModel::invalidateSweepRequests()
+{
+    if (m_sweep_authorization && !m_sweep_authorization->Cancel()) return false;
+    ++m_sweep_request_generation;
+    m_sweep_authorization.reset();
+    Q_EMIT sweepRequestInvalidated(m_sweep_request_generation);
+    return true;
+}
+uint64_t WalletModel::requestSweep(SecureString private_key, CTxDestination destination, bool broadcast,
+                                   std::optional<Txid> expected_txid)
+{
+    if (m_sweep_authorization && !m_sweep_authorization->Cancel()) return 0;
+    const uint64_t generation{++m_sweep_request_generation};
+    auto authorization{std::make_shared<interfaces::SweepAuthorization>()};
+    m_sweep_authorization = authorization;
+    QMetaObject::invokeMethod(&m_sweep_context, [this, generation, authorization, private_key = std::move(private_key), destination = std::move(destination), broadcast, expected_txid]() mutable {
+        auto result{[&]() -> util::Result<interfaces::WalletSweepResult> {
+            try {
+                return m_wallet->sweepPrivateKey(private_key, destination, broadcast, expected_txid, authorization);
+            } catch (const std::exception&) {
+                // RPC interruption can throw during shutdown. Keep errors non-secret
+                // and finish disposal instead of unwinding through Qt's event loop.
+                return util::Error{Untranslated("Sweep interrupted or unavailable")};
+            }
+        }()};
+        if (!private_key.empty()) memory_cleanse(private_key.data(), private_key.size());
+        SecureString{}.swap(private_key);
+        const bool success{result.has_value()};
+        const QString error{success ? QString{} : QString::fromStdString(util::ErrorString(result).original)};
+        const qint64 amount{success ? result->amount : 0};
+        const qint64 fee{success ? result->fee : 0};
+        const quint64 inputs{success ? result->inputs : 0};
+        const qint64 vsize{success ? result->vsize : 0};
+        const bool rbf{success && result->tx && SignalsOptInRBF(*result->tx)};
+        const QString txid{success && result->tx ? QString::fromStdString(result->tx->GetHash().ToString()) : QString{}};
+        QMetaObject::invokeMethod(this, [this, generation, broadcast, success, error, amount, fee, inputs, vsize, rbf, txid] {
+            if (generation != m_sweep_request_generation) return;
+            m_sweep_authorization.reset();
+            Q_EMIT sweepFinished(generation, broadcast, success, error, amount, fee, inputs, vsize, rbf, txid);
+        }, Qt::QueuedConnection);
+    }, Qt::QueuedConnection);
+    return generation;
+}
 void WalletModel::startPollBalance()
 {
     // Update the cached balance right away, so every view can make use of it,
@@ -106,6 +162,13 @@ void WalletModel::pollBalanceChanged()
     }
     if (fForceCheckBalanceChanged || block_hash != m_cached_last_update_tip) {
+        if (!m_cached_last_update_tip.IsNull() && block_hash != m_cached_last_update_tip) {
+            // A sweep preview commits to the currently observed chain state.
+            // Do not leave a key or a broadcastable preview around after a tip
+            // change; the dialog must collect fresh input and preview again.
+            invalidateSweepRequests();
+            Q_EMIT walletStateChanged();
+        }
         fForceCheckBalanceChanged = false;
         // Balance and number of transactions might have changed
@@ -134,6 +197,10 @@ void WalletModel::updateTransaction()
 {
     // Balance and number of transactions might have changed
     fForceCheckBalanceChanged = true;
+    Q_EMIT walletStateChanged();
+    // A competing spend or wallet update can invalidate a sweep before the
+    // next periodic balance refresh observes it.
+    invalidateSweepRequests();
 }
 void WalletModel::updateAddressBook(const QString &address, const QString &label,
@@ -351,7 +418,10 @@ bool WalletModel::changePassphrase(const SecureString &oldPass, const SecureStri
 static void NotifyUnload(WalletModel* walletModel)
 {
     qDebug() << "NotifyUnload";
-    bool invoked = QMetaObject::invokeMethod(walletModel, "unload");
+    bool invoked = QMetaObject::invokeMethod(walletModel, [walletModel] {
+        walletModel->invalidateSweepRequests();
+        Q_EMIT walletModel->unload();
+    });
     assert(invoked);
 }
@@ -415,6 +485,7 @@ void WalletModel::subscribeToCoreSignals()
 void WalletModel::unsubscribeFromCoreSignals()
 {
+    invalidateSweepRequests();
     // Disconnect signals from wallet
     m_handler_unload->disconnect();
     m_handler_status_changed->disconnect();