Struct ContinuityProof 

pub struct ContinuityProof {
    pub origin_hash: u64,
    pub from_seq: u64,
    pub to_seq: u64,
    pub from_hash: u64,
    pub to_hash: u64,
}

Compact proof of continuity that can be transmitted (40 bytes).

A node can send this to another node to prove its chain is intact over a given sequence range, without transferring the full log.

Fields

origin_hash: u64

Entity origin hash.

from_seq: u64

Start of the proven range.

to_seq: u64

End of the proven range.

from_hash: u64

parent_hash computed from the event at from_seq.

to_hash: u64

parent_hash computed from the event at to_seq.

Implementations

impl ContinuityProof

pub fn from_log(log: &EntityLog) -> Option<Self>

Extract a proof from a local entity log.

Returns None if the log is empty.

pub fn verify_against(&self, log: &EntityLog) -> Result<(), ProofError>

Verify this proof against a local entity log.

Walks the entire event range [from_seq, to_seq], re-computing each parent_hash and asserting it matches the chain link emitted by the previous event. The endpoint hashes (from_hash / to_hash) are also verified against the local log.

Rejects reversed bounds, caps the span at MAX_PROOF_VERIFY_SPAN, walks every event in range, and validates each consecutive parent_hash link. Checking only the two endpoint events would let a malicious intermediary holding events 0 and 999 ship a proof spanning [0, 999] with the correct two endpoint hashes that verify_against would accept — even though events 1..998 could be missing or fabricated, defeating the whole point of the proof. The span cap also prevents a peer from forcing a multi-billion-event scan via reversed or wide bounds.

pub fn to_bytes(&self) -> [u8; 40]

Serialize to bytes.

pub fn from_bytes(data: &[u8]) -> Option<Self>

Deserialize from bytes.

Rejects buffers whose length differs from CONTINUITY_PROOF_SIZE so trailing bytes aren’t silently accepted (the old < SIZE guard let concatenated proofs or framing garbage parse as the first proof).

Trait Implementations

impl Clone for ContinuityProof

fn clone(&self) -> ContinuityProof

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ContinuityProof

impl Debug for ContinuityProof

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

Formats the value using the given formatter.

impl Eq for ContinuityProof

impl PartialEq for ContinuityProof

fn eq(&self, other: &ContinuityProof) -> 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 StructuralPartialEq for ContinuityProof