Struct ProofRequest 

pub struct ProofRequest {

    pub id: String,
    pub version: RequestVersion,
    pub proof_type: ProofType,
    pub created_at: u64,
    pub expires_at: u64,
    pub rp_id: RpId,
    pub oprf_key_id: OprfKeyId,
    pub session_id: Option<SessionId>,
    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.

proof_type: ProofType

Requested high-level proof flow.

If omitted, the request is strictly treated as a ProofType::Uniqueness request. Session creation and session proving must opt in explicitly.

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<SessionId>

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

Required for ProofType::Session, absent for all other proof types. 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(version || nonce || created_at || expires_at || action). 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 validate_proof_type(&self) -> Result<(), PrimitiveError>

Validates that the request fields match the explicit proof type.

If proof_type was omitted during deserialization, it defaults to ProofType::Uniqueness. Session flows must opt in explicitly.

Errors

Returns PrimitiveError::InvalidInput when the request has an invalid combination of proof_type, session_id, and action.

pub const fn is_session_proof(&self) -> bool

Returns true if this request produces a Session proof.

pub const fn is_create_session(&self) -> bool

Returns true if this request creates a new session.

pub fn validate_constraints(&self) -> Result<(), ValidationError>

Validates the structural integrity of the constraint expression.

Checks that the constraint tree (when present) does not exceed the maximum nesting depth of 2 or the maximum node count. This is the same check performed inside validate_response; exposing it separately allows callers to pre-flight a request before attempting proof generation.

Errors

Returns ValidationError::ConstraintTooDeep or ValidationError::ConstraintTooLarge if the expression exceeds protocol limits.

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<ProofRequest, 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<(), Error>

Formats the value using the given formatter.

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

fn deserialize<__D>( __deserializer: __D, ) -> Result<ProofRequest, <__D as Deserializer<'de>>::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 as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ProofRequest

impl StructuralPartialEq for ProofRequest