poc: Load snapshot through the options dialog

D33r-Gee · D33r-Gee · commit 60f676abf54a · 2025-08-01T08:10:36.000-07:00
This is a quick and dirty POC to showcase and test the load snapshot functionality. This is by no means meant to be a robust approach...
diff --git a/src/kernel/notifications_interface.h b/src/kernel/notifications_interface.h
@@ -40,6 +40,7 @@ class Notifications
     [[nodiscard]] virtual InterruptResult blockTip(SynchronizationState state, CBlockIndex& index, double verification_progress) { return {}; }
     virtual void headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) {}
     virtual void progress(const bilingual_str& title, int progress_percent, bool resume_possible) {}
+    virtual void snapshotLoadProgress(double progress) {}
     virtual void warningSet(Warning id, const bilingual_str& message) {}
     virtual void warningUnset(Warning id) {}
 
diff --git a/src/node/interface_ui.cpp b/src/node/interface_ui.cpp
@@ -23,6 +23,7 @@ struct UISignals {
     boost::signals2::signal<CClientUIInterface::NotifyNetworkActiveChangedSig> NotifyNetworkActiveChanged;
     boost::signals2::signal<CClientUIInterface::NotifyAlertChangedSig> NotifyAlertChanged;
     boost::signals2::signal<CClientUIInterface::ShowProgressSig> ShowProgress;
+    boost::signals2::signal<CClientUIInterface::SnapshotLoadProgressSig> SnapshotLoadProgress;
     boost::signals2::signal<CClientUIInterface::NotifyBlockTipSig> NotifyBlockTip;
     boost::signals2::signal<CClientUIInterface::NotifyHeaderTipSig> NotifyHeaderTip;
     boost::signals2::signal<CClientUIInterface::BannedListChangedSig> BannedListChanged;
@@ -43,6 +44,7 @@ ADD_SIGNALS_IMPL_WRAPPER(NotifyNumConnectionsChanged);
 ADD_SIGNALS_IMPL_WRAPPER(NotifyNetworkActiveChanged);
 ADD_SIGNALS_IMPL_WRAPPER(NotifyAlertChanged);
 ADD_SIGNALS_IMPL_WRAPPER(ShowProgress);
+ADD_SIGNALS_IMPL_WRAPPER(SnapshotLoadProgress);
 ADD_SIGNALS_IMPL_WRAPPER(NotifyBlockTip);
 ADD_SIGNALS_IMPL_WRAPPER(NotifyHeaderTip);
 ADD_SIGNALS_IMPL_WRAPPER(BannedListChanged);
@@ -55,6 +57,7 @@ void CClientUIInterface::NotifyNumConnectionsChanged(int newNumConnections) { re
 void CClientUIInterface::NotifyNetworkActiveChanged(bool networkActive) { return g_ui_signals.NotifyNetworkActiveChanged(networkActive); }
 void CClientUIInterface::NotifyAlertChanged() { return g_ui_signals.NotifyAlertChanged(); }
 void CClientUIInterface::ShowProgress(const std::string& title, int nProgress, bool resume_possible) { return g_ui_signals.ShowProgress(title, nProgress, resume_possible); }
+void CClientUIInterface::SnapshotLoadProgress(double progress) { return g_ui_signals.SnapshotLoadProgress(progress); }
 void CClientUIInterface::NotifyBlockTip(SynchronizationState s, const CBlockIndex& block, double verification_progress) { return g_ui_signals.NotifyBlockTip(s, block, verification_progress); }
 void CClientUIInterface::NotifyHeaderTip(SynchronizationState s, int64_t height, int64_t timestamp, bool presync) { return g_ui_signals.NotifyHeaderTip(s, height, timestamp, presync); }
 void CClientUIInterface::BannedListChanged() { return g_ui_signals.BannedListChanged(); }
diff --git a/src/node/interface_ui.h b/src/node/interface_ui.h
@@ -102,6 +102,9 @@ class CClientUIInterface
      */
     ADD_SIGNALS_DECL_WRAPPER(ShowProgress, void, const std::string& title, int nProgress, bool resume_possible);
 
+    /** Snapshot load progress. */
+    ADD_SIGNALS_DECL_WRAPPER(SnapshotLoadProgress, void, double progress);
+
     /** New block has been accepted */
     ADD_SIGNALS_DECL_WRAPPER(NotifyBlockTip, void, SynchronizationState, const CBlockIndex& block, double verification_progress);
 
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
@@ -391,6 +391,10 @@ class NodeImpl : public Node
     {
         return MakeSignalHandler(::uiInterface.ShowProgress_connect(fn));
     }
+    std::unique_ptr<Handler> handleSnapshotLoadProgress(SnapshotLoadProgressFn fn) override
+    {
+        return MakeSignalHandler(::uiInterface.SnapshotLoadProgress_connect(fn));
+    }
     std::unique_ptr<Handler> handleInitWallet(InitWalletFn fn) override
     {
         return MakeSignalHandler(::uiInterface.InitWallet_connect(fn));
diff --git a/src/node/kernel_notifications.cpp b/src/node/kernel_notifications.cpp
@@ -77,6 +77,11 @@ void KernelNotifications::progress(const bilingual_str& title, int progress_perc
     uiInterface.ShowProgress(title.translated, progress_percent, resume_possible);
 }
 
+void KernelNotifications::snapshotLoadProgress(double progress)
+{
+    uiInterface.SnapshotLoadProgress(progress);
+}
+
 void KernelNotifications::warningSet(kernel::Warning id, const bilingual_str& message)
 {
     if (m_warnings.Set(id, message)) {
diff --git a/src/node/kernel_notifications.h b/src/node/kernel_notifications.h
@@ -41,6 +41,8 @@ class KernelNotifications : public kernel::Notifications
 
     void progress(const bilingual_str& title, int progress_percent, bool resume_possible) override;
 
+    void snapshotLoadProgress(double progress) override;
+
     void warningSet(kernel::Warning id, const bilingual_str& message) override;
 
     void warningUnset(kernel::Warning id) override;
diff --git a/src/qt/CMakeLists.txt b/src/qt/CMakeLists.txt
@@ -111,6 +111,8 @@ add_library(bitcoinqt STATIC EXCLUDE_FROM_ALL
   qvaluecombobox.h
   rpcconsole.cpp
   rpcconsole.h
+  snapshotmodel.cpp
+  snapshotmodel.h
   splashscreen.cpp
   splashscreen.h
   trafficgraphwidget.cpp
diff --git a/src/qt/optionsdialog.cpp b/src/qt/optionsdialog.cpp
@@ -12,6 +12,7 @@
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
+#include <qt/snapshotmodel.h>
 
 #include <common/system.h>
 #include <interfaces/node.h>
@@ -25,12 +26,16 @@
 #include <QApplication>
 #include <QDataWidgetMapper>
 #include <QDir>
+#include <QFileDialog>
 #include <QFontDialog>
 #include <QIntValidator>
 #include <QLocale>
 #include <QMessageBox>
 #include <QSystemTrayIcon>
 #include <QTimer>
+#include <QProgressDialog>
+
+#include <interfaces/handler.h>
 
 int setFontChoice(QComboBox* cb, const OptionsModel::FontChoice& fc)
 {
@@ -121,6 +126,10 @@ OptionsDialog::OptionsDialog(QWidget* parent, bool enableWallet)
     connect(ui->connectSocksTor, &QPushButton::toggled, ui->proxyPortTor, &QWidget::setEnabled);
     connect(ui->connectSocksTor, &QPushButton::toggled, this, &OptionsDialog::updateProxyValidationState);
 
+    QPushButton* loadSnapshotButton = new QPushButton(tr("Load Snapshot..."), this);
+    ui->verticalLayout_Main->insertWidget(ui->verticalLayout_Main->indexOf(ui->enableServer) + 1, loadSnapshotButton);
+    connect(loadSnapshotButton, &QPushButton::clicked, this, &OptionsDialog::on_loadSnapshotButton_clicked);
+
     /* Window elements init */
 #ifdef Q_OS_MACOS
     /* remove Window tab on Mac */
@@ -400,6 +409,51 @@ void OptionsDialog::on_showTrayIcon_stateChanged(int state)
     }
 }
 
+void OptionsDialog::on_loadSnapshotButton_clicked()
+{
+    QString filename = QFileDialog::getOpenFileName(this,
+        tr("Load Snapshot"),
+        tr("Bitcoin Snapshot Files (*.dat);;"));
+
+    if (filename.isEmpty()) return;
+
+    QMessageBox::StandardButton retval = QMessageBox::question(this, tr("Confirm snapshot load"),
+        tr("Are you sure you want to load this snapshot? This will delete your current blockchain data."),
+        QMessageBox::Yes | QMessageBox::Cancel,
+        QMessageBox::Cancel);
+
+    if (retval != QMessageBox::Yes) return;
+
+    QProgressDialog* progress = new QProgressDialog(tr("Loading snapshot..."), tr("Cancel"), 0, 100, this);
+    progress->setWindowModality(Qt::WindowModal);
+    progress->setMinimumDuration(0);
+    progress->setValue(0);
+    progress->show();
+
+    // Store the handler in the member variable to keep it alive
+    m_snapshot_load_handler = model->node().handleSnapshotLoadProgress(
+        [progress](double p) {
+            progress->setValue(static_cast<int>(p * 100));
+            QApplication::processEvents();
+        });
+
+    SnapshotModel snapshotModel(model->node(), filename);
+    bool success = snapshotModel.processPath();
+
+    // Clean up the progress dialog
+    progress->close();
+    progress->deleteLater();
+
+    // Clean up the handler
+    m_snapshot_load_handler.reset();
+
+    if (success) {
+        QMessageBox::information(this, tr("Success"), tr("Snapshot loaded successfully"));
+    } else {
+        QMessageBox::critical(this, tr("Error"), tr("Error loading snapshot"));
+    }
+}
+
 void OptionsDialog::togglePruneWarning(bool enabled)
 {
     ui->pruneWarning->setVisible(!ui->pruneWarning->isVisible());
diff --git a/src/qt/optionsdialog.h b/src/qt/optionsdialog.h
@@ -20,6 +20,10 @@ namespace Ui {
 class OptionsDialog;
 }
 
+namespace interfaces {
+class Handler;
+}
+
 /** Proxy address widget validator, checks for a valid proxy address.
  */
 class ProxyAddressValidator : public QValidator
@@ -58,6 +62,8 @@ private Q_SLOTS:
     void on_openBitcoinConfButton_clicked();
     void on_okButton_clicked();
     void on_cancelButton_clicked();
+    void on_loadSnapshotButton_clicked();
+
 
     void on_showTrayIcon_stateChanged(int state);
 
@@ -77,6 +83,7 @@ private Q_SLOTS:
     ClientModel* m_client_model{nullptr};
     OptionsModel* model{nullptr};
     QDataWidgetMapper* mapper{nullptr};
+    std::unique_ptr<interfaces::Handler> m_snapshot_load_handler;
 };
 
 #endif // BITCOIN_QT_OPTIONSDIALOG_H
diff --git a/src/qt/snapshotmodel.cpp b/src/qt/snapshotmodel.cpp
@@ -0,0 +1,45 @@
+// Copyright (c) 2024 - present 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 <qt/snapshotmodel.h>
+
+#include <interfaces/node.h>
+#include <node/context.h>
+#include <node/utxo_snapshot.h>
+#include <clientversion.h>
+#include <validation.h>
+#include <util/fs.h>
+#include <util/fs_helpers.h>
+
+SnapshotModel::SnapshotModel(interfaces::Node& node, QString path)
+    : m_node(node), m_path(path) {}
+
+bool SnapshotModel::processPath()
+{
+    ChainstateManager& chainman = *m_node.context()->chainman;
+    const fs::path snapshot_path = fs::u8path(m_path.toStdString());
+    if (!fs::exists(snapshot_path)) {
+        return false;
+    }
+
+    FILE* snapshot_file{fsbridge::fopen(snapshot_path, "rb")};
+    AutoFile coins_file{snapshot_file};
+    if (coins_file.IsNull()) {
+        return false;
+    }
+
+    node::SnapshotMetadata metadata{chainman.GetParams().MessageStart()};
+    try {
+        coins_file >> metadata;
+    } catch (const std::exception& e) {
+        return false;
+    }
+
+    bool result = m_node.loadSnapshot(coins_file, metadata, false);
+    if (!result) {
+        return false;
+    }
+
+    return true;
+}
diff --git a/src/qt/snapshotmodel.h b/src/qt/snapshotmodel.h
@@ -0,0 +1,28 @@
+// Copyright (c) 2024 - present 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_QT_SNAPSHOTMODEL_H
+#define BITCOIN_QT_SNAPSHOTMODEL_H
+
+#include <QObject>
+#include <interfaces/node.h>
+#include <node/context.h>
+#include <node/utxo_snapshot.h>
+
+/** Model for snapshot operations. */
+class SnapshotModel : public QObject
+{
+    Q_OBJECT
+
+public:
+    SnapshotModel(interfaces::Node& node, QString path);
+
+    bool processPath();
+
+private:
+    interfaces::Node& m_node;
+    QString m_path;
+};
+
+#endif // BITCOIN_QT_SNAPSHOTMODEL_H
diff --git a/src/validation.cpp b/src/validation.cpp
@@ -5980,6 +5980,10 @@ util::Result<void> ChainstateManager::PopulateAndValidateSnapshot(
                 --coins_left;
                 ++coins_processed;
 
+                // Show Snapshot Loading progress
+                double progress = static_cast<double>(coins_processed) / static_cast<double>(coins_count);
+                GetNotifications().snapshotLoadProgress(progress);
+
                 if (coins_processed % 1000000 == 0) {
                     LogInfo("[snapshot] %d coins loaded (%.2f%%, %.2f MB)",
                         coins_processed,

Original file line number	Diff line number	Diff line change
`@@ -391,6 +391,10 @@ class NodeImpl : public Node`
`391`	`391`	`{`
`392`	`392`	`return MakeSignalHandler(::uiInterface.ShowProgress_connect(fn));`
`393`	`393`	`}`
	`394`	`+ std::unique_ptr<Handler> handleSnapshotLoadProgress(SnapshotLoadProgressFn fn) override`
	`395`	`+ {`
	`396`	`+ return MakeSignalHandler(::uiInterface.SnapshotLoadProgress_connect(fn));`
	`397`	`+ }`
`394`	`398`	`std::unique_ptr<Handler> handleInitWallet(InitWalletFn fn) override`
`395`	`399`	`{`
`396`	`400`	`return MakeSignalHandler(::uiInterface.InitWallet_connect(fn));`
Original file line number	Diff line number	Diff line change
`@@ -77,6 +77,11 @@ void KernelNotifications::progress(const bilingual_str& title, int progress_perc`
`77`	`77`	`uiInterface.ShowProgress(title.translated, progress_percent, resume_possible);`
`78`	`78`	`}`
`79`	`79`
	`80`	`+void KernelNotifications::snapshotLoadProgress(double progress)`
	`81`	`+{`
	`82`	`+ uiInterface.SnapshotLoadProgress(progress);`
	`83`	`+}`
	`84`	`+`
`80`	`85`	`void KernelNotifications::warningSet(kernel::Warning id, const bilingual_str& message)`
`81`	`86`	`{`
`82`	`87`	`if (m_warnings.Set(id, message)) {`