Struct solana_banks_client::BanksClient

pub struct BanksClient<C = Channel<BanksRequest, BanksResponse>>(_);

The client stub that makes RPC calls to the server. Exposes a Future interface.

Implementations

impl BanksClient<Channel<BanksRequest, BanksResponse>>

pub fn new<T>(
    config: Config,
    transport: T
) -> NewClient<BanksClient<Channel<BanksRequest, BanksResponse>>, RequestDispatch<BanksRequest, BanksResponse, T>> where
    T: Transport<ClientMessage<BanksRequest>, Response<BanksResponse>>, 

Returns a new client stub that sends requests over the given transport.

impl<C> BanksClient<C> where
    C: for<'a> Client<'a, BanksRequest, Response = BanksResponse>, 

pub fn send_transaction_with_context(
    &mut self,
    ctx: Context,
    transaction: Transaction
) -> impl Future<Output = Result<(), Error>>

pub fn get_fees_with_commitment_and_context(
    &mut self,
    ctx: Context,
    commitment: CommitmentLevel
) -> impl Future<Output = Result<(FeeCalculator, Hash, u64), Error>>

pub fn get_transaction_status_with_context(
    &mut self,
    ctx: Context,
    signature: Signature
) -> impl Future<Output = Result<Option<TransactionStatus>, Error>>

pub fn get_slot_with_context(
    &mut self,
    ctx: Context,
    commitment: CommitmentLevel
) -> impl Future<Output = Result<u64, Error>>

pub fn process_transaction_with_commitment_and_context(
    &mut self,
    ctx: Context,
    transaction: Transaction,
    commitment: CommitmentLevel
) -> impl Future<Output = Result<Option<Result<(), TransactionError>>, Error>>

pub fn get_account_with_commitment_and_context(
    &mut self,
    ctx: Context,
    address: Pubkey,
    commitment: CommitmentLevel
) -> impl Future<Output = Result<Option<Account>, Error>>

Trait Implementations

impl BanksClientExt for BanksClient

pub fn send_transaction<'life0, 'async_trait>(
    &'life0 mut self,
    transaction: Transaction
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Send a transaction and return immediately. The server will resend the transaction until either it is accepted by the cluster or the transaction's blockhash expires.

pub fn get_fees<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(FeeCalculator, Hash, Slot)>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Return the fee parameters associated with a recent, rooted blockhash. The cluster will use the transaction's blockhash to look up these same fee parameters and use them to calculate the transaction fee.

pub fn get_rent<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Rent>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Return the cluster rent

pub fn get_recent_blockhash<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Hash>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Return a recent, rooted blockhash from the server. The cluster will only accept transactions with a blockhash that has not yet expired. Use the get_fees method to get both a blockhash and the blockhash's last valid slot.

pub fn process_transaction_with_commitment<'life0, 'async_trait>(
    &'life0 mut self,
    transaction: Transaction,
    commitment: CommitmentLevel
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Send a transaction and return after the transaction has been rejected or reached the given level of commitment.

pub fn process_transaction<'life0, 'async_trait>(
    &'life0 mut self,
    transaction: Transaction
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Send a transaction and return after the transaction has been finalized or rejected.

pub fn get_root_slot<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Slot>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Return the most recent rooted slot height. All transactions at or below this height are said to be finalized. The cluster will not fork to a higher slot height.

pub fn get_account_with_commitment<'life0, 'async_trait>(
    &'life0 mut self,
    address: Pubkey,
    commitment: CommitmentLevel
) -> Pin<Box<dyn Future<Output = Result<Option<Account>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Return the account at the given address at the slot corresponding to the given commitment level. If the account is not found, None is returned.

pub fn get_account<'life0, 'async_trait>(
    &'life0 mut self,
    address: Pubkey
) -> Pin<Box<dyn Future<Output = Result<Option<Account>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Return the account at the given address at the time of the most recent root slot. If the account is not found, None is returned.

pub fn get_balance_with_commitment<'life0, 'async_trait>(
    &'life0 mut self,
    address: Pubkey,
    commitment: CommitmentLevel
) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Return the balance in lamports of an account at the given address at the slot corresponding to the given commitment level.

pub fn get_balance<'life0, 'async_trait>(
    &'life0 mut self,
    address: Pubkey
) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Return the balance in lamports of an account at the given address at the time of the most recent root slot.

pub fn get_transaction_status<'life0, 'async_trait>(
    &'life0 mut self,
    signature: Signature
) -> Pin<Box<dyn Future<Output = Result<Option<TransactionStatus>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Return the status of a transaction with a signature matching the transaction's first signature. Return None if the transaction is not found, which may be because the blockhash was expired or the fee-paying account had insufficient funds to pay the transaction fee. Note that servers rarely store the full transaction history. This method may return None if the transaction status has been discarded.

pub fn get_transaction_statuses<'life0, 'async_trait>(
    &'life0 mut self,
    signatures: Vec<Signature>
) -> Pin<Box<dyn Future<Output = Result<Vec<Option<TransactionStatus>>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Same as get_transaction_status, but for multiple transactions.

impl<C> Clone for BanksClient<C> where
    C: Clone, 

pub fn clone(&self) -> BanksClient<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C> Debug for BanksClient<C> where
    C: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<C> From<C> for BanksClient<C> where
    C: for<'a> Client<'a, BanksRequest, Response = BanksResponse>, 

pub fn from(client: C) -> BanksClient<C>

Performs the conversion.