Struct gsdk::signer::Signer

pub struct Signer {
    pub storage: SignerStorage,
    pub calls: SignerCalls,
    pub rpc: SignerRpc,
    /* private fields */
}

Signer representation that provides access to gear API. Implements low-level methods such as run_tx and force_batch. Other higher-level calls are provided by Signer::storage, Signer::calls, Signer::rpc.

Fields

storage: SignerStorage

Calls that get or set storage.

calls: SignerCalls

Calls for interaction with on-chain programs.

rpc: SignerRpc

Calls to fetch data from node.

Implementations

impl Signer

pub fn backtrace(&self) -> Backtrace

Get backtrace of the signer.

pub fn new(api: Api, suri: &str, passwd: Option<&str>) -> Result<Self>

New signer api.

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

Change inner signer.

pub fn set_nonce(&mut self, nonce: u32)

Set nonce of the signer

Methods from Deref<Target = Inner>

pub async fn log_balance_spent(&self, before: u128) -> Result<()>

Logging balance spent

pub async fn process<'a>(&self, tx: DynamicPayload) -> Result<TxInBlock>

Listen transaction process and print logs.

pub async fn process_sudo( &self, tx: DynamicPayload ) -> Result<ExtrinsicEvents<GearConfig>, Error>

Process sudo transaction.

pub async fn run_tx<'a, Call: CallInfo>( &self, call: Call, fields: impl Into<Composite<()>> ) -> Result<TxInBlock>

Run transaction.

This function allows us to execute any transactions in gear.

You may not need this.

Read the docs of Signer to checkout the wrappred transactions, we need this function only when we want to execute a transaction which has not been wrapped in gsdk.

Example

use gsdk::{
  Api,
  Signer,
  metadata::calls::BalancesCall,
  Value,
};

let api = Api::new(None).await?;
let signer = Signer::new(api, "//Alice", None).await?;

{
    let args = vec![
        Value::unnamed_variant("Id", [Value::from_bytes(dest.into())]),
        Value::u128(value),
    ];
    let in_block = signer.run_tx(BalancesCall::Transfer, args).await?;
}

// The code above euqals to:

{
   let in_block = signer.calls.transfer(dest, value).await?;
}

// ...

pub async fn sudo_run_tx<'a, Call: CallInfo>( &self, call: Call, fields: impl Into<Composite<()>> ) -> Result<ExtrinsicEvents<GearConfig>, Error>

Run transaction with sudo.

pub async fn sudo( &self, call: RuntimeCall ) -> Result<ExtrinsicEvents<GearConfig>, Error>

pallet_sudo::sudo

pub fn address(&self) -> String

Get address of the current signer

pub fn account_id(&self) -> &AccountId32

Get address of the current signer

pub fn api(&self) -> &Api

Get reference to inner unsigned api

Trait Implementations

impl Clone for Signer

fn clone(&self) -> Signer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Deref for Signer

type Target = Inner

The resulting type after dereferencing.

fn deref(&self) -> &Inner

Dereferences the value.

impl From<(Api, PairSigner<GearConfig, Pair>)> for Signer

fn from((api, signer): (Api, PairSigner<GearConfig, Pair>)) -> Self

Converts to this type from the input type.