Struct VerifiablePresentation 

pub struct VerifiablePresentation {
    pub context: Contexts,
    pub id: Option<StringOrURI>,
    pub type_: OneOrMany<String>,
    pub verifiable_credential: Option<OneOrMany<CredentialOrJWT>>,
    pub proof: Option<OneOrMany<Proof>>,
    pub holder: Option<URI>,
    pub holder_binding: Option<OneOrMany<HolderBinding>>,
    pub property_set: Option<HashMap<String, Value>>,
}

Fields

context: Contexts

id: Option<StringOrURI>

type_: OneOrMany<String>

verifiable_credential: Option<OneOrMany<CredentialOrJWT>>

proof: Option<OneOrMany<Proof>>

holder: Option<URI>

holder_binding: Option<OneOrMany<HolderBinding>>

property_set: Option<HashMap<String, Value>>

Implementations

impl Presentation

pub fn from_json(s: &str) -> Result<Presentation, Error>

pub fn from_json_unsigned(s: &str) -> Result<Presentation, Error>

pub fn from_jwt_claims(claims: JWTClaims) -> Result<Presentation, Error>

pub fn to_jwt_claims(&self) -> Result<JWTClaims, Error>

pub fn encode_sign_jwt( &self, keys: &JWTKeys, aud: &str, ) -> Result<String, Error>

👎Deprecated: Use generate_jwt

pub async fn generate_jwt( &self, jwk: Option<&JWK>, options: &LinkedDataProofOptions, resolver: &dyn DIDResolver, ) -> Result<String, Error>

Encode the Verifiable Presentation as JWT. If JWK is passed, sign it, otherwise it is unsigned. Linked data proof options are translated into JWT claims if possible.

pub async fn decode_verify_jwt( jwt: &str, options_opt: Option<LinkedDataProofOptions>, resolver: &dyn DIDResolver, context_loader: &mut ContextLoader, ) -> (Option<Presentation>, VerificationResult)

pub async fn verify_jwt( jwt: &str, options_opt: Option<LinkedDataProofOptions>, resolver: &dyn DIDResolver, context_loader: &mut ContextLoader, ) -> VerificationResult

pub fn validate_unsigned(&self) -> Result<(), Error>

pub fn validate(&self) -> Result<(), Error>

pub async fn generate_proof( &self, jwk: &JWK, options: &LinkedDataProofOptions, resolver: &dyn DIDResolver, context_loader: &mut ContextLoader, ) -> Result<Proof, Error>

pub async fn prepare_proof( &self, public_key: &JWK, options: &LinkedDataProofOptions, resolver: &dyn DIDResolver, context_loader: &mut ContextLoader, ) -> Result<ProofPreparation, Error>

Prepare to generate a linked data proof. Returns the signing input for the caller to sign and then pass to [ProofPreparation::complete] to complete the proof.

pub fn add_proof(&mut self, proof: Proof)

pub async fn verify( &self, options: Option<LinkedDataProofOptions>, resolver: &dyn DIDResolver, context_loader: &mut ContextLoader, ) -> VerificationResult

Trait Implementations

impl Clone for Presentation

fn clone(&self) -> Presentation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Presentation

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

Formats the value using the given formatter.

impl Default for Presentation

fn default() -> Presentation

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Presentation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl LinkedDataDocument for Presentation

fn get_contexts(&self) -> Result<Option<String>, Error>

fn to_dataset_for_signing<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, parent: Option<&'life1 (dyn LinkedDataDocument + Sync)>, context_loader: &'life2 mut ContextLoader, ) -> Pin<Box<dyn Future<Output = Result<HashDataset<Subject, IriBuf, Term>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Presentation: 'async_trait,

fn to_value(&self) -> Result<Value, Error>

fn get_issuer(&self) -> Option<&str>

fn get_default_proof_purpose(&self) -> Option<VerificationRelationship>

impl PartialEq for Presentation

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

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 StructuralPartialEq for Presentation