Struct PayloadAad 

pub struct PayloadAad { /* private fields */ }

The associated data bound into a payload seal.

Binding the payload to its location — (execution_id, step_id, entry_kind, idem_key) — is what makes a sealed blob un-relocatable. Moving a StepResult blob to a different step_id, or replaying it under a different execution_id, changes the AAD and makes PayloadCipher::open fail authentication (fail-closed). The fields are private; construct via PayloadAad::new and read the bound encoding via PayloadAad::canonical_bytes.

Security

The bound idem_key and the plaintext payload MUST be derived from non-secret descriptors only (INV-6): resolved secret material is referenced by vault key name, never embedded here or in the IdempotencyKey fingerprint. The AAD is authenticated but not encrypted, so it must never carry a secret value.

Examples

use zeph_durable::{ExecutionId, IdempotencyKey, StepId};
use zeph_durable::cipher::{EntryKindTag, PayloadAad};

let exec = ExecutionId::new();
let key = IdempotencyKey::derive(exec, StepId::new(0), b"tool:transfer");
let with_key = PayloadAad::new(exec, StepId::new(0), EntryKindTag::StepResult, Some(key));
let without_key = PayloadAad::new(exec, StepId::new(0), EntryKindTag::StepResult, None);

// The optional idempotency key is part of the binding.
assert_ne!(with_key.canonical_bytes(), without_key.canonical_bytes());

Implementations

impl PayloadAad

pub fn new( execution_id: ExecutionId, step_id: StepId, entry_kind: EntryKindTag, idem_key: Option<IdempotencyKey>, ) -> Self

Construct the associated data for a payload at a known journal location.

pub fn canonical_bytes(&self) -> Vec<u8>

Encode the AAD as deterministic, injective bytes for the AEAD associated-data channel.

Layout (fixed positions, so the encoding is injective without per-field length prefixes): version(1) || execution_id(16) || step_id_le(4) || entry_kind(1) || idem_present(1) || [idem_key(32) when present]. Every concrete PayloadCipher feeds these exact bytes to its AEAD so seal and open agree on the binding.

Examples

use zeph_durable::{ExecutionId, StepId};
use zeph_durable::cipher::{EntryKindTag, PayloadAad};

let aad = PayloadAad::new(ExecutionId::new(), StepId::new(1), EntryKindTag::Checkpoint, None);
// version + 16 + 4 + 1 + 1 = 23 bytes when no idempotency key is bound.
assert_eq!(aad.canonical_bytes().len(), 23);

Trait Implementations

impl Clone for PayloadAad

fn clone(&self) -> PayloadAad

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PayloadAad

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

Formats the value using the given formatter.

impl Eq for PayloadAad

impl PartialEq for PayloadAad

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PayloadAad