Struct IdentityClient 

pub struct IdentityClient<S = NoSigner> { /* private fields */ }

A client for interacting with the IOTA Identity framework.

Implementations

impl IdentityClient

pub async fn from_iota_client( iota_client: IotaClient, custom_package_id: impl Into<Option<ObjectID>>, ) -> Result<IdentityClient, FromIotaClientError>

Creates a new IdentityClient, with no signing capabilities, from the given [IotaClient].

Warning

Passing a custom_package_id is only required when connecting to a custom IOTA network.

Relying on a custom Identity package when connected to an official IOTA network is highly discouraged and is sure to result in compatibility issues when interacting with other official IOTA Trust Framework’s products.

Examples

let iota_client = iota_sdk::IotaClientBuilder::default()
  .build_testnet()
  .await?;
// No package ID is required since we are connecting to an official IOTA network.
let identity_client = IdentityClient::from_iota_client(iota_client, None).await?;

impl<S> IdentityClient<S>

where S: Signer<IotaKeySignature>,

pub async fn new( client: IdentityClientReadOnly, signer: S, ) -> Result<IdentityClient<S>, Error>

👎Deprecated since 1.9.0: Use IdentityClient::from_iota_client instead

Creates a new IdentityClient.

pub fn public_key(&self) -> &PublicKey

Returns a reference to the [PublicKey] wrapped by this client.

pub fn address(&self) -> IotaAddress

Returns the [IotaAddress] wrapped by this client.

pub async fn controlled_dids( &self, ) -> Result<Vec<IotaDID>, QueryControlledDidsError>

Returns the list of all unique DIDs the address wrapped by this client can access as a controller.

impl<S> IdentityClient<S>

pub fn create_identity(&self, iota_document: IotaDocument) -> IdentityBuilder

Returns a new IdentityBuilder in order to build a new crate::rebased::migration::OnChainIdentity.

pub fn create_authenticated_asset<T>( &self, content: T, ) -> AuthenticatedAssetBuilder<T>

where T: MoveType + DeserializeOwned + Send + Sync + PartialEq,

Returns a new IdentityBuilder in order to build a new crate::rebased::migration::OnChainIdentity.

pub async fn with_signer<NewS>( self, signer: NewS, ) -> Result<IdentityClient<NewS>, Error>

where NewS: Signer<IotaKeySignature>,

Sets a new signer for this client.

impl<S> IdentityClient<S>

where S: Signer<IotaKeySignature> + OptionalSync,

pub fn publish_did_document( &self, document: IotaDocument, ) -> TransactionBuilder<PublishDidDocument>

Returns a PublishDidDocument transaction wrapped by a [TransactionBuilder].

pub async fn publish_did_document_update( &self, document: IotaDocument, gas_budget: u64, ) -> Result<IotaDocument, Error>

Updates a DID Document.

pub async fn deactivate_did_output( &self, did: &IotaDID, gas_budget: u64, ) -> Result<(), Error>

Deactivates a DID document.

pub async fn publish_did_update( &self, did_document: IotaDocument, ) -> Result<TransactionBuilder<ShorthandDidUpdate>, MakeUpdateDidDocTxError>

A shorthand for OnChainIdentity::update_did_document’s DID Document.

This method makes the following assumptions:

• The given did_document has already been published on-chain within an Identity.
• This IdentityClient is a controller of the corresponding Identity with enough voting power to execute the transaction without any other controller approval.

pub async fn find_owned_ref<P>( &self, tag: StructTag, predicate: P, ) -> Result<Option<(ObjectID, SequenceNumber, ObjectDigest)>, Error>

where P: Fn(&IotaObjectData) -> bool,

Query the objects owned by the address wrapped by this client to find the object of type tag and that satisfies predicate.

Methods from Deref<Target = IdentityClientReadOnly>

pub fn package_id(&self) -> ObjectID

Returns iota_identity’s package ID. The ID of the packages depends on the network the client is connected to.

pub fn network(&self) -> &NetworkName

Returns the name of the network the client is currently connected to.

pub fn chain_id(&self) -> &str

Returns the chain identifier for the network this client is connected to. This method differs from IdentityClientReadOnly::network as it doesn’t return the human-readable network ID when available.

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

Queries an IotaDocument DID Document through its did.

pub async fn get_identity(&self, object_id: ObjectID) -> Result<Identity, Error>

Resolves an Identity from its ID object_id.

pub async fn dids_controlled_by( &self, address: IotaAddress, ) -> Result<Vec<IotaDID>, QueryControlledDidsError>

Returns the list of all unique DIDs the given address has access to as a controller.

Notes

For a streaming version of this API see dids_controlled_by_streamed.

Errors

This method might return a QueryControlledDidsError when the underlying RPC call fails. QueryControlledDidsError’s source can be downcasted to SDK’s Error in order to check whether calling this method again might return a successful result.

Example

let address = "0x666638f5118b8f894c4e60052f9bc47d6fcfb04fdb990c9afbb988848b79c475".parse()?;
let controlled_dids = identity_client.dids_controlled_by(address).await?;
assert_eq!(
  controlled_dids,
  vec![IotaDID::parse(
    "did:iota:testnet:0x052cfb920024f7a640dc17f7f44c6042ea0038d26972c2cff5c7ba31c82fbb08"
  )?]
);

Trait Implementations

impl<S> Clone for IdentityClient<S>

where S: Clone,

fn clone(&self) -> IdentityClient<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> CoreClient<S> for IdentityClient<S>

where S: Signer<IotaKeySignature> + OptionalSync,

fn sender_address(&self) -> IotaAddress

Returns this Client’s sender address

fn signer(&self) -> &S

Returns the signer of the client.

fn sender_public_key(&self) -> &PublicKey

Returns the bytes of the sender’s public key.

impl<S> CoreClientReadOnly for IdentityClient<S>

where S: OptionalSync,

fn client_adapter(&self) -> &IotaClientRustSdk

Returns the underlying [IotaClientAdapter] used by this client.

fn package_id(&self) -> ObjectID

Returns the package ID associated with the Client.

fn package_history(&self) -> Vec<ObjectID>

Returns the IDs of all packages version, from initial to current.

fn network_name(&self) -> &NetworkName

Returns the name of the network the client is connected to.

fn get_object_by_id<'life0, 'async_trait, T>( &'life0 self, object_id: ObjectID, ) -> Pin<Box<dyn Future<Output = Result<T, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, T: 'async_trait + DeserializeOwned, Self: Sync + 'async_trait,

Retrieves a Move Object by its ID.

fn get_object_ref_by_id<'life0, 'async_trait>( &'life0 self, object_id: ObjectID, ) -> Pin<Box<dyn Future<Output = Result<Option<OwnedObjectRef>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Retrieves an object’s [OwnedObjectRef], if any.

fn find_object_for_address<'life0, 'async_trait, T, P>( &'life0 self, address: IotaAddress, predicate: P, ) -> Pin<Box<dyn Future<Output = Result<Option<T>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, T: MoveType + DeserializeOwned + 'async_trait, P: Fn(&T) -> bool + Send + 'async_trait, Self: Sync + 'async_trait,

Retrieves an object owned by the specified address that matches the given predicate.

fn get_iota_coins_with_at_least_balance<'life0, 'async_trait>( &'life0 self, owner: IotaAddress, balance: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<(ObjectID, SequenceNumber, ObjectDigest)>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Retrieves coins owned by the specified address with a balance of at least balance.

fn find_owned_ref_for_address<'life0, 'async_trait, P>( &'life0 self, address: IotaAddress, tag: StructTag, predicate: P, ) -> Pin<Box<dyn Future<Output = Result<Option<(ObjectID, SequenceNumber, ObjectDigest)>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, P: Fn(&IotaObjectData) -> bool + Send + 'async_trait, Self: Sync + 'async_trait,

Queries the object owned by this sender address and returns the first one that matches tag and for which predicate returns true.

impl<S> Deref for IdentityClient<S>

type Target = IdentityClientReadOnly

The resulting type after dereferencing.

fn deref(&self) -> &<IdentityClient<S> as Deref>::Target

Dereferences the value.