Struct identity_iota::client::Client

pub struct Client { /* private fields */ }

Client for performing IOTA Identity operations on the Tangle.

Implementations

impl Client

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

Creates a new Client with default settings.

pub fn builder() -> ClientBuilder

Creates a ClientBuilder to configure a new Client.

This is the same as ClientBuilder::new.

pub async fn from_builder(builder: ClientBuilder) -> Result<Client, Error>

Creates a new Client based on the ClientBuilder configuration.

pub fn network(&self) -> Network

Returns the IOTA Network that the Client is configured to use.

pub async fn publish_document(
    &self,
    document: &IotaDocument
) -> Result<Receipt, Error>

Publishes an IotaDocument to the Tangle. If retry_until_included is true, this method calls publish_json_with_retry with its default interval and max_attempts values to increase the probability that the message will be referenced by a milestone.

pub async fn publish_diff(
    &self,
    message_id: &MessageId,
    diff: &DiffMessage
) -> Result<Receipt, Error>

👎 Deprecated since 0.5.0:

diff chain features are slated for removal

Publishes a DiffMessage to the Tangle to form part of the diff chain for the integration. chain message specified by the given MessageId.

This method calls publish_json_with_retry with its default interval and max_attempts values for increasing the probability that the message will be referenced by a milestone.

pub async fn publish_json<T>(
    &self,
    index: &str,
    data: &T
) -> Result<Receipt, Error> where
    T: ToJson, 

Compresses and publishes arbitrary JSON data to the specified index on the Tangle.

pub async fn publish_json_with_retry<T>(
    &self,
    index: &str,
    data: &T,
    interval: Option<u64>,
    max_attempts: Option<u64>
) -> Result<Receipt, Error> where
    T: ToJson, 

Publishes arbitrary JSON data to the specified index on the Tangle. Retries (promotes or reattaches) the message until it’s included (referenced by a milestone). Default interval is 5 seconds and max attempts is 40.

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

Fetch the IotaDocument specified by the given IotaDID.

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

Fetches a DocumentChain given an IotaDID.

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

Returns 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

Returns the ChainHistory of a diff chain starting from an IotaDocument on the integration chain.

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

pub async fn is_message_included(
    &self,
    message_id: &MessageId
) -> Result<bool, Error>

Checks if a message is confirmed by a milestone.

Trait Implementations

impl Debug for Client

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

Formats the value using the given formatter.

impl TangleResolve for 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,
    Client: 'async_trait, 

Resolves a DID on the Tangle