Struct gsdk::Api

pub struct Api { /* private fields */ }

Gear api wrapper.

Implementations

impl Api

pub async fn new(uri: impl Into<Option<&str>>) -> Result<Self>

Create new API client.

pub fn builder() -> ApiBuilder

Resolve api builder

pub fn rpc(&self) -> Rpc

Gear RPC Client

pub async fn subscribe_blocks(&self) -> Result<Blocks>

Subscribe all blocks

let api = Api::new(None).await?;
let blocks = api.subscribe_blocks().await?;

while let Ok(block) = blocks.next().await {
  // ...
}

pub async fn subscribe_finalized_blocks(&self) -> Result<Blocks>

Subscribe finalized blocks

Same as subscribe_blocks but only finalized blocks.

pub async fn events(&self) -> Result<Events>

Subscribe all events.

let api = Api::new(None).await?;
let events = api.events().await?;

while let Ok(evs) = events.next().await {
  // ...
}

pub async fn events_of(&self, tx: &TxInBlock) -> Result<Vec<Event>>

Parse events of an extrinsic

pub async fn finalized_events(&self) -> Result<Events>

Subscribe finalized events

Same as events but only finalized events.

pub fn signer(self, suri: &str, passwd: Option<&str>) -> Result<Signer>

New signer from api

impl Api

pub fn gas_limit(&self) -> Result<u64>

pallet gas constants

Get gas limit.

pub fn expected_block_time(&self) -> Result<u64>

pallet babe constant

Get expected block time.

impl Api

pub async fn capture_dispatch_info( &self, tx: &TxInBlock<GearConfig, OnlineClient<GearConfig>>, ) -> Result<TxEvents<GearConfig>>

Capture the dispatch info of any extrinsic and display the weight spent

pub fn capture_weight_info(details: &EventDetails<GearConfig>) -> Result<()>

Parse transaction fee from InBlockEvents

impl Api

pub async fn calculate_create_gas( &self, origin: H256, code_id: CodeId, payload: Vec<u8>, value: u128, allow_other_panics: bool, at: Option<H256>, ) -> Result<GasInfo>

gear_calculateInitCreateGas

pub async fn calculate_upload_gas( &self, origin: H256, code: Vec<u8>, payload: Vec<u8>, value: u128, allow_other_panics: bool, at: Option<H256>, ) -> Result<GasInfo>

gear_calculateInitUploadGas

pub async fn calculate_handle_gas( &self, origin: H256, destination: ProgramId, payload: Vec<u8>, value: u128, allow_other_panics: bool, at: Option<H256>, ) -> Result<GasInfo>

gear_calculateHandleGas

pub async fn calculate_reply_gas( &self, origin: H256, message_id: MessageId, payload: Vec<u8>, value: u128, allow_other_panics: bool, at: Option<H256>, ) -> Result<GasInfo>

gear_calculateReplyGas

pub async fn read_meta_hash(&self, pid: H256, at: Option<H256>) -> Result<H256>

gear_meta_hash

pub async fn read_state( &self, pid: H256, payload: Vec<u8>, at: Option<H256>, ) -> Result<String>

gear_readState

pub async fn read_state_using_wasm( &self, pid: H256, payload: Vec<u8>, method: &str, wasm: Vec<u8>, args: Option<Vec<u8>>, at: Option<H256>, ) -> Result<String>

gear_readStateUsingWasm

pub async fn runtime_wasm_blob_version( &self, at: Option<H256>, ) -> Result<String>

runtime_wasmBlobVersion

pub async fn calculate_reply_for_handle( &self, origin: H256, destination: ProgramId, payload: Vec<u8>, gas_limit: u64, value: u128, at: Option<H256>, ) -> Result<ReplyInfo>

gear_calculateReplyForHandle

impl Api

pub async fn fetch_storage_at<'a, Addr, Value>( &self, address: &'a Addr, block_hash: impl Into<Option<H256>>, ) -> Result<Value>

where Addr: Address<IsFetchable = Yes, IsDefaultable = Yes, Target = DecodedValueThunk> + 'a, Value: Decode,

Shortcut for fetching storage at specified block.

You may not need this.

Read the docs of Api to checkout the wrapped storage queries, we need this function only when we want to execute a query which has not been wrapped in gsdk.

Example

use gsdk::{Api, metadata::storage::SystemStorage};

let api = Api::new(None);

{
    let address = Api::storage(SystemStorage::Number);
    let bn = api.fetch_storage(address).await?;
}

// The code above equals to the following code due to
// the implemented storage query `number` in `Api`.

{
    let bn = api.number().await?;
}

pub async fn fetch_storage<'a, Addr, Value>( &self, address: &'a Addr, ) -> Result<Value>

where Addr: Address<IsFetchable = Yes, IsDefaultable = Yes, Target = DecodedValueThunk> + 'a, Value: Decode,

Shortcut for fetching storage.

You may not need this.

Read the docs of Api to checkout the wrapped storage queries, we need this function only when we want to execute a query which has not been wrapped in gsdk.

Example

use gsdk::{Api, metadata::storage::SystemStorage};

let api = Api::new(None);

{
    let address = Api::storage(SystemStorage::Number);
    let bn = api.fetch_storage(address).await?;
}

// The code above equals to the following code due to
// the implemented storage query `number` in `Api`.

{
    let bn = api.number().await?;
}

pub async fn program_pages(&self, program_id: ProgramId) -> Result<GearPages>

Get program pages from program id.

impl Api

pub async fn info_at( &self, address: &str, block_hash: impl Into<Option<H256>>, ) -> Result<AccountInfo<u32, AccountData<u128>>>

Get account info by address at specified block.

pub async fn info( &self, address: &str, ) -> Result<AccountInfo<u32, AccountData<u128>>>

Get account info by address.

pub async fn number(&self) -> Result<u32>

Get block number.

pub async fn get_balance(&self, address: &str) -> Result<u128>

Get balance by account address.

pub async fn get_events_at( &self, block_hash: impl Into<Option<H256>>, ) -> Result<Vec<RuntimeEvent>>

Get events at specified block.

pub async fn get_events(&self) -> Result<Vec<RuntimeEvent>>

Get events.

impl Api

pub async fn block_timestamp(&self, block_hash: Option<H256>) -> Result<u64>

Return a timestamp of the block.

impl Api

pub async fn validators(&self) -> Result<Vec<AccountId32>>

Get all validators from pallet_session.

impl Api

pub async fn total_issuance_at( &self, block_hash: impl Into<Option<H256>>, ) -> Result<u64>

Get value of gas total issuance at specified block.

pub async fn total_issuance(&self) -> Result<u64>

Get value of gas total issuance.

pub async fn gas_nodes_at( &self, gas_node_ids: &impl AsRef<[GearGasNodeId]>, block_hash: impl Into<Option<H256>>, ) -> Result<Vec<(GearGasNodeId, GearGasNode)>>

Get Gear gas nodes by their ids at specified block.

pub async fn gas_nodes( &self, gas_node_ids: &impl AsRef<[GearGasNodeId]>, ) -> Result<Vec<(GearGasNodeId, GearGasNode)>>

Get Gear gas nodes by their ids.

impl Api

pub async fn bank_info_at( &self, account_id: AccountId32, block_hash: impl Into<Option<H256>>, ) -> Result<BankAccount<u128>>

Get Gear bank account data at specified block.

pub async fn bank_info( &self, account_id: AccountId32, ) -> Result<BankAccount<u128>>

Get Gear bank account data.

impl Api

pub async fn execute_inherent(&self) -> Result<bool>

Check whether the message queue processing is stopped or not.

pub async fn gear_block_number( &self, block_hash: Option<H256>, ) -> Result<BlockNumber>

Get gear block number.

impl Api

pub async fn original_code_storage_at( &self, code_id: CodeId, block_hash: impl Into<Option<H256>>, ) -> Result<Vec<u8>>

Get original code by its CodeId at specified block.

pub async fn original_code_storage(&self, code_id: CodeId) -> Result<Vec<u8>>

Get original code by its CodeId.

pub async fn code_storage_at( &self, code_id: CodeId, block_hash: impl Into<Option<H256>>, ) -> Result<InstrumentedCode>

Get InstrumentedCode by its `CodeId at specified block.

pub async fn code_storage(&self, code_id: CodeId) -> Result<InstrumentedCode>

Get InstrumentedCode by its `CodeId.

pub async fn code_len_storage_at( &self, code_id: CodeId, block_hash: impl Into<Option<H256>>, ) -> Result<u32>

Get InstrumentedCode length by its CodeId at specified block.

pub async fn code_len_storage(&self, code_id: CodeId) -> Result<u32>

Get InstrumentedCode length by its CodeId.

pub async fn gprog_at( &self, program_id: ProgramId, block_hash: impl Into<Option<H256>>, ) -> Result<ActiveProgram<BlockNumber>>

Get active program from program id at specified block.

pub async fn gprog( &self, program_id: ProgramId, ) -> Result<ActiveProgram<BlockNumber>>

Get active program from program id.

pub async fn gpages_at( &self, program_id: ProgramId, memory_infix: Option<u32>, block_hash: impl Into<Option<H256>>, ) -> Result<GearPages>

Get pages of active program at specified block.

pub async fn gpages( &self, program_id: ProgramId, memory_infix: Option<u32>, ) -> Result<GearPages>

Get pages of active program.

pub async fn specified_gpages_at( &self, program_id: ProgramId, memory_infix: Option<u32>, page_numbers: impl Iterator<Item = u32>, block_hash: impl Into<Option<H256>>, ) -> Result<GearPages>

Get pages of active program at specified block.

pub async fn specified_gpages( &self, program_id: ProgramId, memory_infix: Option<u32>, page_numbers: impl Iterator<Item = u32>, ) -> Result<GearPages>

Get pages of active program.

impl Api

pub async fn get_mailbox_account_message( &self, account_id: AccountId32, message_id: impl AsRef<[u8]>, ) -> Result<Option<(UserStoredMessage, Interval<u32>)>>

Get a message identified by message_id from the account_id’s mailbox.

pub async fn mailbox( &self, account_id: Option<AccountId32>, count: u32, ) -> Result<Vec<(UserStoredMessage, Interval<u32>)>>

Get all mailbox messages or for the provided address.

impl Api

pub fn cmp_gas_limit(&self, gas: u64) -> Result<u64>

compare gas limit

pub fn decode_error(&self, dispatch_error: DispatchError) -> Error

Decode DispatchError to subxt::error::Error.

pub async fn get_storage( &self, block_hash: Option<H256>, ) -> Result<Storage<GearConfig, OnlineClient<GearConfig>>>

Get storage from optional block hash.

pub fn storage<T: StorageInfo, Keys: StorageKey>( storage: T, keys: Keys, ) -> DynamicAddress<Keys>

Get the storage address from storage info.

pub fn storage_root<T: StorageInfo>(storage: T) -> DynamicAddress<Vec<Value>>

Get the storage root address from storage info.

Methods from Deref<Target = OnlineClient<GearConfig>>

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 Clone for Api

fn clone(&self) -> Api

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Deref for Api

type Target = OnlineClient<GearConfig>

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for Api

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.