Struct RequestItem 

pub struct RequestItem {
    pub identifier: String,
    pub issuer_schema_id: u64,
    pub signal: Option<String>,
    pub genesis_issued_at_min: Option<u64>,
    pub expires_at_min: Option<u64>,
}

Per-credential request payload.

Fields

identifier: String

An RP-defined identifier for this request item used to match against constraints and responses.

Example: orb, document.

issuer_schema_id: u64

Unique identifier for the credential schema and issuer pair.

Registered in the CredentialSchemaIssuerRegistry.

signal: Option<String>

Arbitrary data provided by the RP that gets cryptographically bound into the proof.

When present, the Authenticator hashes this via signal_hash and commits it into the proof circuit so the RP can tie the proof to a particular context.

genesis_issued_at_min: Option<u64>

Minimum genesis_issued_at timestamp that the used Credential must meet.

If present, the proof will include a constraint that the credential’s genesis issued at timestamp is greater than or equal to this value. Can be set to 0 to skip. This is useful for migration from previous protocol versions.

expires_at_min: Option<u64>

The minimum expiration required for the Credential used in the proof.

If the constraint is not required, it should use the current time as the minimum expiration. The Authenticator will normally expose the effective input used in the proof.

This is particularly useful to specify a minimum duration for a Credential proportional to the action being performed. For example, when claiming a benefit that is once every 6 months, the minimum duration can be set to 180 days to prevent double claiming in that period in case the Credential is set to expire earlier.

It is an RP’s responsibility to understand the issuer’s policies regarding expiration to ensure the request can be fulfilled.

If not provided, this will default to the ProofRequest::created_at attribute.

Implementations

impl RequestItem

pub const fn new( identifier: String, issuer_schema_id: u64, signal: Option<String>, genesis_issued_at_min: Option<u64>, expires_at_min: Option<u64>, ) -> Self

Create a new request item with the given identifier, issuer schema ID and optional signal.

pub fn signal_hash(&self) -> FieldElement

Get the signal hash for the request item.

pub const fn effective_expires_at_min(&self, request_created_at: u64) -> u64

Get the effective minimum expiration timestamp for this request item.

If expires_at_min is Some, returns that value. Otherwise, returns the request_created_at value (which should be the ProofRequest::created_at timestamp).

Trait Implementations

impl Clone for RequestItem

fn clone(&self) -> RequestItem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RequestItem

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RequestItem

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RequestItem

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RequestItem

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RequestItem

impl StructuralPartialEq for RequestItem