Struct ClaimState 

pub struct ClaimState {

    pub claim_id: ClaimId,
    pub subject: EntityRef,
    pub predicate: Predicate,
    pub value: ClaimValue,
    pub authority: Authority,
    pub ttl: Ttl,
    pub freshness_anchor: TimestampMillis,
    pub lifecycle: ClaimLifecycle,
    pub created_at: TimestampMillis,
    pub updated_at: TimestampMillis,
    pub last_event_id: ClaimEventId,
    pub superseded_by: Option<ClaimId>,
    pub contradicted_by: Vec<ClaimId>,
    pub evidence_count: usize,
    pub corroborating_sources: BTreeMap<SourceId, AuthorityLevel>,
}

The current projected state of a claim — the fold of its event stream. Serializable so a backend may materialize it (cache it as a derived row) or transmit it; it remains a pure projection of the log, never an independent source of truth.

Fields

claim_id: ClaimId

subject: EntityRef

predicate: Predicate

value: ClaimValue

authority: Authority

Entrenchment of the incumbent claim, captured at assertion. Drives authority-weighted supersession arbitration; see docs/belief-revision.md.

ttl: Ttl

TTL captured at assertion, used by ClaimState::is_expired_at for read-time freshness evaluation.

freshness_anchor: TimestampMillis

Valid-time anchor for TTL freshness: valid_from, else observed_at, else the assertion’s recorded_at.

lifecycle: ClaimLifecycle

created_at: TimestampMillis

updated_at: TimestampMillis

last_event_id: ClaimEventId

superseded_by: Option<ClaimId>

contradicted_by: Vec<ClaimId>

evidence_count: usize

corroborating_sources: BTreeMap<SourceId, AuthorityLevel>

The distinct provenance sources that have asserted or reinforced this exact value, each mapped to the highest authority it backed at. This measures same-value corroboration only — surviving a contradiction or a rejected supersession is deliberately not counted here (that would require recording rejected attempts; see docs/research/novelty.md rank 3). The asserter is the first entry.

Implementations

impl ClaimState

pub fn corroboration(&self) -> usize

Raw earned-entrenchment degree: the number of distinct sources backing this value. Sybil-inflatable on its own (an attacker minting many sources raises it), so security decisions should use ClaimState::corroboration_at_or_above to count only sufficiently-authoritative backers.

pub fn corroboration_at_or_above(&self, min: AuthorityLevel) -> usize

Authority-weighted corroboration: the number of distinct backing sources whose authority is at least min. This is the Sybil-resistant entrenchment signal — minting low-authority sources cannot raise the count measured at a higher floor.

pub fn expires_at(&self) -> Option<TimestampMillis>

When this claim’s TTL elapses relative to its freshness anchor, if ever.

pub fn is_expired_at(&self, now: TimestampMillis) -> bool

Whether the claim’s TTL has elapsed at now. A claim with Ttl::Never is never expired. This is the read-time freshness predicate; it does not consult lifecycle (a superseded claim can still be “unexpired” by TTL).

Trait Implementations

impl Clone for ClaimState

fn clone(&self) -> ClaimState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClaimState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ClaimState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ClaimState

impl PartialEq for ClaimState

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

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 ClaimState