Struct KeyStateRecord 

pub struct KeyStateRecord {

    pub vn: [u32; 2],
    pub i: Prefix,
    pub s: String,
    pub p: String,
    pub d: Said,
    pub f: String,
    pub dt: String,
    pub et: String,
    pub kt: Threshold,
    pub k: Vec<CesrKey>,
    pub nt: Threshold,
    pub n: Vec<Said>,
    pub bt: Threshold,
    pub b: Vec<Prefix>,
    pub c: Vec<ConfigTrait>,
    pub ee: LatestEstablishmentEvent,
    pub di: String,
}

A KERI-conformant key-state notice — the wire record keripy emits as a ksn/rpy reply and persists as KeyStateRecord.

This is the byte-interoperable counterpart to the auths-internal KeyStateNotice: where KeyStateNotice is an auths-only envelope around a KeyState, KeyStateRecord is the canonical KERI shape a peer (keripy, keriox) produces and consumes — field order and labels {vn, i, s, p, d, f, dt, et, kt, k, nt, n, bt, b, c, ee, di}, sequence numbers as lowercase hex, thresholds as KERI hex/clause strings.

It is a parsed type: holding one means the labels and shapes already matched the KERI form, so KeyStateRecord::into_key_state is total. Build one from an auths KEL with KeyStateRecord::from_kel (emit a record a peer can read); accept one from a peer by deserializing then into_key_state (consume a keripy KSN).

Fields

vn: [u32; 2]

Protocol version [major, minor] — [1, 0] for the KERI10 generation.

i: Prefix

Identifier prefix (the AID this state describes).

s: String

Sequence number of the latest event, lowercase-hex.

p: String

SAID of the prior event (empty at inception).

d: Said

SAID of the latest event.

f: String

First-seen ordinal. auths does not maintain a first-seen log separate from the KEL, so this mirrors s (the latest sequence) — truthful for a single-source replay, where first-seen order is event order.

dt: String

Controller-asserted timestamp (RFC 3339).

et: String

Latest establishment event type (icp/rot/dip/drt).

kt: Threshold

Current signing threshold (KERI hex/clause string).

k: Vec<CesrKey>

Current signing key(s), CESR-encoded.

nt: Threshold

Next-key threshold (KERI hex/clause string).

n: Vec<Said>

Next-key commitment digest(s).

bt: Threshold

Backer (witness) threshold (bt, hex string).

b: Vec<Prefix>

Current backer (witness) list.

c: Vec<ConfigTrait>

Configuration traits.

ee: LatestEstablishmentEvent

Latest establishment event summary ({s, d, br, ba}).

di: String

Delegator AID (empty string when not delegated).

Implementations

impl KeyStateRecord

pub fn from_kel( events: &[Event], state: &KeyState, dt: impl Into<String>, ) -> Option<Self>

Build a KERI key-state record by replaying a validated KEL into its current state, stamped at dt.

events is the full, in-order KEL (inception first); the record’s s/d come from the last event and p/ee/et from its latest establishment event. Returns None only if events is empty (no inception to anchor a state) — the caller has nothing to notice.

Args:

• events: The replayed KEL, in sequence order.
• state: The resolved current KeyState (from replay).
• dt: An RFC-3339 timestamp (injected now).

pub fn sequence(&self) -> u128

The sequence number this record notices (the latest event’s s, decoded from its lowercase-hex wire form).

pub fn check_not_stale(&self, last_seen_seq: u128) -> Result<(), KsnError>

Reject this notice if it is older than a state the verifier already trusts.

A key-state notice is a snapshot; a thin client that has already seen sequence last_seen_seq (e.g. it holds a fresher witness receipt) must not accept a notice that rewinds below it — that is a stale or replayed view of the identity. Returns KsnError::Stale when self.sequence() < last_seen_seq; equal-or-newer is fine.

Args:

• last_seen_seq: The highest sequence the verifier already trusts.

pub fn into_key_state(self) -> KeyState

Project this KERI record back to the auths KeyState the rest of the platform reasons over (a thin client ingesting a peer’s published state).

Total: a parsed KeyStateRecord already carries the labels and shapes a KeyState needs, so no field can be missing or mistyped here.

Trait Implementations

impl Clone for KeyStateRecord

fn clone(&self) -> KeyStateRecord

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyStateRecord

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KeyStateRecord

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for KeyStateRecord

impl PartialEq for KeyStateRecord

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for KeyStateRecord

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 KeyStateRecord