Struct TangleClient 

pub struct TangleClient {
    pub config: BlueprintEnvironment,
    /* private fields */
}

Fields

config: BlueprintEnvironment

Implementations

impl TangleClient

pub async fn new(config: BlueprintEnvironment) -> Result<Self, Error>

Create a new Tangle runtime client from an existing BlueprintEnvironment.

Errors

See Keystore::new() See Self::with_keystore()

pub async fn with_keystore( config: BlueprintEnvironment, keystore: Keystore, ) -> Result<Self, Error>

Create a new Tangle runtime client from an existing BlueprintEnvironment and a Keystore.

Errors

See subxt::OnlineClient::from_url()

pub fn services_client(&self) -> &TangleServicesClient<PolkadotConfig>

Get the associated TangleServicesClient

pub fn subxt_client(&self) -> &OnlineClient

pub fn runtime_api( &self, at: [u8; 32], ) -> RuntimeApi<TangleConfig, OnlineClient>

pub fn account_id(&self) -> &AccountId32

pub async fn operator_metadata( &self, operator: AccountId32, ) -> Result<Option<OperatorMetadata<AccountId32, Balance, AssetId, MaxDelegations, MaxOperatorBlueprints>>, Error>

Get metadata for an operator by Account ID

pub async fn get_party_index_and_operators( &self, ) -> Result<(usize, BTreeMap<AccountId32, Public>), Error>

Retrieves the current party index and operator mapping

Errors

Returns an error if:

• Failed to retrieve operator keys
• Current party is not found in the operator list

pub async fn now(&self) -> Option<[u8; 32]>

Methods from Deref<Target = TangleServicesClient<TangleConfig>>

pub async fn get_blueprint_by_id( &self, at: [u8; 32], blueprint_id: u64, ) -> Result<Option<ServiceBlueprint>>

Get the Blueprint with the given ID at the given block

Errors

Returns an error if the Blueprint could not be fetched

pub async fn query_operator_blueprints( &self, at_block: [u8; 32], address: AccountId32, ) -> Result<Vec<RpcServicesWithBlueprint>>

Get the Blueprints provided by the operator at address

Errors

Returns an error if the Blueprints could not be fetched

pub async fn current_blueprint_owner( &self, at: [u8; 32], blueprint_id: u64, ) -> Result<AccountId32>

Query the current Blueprint owner

pub async fn current_service_operators( &self, at: [u8; 32], service_id: u64, ) -> Result<Vec<(AccountId32, Vec<AssetSecurityCommitment<u128>>)>>

Get the current service operators with their restake exposure

pub async fn current_service_request_arguments( &self, service_id: u64, ) -> Result<RequestArgs>

Get the current service operators with their restake exposure

Methods from Deref<Target = OnlineClient<C>>

pub fn updater(&self) -> ClientRuntimeUpdater<T>

Create an object which can be used to keep the runtime up to date in a separate thread.

Example

use subxt::{ OnlineClient, PolkadotConfig };

let client = OnlineClient::<PolkadotConfig>::new().await.unwrap();

// high level API.

let update_task = client.updater();
tokio::spawn(async move {
    update_task.perform_runtime_updates().await;
});


// low level API.

let updater = client.updater();
tokio::spawn(async move {
    let mut update_stream = updater.runtime_updates().await.unwrap();

    while let Some(Ok(update)) = update_stream.next().await {
        let version = update.runtime_version().spec_version;

        match updater.apply_update(update) {
            Ok(()) => {
                println!("Upgrade to version: {} successful", version)
            }
            Err(e) => {
               println!("Upgrade to version {} failed {:?}", version, e);
            }
       };
    }
});

pub fn metadata(&self) -> Metadata

Return the Metadata used in this client.

pub fn set_metadata(&self, metadata: impl Into<Metadata>)

Change the Metadata used in this client.

Warning

Setting custom metadata may leave Subxt unable to work with certain blocks, subscribe to latest blocks or submit valid transactions.

pub fn genesis_hash(&self) -> <T as Config>::Hash

Return the genesis hash.

pub fn set_genesis_hash(&self, genesis_hash: <T as Config>::Hash)

Change the genesis hash used in this client.

Warning

Setting a custom genesis hash may leave Subxt unable to submit valid transactions.

pub fn runtime_version(&self) -> RuntimeVersion

Return the runtime version.

pub fn set_runtime_version(&self, runtime_version: RuntimeVersion)

Change the RuntimeVersion used in this client.

Warning

Setting a custom runtime version may leave Subxt unable to submit valid transactions.

pub fn backend(&self) -> &(dyn Backend<T> + 'static)

Return an RPC client to make raw requests with.

pub fn offline(&self) -> OfflineClient<T>

Return an offline client with the same configuration as this.

pub fn tx(&self) -> TxClient<T, OnlineClient<T>>

Work with transactions.

pub fn events(&self) -> EventsClient<T, OnlineClient<T>>

Work with events.

pub fn storage(&self) -> StorageClient<T, OnlineClient<T>>

Work with storage.

pub fn constants(&self) -> ConstantsClient<T, OnlineClient<T>>

Access constants.

pub fn custom_values(&self) -> CustomValuesClient<T, OnlineClient<T>>

Access custom types.

pub fn blocks(&self) -> BlocksClient<T, OnlineClient<T>>

Work with blocks.

pub fn runtime_api(&self) -> RuntimeApiClient<T, OnlineClient<T>>

Work with runtime API.

Trait Implementations

impl BlueprintServicesClient for TangleClient

async fn get_operators( &self, ) -> Result<OperatorSet<Self::PublicAccountIdentity, Self::PublicApplicationIdentity>, Self::Error>

Retrieves the ECDSA keys for all current service operators

Errors

Returns an error if:

• Failed to connect to the Tangle client
• Failed to retrieve operator information
• Missing ECDSA key for any operator

async fn blueprint_id(&self) -> Result<Self::Id, Self::Error>

Retrieves the current blueprint ID from the configuration

Errors

Returns an error if the blueprint ID is not found in the configuration

type PublicApplicationIdentity = CryptoBytes<sp_core::::ecdsa::Public::{constant#0}, (PublicTag, EcdsaTag)>

The ID of for operators at the blueprint/application layer. Typically a cryptograpgic key in the form of a point on some elliptic curve, e.g., an ECDSA public key (point). However, this is not required.

type PublicAccountIdentity = AccountId32

The ID of the operator’s account, not necessarily associated with the PublicApplicationIdentity, but may be cryptographically related thereto. E.g., AccountId32

type Id = u64

A generalized ID that distinguishes the current blueprint from others

type Error = Error

async fn operator_id( &self, ) -> Result<Self::PublicApplicationIdentity, Self::Error>

Returns the ID of the operator

async fn get_operators_and_operator_id( &self, ) -> Result<(BTreeMap<usize, Self::PublicApplicationIdentity>, usize), Self::Error>

Returns an operator set with the index of the current operator within that set

async fn get_operator_index(&self) -> Result<usize, Self::Error>

Returns the index of the current operator in the operator set

impl Clone for TangleClient

fn clone(&self) -> TangleClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Deref for TangleClient

type Target = TangleServicesClient<PolkadotConfig>

The resulting type after dereferencing.

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

Dereferences the value.

impl EventsClient<TangleEvent> for TangleClient

async fn next_event(&self) -> Option<TangleEvent>

Fetch the next event from the client.

async fn latest_event(&self) -> Option<TangleEvent>

Fetch the latest event from the client.