Struct solana_program_test::BanksClient

pub struct BanksClient { /* private fields */ }

Implementations

impl BanksClient

pub fn new<C>(
    config: Config,
    transport: C
) -> NewClient<BanksClient<Channel<BanksRequest, BanksResponse>>, RequestDispatch<BanksRequest, BanksResponse, C>> where
    C: Transport<ClientMessage<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 get_block_height_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>>

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

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_clock(&mut self) -> impl Future<Output = Result<Clock, Error>>

Return the cluster clock

pub fn get_fees(
    &mut self
) -> impl Future<Output = Result<(FeeCalculator, Hash, u64), Error>>

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_sysvar<T>(&mut self) -> impl Future<Output = Result<T, Error>> where
    T: Sysvar, 

Return the cluster Sysvar

pub fn get_rent(&mut self) -> impl Future<Output = Result<Rent, Error>>

Return the cluster rent

pub fn get_recent_blockhash(
    &mut self
) -> impl Future<Output = Result<Hash, Error>>

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(
    &mut self,
    transaction: Transaction,
    commitment: CommitmentLevel
) -> impl Future<Output = Result<(), TransportError>>

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

pub fn process_transaction(
    &mut self,
    transaction: Transaction
) -> impl Future<Output = Result<(), TransportError>>

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

pub async fn process_transactions_with_commitment(
    &'_ mut self,
    transactions: Vec<Transaction, Global>,
    commitment: CommitmentLevel
) -> Result<(), TransportError>

pub fn process_transactions(
    &mut self,
    transactions: Vec<Transaction, Global>
) -> impl Future<Output = Result<(), TransportError>>

Send transactions and return until the transaction has been finalized or rejected.

pub fn get_root_slot(&mut self) -> impl Future<Output = Result<u64, Error>>

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

pub fn get_root_block_height(
    &mut self
) -> impl Future<Output = Result<u64, Error>>

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

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

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(
    &mut self,
    address: Pubkey
) -> impl Future<Output = Result<Option<Account>, Error>>

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_packed_account_data<T>(
    &mut self,
    address: Pubkey
) -> impl Future<Output = Result<T, Error>> where
    T: Pack, 

Return the unpacked account data at the given address If the account is not found, an error is returned

pub fn get_account_data_with_borsh<T>(
    &mut self,
    address: Pubkey
) -> impl Future<Output = Result<T, Error>> where
    T: BorshDeserialize, 

Return the unpacked account data at the given address If the account is not found, an error is returned

pub fn get_balance_with_commitment(
    &mut self,
    address: Pubkey,
    commitment: CommitmentLevel
) -> impl Future<Output = Result<u64, Error>>

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(
    &mut self,
    address: Pubkey
) -> impl Future<Output = Result<u64, Error>>

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(
    &mut self,
    signature: Signature
) -> impl Future<Output = Result<Option<TransactionStatus>, Error>>

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 async fn get_transaction_statuses(
    &'_ mut self,
    signatures: Vec<Signature, Global>
) -> Result<Vec<Option<TransactionStatus>, Global>, Error>

Same as get_transaction_status, but for multiple transactions.

Trait Implementations

impl Clone for BanksClient

pub fn clone(&self) -> BanksClient

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ProgramTestBanksClientExt for BanksClient

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

Get a new blockhash, similar in spirit to RpcClient::get_new_blockhash()

This probably should eventually be moved into BanksClient proper in some form