Struct Ceremony 

pub struct Ceremony {
    pub enactment: String,
    pub step: String,
    pub definition: Option<String>,
    pub definition_digest: Option<String>,
    pub parent_enactment: Option<String>,
    pub round: Option<u32>,
    pub terminal: Option<bool>,
    pub prev: Option<Vec<CeremonyPrev>>,
}

Records that a document is a step of a Trust Ceremony (SPEC.md §4.11).

Fields

enactment: String

Identifies one run of a ceremony.

Globally unique and never reused, on the same terms as the document id — and unlike threadId, which §4.9 does not require to be either. Evidence about a flow needs a stable anchor, and this is the value an outside reference names when citing the flow rather than one exchange (§4.9.1).

step: String

Names this step within the ceremony.

The step name — not the Type URI — is the step’s identity: one Type URI may serve several steps whose meaning differs by context, and may recur within a flow.

definition: Option<String>

The ceremony definition this step is enacted under (§6.7).

Optional: a flow whose evidence is only its collected or chained documents needs no published definition, and requiring one would make ad-hoc use impossible. Where set, definition_digest MUST also be set.

definition_digest: Option<String>

Multibase-encoded multihash over the RFC 8785 (JCS) canonicalization of the definition named by definition.

Pins the definition by content rather than by name. Without it the completion rule, role list and evidence level of a flow are whatever the URI serves at verification time — which may be years later, under different control, and retroactively for every enactment already performed.

parent_enactment: Option<String>

The enactment containing this one, where a ceremony is conducted as a step of another.

Takes the posture of parentThreadId (§4.9.2): one level, navigation only, no normative validation semantics, and never equal to this document’s own enactment. One level is not a depth limit — the pointers form a chain, so ceremonies nest arbitrarily deep.

round: Option<u32>

Distinguishes repetitions of the same step by the same party, where a definition permits bounded repetition. None means round 1.

Being signed, it is what stops one round’s document being replayed as another’s.

terminal: Option<bool>

Marks a step that ends the enactment.

A set of steps containing none so marked is a prefix, not a completed flow — which is what makes truncation of a ceremony’s record detectable, since the marker cannot be minted without this step issuer’s key.

prev: Option<Vec<CeremonyPrev>>

The steps this one follows.

A set rather than a single predecessor, so a flow with concurrent branches is expressible and a linear chain is the degenerate case.

Implementations

impl Ceremony

pub fn new(enactment: impl Into<String>, step: impl Into<String>) -> Ceremony

Construct a ceremony member with only the required members populated.

pub fn is_well_formed(&self) -> bool

Whether this member is internally well-formed per §4.11.

Checks only what a single document can establish: that a definition is accompanied by its digest, and that the member does not claim to be its own parent. It deliberately says nothing about whether the enactment exists as described — no document can establish that, which is why §4.11.4 forbids granting authority on membership.

Trait Implementations

impl Clone for Ceremony

fn clone(&self) -> Ceremony

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ceremony

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Ceremony

fn deserialize<__D>( __deserializer: __D, ) -> Result<Ceremony, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Ceremony

impl PartialEq for Ceremony

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Ceremony

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Ceremony