interfaces: Rename and enhance UTXO snapshot methods

- Renamed the `loadSnapshot` method to `utxoSnapshot` in the node interface for clarity.
- Added a new `generate` method in the `Snapshot` interface to create a UTXO snapshot of the current chainstate and write it to disk.
- Updated the `SnapshotImpl` class to implement the new `generate` method, including file handling and error management.

These changes improve the clarity and functionality of UTXO snapshot handling in the node interface.

Author: D33r-Gee

src/interfaces/node.h

@@ -208,7 +208,7 @@ class Node
     virtual std::vector<std::string> listRpcCommands() = 0;
 
     //! Load UTXO Snapshot.
-    virtual std::unique_ptr<Snapshot> loadSnapshot(const fs::path& path) = 0;
+    virtual std::unique_ptr<Snapshot> utxoSnapshot(const fs::path& path) = 0;
 
     //! Get unspent output associated with a transaction.
     virtual std::optional<Coin> getUnspentOutput(const COutPoint& output) = 0;

src/interfaces/snapshot.h

@@ -7,6 +7,7 @@
 
 #include <memory>
 #include <uint256.h>
+#include <util/fs.h>
 
 namespace node {
 class SnapshotMetadata;
@@ -22,6 +23,11 @@ class Snapshot
 
     //! Activate the snapshot, making it the active chainstate.
     virtual bool activate() = 0;
+
+    //! Generate a UTXO snapshot of the current chainstate and write it to disk.
+    //! Returns true on success, false on failure. The snapshot content matches
+    //! the current tip (equivalent to the "latest" type in the dumptxoutset RPC).
+    virtual bool generate(const fs::path& output_path) = 0;
 };
 
 } // namespace interfaces

src/node/interfaces.cpp

@@ -94,8 +94,8 @@ namespace {
 class SnapshotImpl : public interfaces::Snapshot
 {
 public:
-    SnapshotImpl(ChainstateManager& chainman, const fs::path& path, bool in_memory)
-        : m_chainman(chainman), m_path(path), m_in_memory(in_memory) {}
+    SnapshotImpl(NodeContext& node, ChainstateManager& chainman, const fs::path& path, bool in_memory)
+        : m_node(node), m_chainman(chainman), m_path(path), m_in_memory(in_memory) {}
 
     bool activate() override
     {
@@ -120,7 +120,37 @@ class SnapshotImpl : public interfaces::Snapshot
         return activation_result.has_value();
     }
 
+    bool generate(const fs::path& output_path) override
+    {
+        try {
+            const fs::path path = fsbridge::AbsPathJoin(Assert(m_node.args)->GetDataDirNet(), output_path);
+            const std::string out_str = fs::PathToString(output_path);
+            const fs::path temppath = fsbridge::AbsPathJoin(Assert(m_node.args)->GetDataDirNet(), fs::u8path(out_str + ".incomplete"));
+
+            if (fs::exists(path)) {
+                // Do not overwrite existing files
+                return false;
+            }
+
+            FILE* file{fsbridge::fopen(temppath, "wb")};
+            AutoFile afile{file};
+            if (afile.IsNull()) {
+                return false;
+            }
+
+            Chainstate& chainstate = m_chainman.ActiveChainstate();
+            /* Create the snapshot at the current tip ("latest"). */
+            (void)::CreateUTXOSnapshot(m_node, chainstate, std::move(afile), path, temppath);
+
+            fs::rename(temppath, path);
+            return true;
+        } catch (const std::exception&) {
+            return false;
+        }
+    }
+
 private:
+    NodeContext& m_node;
     ChainstateManager& m_chainman;
     fs::path m_path;
     bool m_in_memory;
@@ -393,9 +423,9 @@ class NodeImpl : public Node
         return ::tableRPC.execute(req);
     }
     std::vector<std::string> listRpcCommands() override { return ::tableRPC.listCommands(); }
-    std::unique_ptr<interfaces::Snapshot> loadSnapshot(const fs::path& path) override
+    std::unique_ptr<interfaces::Snapshot> utxoSnapshot(const fs::path& path) override
     {
-        return std::make_unique<SnapshotImpl>(chainman(), path, /*in_memory=*/ false);
+        return std::make_unique<SnapshotImpl>(*Assert(m_context), chainman(), path, /*in_memory=*/ false);
     }
     std::optional<Coin> getUnspentOutput(const COutPoint& output) override
     {