qml: Implement snapshot loading functionality

- Added snapshot loading capabilities to NodeModel, including progress tracking and error handling.
- Introduced SnapshotQml class for processing snapshot files.
- Enhanced ChainModel with methods to retrieve snapshot information and check if a snapshot is active.
- Updated QML properties to reflect snapshot loading state and progress.
- Included necessary includes for snapshot handling in relevant files.

Author: D33r-Gee

bitcoin

@@ -36,6 +36,7 @@
 #include <qml/models/peerdetailsmodel.h>
 #include <qml/models/peerlistsortproxy.h>
 #include <qml/models/sendrecipient.h>
+#include <qml/models/snapshotqml.h>
 #include <qml/models/walletlistmodel.h>
 #include <qml/models/walletqmlmodel.h>
 #include <qml/models/walletqmlmodeltransaction.h>

qml/bitcoin.cpp

@@ -9,6 +9,9 @@
 #include <QThread>
 #include <QTime>
 #include <interfaces/chain.h>
+#include <node/utxo_snapshot.h>
+#include <kernel/chainparams.h>
+#include <validation.h>
 
 using interfaces::FoundBlock;
 
@@ -106,3 +109,39 @@ 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;
+
+    std::vector<int> available_heights = Params().GetAvailableSnapshotHeights();
+    if (!available_heights.empty()) {
+        // Get the highest height snapshot (last element in the vector)
+        const int height = available_heights.back();
+        std::optional<AssumeutxoData> maybe_snapshot = Params().AssumeutxoForHeight(height);
+
+        if (maybe_snapshot.has_value()) {
+            const auto& latest_snapshot = maybe_snapshot.value();
+            const auto& hash_serialized = latest_snapshot.hash_serialized;
+
+            // Get block time using the interfaces pattern
+            uint256 block_hash{m_chain.getBlockHash(height)};
+            int64_t block_time;
+            m_chain.findBlock(block_hash, FoundBlock().time(block_time));
+
+            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(block_time).toString("MMMM d yyyy");
+        }
+    }
+
+    return snapshot_info;
+}

qml/models/chainmodel.cpp

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

qml/models/chainmodel.h

@@ -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,14 @@ void NodeModel::setVerificationProgress(double new_progress)
     if (new_progress != m_verification_progress) {
         setRemainingSyncTime(new_progress);
 
+        if (new_progress >= 0.00014) {
+            setHeadersSynced(true);
+        }
+
+        if (new_progress >= 0.999) {
+            setIsIBDCompleted(true);
+        }
+
         m_verification_progress = new_progress;
         Q_EMIT verificationProgressChanged();
     }
@@ -190,3 +204,82 @@ QString NodeModel::defaultProxyAddress()
 {
     return QString::fromStdString(std::string(DEFAULT_PROXY_HOST) + ":" + util::ToString(DEFAULT_PROXY_PORT));
 }
+
+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();
+            m_snapshot_error = true;
+            Q_EMIT snapshotErrorChanged();
+        } 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();
+        checkAndLoadSnapshot();
+    }
+}
+
+void NodeModel::setIsIBDCompleted(bool new_completed) {
+    if (new_completed != m_is_ibd_completed) {
+        m_is_ibd_completed = new_completed;
+        Q_EMIT isIBDCompletedChanged();
+    }
+}
+
+void NodeModel::setSnapshotFilePath(const QString& new_path) {
+    if (new_path != m_snapshot_file_path) {
+        m_snapshot_file_path = new_path;
+        Q_EMIT snapshotFilePathChanged();
+    }
+}
+
+void NodeModel::checkAndLoadSnapshot()
+{
+    if (m_headers_synced && !m_snapshot_file_path.isEmpty()) {
+        snapshotLoadThread(m_snapshot_file_path);
+    }
+}
+
+void NodeModel::setSnapshotError(bool new_error) {
+    if (new_error != m_snapshot_error) {
+        m_snapshot_error = new_error;
+        Q_EMIT snapshotErrorChanged();
+    }
+}

qml/models/nodemodel.cpp

@@ -37,6 +37,13 @@ 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)
+    Q_PROPERTY(bool isIBDCompleted READ isIBDCompleted WRITE setIsIBDCompleted NOTIFY isIBDCompletedChanged)
+    Q_PROPERTY(QString snapshotFilePath READ snapshotFilePath WRITE setSnapshotFilePath NOTIFY snapshotFilePathChanged)
+    Q_PROPERTY(bool snapshotError READ snapshotError WRITE setSnapshotError NOTIFY snapshotErrorChanged)
 
 public:
     explicit NodeModel(interfaces::Node& node);
@@ -55,13 +62,28 @@ 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);
+    bool isIBDCompleted() const { return m_is_ibd_completed; }
+    void setIsIBDCompleted(bool new_completed);
+    QString snapshotFilePath() const { return m_snapshot_file_path; }
+    Q_INVOKABLE void setSnapshotFilePath(const QString& new_path);
+    bool snapshotError() const { return m_snapshot_error; }
+    Q_INVOKABLE void setSnapshotError(bool new_error);
 
     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);
+    Q_INVOKABLE void checkAndLoadSnapshot();
+
     void startShutdownPolling();
     void stopShutdownPolling();
 
@@ -83,6 +105,15 @@ 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();
+    void isIBDCompletedChanged();
+    void snapshotFilePathChanged();
+    void snapshotErrorChanged();
 
 protected:
     void timerEvent(QTimerEvent* event) override;
@@ -96,17 +127,25 @@ 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};
+    bool m_is_ibd_completed{false};
+    QString m_snapshot_file_path;
+    bool m_snapshot_error{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

qml/models/nodemodel.h

@@ -0,0 +1,47 @@
+// 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 <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>
+#include <streams.h>
+#include <QString>
+#include <QObject>
+
+SnapshotQml::SnapshotQml(interfaces::Node& node, QString path)
+    : m_node(node), m_path(path) {}
+
+bool SnapshotQml::processPath()
+{
+    ChainstateManager& chainman = *m_node.context()->chainman;
+    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{chainman.GetParams().MessageStart()};
+    try {
+        afile >> metadata;
+    } catch (const std::exception& e) {
+        return false;
+    }
+
+    bool result = m_node.loadSnapshot(afile, metadata, false);
+    if (!result) {
+        return false;
+    }
+    return true;
+}

qml/models/snapshotqml.cpp

@@ -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