Struct Mandate 

pub struct Mandate {

    pub grant_id: String,
    pub grantor: String,
    pub issuer_sig: Option<String>,
    pub objective_hash: Option<String>,
    pub scope: Vec<String>,
    pub audience: String,
    pub parent_request_id: Option<String>,
    pub delegation_depth: u32,
    pub issued_at: String,
    pub expiry: String,
    pub max_delegation: u32,
    pub revocation: Revocation,
    pub grantee: Option<String>,
    pub chain: Vec<Grant>,
}

The per-hop authorization an action was exercised under.

Fields

grant_id: String

Id of the capability grant this hop was minted from.

grantor: String

Who issued the grant (parent hop / operator). Ed25519 pubkey, base64url-no-pad, so a verifier can check issuer_sig offline.

issuer_sig: Option<String>

Grantor’s signature over the grant’s canonical bytes (see Grant). Optional in the receipt because a verifier may resolve the grant (and its signature) out of band by grant_id; when present it lets the grant chain be walked fully offline.

objective_hash: Option<String>

Hash of the declared task/intent this hop serves.

scope: Vec<String>

Allowed action set. Each entry is an exact label (payments.charge) or a family glob (payments.*). An empty scope authorizes nothing.

audience: String

Who this grant is FOR. Prevents cross-audience replay (a grant minted for audience A cannot authorize an action against audience B).

parent_request_id: Option<String>

The delegation edge this hop descends from.

delegation_depth: u32

Hops from the root grant. Caps re-delegation together with max_delegation.

issued_at: String

RFC 3339 instant the grant became valid.

expiry: String

RFC 3339 instant the grant expires (exclusive upper bound).

max_delegation: u32

Deepest this grant may be re-minted.

revocation: Revocation

Revocation source + (optional) revoked-at timestamp.

grantee: Option<String>

Base64url-no-pad Ed25519 public key the grant was issued to, mirrored from Grant::grantee so a verifier can check the receipt’s signer against it without resolving the chain.

None means the grant was bearer. A verifier must report that rather than pass silently: a valid signature proves who signed the receipt and who issued the grant, never that the two are related.

chain: Vec<Grant>

Ancestors of this grant, root-first, each carrying its own issuer_sig. Optional and skipped when empty so existing v2 receipts keep byte-identical canonical bytes.

Carried inline rather than fetched: issuer_sig already exists so one receipt can be checked offline, and that promise breaks the moment verifying a delegated action requires N network round-trips. The carrier’s ordering is not trusted – see resolve_grant_chain.

Trait Implementations

impl Clone for Mandate

fn clone(&self) -> Mandate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Mandate

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Mandate

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Mandate

impl PartialEq for Mandate

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Mandate

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 Mandate