Struct ProofRequest 

pub struct ProofRequest {
    pub id: String,
    pub version: RequestVersion,
    pub created_at: u64,
    pub expires_at: u64,
    pub rp_id: RpId,
    pub action: FieldElement,
    pub oprf_public_key: OprfPublicKey,
    pub signature: Signature,
    pub nonce: FieldElement,
    pub requests: Vec<RequestItem>,
    pub constraints: Option<ConstraintExpr<'static>>,
}

A proof request from a relying party for an authenticator

Fields

id: String

Unique identifier for this request

version: RequestVersion

Version of the request

created_at: u64

Unix timestamp (seconds since epoch) when the request was created

expires_at: u64

Unix timestamp (seconds since epoch) when request expires

rp_id: RpId

Registered RP id

action: FieldElement

The raw representation of the action. This must be already a field element.

When dealing with strings or bytes, such value can be hashed e.g. with a byte-friendly hash function like keccak256 or SHA256 and then reduced to a field element.

oprf_public_key: OprfPublicKey

The nullifier key of the RP (FIXME: documentation & serialization after #129)

signature: Signature

The RP’s ECDSA signature over the request

nonce: FieldElement

Unique nonce for this request (serialized as hex string)

requests: Vec<RequestItem>

Specific credential requests. This defines which credentials to ask for.

constraints: Option<ConstraintExpr<'static>>

Constraint expression (all/any) optional

Implementations

impl ProofRequest

pub fn credentials_to_prove( &self, available: &HashSet<String>, ) -> Option<Vec<&RequestItem>>

Determine which requested credentials to prove given available credentials.

Returns None if constraints (or lack thereof) cannot be satisfied with the available set.

Panics

Panics if constraints are present but invalid according to the type invariants (this should not occur as constraints are provided by trusted request issuer).

pub fn find_request_by_issuer_schema_id( &self, issuer_schema_id: FieldElement, ) -> Option<&RequestItem>

Find a request item by issuer schema ID if available

pub const fn is_expired(&self, now: u64) -> bool

Returns true if the request is expired relative to now (unix timestamp in seconds)

pub fn digest_hash(&self) -> Result<[u8; 32], PrimitiveError>

Compute the digest hash of this request that should be signed by the RP, which right now includes the nonce and the timestamp of the request.

Returns

A 32-byte hash that represents this request and should be signed by the RP.

Errors

Returns a PrimitiveError if FieldElement serialization fails (which should never occur in practice).

Note: the timestamp is encoded as little-endian to mirror the RP-side signing performed in test fixtures and the OPRF stub.

pub fn validate_response( &self, response: &ProofResponse, ) -> Result<(), ValidationError>

Validate that a response satisfies this request: id match and constraints semantics.

Errors

Returns a ValidationError if the response does not correspond to this request or does not satisfy the declared constraints.

pub fn from_json(json: &str) -> Result<Self, Error>

Parse from JSON

Errors

Returns an error if the JSON is invalid or contains duplicate issuer schema ids.

pub fn to_json(&self) -> Result<String, Error>

Serialize to JSON

Errors

Returns an error if serialization unexpectedly fails.

pub fn to_json_pretty(&self) -> Result<String, Error>

Serialize to pretty JSON

Errors

Returns an error if serialization unexpectedly fails.

Trait Implementations

impl Clone for ProofRequest

fn clone(&self) -> ProofRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProofRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProofRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ProofRequest

fn eq(&self, other: &ProofRequest) -> 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 ProofRequest

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 ProofRequest

impl StructuralPartialEq for ProofRequest