Struct Provenance 

pub struct Provenance {
    pub run: RunId,
    pub case: Option<CaseId>,
    pub effect: EffectKey,
    pub dispatch: Option<EffectKey>,
    pub agent: String,
    pub signature: Option<KeySignature>,
}

Who is calling, on whose behalf, for which piece of work.

Fields

run: RunId

case: Option<CaseId>

effect: EffectKey

Which effect within the run — unique per run and per attempt.

dispatch: Option<EffectKey>

The logical dispatch, stable across retries of the same call.

effect hashes the attempt number, and it must: without it a retry would collide with the recorded failure of the attempt before it, and replay would read back the failure instead of the retry.

That makes it the wrong thing to hand a callee for duplicate detection, which is the opposite question — “have I already done this work?” — and must answer yes for a retry. A peer given the effect key sees two unrelated messages and may act twice, which is precisely the outcome deduplication exists to prevent.

agent: String

The agent, as the deployment names it.

signature: Option<KeySignature>

The signature over payload, if the plane has a signer.

None is honest rather than convenient: a plane with no workload identity cannot attest, and a self-signed block would look attested and prove nothing — the same reasoning that keeps unsigned journal records unsigned rather than self-signed.

Implementations

impl Provenance

pub fn new(run: RunId, effect: EffectKey, agent: impl Into<String>) -> Self

pub const fn dispatching(self, dispatch: EffectKey) -> Self

Name the logical dispatch this call belongs to.

See Provenance::dispatch for why it is not the effect key.

pub fn dedupe_key(&self) -> EffectKey

The identity a callee should deduplicate on.

Falls back to the effect key when no dispatch id was supplied, which is wrong across retries and right for everything else — and is what a transport gets if the runtime did not set one.

pub const fn in_case(self, case: Option<CaseId>) -> Self

pub fn payload(&self, target: &str, arguments: &Value) -> Digest

The bytes a signature covers.

Canonical — the same map always hashes the same way — because the callee recomputes this from the wire form and the two must agree byte for byte. Uses this crate’s own canonical writer rather than serde_json’s ordering, for the reason recorded against core::canon: map order is not something to inherit from a dependency’s feature flags.

target and arguments are what bind the signature to this call.

pub fn seal(self, signer: &dyn Signer, target: &str, arguments: &Value) -> Self

Sign this block for one specific call.

pub fn verify( &self, verifier: &dyn Verifier, target: &str, arguments: &Value, ) -> bool

Whether this block was signed for exactly this call.

The callee’s side. Returns false for an unsigned block, an unknown key, and a signature made for a different call alike — they are the same answer to the only question being asked, which is may I act on this.

pub fn to_meta(&self) -> Map<String, Value>

The wire form: a _meta-shaped object.

pub fn from_meta(meta: &Map<String, Value>) -> Option<Self>

Read a block back off the wire.

For a callee, and for the tests that stand in for one. Returns None when the required fields are absent or malformed — a partially parsed block is not something to act on.

Trait Implementations

impl Clone for Provenance

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Provenance

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Provenance

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Provenance

impl PartialEq for Provenance

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Provenance

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 Provenance