Struct ProofRequest 

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

A proof request from a Relying Party (RP) for an Authenticator.

Fields

id: String

Unique identifier for this request.

version: RequestVersion

Version of the request.

created_at: u64

Unix timestamp (seconds) when the request was created.

expires_at: u64

Unix timestamp (seconds) when the request expires.

rp_id: RpId

Registered RP identifier from the RpRegistry.

oprf_key_id: OprfKeyId

OprfKeyId of the RP.

session_id: Option<FieldElement>

Session identifier that links proofs for the same user/RP pair across requests.

If provided, a Session Proof will be generated instead of a Uniqueness Proof. The proof will only be valid if the session ID is meant for this context and this particular World ID holder.

action: Option<FieldElement>

An RP-defined context that scopes what the user is proving uniqueness on.

This parameter expects a field element. When dealing with strings or bytes, hash with a byte-friendly hash function like keccak256 or SHA256 and reduce to the field.

signature: Signature

The RP’s ECDSA signature over the request.

nonce: FieldElement

Unique nonce for this request provided by the RP.

requests: Vec<RequestItem>

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

constraints: Option<ConstraintExpr<'static>>

Constraint expression (all/any/enumerate) optional.

Implementations

impl ProofRequest

pub fn credentials_to_prove( &self, available: &HashSet<u64>, ) -> 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: u64, ) -> 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).

The digest is computed as: SHA256(nonce || action || created_at || expires_at). This mirrors the RP signature message format from rp::compute_rp_signature_msg. Note: the timestamp is encoded as big-endian to mirror the RP-side signing performed in test fixtures and the OPRF stub.

pub fn computed_action<R: CryptoRng + RngCore>( &self, rng: &mut R, ) -> FieldElement

Gets the action value to use in the proof.

• When an explicit action is provided, it is returned directly.
• For session proofs (action is None), a random action is generated.

Callers should cache the action during proof generation to ensure consistency across proof steps.

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