Struct RotEvent 

pub struct RotEvent {

    pub v: String,
    pub d: Said,
    pub i: Prefix,
    pub s: String,
    pub p: Said,
    pub kt: String,
    pub k: Vec<String>,
    pub nt: String,
    pub n: Vec<String>,
    pub bt: String,
    pub b: Vec<String>,
    pub a: Vec<Seal>,
    pub x: String,
}

Rotation event.

Fields

v: String

KERI version string.

d: Said

SAID of this event.

i: Prefix

KERI prefix of the identity being rotated.

s: String

Sequence number.

p: Said

SAID of the prior event (chain link).

kt: String

Signing key threshold.

k: Vec<String>

Current signing keys after rotation.

nt: String

Next-key commitment threshold.

n: Vec<String>

Next-key commitments for the subsequent rotation.

bt: String

Witness threshold.

b: Vec<String>

Witness list.

a: Vec<Seal>

Anchored seals.

x: String

Ed25519 signature over the canonical event body.

Trait Implementations

impl Clone for RotEvent

fn clone(&self) -> RotEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RotEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RotEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RotEvent

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

Spec field order: v, t, d, i, s, p, kt, k, nt, n, bt, b, a, x

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for RotEvent

impl StructuralPartialEq for RotEvent