Struct StateVisibilityBlob 

pub struct StateVisibilityBlob {
    pub format_version: u8,
    pub records: Vec<StateVisibility>,
}

On-disk blob containing all visibility records for a single state. One file per state, encoded with rmp-serde — mirrors the RedactionsBlob sidecar pattern.

Fields

format_version: u8

records: Vec<StateVisibility>

Implementations

impl StateVisibilityBlob

pub const FORMAT_VERSION: u8 = 1

pub fn new(records: Vec<StateVisibility>) -> Self

pub fn encode(&self) -> Result<Vec<u8>, StateVisibilityError>

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

pub fn validate(&self) -> Result<(), StateVisibilityError>

impl StateVisibilityBlob

pub fn empty() -> Self

pub fn push(&mut self, record: StateVisibility)

pub fn has_record(&self) -> bool

true iff this state carries any visibility record — i.e. it is not public-by-absence. Used by the sidecar’s has_visibility_for_state.

pub fn latest(&self) -> Result<Option<&StateVisibility>, StateVisibilityError>

The effective record: the head of the supersede DAG — the record in this blob that no other record supersedes — resolved purely from the records’ content-intrinsic supersedes pointers, never from wall-clock declared_at.

Each locally-committed declaration links onto the prior head it read under the repo write lock — its supersedes points at that head’s content hash (heddle#317 / PR #529 P1) — so for serialized local writes the chain is linear and the head is the last-committed record, independent of clock skew or whatever order the timestamps happen to carry. declared_at is an audit/display field only. This also fixes a latent cross-host bug: wall-clock cannot order records replicated across hosts whose clocks disagree, but the content-hash chain can.

Fork tie-break (concurrent / cross-host). Two records can supersede the same prior with neither superseding the other — a genuine concurrent fork, e.g. two hosts that diverged. Both are heads. To make every replica resolve the SAME effective record without consulting wall-clock, the tie is broken by the lexicographically greatest record content hash — a content-intrinsic, host-independent key. Cycles are cryptographically unconstructable (a record’s hash covers its supersedes pointer, so no record can supersede one minted after it), so a non-empty blob always has at least one head.

Trait Implementations

impl Clone for StateVisibilityBlob

fn clone(&self) -> StateVisibilityBlob

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StateVisibilityBlob

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StateVisibilityBlob

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for StateVisibilityBlob

impl PartialEq for StateVisibilityBlob

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

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 StateVisibilityBlob