Struct SnapshotBundle 

pub struct SnapshotBundle {
    pub format_version: u32,
    pub tree: Tree,
    pub nodes: Vec<SnapshotBundleNode>,
}

Self-contained transport bundle for one tree and its reachable node bytes.

The bundle is intended for import/export between stores, processes, and language bindings. nodes should contain exactly the node CIDs reachable from tree.root, sorted by raw CID bytes for deterministic transport.

Fields

format_version: u32

Bundle schema version. Currently always 1.

tree: Tree

Tree handle the imported store will be able to read.

nodes: Vec<SnapshotBundleNode>

Reachable serialized nodes for the tree.

Implementations

impl SnapshotBundle

pub fn new(tree: Tree, nodes: Vec<SnapshotBundleNode>) -> Self

Create a versioned snapshot bundle from a tree and reachable node bytes.

pub fn node_count(&self) -> usize

Number of serialized nodes in the bundle.

pub fn byte_count(&self) -> usize

Total serialized node bytes in the bundle.

pub fn digest(&self) -> Result<Cid, Error>

Return the SHA-256 digest of this bundle’s canonical byte encoding.

The digest is stable for semantically equivalent bundles: node entries are canonicalized by CID before encoding, so caller-side ordering does not affect the result.

pub fn summary(&self) -> Result<SnapshotBundleSummary, Error>

Return validated metadata for this bundle without importing it.

The summary canonicalizes node order, deduplicates identical repeated nodes, and verifies each node byte payload against its CID.

pub fn verify(&self) -> Result<SnapshotBundleVerification, Error>

Verify that this bundle is complete and contains no unreachable nodes.

This check is read-only: it validates version, canonicalizes nodes, verifies every node byte payload by CID, decodes reachable nodes from the supplied bytes, and compares the reachable CID set with the bundled CID set.

pub fn validate_format_version(&self) -> Result<(), Error>

Validate that the bundle version is supported by this crate.

pub fn to_bytes(&self) -> Result<Vec<u8>, Error>

Serialize this bundle as deterministic, versioned bytes.

The encoded form canonicalizes node order by CID bytes and deduplicates repeated identical nodes. It rejects unsupported bundle versions, malformed CIDs, and node bytes whose content hash does not match the supplied CID.

pub fn from_bytes(bytes: &[u8]) -> Result<Self, Error>

Decode a deterministic, versioned snapshot bundle byte payload.

Trait Implementations

impl Clone for SnapshotBundle

fn clone(&self) -> SnapshotBundle

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SnapshotBundle

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for SnapshotBundle

fn eq(&self, other: &SnapshotBundle) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for SnapshotBundle