Struct ReceiptEnvelope 

pub struct ReceiptEnvelope {
    pub version: String,
    pub kind: String,
    pub composed_root: String,
    pub intent_hash: String,
    pub artifact_hash: String,
    pub control_hash: String,
    pub generated_at: DateTime<Utc>,
    pub process_ref: Option<String>,
    pub evidence: Value,
}

Typed receipt envelope. Any Job in pleme-io that wants its result to chain into a Process’s status.attestation writes one of these.

Fields

version: String

Must equal RECEIPT_VERSION. Mismatches reject the receipt.

kind: String

What this receipt proves. Known: closed-loop-auth, db-migration, test-suite, nix-build. Operators may register new kinds — the envelope is open.

composed_root: String

Three-pillar root: BLAKE3(domain ++ artifact ++ control ++ intent ++ previous).

intent_hash: String

Pillar 1: what the Job was trying to do (canonical intent).

artifact_hash: String

Pillar 2: what the Job produced (artifact / proof material).

control_hash: String

Pillar 3: how the Job verified its work (controls / signatures / auth steps). Empty string when there was no control step.

generated_at: DateTime<Utc>

Timestamp the Job set when it wrote the receipt.

process_ref: Option<String>

Optional owning-Process reference (namespace/name). When the reconciler creates the Job it stamps this in via the downward API; receipts without it still parse for ad-hoc / out-of-cluster runs.

evidence: Value

Optional structured evidence. Free-form JSON. The reconciler does not parse this — it’s for human / downstream-tool inspection.

Implementations

impl ReceiptEnvelope

pub fn build( kind: impl Into<String>, intent_hash: impl Into<String>, artifact_hash: impl Into<String>, control_hash: impl Into<String>, previous_root: Option<&str>, ) -> Self

Build a receipt envelope from typed pillars + kind. generated_at defaults to Utc::now().

pub fn parse_json(payload: &str) -> Result<Self, ReceiptError>

Parse a receipt from a JSON string.

pub fn parse_yaml(payload: &str) -> Result<Self, ReceiptError>

Parse a receipt from a YAML string. Useful for ConfigMaps that store the payload in YAML form.

pub fn parse_either(payload: &str) -> Result<Self, ReceiptError>

Parse via JSON first, then YAML if JSON fails. Lets a single reader accept either wire form without the operator having to declare it. Useful when the Job writes JSON and the reconciler reads back through a kube DynamicObject whose data is YAML.

pub fn verify_shape(&self) -> Result<(), ReceiptError>

Verify the schema-level invariants: correct version + non-empty kind + non-empty pillar hashes (length-only, not BLAKE3-recompute).

pub fn verify_root(&self, expected_previous_root: Option<&str>) -> bool

Verify that composed_root is consistent with the pillars. expected_previous_root is the previous root in the Process’s attestation chain (or None for first attestation).

pub fn expect_root(&self, expected: Option<&str>) -> Result<&str, ReceiptError>

Strict-equality check against an operator-provided expected root. Returns the receipt’s root unchanged on success.

pub fn known_kind(&self) -> Option<ReceiptKind>

Decode self.kind into the typed ReceiptKind variant when the wire string matches one of the four substrate-emitted canonical kebab-case kinds; None when the kind is an operator-registered open string (the schema is open by design — every receipt remains a valid receipt, but only typed kinds participate in closed-set dispatch). The (open String, closed-typed view) split lets future kind-keyed consumers (verifier registries, dashboard completion, audit-trail classifiers) sweep the typed variants without touching the open-by-design wire shape. Lifted as the canonical decode site so no consumer re-implements the match self.kind.as_str() arm-by-arm — the closed-set sweep happens through [ReceiptKind::from_str] at ONE site.

pub fn to_attestation( &self, generation: u64, previous_root: Option<&str>, ) -> ProcessAttestation

Lower into a ProcessAttestation — the canonical handoff so a Job’s typed receipt becomes evidence on a Process. generation

• previous_root come from the owning Process’s prior attestation (or 0 + None for the first cycle).

Trait Implementations

impl Clone for ReceiptEnvelope

fn clone(&self) -> ReceiptEnvelope

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReceiptEnvelope

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReceiptEnvelope

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ReceiptEnvelope

impl JsonSchema for ReceiptEnvelope

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for ReceiptEnvelope

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ReceiptEnvelope

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 ReceiptEnvelope