poc: Implement GUI snapshot loading functionality

- Added a new signal `snapshotLoadProgress` to the notifications interface for tracking snapshot loading progress.
- Introduced a `SnapshotLoadWorker` class to handle snapshot loading in a separate thread, emitting progress updates.
- Updated `ClientModel` to manage snapshot loading, including methods for setting verification progress and loading snapshots based on that progress.
- Enhanced the GUI to allow users to select a snapshot file and display loading progress through a dialog.
- Integrated snapshot path handling in the application initialization process.

This change improves user experience by providing real-time feedback during snapshot loading operations.

Author: D33r-Gee

src/interfaces/node.h

@@ -12,6 +12,7 @@
 #include <net_types.h>
 #include <netaddress.h>
 #include <netbase.h>
+#include <interfaces/snapshot.h>
 #include <node/utxo_snapshot.h>
 #include <support/allocators/secure.h>
 #include <util/translation.h>

src/interfaces/snapshot.h

@@ -33,6 +33,9 @@ class Snapshot
 
     //! Get the last error message from activation attempt.
     virtual std::string getLastError() const = 0;
+
+    //! Get the path of the snapshot.
+    virtual fs::path getPath() const = 0;
 };
 
 } // namespace interfaces

src/kernel/notifications_interface.h

@@ -40,6 +40,7 @@ class Notifications
     [[nodiscard]] virtual InterruptResult blockTip(SynchronizationState state, const 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) {}
 

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(); }

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);
 

src/node/interfaces.cpp

@@ -150,6 +150,11 @@ class SnapshotImpl : public interfaces::Snapshot
         return m_last_error;
     }
 
+    fs::path getPath() const override
+    {
+        return m_path;
+    }
+
 private:
     ChainstateManager& m_chainman;
     fs::path m_path;

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)) {

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;

src/qt/bitcoin.cpp

@@ -14,7 +14,9 @@
 #include <interfaces/handler.h>
 #include <interfaces/init.h>
 #include <interfaces/node.h>
+#include <interfaces/snapshot.h>
 #include <logging.h>
+#include <validation.h>
 #include <node/context.h>
 #include <node/interface_ui.h>
 #include <noui.h>
@@ -35,7 +37,6 @@
 #include <util/string.h>
 #include <util/threadnames.h>
 #include <util/translation.h>
-#include <validation.h>
 
 #ifdef ENABLE_WALLET
 #include <qt/paymentserver.h>
@@ -319,6 +320,12 @@ void BitcoinApplication::InitPruneSetting(int64_t prune_MiB)
     optionsModel->SetPruneTargetGB(PruneMiBtoGB(prune_MiB));
 }
 
+void BitcoinApplication::setSnapshotPath(const QString& snapshot_path)
+{
+    qDebug() << "setSnapshotPath called with:" << snapshot_path;
+    m_snapshot_path = snapshot_path;
+}
+
 void BitcoinApplication::requestInitialize()
 {
     qDebug() << __func__ << ": Requesting initialize";
@@ -386,7 +393,7 @@ void BitcoinApplication::initializeResult(bool success, interfaces::BlockAndHead
 
         // Log this only after AppInitMain finishes, as then logging setup is guaranteed complete
         qInfo() << "Platform customization:" << platformStyle->getName();
-        clientModel = new ClientModel(node(), optionsModel);
+        clientModel = new ClientModel(node(), optionsModel, this, m_snapshot_path);
         window->setClientModel(clientModel, &tip_info);
 
         // If '-min' option passed, start window minimized (iconified) or minimized to tray
@@ -580,8 +587,9 @@ int GuiMain(int argc, char* argv[])
     // User language is set up: pick a data directory
     bool did_show_intro = false;
     int64_t prune_MiB = 0;  // Intro dialog prune configuration
+    QString snapshot_path;  // Intro dialog snapshot path
     // Gracefully exit if the user cancels
-    if (!Intro::showIfNeeded(did_show_intro, prune_MiB)) return EXIT_SUCCESS;
+    if (!Intro::showIfNeeded(did_show_intro, prune_MiB, snapshot_path)) return EXIT_SUCCESS;
 
     /// 6-7. Parse bitcoin.conf, determine network, switch to network specific
     /// options, and create datadir and settings.json.
@@ -662,6 +670,11 @@ int GuiMain(int argc, char* argv[])
         app.InitPruneSetting(prune_MiB);
     }
 
+    // Store snapshot path for later loading after node initialization
+    if (!snapshot_path.isEmpty()) {
+        app.setSnapshotPath(snapshot_path);
+    }
+
     try
     {
         app.createWindow(networkStyle.data());

src/qt/bitcoin.h

@@ -16,6 +16,8 @@
 
 #include <QApplication>
 
+enum class SynchronizationState;
+
 class BitcoinGUI;
 class ClientModel;
 class NetworkStyle;
@@ -48,6 +50,12 @@ class BitcoinApplication: public QApplication
     [[nodiscard]] bool createOptionsModel(bool resetSettings);
     /// Initialize prune setting
     void InitPruneSetting(int64_t prune_MiB);
+    /// Set snapshot path for loading after node initialization
+    void setSnapshotPath(const QString& snapshot_path);
+    /// Test method to manually trigger snapshot loading (for debugging)
+    void testLoadSnapshot();
+    /// Force load snapshot regardless of sync status (for debugging)
+    void forceLoadSnapshot();
     /// Create main window
     void createWindow(const NetworkStyle *networkStyle);
     /// Create splash screen
@@ -66,6 +74,10 @@ class BitcoinApplication: public QApplication
     /// Setup platform style
     void setupPlatformStyle();
 
+    void loadSnapshotIfNeeded();
+    bool areHeadersSynced() const;
+    void onHeaderTipChanged(SynchronizationState sync_state, interfaces::BlockTip tip, bool presync);
+
     interfaces::Node& node() const { assert(m_node); return *m_node; }
 
 public Q_SLOTS:
@@ -103,6 +115,9 @@ public Q_SLOTS:
     std::unique_ptr<QWidget> shutdownWindow;
     SplashScreen* m_splash = nullptr;
     std::unique_ptr<interfaces::Node> m_node;
+    QString m_snapshot_path;
+    std::unique_ptr<interfaces::Handler> m_header_tip_handler;
+    QTimer* m_sync_check_timer;
 
     void startThread();
 };