Struct DataIntegrity

pub struct DataIntegrity<T, S: CryptographicSuite> {
    pub claims: T,
    pub proofs: Proofs<S>,
}

Data-Integrity-secured document.

Fields

claims: T

proofs: Proofs<S>

Implementations

impl<T, S: CryptographicSuite> DataIntegrity<T, S>

pub fn new(claims: T, proofs: Proofs<S>) -> Self

Create new Data-Integrity-secured claims by providing the proofs.

pub async fn verify<P>( &self, params: P, ) -> Result<Verification, ProofValidationError>

where T: ValidateClaims<P, Proofs<S>>, Proofs<S>: ValidateProof<P, T>,

Verify the claims and proofs.

The params argument provides all the verification parameters required to validate the claims and proof.

What verification parameters should I use?

It really depends on the claims type T and cryptosuite type S, but the ssi::claims::VerificationParameters type is a good starting point that should work most of the time.

Passing the parameters by reference

If the validation traits are implemented for P, they will be implemented for &P as well. This means the parameters can be passed by move or by reference.

pub async fn select<P>( &self, params: P, options: S::SelectionOptions, ) -> Result<DataIntegrity<Object, S>, SelectionError>

where S: CryptographicSuiteSelect<T, P>,

Select a subset of claims to disclose.

The params argument is similar to the verification parameters of the verify function. It must provides resources necessary to the selection of claims. This depends on the cryptosuite type S, but probably includes a verification method resolver. Using ssi::claims::VerificationParameters will work in most cases.

pub fn map<U>(self, f: impl FnOnce(T) -> U) -> DataIntegrity<U, S>

Trait Implementations

impl<T, S> Clone for DataIntegrity<T, S>

where T: Clone, S: CloneCryptographicSuite + CryptographicSuite,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, S> Debug for DataIntegrity<T, S>

where T: Debug, S: DebugCryptographicSuite + CryptographicSuite,

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

Formats the value using the given formatter.

impl<T, S: CryptographicSuite> Deref for DataIntegrity<T, S>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, S: CryptographicSuite> DerefMut for DataIntegrity<T, S>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, T, S> Deserialize<'de> for DataIntegrity<T, S>

where T: Deserialize<'de>, S: DeserializeCryptographicSuite<'de>,

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, S> Serialize for DataIntegrity<T, S>

where T: Serialize, 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<T, S: CryptographicSuite> VerifiableClaims for DataIntegrity<T, S>

type Claims = T

Claims type.

type Proof = Proofs<S>

Proof type.

fn claims(&self) -> &Self::Claims

The claims.

fn proof(&self) -> &Self::Proof

The proof.

async fn verify<P>( &self, params: P, ) -> Result<Result<(), Invalid>, ProofValidationError>

where Self::Claims: ValidateClaims<P, Self::Proof>, Self::Proof: ValidateProof<P, Self::Claims>,

Validates the claims and proof.