Struct Checkpoint 

pub struct Checkpoint {
    pub origin: String,
    pub size: u64,
    pub root: Digest,
}

A commitment to every run sealed so far.

Deliberately shaped like a C2SP tlog-checkpoint: an origin naming the log, a size, and a root. Using the interoperable shape rather than a bespoke one means existing verifiers and witness operators work — and inventing a format here would buy nothing and cost every integrator.

Serialize because a checkpoint is the artifact that has to leave: it heads every export and appears in every audit report, and a reader who has to link this crate to parse it is not the independent party either exists for. Deserialize because the same reader hands it back — verifying an export means comparing a rebuilt root against the checkpoint the file carries. Checkpoint::to_note remains the interoperable text form for a witness or a ticket; these are for a consumer already reading JSON.

Fields

origin: String

Which log. A deployment-chosen name, so two planes’ checkpoints cannot be confused for one another. Held to Checkpoint::validate_origin when read, so a header or file naming a log no witness would accept is refused here as it would be there.

size: u64

How many runs are committed to.

root: Digest

The Merkle root over their sealed digests.

Implementations

impl Checkpoint

pub const MAX_ORIGIN_BYTES: usize = 255

The longest origin C2SP tlog-cosignature admits, in UTF-8 bytes.

pub fn validate_origin(origin: &str) -> Result<(), StoreError>

Whether origin may name a log, by C2SP tlog-cosignature’s rule: a non-empty UTF-8 string of at most 255 bytes with no Unicode space, no + and no control character below U+0020.

One rule for every door an origin arrives at — a store’s name, a note, an export header, a witness lookup — because a log named one way here and refused by a conforming witness is a log whose checkpoints nobody can cosign, and a newline in it is a note that reads back as another.

Errors

Naming the class and, for a character, which one.

pub fn to_note(&self) -> String

The C2SP tlog-checkpoint note body: origin, size, base64 root.

A text form matters more than it looks. A checkpoint is the one artifact that has to leave the operator’s control — handed to an auditor, posted to a witness, pasted into a ticket — and an artifact that only exists as a Rust struct cannot do that. Using the interoperable encoding rather than a bespoke one means the thing they hold is checkable by tools this project did not write.

pub fn is_coherent(&self) -> bool

Whether this checkpoint’s size and root can both be true.

One pair is checkable without holding the log: the empty tree has exactly one root, so a checkpoint claiming size 0 beside any other root is describing a log that cannot exist. That matters more than a tidy invariant because of what a witness does with a first submission — it has no prior memory to check against, so it records what it is told and holds every later checkpoint to it. One incoherent size-0 submission therefore poisons the origin permanently: every honest checkpoint afterwards fails consistency against a root no log ever had, and is reported as Forked — an integrity page, forever, from a single malformed request.

pub fn from_note(note: &str) -> Result<Self, StoreError>

Read one back.

Errors

If the note is malformed. Deliberately strict: a checkpoint that parses “close enough” is a checkpoint that compares against the wrong log.

Trait Implementations

impl Clone for Checkpoint

fn clone(&self) -> Self

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 Eq for Checkpoint

impl PartialEq for Checkpoint

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

Equality operator ==.

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

Inequality operator !=.

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