qml: Implement UTXO snapshot loading infrastructure

- Add SnapshotQml class to encapsulate snapshot loading operations
- Integrate QML properties for UTXO snapshot management
- Wire up snapshot loading functionality with node interface

Author: D33r-Gee

src/Makefile.qt.include

@@ -46,6 +46,7 @@ QT_MOC_CPP = \
   qml/models/moc_peerlistsortproxy.cpp \
   qml/models/moc_transaction.cpp \
   qml/models/moc_sendrecipient.cpp \
+  qml/models/moc_snapshotqml.cpp \
   qml/models/moc_walletlistmodel.cpp \
   qml/models/moc_walletqmlmodel.cpp \
   qml/models/moc_walletqmlmodel.cpp \
@@ -136,6 +137,7 @@ BITCOIN_QT_H = \
   qml/models/peerlistsortproxy.h \
   qml/models/transaction.h \
   qml/models/sendrecipient.h \
+  qml/models/snapshotqml.h \
   qml/models/walletlistmodel.h \
   qml/models/walletqmlmodel.h \
   qml/models/walletqmlmodeltransaction.h \
@@ -335,6 +337,7 @@ BITCOIN_QML_BASE_CPP = \
   qml/models/peerlistsortproxy.cpp \
   qml/models/transaction.cpp \
   qml/models/sendrecipient.cpp \
+  qml/models/snapshotqml.cpp \
   qml/models/walletlistmodel.cpp \
   qml/models/walletqmlmodel.cpp \
   qml/models/walletqmlmodeltransaction.cpp \

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,29 @@ void ChainModel::setCurrentTimeRatio()
 
     Q_EMIT timeRatioListChanged();
 }
+
+// TODO: Change this once a better solution has been found.
+// 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);
+
+        QString fullHash = QString::fromStdString(hash_serialized.ToString());
+
+        int midPoint = fullHash.length() / 2;
+        QString firstHalf = fullHash.left(midPoint);
+        QString secondHalf = fullHash.mid(midPoint);
+
+        snapshot_info["height"] = height;
+        snapshot_info["hashSerializedFirstHalf"] = firstHalf;
+        snapshot_info["hashSerializedSecondHalf"] = secondHalf;
+        snapshot_info["date"] = QDateTime::fromSecsSinceEpoch(date).toString("MMMM d yyyy");
+    }
+
+    return snapshot_info;
+}

src/qml/models/chainmodel.h

@@ -27,6 +27,7 @@ class ChainModel : public QObject
     Q_PROPERTY(quint64 assumedBlockchainSize READ assumedBlockchainSize CONSTANT)
     Q_PROPERTY(quint64 assumedChainstateSize READ assumedChainstateSize CONSTANT)
     Q_PROPERTY(QVariantList timeRatioList READ timeRatioList NOTIFY timeRatioListChanged)
+    Q_PROPERTY(bool isSnapshotActive READ isSnapshotActive NOTIFY isSnapshotActiveChanged)
 
 public:
     explicit ChainModel(interfaces::Chain& chain);
@@ -36,18 +37,21 @@ class ChainModel : public QObject
     quint64 assumedBlockchainSize() const { return m_assumed_blockchain_size; };
     quint64 assumedChainstateSize() const { return m_assumed_chainstate_size; };
     QVariantList timeRatioList() const { return m_time_ratio_list; };
-
+    bool isSnapshotActive() const { return m_chain.hasAssumedValidChain(); };
     int timestampAtMeridian();
 
     void setCurrentTimeRatio();
 
+    Q_INVOKABLE QVariantMap getSnapshotInfo();
+
 public Q_SLOTS:
     void setTimeRatioList(int new_time);
     void setTimeRatioListInitial();
 
 Q_SIGNALS:
     void timeRatioListChanged();
     void currentNetworkNameChanged();
+    void isSnapshotActiveChanged();
 
 private:
     QString m_current_network_name;

src/qml/models/nodemodel.cpp

@@ -3,6 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qml/models/nodemodel.h>
+#include <qml/models/snapshotqml.h>
 
 #include <interfaces/node.h>
 #include <net.h>
@@ -14,14 +15,19 @@
 
 #include <QDateTime>
 #include <QMetaObject>
+#include <QObject>
 #include <QTimerEvent>
 #include <QString>
+#include <QUrl>
+#include <QThread>
+#include <QDebug>
 
 NodeModel::NodeModel(interfaces::Node& node)
     : m_node{node}
 {
     ConnectToBlockTipSignal();
     ConnectToNumConnectionsChangedSignal();
+    ConnectToSnapshotLoadProgressSignal();
 }
 
 void NodeModel::setBlockTipHeight(int new_height)
@@ -80,6 +86,10 @@ void NodeModel::setVerificationProgress(double new_progress)
     if (new_progress != m_verification_progress) {
         setRemainingSyncTime(new_progress);
 
+        if (new_progress >= 0.00001) {
+            setHeadersSynced(true);
+        }
+
         m_verification_progress = new_progress;
         Q_EMIT verificationProgressChanged();
     }
@@ -176,3 +186,51 @@ QString NodeModel::defaultProxyAddress()
 {
     return QString::fromStdString(m_node.defaultProxyAddress());
 }
+
+void NodeModel::ConnectToSnapshotLoadProgressSignal()
+{
+    assert(!m_handler_snapshot_load_progress);
+
+    m_handler_snapshot_load_progress = m_node.handleSnapshotLoadProgress(
+        [this](double progress) {
+            setSnapshotProgress(progress);
+        });
+}
+
+void NodeModel::snapshotLoadThread(QString path_file) {
+    m_snapshot_loading = true;
+    Q_EMIT snapshotLoadingChanged();
+
+    path_file = QUrl(path_file).toLocalFile();
+
+    QThread* snapshot_thread = QThread::create([this, path_file]() {
+        SnapshotQml loader(m_node, path_file);
+        bool result = loader.processPath();
+        if (!result) {
+            m_snapshot_loading = false;
+            Q_EMIT snapshotLoadingChanged();
+        } else {
+            m_snapshot_loaded = true;
+            Q_EMIT snapshotLoaded(result);
+            Q_EMIT snapshotLoadingChanged();
+        }
+    });
+
+    connect(snapshot_thread, &QThread::finished, snapshot_thread, &QThread::deleteLater);
+
+    snapshot_thread->start();
+}
+
+void NodeModel::setSnapshotProgress(double new_progress) {
+    if (new_progress != m_snapshot_progress) {
+        m_snapshot_progress = new_progress;
+        Q_EMIT snapshotProgressChanged();
+    }
+}
+
+void NodeModel::setHeadersSynced(bool new_synced) {
+    if (new_synced != m_headers_synced) {
+        m_headers_synced = new_synced;
+        Q_EMIT headersSyncedChanged();
+    }
+}

src/qml/models/nodemodel.h

@@ -34,6 +34,11 @@ class NodeModel : public QObject
     Q_PROPERTY(double verificationProgress READ verificationProgress NOTIFY verificationProgressChanged)
     Q_PROPERTY(bool pause READ pause WRITE setPause NOTIFY pauseChanged)
     Q_PROPERTY(bool faulted READ errorState WRITE setErrorState NOTIFY errorStateChanged)
+    Q_PROPERTY(double snapshotProgress READ snapshotProgress WRITE setSnapshotProgress NOTIFY snapshotProgressChanged)
+    Q_PROPERTY(bool snapshotLoading READ snapshotLoading NOTIFY snapshotLoadingChanged)
+    Q_PROPERTY(bool isSnapshotLoaded READ isSnapshotLoaded NOTIFY snapshotLoaded)
+    Q_PROPERTY(bool headersSynced READ headersSynced WRITE setHeadersSynced NOTIFY headersSyncedChanged)
+
 
 public:
     explicit NodeModel(interfaces::Node& node);
@@ -52,13 +57,21 @@ class NodeModel : public QObject
     void setPause(bool new_pause);
     bool errorState() const { return m_faulted; }
     void setErrorState(bool new_error);
+    bool isSnapshotLoaded() const { return m_snapshot_loaded; }
+    double snapshotProgress() const { return m_snapshot_progress; }
+    void setSnapshotProgress(double new_progress);
+    bool snapshotLoading() const { return m_snapshot_loading; }
+    bool headersSynced() const { return m_headers_synced; }
+    void setHeadersSynced(bool new_synced);
 
     Q_INVOKABLE float getTotalBytesReceived() const { return (float)m_node.getTotalBytesRecv(); }
     Q_INVOKABLE float getTotalBytesSent() const { return (float)m_node.getTotalBytesSent(); }
 
     Q_INVOKABLE void startNodeInitializionThread();
     Q_INVOKABLE void requestShutdown();
 
+    Q_INVOKABLE void snapshotLoadThread(QString path_file);
+
     void startShutdownPolling();
     void stopShutdownPolling();
 
@@ -80,7 +93,12 @@ public Q_SLOTS:
 
     void setTimeRatioList(int new_time);
     void setTimeRatioListInitial();
-
+    void initializationFinished();
+    void snapshotLoaded(bool result);
+    void snapshotProgressChanged();
+    void snapshotLoadingChanged();
+    void showProgress(const QString& title, int progress);
+    void headersSyncedChanged();
 protected:
     void timerEvent(QTimerEvent* event) override;
 
@@ -93,17 +111,21 @@ public Q_SLOTS:
     double m_verification_progress{0.0};
     bool m_pause{false};
     bool m_faulted{false};
-
+    double m_snapshot_progress{0.0};
     int m_shutdown_polling_timer_id{0};
-
+    int m_snapshot_timer_id{0};
+    bool m_snapshot_loading{false};
+    bool m_snapshot_loaded{false};
+    bool m_headers_synced{false};
     QVector<QPair<int, double>> m_block_process_time;
 
     interfaces::Node& m_node;
     std::unique_ptr<interfaces::Handler> m_handler_notify_block_tip;
     std::unique_ptr<interfaces::Handler> m_handler_notify_num_peers_changed;
-
+    std::unique_ptr<interfaces::Handler> m_handler_snapshot_load_progress;
     void ConnectToBlockTipSignal();
     void ConnectToNumConnectionsChangedSignal();
+    void ConnectToSnapshotLoadProgressSignal();
 };
 
 #endif // BITCOIN_QML_MODELS_NODEMODEL_H

src/qml/models/snapshotqml.cpp

@@ -0,0 +1,40 @@
+// Copyright (c) 2024 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 <qml/models/snapshotqml.h>
+
+#include <node/utxo_snapshot.h>
+#include <sync.h>
+#include <util/fs.h>
+#include <util/fs_helpers.h>
+
+SnapshotQml::SnapshotQml(interfaces::Node& node, QString path)
+    : m_node(node), m_path(path) {}
+
+bool SnapshotQml::processPath()
+{
+    const fs::path path = fs::u8path(m_path.toStdString());
+    if (!fs::exists(path)) {
+        return false;
+    }
+
+    FILE* snapshot_file{fsbridge::fopen(path, "rb")};
+    AutoFile afile{snapshot_file};
+    if (afile.IsNull()) {
+        return false;
+    }
+
+    node::SnapshotMetadata metadata;
+    try {
+        afile >> metadata;
+    } catch (const std::exception& e) {
+        return false;
+    }
+
+    bool result = m_node.loadSnapshot(afile, metadata, false);
+    if (!result) {
+        return false;
+    }
+    return true;
+}

src/qml/models/snapshotqml.h

@@ -0,0 +1,26 @@
+// Copyright (c) 2024 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_QML_MODELS_SNAPSHOTQML_H
+#define BITCOIN_QML_MODELS_SNAPSHOTQML_H
+
+#include <interfaces/handler.h>
+#include <interfaces/node.h>
+
+#include <QObject>
+
+class SnapshotQml : public QObject
+{
+   Q_OBJECT
+public:
+    SnapshotQml(interfaces::Node& node, QString path);
+
+    bool processPath();
+
+private:
+    interfaces::Node& m_node;
+    QString m_path;
+};
+
+#endif // BITCOIN_QML_MODELS_SNAPSHOTQML_H

src/qml/pages/settings/SettingsConnection.qml

@@ -99,14 +99,5 @@ Page {
                 onBack: stack.pop()
             }
         }
-        Component {
-            id: generateSnapshotSettings
-            SettingsSnapshotGen {
-                onboarding: root.onboarding
-                generateSnapshot: true
-                isSnapshotGenerated: ( nodeModel.isSnapshotFileExists() || nodeModel.isSnapshotGenerated )
-                onBack: stack.pop()
-            }
-        }
     }
 }