Struct ProofOptions 

pub struct ProofOptions<M, T> {
    pub context: Option<Context>,
    pub created: Option<Lexical<DateTimeStamp>>,
    pub verification_method: Option<ReferenceOrOwned<M>>,
    pub proof_purpose: ProofPurpose,
    pub expires: Option<Lexical<DateTimeStamp>>,
    pub domains: Vec<String>,
    pub challenge: Option<String>,
    pub nonce: Option<String>,
    pub options: T,
    pub extra_properties: BTreeMap<String, Value>,
}

Proof options.

Fields

context: Option<Context>

created: Option<Lexical<DateTimeStamp>>

Date a creation of the proof.

verification_method: Option<ReferenceOrOwned<M>>

Verification method.

proof_purpose: ProofPurpose

Purpose of the proof.

expires: Option<Lexical<DateTimeStamp>>

Specifies when the proof expires.

domains: Vec<String>

Conveys one or more security domains in which the proof is meant to be used.

A verifier SHOULD use the value to ensure that the proof was intended to be used in the security domain in which the verifier is operating. The specification of the domain parameter is useful in challenge-response protocols where the verifier is operating from within a security domain known to the creator of the proof.

Example domain values include: domain.example`` (DNS domain), https://domain.example:8443(Web origin),mycorp-intranet(bespoke text string), andb31d37d4-dd59-47d3-9dd8-c973da43b63a` (UUID).

challenge: Option<String>

Used to mitigate replay attacks.

Used once for a particular domain and window of time. Examples of a challenge value include: 1235abcd6789, 79d34551-ae81-44ae-823b-6dadbab9ebd4, and ruby.

nonce: Option<String>

Arbitrary string supplied by the proof creator.

One use of this field is to increase privacy by decreasing linkability that is the result of deterministically generated signatures.

options: T

Additional proof options required by the cryptographic suite.

For instance, tezos cryptosuites requires the public key associated with the verification method, which is a blockchain account id.

extra_properties: BTreeMap<String, Value>

Extra properties.

Implementations

impl<M, T> ProofOptions<M, T>

pub fn new( created: Lexical<DateTimeStamp>, verification_method: ReferenceOrOwned<M>, proof_purpose: ProofPurpose, options: T, ) -> ProofOptions<M, T>

pub fn from_method_and_options( verification_method: ReferenceOrOwned<M>, options: T, ) -> ProofOptions<M, T>

pub fn from_method( verification_method: ReferenceOrOwned<M>, ) -> ProofOptions<M, T>

where T: Default,

pub fn map<N, U>( self, map_verification_method: impl FnOnce(M) -> N, map_options: impl FnOnce(T) -> U, ) -> ProofOptions<N, U>

pub fn cast<N, U>(self) -> ProofOptions<N, U>

where M: Into<N>, T: Into<U>,

pub fn try_map<N, U, E>( self, map_verification_method: impl FnOnce(M) -> Result<N, E>, map_options: impl FnOnce(T) -> Result<U, E>, ) -> Result<ProofOptions<N, U>, E>

pub fn into_configuration_with<S>( self, type_: S, f: impl FnOnce(T) -> <S as CryptographicSuite>::ProofOptions, ) -> Result<ProofConfiguration<S>, ConfigurationError>

where S: CryptographicSuite<VerificationMethod = M>,

pub fn into_configuration<S>( self, type_: S, ) -> Result<ProofConfiguration<S>, ConfigurationError>

where S: CryptographicSuite<VerificationMethod = M, ProofOptions = T>,

Trait Implementations

impl<M, T> Clone for ProofOptions<M, T>

where M: Clone, T: Clone,

fn clone(&self) -> ProofOptions<M, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M, T> Debug for ProofOptions<M, T>

where M: Debug, T: Debug,

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

Formats the value using the given formatter.

impl<M, T> Default for ProofOptions<M, T>

where T: Default,

fn default() -> ProofOptions<M, T>

Returns the “default value” for a type.

impl<'de, M, T> Deserialize<'de> for ProofOptions<M, T>

where M: Deserialize<'de>, T: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<ProofOptions<M, T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<M, T> Serialize for ProofOptions<M, T>

where M: Serialize, T: Serialize,

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.