wip: Add minimal support for loading signet UTXO snapshots

        Adds minimal wiring to connect QML GUI to loading a signet UTXO snapshot via
        the connection settings. Uses SnapshotSettings.qml to allow user interaction.
	Modifies src/interfaces/node.h and adds new handler class SnapshotLoadHandler
	to src/node/interfaces.cpp
        Also modifies src/validation.h and src/validation.cpp to enable snapshot loading
	progress callback
	And touches chainparams.cpp (temporarily for signet snapshot testing)
        to expose snapshot loading functionality through the node model.

        Current limitations:
        - Not integrated with onboarding process
        - Requires manual navigation to connection settings after initial startup
        - Snapshot verification progress is not fully working yet

        Testing:
        1. Start the node
        2. Complete onboarding
        3. Navigate to connection settings
        4. Load snapshot from provided interface

src/interfaces/node.h

@@ -11,6 +11,7 @@
 #include <net_types.h>                 // For banmap_t
 #include <netaddress.h>                // For Network
 #include <netbase.h>                   // For ConnectionDirection
+#include <node/utxo_snapshot.h>         // For SnapshotMetadata
 #include <support/allocators/secure.h> // For SecureString
 #include <util/translation.h>
 
@@ -31,6 +32,13 @@ class UniValue;
 class Proxy;
 enum class SynchronizationState;
 enum class TransactionError;
+// enum class SnapshotLoadState;
+enum class SnapshotLoadState {
+    INITIAL,              // Before snapshot loading begins
+    PROGRESS_LOADING,     // During chainstate activation
+    ERROR                 // Error state
+};
+class SnapshotLoadHandler;
 struct CNodeStateStats;
 struct bilingual_str;
 struct PeersNumByType;
@@ -199,6 +207,12 @@ class Node
     //! List rpc commands.
     virtual std::vector<std::string> listRpcCommands() = 0;
 
+    //! Load UTXO Snapshot.
+    virtual bool snapshotLoad(const std::string& path_string) = 0;
+
+    //! Get snapshot progress.
+    virtual double getSnapshotProgress() = 0;
+
     //! Set RPC timer interface if unset.
     virtual void rpcSetTimerInterfaceIfUnset(RPCTimerInterface* iface) = 0;
 

src/kernel/chainparams.cpp

@@ -371,6 +371,13 @@ class SigNetParams : public CChainParams {
 
         vFixedSeeds.clear();
 
+        m_assumeutxo_data = MapAssumeutxo{
+            {
+                160000,
+                {AssumeutxoHash{uint256S("0x5225141cb62dee63ab3be95f9b03d60801f264010b1816d4bd00618b2736e7be")}, 1278002},
+            },
+        };
+
         base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
         base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
         base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,239);

src/node/interfaces.cpp

@@ -29,6 +29,7 @@
 #include <node/context.h>
 #include <node/interface_ui.h>
 #include <node/transaction.h>
+#include <node/utxo_snapshot.h>
 #include <policy/feerate.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
@@ -83,6 +84,74 @@ class ExternalSignerImpl : public interfaces::ExternalSigner
 };
 #endif
 
+//! Snapshot load handler
+class SnapshotLoadHandler {
+public:
+    explicit SnapshotLoadHandler(NodeContext* context) : m_context(context) {}
+
+    bool load(const std::string& path_string) {
+
+        const fs::path path = fs::u8path(path_string);
+        if (!fs::exists(path)) {
+            updateState(SnapshotLoadState::ERROR);
+            return false;
+        }
+
+        AutoFile afile{fsbridge::fopen(path, "rb")};
+        if (afile.IsNull()) {
+            updateState(SnapshotLoadState::ERROR);
+            return false;
+        }
+
+        SnapshotMetadata metadata;
+        try {
+            afile >> metadata;
+        } catch (const std::exception& e) {
+            updateState(SnapshotLoadState::ERROR);
+            return false;
+        }
+
+        chainman().SetProgressCallback([this](double progress) {
+            updateState(SnapshotLoadState::PROGRESS_LOADING);
+            chainman().SetSnapshotProgress(progress);
+        });
+
+        bool success = chainman().ActivateSnapshot(afile, metadata, false);
+
+        chainman().SetProgressCallback(nullptr);
+
+        if (!success) {
+            updateState(SnapshotLoadState::ERROR);
+        }
+
+        return success;
+    }
+
+    SnapshotLoadState getState() const { return m_state; }
+
+    bool isBackgroundValidationComplete() const {
+        LOCK(::cs_main);
+        return chainman().IsSnapshotValidated();
+    }
+
+    void updateState(SnapshotLoadState new_state) {
+        m_state = new_state;
+        switch (new_state) {
+            case SnapshotLoadState::INITIAL:
+                chainman().SetSnapshotProgress(0.0);
+                break;
+            case SnapshotLoadState::PROGRESS_LOADING:
+            case SnapshotLoadState::ERROR:
+                break;
+        }
+    }
+
+    ChainstateManager& chainman() const { return *Assert(m_context->chainman); }
+
+    NodeContext* m_context{nullptr};
+    SnapshotLoadState m_state{SnapshotLoadState::INITIAL};
+};
+
 class NodeImpl : public Node
 {
 public:
@@ -395,6 +464,12 @@ class NodeImpl : public Node
     {
         m_context = context;
     }
+    double getSnapshotProgress() override { return chainman().GetSnapshotProgress(); }
+    bool snapshotLoad(const std::string& path_string) override
+    {
+        SnapshotLoadHandler handler(m_context);
+        return handler.load(path_string);
+    }
     ArgsManager& args() { return *Assert(Assert(m_context)->args); }
     ChainstateManager& chainman() { return *Assert(m_context->chainman); }
     NodeContext* m_context{nullptr};
@@ -510,7 +585,7 @@ class RpcHandlerImpl : public Handler
 class ChainImpl : public Chain
 {
 public:
-    explicit ChainImpl(NodeContext& node) : m_node(node) {}
+    explicit ChainImpl(node::NodeContext& node) : m_node(node) {}
     std::optional<int> getHeight() override
     {
         const int height{WITH_LOCK(::cs_main, return chainman().ActiveChain().Height())};

src/qml/components/ConnectionSettings.qml

@@ -11,13 +11,21 @@ ColumnLayout {
     id: root
     signal next
     signal gotoSnapshot
-    property bool snapshotImported: false
-    function setSnapshotImported(imported) {
-        snapshotImported = imported
+    property bool snapshotImportCompleted: false
+    property bool onboarding: false
+
+    Component.onCompleted: {
+        if (!onboarding) {
+            snapshotImportCompleted = chainModel.isSnapshotActive
+        } else {
+            snapshotImportCompleted = false
+        }
     }
+
     spacing: 4
     Setting {
         id: gotoSnapshot
+        visible: !root.onboarding
         Layout.fillWidth: true
         header: qsTr("Load snapshot")
         description: qsTr("Instant use with background sync")
@@ -26,19 +34,22 @@ ColumnLayout {
             height: 26
             CaretRightIcon {
                 anchors.centerIn: parent
-                visible: !snapshotImported
+                visible: !snapshotImportCompleted
                 color: gotoSnapshot.stateColor
             }
             GreenCheckIcon {
                 anchors.centerIn: parent
-                visible: snapshotImported
+                visible: snapshotImportCompleted
                 color: Theme.color.transparent
                 size: 30
             }
         }
         onClicked: root.gotoSnapshot()
     }
-    Separator { Layout.fillWidth: true }
+    Separator {
+        visible: !root.onboarding
+        Layout.fillWidth: true
+    }
     Setting {
         Layout.fillWidth: true
         header: qsTr("Enable listening")

src/qml/components/SnapshotSettings.qml

@@ -5,44 +5,28 @@
 import QtQuick 2.15
 import QtQuick.Controls 2.15
 import QtQuick.Layouts 1.15
+import QtQuick.Dialogs 1.3
 
 import "../controls"
 
 ColumnLayout {
-    signal snapshotImportCompleted()
-    property int snapshotVerificationCycles: 0
-    property real snapshotVerificationProgress: 0
-    property bool snapshotVerified: false
-
     id: columnLayout
+    signal back
+    property bool snapshotLoading: nodeModel.snapshotLoading
+    property bool snapshotLoaded: nodeModel.isSnapshotLoaded
+    property bool snapshotImportCompleted: chainModel.isSnapshotActive
+    property bool onboarding: false
+    property bool snapshotVerified: onboarding ? false : chainModel.isSnapshotActive
+    property string snapshotFileName: ""
+    property var snapshotInfo: ({})
+    property string selectedFile: ""
+
     width: Math.min(parent.width, 450)
     anchors.horizontalCenter: parent.horizontalCenter
 
-
-    Timer {
-        id: snapshotSimulationTimer
-        interval: 50 // Update every 50ms
-        running: false
-        repeat: true
-        onTriggered: {
-            if (snapshotVerificationProgress < 1) {
-                snapshotVerificationProgress += 0.01
-            } else {
-                snapshotVerificationCycles++
-                if (snapshotVerificationCycles < 1) {
-                    snapshotVerificationProgress = 0
-                } else {
-                    running = false
-                    snapshotVerified = true
-                    settingsStack.currentIndex = 2
-                }
-            }
-        }
-    }
-
     StackLayout {
         id: settingsStack
-        currentIndex: 0
+        currentIndex: onboarding ? 0 : snapshotLoaded ? 2 : snapshotVerified ? 2 : snapshotLoading ? 1 : 0
 
         ColumnLayout {
             Layout.alignment: Qt.AlignHCenter
@@ -77,11 +61,22 @@ ColumnLayout {
                 Layout.bottomMargin: 20
                 Layout.alignment: Qt.AlignCenter
                 text: qsTr("Choose snapshot file")
-                onClicked: {
-                    settingsStack.currentIndex = 1
-                    snapshotSimulationTimer.start()
+                onClicked: fileDialog.open()
+            }
+
+            FileDialog {
+                id: fileDialog
+                folder: shortcuts.home
+                selectMultiple: false
+                selectExisting: true
+                nameFilters: ["Snapshot files (*.dat)", "All files (*)"]
+                onAccepted: {
+                    selectedFile = fileUrl.toString()
+                    snapshotFileName = selectedFile
+                    nodeModel.initializeSnapshot(true, snapshotFileName)
                 }
             }
+            // TODO: Handle file error signal
         }
 
         ColumnLayout {
@@ -102,14 +97,16 @@ ColumnLayout {
                 Layout.leftMargin: 20
                 Layout.rightMargin: 20
                 header: qsTr("Loading Snapshot")
+                description: qsTr("This might take a while...")
             }
 
+            //progress indicator once the snapshot progress is implemented
             ProgressIndicator {
                 id: progressIndicator
                 Layout.topMargin: 20
                 width: 200
                 height: 20
-                progress: snapshotVerificationProgress
+                progress: nodeModel.snapshotProgress
                 Layout.alignment: Qt.AlignCenter
                 progressColor: Theme.color.blue
             }
@@ -137,20 +134,19 @@ ColumnLayout {
                 descriptionColor: Theme.color.neutral6
                 descriptionSize: 17
                 descriptionLineHeight: 1.1
-                description: qsTr("It contains transactions up to January 12, 2024. Newer transactions still need to be downloaded." +
-                " The data will be verified in the background.")
+                description: snapshotInfo && snapshotInfo["date"] ?
+                    qsTr("It contains transactions up to %1. Newer transactions still need to be downloaded." +
+                    " The data will be verified in the background.").arg(snapshotInfo["date"]) :
+                    qsTr("It contains transactions up to DEBUG. Newer transactions still need to be downloaded." +
+                    " The data will be verified in the background.")
             }
 
             ContinueButton {
                 Layout.preferredWidth: Math.min(300, columnLayout.width - 2 * Layout.leftMargin)
                 Layout.topMargin: 40
                 Layout.alignment: Qt.AlignCenter
                 text: qsTr("Done")
-                onClicked: {
-                    snapshotImportCompleted()
-                    connectionSwipe.decrementCurrentIndex()
-                    connectionSwipe.decrementCurrentIndex()
-                }
+                onClicked: back()
             }
 
             Setting {
@@ -188,16 +184,25 @@ ColumnLayout {
                         font.pixelSize: 14
                     }
                     CoreText {
-                        text: qsTr("200,000")
+                        text: snapshotInfo && snapshotInfo["height"] ?
+                            snapshotInfo["height"] : qsTr("DEBUG")
                         Layout.alignment: Qt.AlignRight
                         font.pixelSize: 14
                     }
                 }
                 Separator { Layout.fillWidth: true }
                 CoreText {
-                    text: qsTr("Hash: 0x1234567890abcdef...")
+                    text: snapshotInfo && snapshotInfo["hashSerialized"] ?
+                        qsTr("Hash: %1").arg(snapshotInfo["hashSerialized"].substring(0, 13) + "...") :
+                        qsTr("Hash: DEBUG")
                     font.pixelSize: 14
                 }
+
+                Component.onCompleted: {
+                    if (snapshotVerified || snapshotLoaded) {
+                        snapshotInfo = chainModel.getSnapshotInfo()
+                    }
+                }
             }
         }
     }

src/qml/models/chainmodel.cpp

@@ -9,9 +9,13 @@
 #include <QThread>
 #include <QTime>
 #include <interfaces/chain.h>
+#include <node/utxo_snapshot.h>
+#include <kernel/chainparams.h>
+#include <validation.h>
 
 ChainModel::ChainModel(interfaces::Chain& chain)
     : m_chain{chain}
+    //   m_params{Params()}
 {
     QTimer* timer = new QTimer();
     connect(timer, &QTimer::timeout, this, &ChainModel::setCurrentTimeRatio);
@@ -101,3 +105,21 @@ void ChainModel::setCurrentTimeRatio()
 
     Q_EMIT timeRatioListChanged();
 }
+
+// Using hardcoded snapshot info to display in SnapshotSettings.qml
+QVariantMap ChainModel::getSnapshotInfo() {
+    QVariantMap snapshot_info;
+
+   const MapAssumeutxo& valid_assumeutxos_map = Params().Assumeutxo();
+    if (!valid_assumeutxos_map.empty()) {
+        const int height = valid_assumeutxos_map.rbegin()->first;
+        const auto& hash_serialized = valid_assumeutxos_map.rbegin()->second.hash_serialized;
+        int64_t date = m_chain.getBlockTime(height);
+
+        snapshot_info["height"] = height;
+        snapshot_info["hashSerialized"] = QString::fromStdString(hash_serialized.ToString());
+        snapshot_info["date"] = QDateTime::fromSecsSinceEpoch(date).toString("MMMM d yyyy");
+    }
+
+    return snapshot_info;
+}