Struct Checkpoint 

pub struct Checkpoint {
    pub frontier: BTreeMap<String, FrontierEntry>,
    pub scopes: Vec<String>,
    pub state_hash: String,
    pub checkpoint_hash: String,
    pub state: SyncState,
}

A serialized fold at a frontier — see the module docs for the design.

Fields

frontier: BTreeMap<String, FrontierEntry>

device_id → last covered op ({seq, hlc, head}). A device absent here has NO ops below the frontier (its full chain is retained).

scopes: Vec<String>

Sorted, deduped scope tags covered (crate::oplog::Scope::tag) — whole-chain checkpointing, see module docs.

state_hash: String

state_hash of state — the divergence invariant (“same frontier ⇒ same snapshot hash”). Recomputed and enforced on Checkpoint::load.

checkpoint_hash: String

Whole-record content address covering frontier + scopes + state (see module docs for why state-only addressing forks chains). The file name; recomputed and enforced on Checkpoint::load.

state: SyncState

The folded state at the frontier (possibly retention-compacted by crate::compact::plan_compaction).

Implementations

impl Checkpoint

pub fn assemble( frontier: BTreeMap<String, FrontierEntry>, scopes: Vec<String>, state: SyncState, ) -> Self

Assemble a checkpoint from its parts, stamping both hashes — the one construction path, so a Checkpoint value is coherent by build.

pub fn from_ops(ops: &[OpRecord]) -> Result<Self, ChainError>

Checkpoint an op-set: verify it (the B1 verify-before-fold contract), fold it, and record the per-device frontier + scopes. The state is the exact fold — retention is applied separately by crate::compact::plan_compaction, so the equivalence fold_onto(checkpoint.state, tail) == fold(full log) holds exactly.

pub fn content_hash(&self) -> String

Recompute the whole-record content address from the checkpoint’s fields (everything except checkpoint_hash itself, over the canonical serialization). Covers the frontier and scopes, not just the state — see the module docs for the chain-fork this prevents.

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

Recompute BOTH hashes and reject any mismatch — the load-verify half of the durability discipline (also callable on an in-memory checkpoint received from a peer). state_hash proves the state; checkpoint_hash proves the whole record, so a tampered frontier is caught too.

pub fn file_name(&self) -> String

Content-addressed file name: <checkpoint_hash>.checkpoint.json. Same frontier + same retention ⇒ same record ⇒ same file (the relay dedup the proposal leans on) — and, because the address covers the whole record, same file ⇒ same checkpoint.

pub fn save(&self, dir: &Path) -> Result<PathBuf>

Durably write the checkpoint into dir (created if needed): temp file → fsync → atomic rename → best-effort dir fsync. Returns the final path. Writing the same checkpoint twice is idempotent (content-addressed name, rename-over-identical).

pub fn load(path: &Path) -> Result<Self, CheckpointError>

Load a checkpoint and verify it: both stored hashes must recompute from the stored content (Checkpoint::verify), and the file’s name must BE the content address — a renamed or wrongly-addressed file is rejected (CheckpointError::AddressMismatch) so a store can never serve checkpoint X under checkpoint Y’s name. Never fold a snapshot that doesn’t prove itself.

Trait Implementations

impl Clone for Checkpoint

fn clone(&self) -> Checkpoint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Checkpoint

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Checkpoint

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Checkpoint

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Checkpoint

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Checkpoint