Struct KeyState 

pub struct KeyState {
    pub prefix: Prefix,
    pub current_keys: Vec<String>,
    pub next_commitment: Vec<String>,
    pub sequence: u64,
    pub last_event_said: Said,
    pub is_abandoned: bool,
    pub threshold: u64,
    pub next_threshold: u64,
}

Current key state derived from replaying a KEL.

This struct captures the complete state of a KERI identity at a given point in its event log. It is computed by walking the KEL from inception to the latest event.

Fields

prefix: Prefix

The KERI identifier prefix (used in did:keri:<prefix>)

current_keys: Vec<String>

Current signing key(s), Base64url encoded with derivation code prefix. For Ed25519 keys, this is “D” + base64url(pubkey).

next_commitment: Vec<String>

Next key commitment(s) for pre-rotation. These are Blake3 hashes of the next public key(s).

sequence: u64

Current sequence number (0 for inception, increments with each event)

last_event_said: Said

SAID of the last processed event

is_abandoned: bool

Whether this identity has been abandoned (empty next commitment)

threshold: u64

Current signing threshold

next_threshold: u64

Next signing threshold (committed)

Implementations

impl KeyState

pub fn from_inception( prefix: Prefix, keys: Vec<String>, next: Vec<String>, threshold: u64, next_threshold: u64, said: Said, ) -> Self

Create initial state from an inception event.

Arguments

• prefix - The KERI identifier (same as inception SAID)
• keys - The initial signing key(s)
• next - The next-key commitment(s)
• threshold - Initial signing threshold
• next_threshold - Committed next signing threshold
• said - The inception event SAID

pub fn apply_rotation( &mut self, new_keys: Vec<String>, new_next: Vec<String>, threshold: u64, next_threshold: u64, sequence: u64, said: Said, )

Apply a rotation event to update state.

This should only be called after verifying:

1. The new key matches the previous next_commitment
2. The event’s previous SAID matches last_event_said
3. The sequence is exactly last_sequence + 1

pub fn apply_interaction(&mut self, sequence: u64, said: Said)

Apply an interaction event (updates sequence and SAID only).

Interaction events anchor data but don’t change keys.

pub fn current_key(&self) -> Option<&str>

Get the current signing key (first key for single-sig).

Returns the encoded key string (e.g., “DBase64EncodedKey…”)

pub fn can_rotate(&self) -> bool

Check if key can be rotated.

Returns false if the identity has been abandoned (empty next commitment).

pub fn did(&self) -> String

Get the DID for this identity.

Trait Implementations

impl Clone for KeyState

fn clone(&self) -> KeyState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KeyState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for KeyState

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for KeyState

impl StructuralPartialEq for KeyState