Struct rosetta_client::Wallet

pub struct Wallet { /* private fields */ }

The wallet provides the main entry point to this crate.

Implementations

impl Wallet

pub fn new( config: BlockchainConfig, signer: &Signer, client: Client ) -> Result<Self>

Creates a new wallet from a config, signer and client.

pub fn config(&self) -> &BlockchainConfig

Returns the blockchain config.

pub fn client(&self) -> &Client

Returns the rosetta client.

pub fn public_key(&self) -> &PublicKey

Returns the public key.

pub fn account(&self) -> &AccountIdentifier

Returns the account identifier.

pub async fn status(&self) -> Result<BlockIdentifier>

Returns the current block identifier.

pub async fn balance(&self) -> Result<Amount>

Returns the balance of the wallet.

pub async fn block(&self, data: PartialBlockIdentifier) -> Result<Block>

Returns block data Takes PartialBlockIdentifier

pub async fn block_transaction( &self, block_identifer: BlockIdentifier, tx_identifier: TransactionIdentifier ) -> Result<BlockTransactionResponse>

Returns transactions included in a block Parameters:

1. block_identifier: BlockIdentifier containing block number and hash
2. tx_identifier: TransactionIdentifier containing hash of transaction

pub async fn call(&self, method: String, params: &Value) -> Result<CallResponse>

Extension of rosetta-api does multiple things

1. fetching storage
2. calling extrinsic/contract

pub async fn coins(&self) -> Result<Vec<Coin>>

Returns the coins of the wallet.

pub async fn metadata(&self, metadata_params: Value) -> Result<Value>

Returns the on chain metadata. Parameters:

• metadata_params: the metadata parameters which we got from transaction builder.

pub async fn submit(&self, transaction: &[u8]) -> Result<TransactionIdentifier>

Submits a transaction and returns the transaction identifier. Parameters:

• transaction: the transaction bytes to submit

pub async fn construct( &self, metadata_params: Value ) -> Result<TransactionIdentifier>

Creates, signs and submits a transaction.

pub async fn transfer( &self, account: &AccountIdentifier, amount: u128 ) -> Result<TransactionIdentifier>

Makes a transfer. Parameters:

• account: the account to transfer to
• amount: the amount to transfer

pub async fn faucet( &self, faucet_parameter: u128 ) -> Result<TransactionIdentifier>

Uses the faucet on dev chains to seed the account with funds. Parameters:

• faucet_parameter: the amount to seed the account with

pub async fn transaction( &self, tx: TransactionIdentifier ) -> Result<BlockTransaction>

Returns the transaction matching the transaction identifier. Parameters:

• tx: the transaction identifier to search for.

pub fn transactions(&self, limit: u16) -> TransactionStream

Returns a stream of transactions associated with the account.

Trait Implementations

impl EthereumExt for Wallet

fn eth_deploy_contract<'life0, 'async_trait>( &'life0 self, bytecode: Vec<u8> ) -> Pin<Box<dyn Future<Output = Result<TransactionIdentifier>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

deploys contract to chain

fn eth_send_call<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, contract_address: &'life1 str, method_signature: &'life2 str, params: &'life3 [String] ) -> Pin<Box<dyn Future<Output = Result<TransactionIdentifier>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

calls contract send call function

fn eth_view_call<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, contract_address: &'life1 str, method_signature: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<CallResponse>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

calls a contract view call function

fn eth_storage<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, contract_address: &'life1 str, storage_slot: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<CallResponse>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

gets storage from ethereum contract

fn eth_storage_proof<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, contract_address: &'life1 str, storage_slot: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<CallResponse>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

gets storage proof from ethereum contract

fn eth_transaction_receipt<'life0, 'life1, 'async_trait>( &'life0 self, tx_hash: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<CallResponse>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

gets transaction receipt of specific hash