Struct UsageCap 

pub struct UsageCap { /* private fields */ }

A quantitative usage bound parsed from a Capability.

Capabilities are normally opaque presence tokens (sign_commit, acme:deploy): holding the credential grants the action, with no notion of “how many times”. A quantitative capability instead bounds a measured resource. The first such resource is the call count: calls:<N> means “at most N exercises of this credential”. The bound rides in the capability claim, which is part of the ACDC SAID, so it cannot be edited without breaking the credential.

The verifier consumes a monotonic usage record alongside the credential: a presentation whose observed count has reached the cap is rejected with a distinct cap-exceeded verdict, and a presentation replaying an earlier (lower) count than the highest already observed is rejected as a rolled-back counter.

Examples

use auths_keri::{Capability, UsageCap};

let cap = Capability::parse("calls:3").unwrap();
assert_eq!(UsageCap::from_capability(&cap), Some(UsageCap::calls(3)));

// A presence token carries no quantitative bound.
let sign = Capability::sign_commit();
assert_eq!(UsageCap::from_capability(&sign), None);

Implementations

impl UsageCap

pub const fn calls(max_calls: u64) -> Self

Construct a call-count cap admitting at most max_calls exercises.

pub const fn max_calls(self) -> u64

The maximum number of calls this credential admits.

pub fn from_capability(cap: &Capability) -> Option<Self>

Parse the quantitative usage bound carried by a capability, if any.

Recognizes the call-count grammar calls:<N> and the comparison spelling calls<=<N>, where <N> is a non-negative decimal integer. Any other capability (a presence token, a different resource) carries no bound and yields None. A calls resource with a missing or non-numeric bound also yields None — the credential then has no enforceable quantitative cap and is treated as an ordinary (unbounded) capability, never silently zero.

pub fn from_capabilities(caps: &[Capability]) -> Option<Self>

The first quantitative usage bound among a set of capabilities, if any.

A credential carries at most one call-count cap; this returns the first one found so the verifier can enforce it regardless of where it sits among the granted capabilities.

pub fn is_malformed_quant_predicate(cap: &Capability) -> bool

Whether cap is a MALFORMED quantitative usage predicate.

true iff the capability targets the reserved calls usage resource (the calls: / calls<= prefix) but its bound does NOT parse to a valid non-negative call count — e.g. calls:, calls:abc, calls:-1. Such a capability looks like a budget but enforces none: Self::from_capability yields None, so the credential would verify at any count. An issuer must refuse it rather than mint a cap that is silently no cap.

A well-formed cap (calls:3) is not malformed; a presence token (sign_commit, acme:deploy) is not malformed (it targets no usage resource); only a calls-resource capability with an unparseable bound is.

Examples

use auths_keri::{Capability, UsageCap};

assert!(UsageCap::is_malformed_quant_predicate(&Capability::parse("calls:abc").unwrap()));
assert!(UsageCap::is_malformed_quant_predicate(&Capability::parse("calls:").unwrap()));
assert!(!UsageCap::is_malformed_quant_predicate(&Capability::parse("calls:3").unwrap()));
assert!(!UsageCap::is_malformed_quant_predicate(&Capability::sign_commit()));

Trait Implementations

impl Clone for UsageCap

fn clone(&self) -> UsageCap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for UsageCap

impl Debug for UsageCap

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for UsageCap

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for UsageCap

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

Formats the value using the given formatter.

impl Eq for UsageCap

impl Hash for UsageCap

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for UsageCap

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for UsageCap

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 UsageCap