Struct Proof

pub struct Proof<S: CryptographicSuite> {
    pub context: Option<Context>,
    pub type_: S,
    pub created: Option<Lexical<DateTimeStamp>>,
    pub verification_method: ReferenceOrOwned<S::VerificationMethod>,
    pub proof_purpose: ProofPurpose,
    pub expires: Option<Lexical<DateTimeStamp>>,
    pub domains: Vec<String>,
    pub challenge: Option<String>,
    pub nonce: Option<String>,
    pub options: S::ProofOptions,
    pub signature: S::Signature,
    pub extra_properties: BTreeMap<String, Value>,
}

Data Integrity Proof.

A data integrity proof provides information about the proof mechanism, parameters required to verify that proof, and the proof value itself.

Fields

context: Option<Context>

Proof context.

type_: S

Proof type.

Also includes the cryptographic suite variant.

created: Option<Lexical<DateTimeStamp>>

Date a creation of the proof.

verification_method: ReferenceOrOwned<S::VerificationMethod>

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: S::ProofOptions

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.

signature: S::Signature

Proof signature.

extra_properties: BTreeMap<String, Value>

Extra properties unrelated to the cryptographic suite.

Implementations

impl<T: CryptographicSuite> Proof<T>

pub fn new( type_: T, created: Lexical<DateTimeStamp>, verification_method: ReferenceOrOwned<T::VerificationMethod>, proof_purpose: ProofPurpose, options: T::ProofOptions, signature: T::Signature, ) -> Self

Creates a new proof.

pub fn borrowed(&self) -> ProofRef<'_, T>

pub fn with_context(self, context: Context) -> Self

pub fn suite(&self) -> &T

pub fn configuration(&self) -> ProofConfigurationRef<'_, T>

pub fn map_type<U: CryptographicSuite>( self, type_: impl FnOnce(T) -> U, verification_method: impl FnOnce(T::VerificationMethod) -> U::VerificationMethod, options: impl FnOnce(T::ProofOptions) -> U::ProofOptions, signature: impl FnOnce(T::Signature) -> U::Signature, ) -> Proof<U>

Trait Implementations

impl<T, S: CryptographicSuite> AttachProof<T> for Proof<S>

type Attached = DataIntegrity<T, S>

Set of claims with a proof.

fn attach_to(self, claims: T) -> Self::Attached

Bundles the given claims with this proof.

impl<S: CloneCryptographicSuite> Clone for Proof<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: DebugCryptographicSuite> Debug for Proof<S>

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

Formats the value using the given formatter.

impl<'de, T: DeserializeCryptographicSuite<'de>> Deserialize<'de> for Proof<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S: CryptographicSuite> Extend<Proof<S>> for Proofs<S>

fn extend<T: IntoIterator<Item = Proof<S>>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<S: CryptographicSuite> From<Proof<S>> for Proofs<S>

fn from(value: Proof<S>) -> Self

Converts to this type from the input type.

impl<S: CryptographicSuite> FromIterator<Proof<S>> for Proofs<S>

fn from_iter<T: IntoIterator<Item = Proof<S>>>(iter: T) -> Self

Creates a value from an iterator.

impl<S> Serialize for Proof<S>

where S: SerializeCryptographicSuite + CryptographicSuite,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S, T, V> ValidateProof<V, T> for Proof<S>

where S: CryptographicSuiteVerification<T, V> + CryptographicSuite, V: ResourceProvider<InputVerificationOptions<S>>,

async fn validate_proof<'a>( &'a self, verifier: &'a V, claims: &'a T, ) -> Result<ProofValidity, ProofValidationError>

Validates the input claim’s proof using the given verifier.