Struct Act 

pub struct Act {
    pub sub: String,
    pub act: Option<Box<Act>>,
}

The acting party (RFC 8693 §4.1), and — through Self::act — the delegation chain behind it.

Wire shape is the RFC’s: {"sub": "…", "act": {"sub": "…"}}. The outermost value is the current actor; each nested act is the party that authorized the one enclosing it.

Fields

sub: String

Identifier of the acting party. PAS stamps the actor’s ppnum_id (ULID); the engine does not validate the format, because a future Token Exchange phase may carry non-ppoppo principals here.

act: Option<Box<Act>>

The prior link in the delegation chain, if any. Box because the type is self-referential; None for the common single-hop case.

Implementations

impl Act

pub fn new(sub: impl Into<String>) -> Self

A single-hop actor — the shape both PAS agent-flow mint sites emit.

There is deliberately no chain builder: no mint site nests today (the retired flat delegator claim could not express a chain either, so nothing regresses). The engine still enforces Self::depth on inbound tokens regardless, because a nested act arriving at verify is either another issuer’s or a forgery.

pub fn depth(&self) -> usize

Delegation depth — 1 for a single actor, +1 per nested link.

Iterative rather than recursive: the payload is attacker-supplied, and a bound that could blow the stack while measuring it would be no bound at all.

Trait Implementations

impl Clone for Act

fn clone(&self) -> Act

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Act

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Act

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Eq for Act

impl PartialEq for Act

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Act

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 Act