Struct ProofContext 

pub struct ProofContext {
    pub external_nullifier: U256Wrapper,
    pub credential_type: CredentialType,
    pub signal_hash: U256Wrapper,
    pub require_mined_proof: bool,
}

A ProofContext contains the basic information on the verifier and the specific action a user will be proving.

It is required to generate a Proof and will generally be initialized from an app_id and action.

Note on naming: ProofContext is used to make it clear in FFIs which may not respect the module structure.

Fields

external_nullifier: U256Wrapper

The external_nullifier is the computed result of a specific context for which a World ID Proof is generated. It is used in the Sempahore ZK circuit and in the computation of the nullifier_hash to guarantee uniqueness in a privacy-preserving way.

credential_type: CredentialType

Represents the specific credential to be used for a World ID Proof.

signal_hash: U256Wrapper

The hashed signal which is included in the ZKP and committed to in the proof. When verifying the proof, the same signal must be provided.

require_mined_proof: bool

Whether the request requires a mined on-chain proof.

Implementations

impl ProofContext

pub fn new( app_id: &str, action: Option<String>, signal: Option<String>, credential_type: CredentialType, ) -> Self

Initializes a ProofContext.

Will compute the relevant external nullifier from the provided app_id and action as defined by the World ID Protocol. The external nullifier generation matches the logic in the Developer Portal.

Arguments

• app_id - The ID of the application requesting proofs. This can be obtained from the Developer Portal.
• action - Optional. Custom incognito action being requested.
• signal - Optional. The signal is included in the ZKP and is committed to in the proof. When verifying the proof, the same signal must be provided to ensure the proof is valid. The signal can be used to prevent replay attacks, MITM or other cases. More details available in the docs.
• credential_type - The type of credential being requested.

pub fn new_from_bytes( app_id: &str, action: Option<Vec<u8>>, signal: Option<Vec<u8>>, credential_type: CredentialType, ) -> Self

Initializes a Proof::ProofContext where the action is provided as raw bytes. This is useful for advanced cases where the action is an already ABI encoded value for on-chain usage. See walletkit-core/tests/solidity.rs for an example.

Will compute the relevant external nullifier from the provided app_id and action.

Arguments

See ProofContext::new for reference. The action and signal need to be provided as raw bytes.

pub fn new_from_signal_hash( app_id: &str, action: Option<Vec<u8>>, credential_type: CredentialType, signal_hash: &U256Wrapper, ) -> Result<Self, WalletKitError>

Initializes a ProofContext from an already hashed signal.

Please note it is imperative to hash into the Semaphore field. Not all U256 are part of the field. Use the hash_to_field function to hash into the field.

Usage

• This may be used when the hash of the signal is computed externally.
• For example, this is used for support of legacy MiniKit v1 commands in World App where minikit-js hashed the signal.

Arguments

• app_id - The ID of the application requesting proofs. This can be obtained from the Developer Portal.
• action - Optional. Custom incognito action being requested as bytes.
• credential_type - The type of credential being requested.
• signal - The already hashed signal as a field element.

Errors

• Returns an error if the signal is not a valid number in the field.

pub const fn get_external_nullifier(&self) -> U256Wrapper

Get the raw external nullifier for this context.

pub const fn get_signal_hash(&self) -> U256Wrapper

Get the signal hash for this context.

pub const fn get_credential_type(&self) -> CredentialType

Get the credential type for this context.

Trait Implementations

impl Clone for ProofContext

fn clone(&self) -> ProofContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProofContext

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

Formats the value using the given formatter.

impl PartialEq for ProofContext

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

impl StructuralPartialEq for ProofContext