Struct identity_iota::client::Resolver

pub struct Resolver<C = Arc<Client>> where
    C: SharedPtr<Client>,  { /* private fields */ }

A Resolver supports resolving DID Documents across different Tangle networks using multiple Clients.

Also provides convenience functions for resolving DID Documents associated with verifiable Credentials and Presentations.

Implementations

impl<C> Resolver<C> where
    C: SharedPtr<Client>, 

pub async fn new() -> Result<Resolver<C>, Error>

Constructs a new Resolver with a default Client for the Mainnet.

See also Resolver::builder.

pub fn builder() -> ResolverBuilder<Arc<Client>>

Returns a new ResolverBuilder with no configured Clients.

pub fn get_client(&self, network_name: &NetworkName) -> Option<&C>

Returns the Client corresponding to the given NetworkName if one exists.

pub async fn resolve(
    &self,
    did: &IotaDID
) -> Result<ResolvedIotaDocument, Error>

Fetches the ResolvedIotaDocument of the given IotaDID.

pub async fn resolve_history(
    &self,
    did: &IotaDID
) -> Result<DocumentHistory, Error>

Fetches the DocumentHistory of the given IotaDID.

pub async fn resolve_diff_history(
    &self,
    document: &ResolvedIotaDocument
) -> Result<ChainHistory<DiffMessage>, Error>

👎 Deprecated since 0.5.0:

diff chain features are slated for removal

Fetches the ChainHistory of a diff chain starting from a ResolvedIotaDocument on the integration chain.

NOTE: the document must have been published to the Tangle and have a valid message id.

pub async fn resolve_credential_issuer<U>(
    &self,
    credential: &Credential<U>
) -> Result<ResolvedIotaDocument, Error> where
    U: Serialize, 

Fetches the DID Document of the issuer on a Credential.

Errors

Errors if the issuer URL is not a valid IotaDID or DID resolution fails.

pub async fn resolve_presentation_issuers<U, V>(
    &self,
    presentation: &Presentation<U, V>
) -> Result<Vec<ResolvedIotaDocument, Global>, Error> where
    V: Serialize, 

Fetches all DID Documents of Credential issuers contained in a Presentation. Issuer documents are returned in arbitrary order.

Errors

Errors if any issuer URL is not a valid IotaDID or DID resolution fails.

pub async fn resolve_presentation_holder<U, V>(
    &self,
    presentation: &Presentation<U, V>
) -> Result<ResolvedIotaDocument, Error>

Fetches the DID Document of the holder of a Presentation.

Errors

Errors if the holder URL is missing, is not a valid IotaDID, or DID resolution fails.

pub async fn verify_presentation<U, V>(
    &self,
    presentation: &Presentation<U, V>,
    options: &PresentationValidationOptions,
    fail_fast: FailFast,
    holder: Option<&ResolvedIotaDocument>,
    issuers: Option<&[ResolvedIotaDocument]>
) -> Result<(), Error> where
    U: Serialize,
    V: Serialize, 

Verifies a Presentation.

Important

See PresentationValidator::validate for information about which properties get validated and what is expected of the optional arguments holder and issuer.

Resolution

The DID Documents for the holder and issuers are optionally resolved if not given. If you already have up-to-date versions of these DID Documents, you may want to use PresentationValidator::validate. See also Resolver::resolve_presentation_issuers and Resolver::resolve_presentation_holder.

Errors

Errors from resolving the holder and issuer DID Documents, if not provided, will be returned immediately. Otherwise, errors from validating the presentation and its credentials will be returned according to the fail_fast parameter.

Trait Implementations

impl<C> Debug for Resolver<C> where
    C: Debug + SharedPtr<Client>, 

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

Formats the value using the given formatter.

impl TangleResolve for Resolver<Arc<Client>>

fn resolve<'life0, 'life1, 'async_trait>(
    &'life0 self,
    did: &'life1 IotaDID
) -> Pin<Box<dyn Future<Output = Result<ResolvedIotaDocument, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Resolver<Arc<Client>>: 'async_trait, 

Resolves a DID on the Tangle