Struct ThinClient

pub struct ThinClient<P, M, C> { /* private fields */ }

An object for querying and sending transactions to the network.

Implementations

impl<P, M, C> ThinClient<P, M, C>

where P: ConnectionPool<NewConnectionConfig = C>, M: ConnectionManager<ConnectionPool = P, NewConnectionConfig = C>, C: NewConnectionConfig,

pub fn new( rpc_addr: SocketAddr, tpu_addr: SocketAddr, connection_cache: Arc<ConnectionCache<P, M, C>>, ) -> Self

Create a new ThinClient that will interface with the Rpc at rpc_addr using TCP and the Tpu at tpu_addr over transactions_socket using Quic or UDP (currently hardcoded to UDP)

pub fn new_socket_with_timeout( rpc_addr: SocketAddr, tpu_addr: SocketAddr, timeout: Duration, connection_cache: Arc<ConnectionCache<P, M, C>>, ) -> Self

pub fn new_from_addrs( rpc_addrs: Vec<SocketAddr>, tpu_addrs: Vec<SocketAddr>, connection_cache: Arc<ConnectionCache<P, M, C>>, ) -> Self

pub fn rpc_client(&self) -> &RpcClient

pub fn retry_transfer_until_confirmed( &self, keypair: &Keypair, transaction: &mut Transaction, tries: usize, min_confirmed_blocks: usize, ) -> TransportResult<Signature>

Retry a sending a signed Transaction to the server for processing.

pub fn retry_transfer( &self, keypair: &Keypair, transaction: &mut Transaction, tries: usize, ) -> TransportResult<Signature>

Retry sending a signed Transaction with one signing Keypair to the server for processing.

pub fn send_and_confirm_transaction<T: Signers + ?Sized>( &self, keypairs: &T, transaction: &mut Transaction, tries: usize, pending_confirmations: usize, ) -> TransportResult<Signature>

pub fn poll_get_balance(&self, pubkey: &Pubkey) -> TransportResult<u64>

pub fn poll_get_balance_with_commitment( &self, pubkey: &Pubkey, commitment_config: CommitmentConfig, ) -> TransportResult<u64>

pub fn wait_for_balance( &self, pubkey: &Pubkey, expected_balance: Option<u64>, ) -> Option<u64>

pub fn get_program_accounts_with_config( &self, pubkey: &Pubkey, config: RpcProgramAccountsConfig, ) -> TransportResult<Vec<(Pubkey, Account)>>

pub fn wait_for_balance_with_commitment( &self, pubkey: &Pubkey, expected_balance: Option<u64>, commitment_config: CommitmentConfig, ) -> Option<u64>

pub fn poll_for_signature_with_commitment( &self, signature: &Signature, commitment_config: CommitmentConfig, ) -> TransportResult<()>

pub fn get_num_blocks_since_signature_confirmation( &mut self, sig: &Signature, ) -> TransportResult<usize>

Trait Implementations

impl<P, M, C> AsyncClient for ThinClient<P, M, C>

where P: ConnectionPool<NewConnectionConfig = C>, M: ConnectionManager<ConnectionPool = P, NewConnectionConfig = C>, C: NewConnectionConfig,

fn async_send_versioned_transaction( &self, transaction: VersionedTransaction, ) -> TransportResult<Signature>

Send a signed versioned transaction, but don’t wait to see if the server accepted it.

fn async_send_versioned_transaction_batch( &self, batch: Vec<VersionedTransaction>, ) -> TransportResult<()>

Send a batch of signed versioned transactions without confirmation.

fn async_send_transaction( &self, transaction: Transaction, ) -> Result<Signature, TransportError>

Send a signed transaction, but don’t wait to see if the server accepted it.

fn async_send_batch( &self, transactions: Vec<Transaction>, ) -> Result<(), TransportError>

Send a batch of signed transactions without confirmation.

fn async_send_message<T>( &self, keypairs: &T, message: Message, recent_blockhash: Hash, ) -> Result<Signature, TransportError>

where T: Signers + ?Sized,

Create a transaction from the given message, and send it to the server, but don’t wait for to see if the server accepted it.

fn async_send_instruction( &self, keypair: &Keypair, instruction: Instruction, recent_blockhash: Hash, ) -> Result<Signature, TransportError>

Create a transaction from a single instruction that only requires a single signer. Then send it to the server, but don’t wait for a reply.

fn async_transfer( &self, lamports: u64, keypair: &Keypair, pubkey: &Pubkey, recent_blockhash: Hash, ) -> Result<Signature, TransportError>

Attempt to transfer lamports from keypair to pubkey, but don’t wait to confirm.

impl<P, M, C> Client for ThinClient<P, M, C>

where P: ConnectionPool<NewConnectionConfig = C>, M: ConnectionManager<ConnectionPool = P, NewConnectionConfig = C>, C: NewConnectionConfig,

fn tpu_addr(&self) -> String

impl<P, M, C> SyncClient for ThinClient<P, M, C>

where P: ConnectionPool<NewConnectionConfig = C>, M: ConnectionManager<ConnectionPool = P, NewConnectionConfig = C>, C: NewConnectionConfig,

fn poll_for_signature_confirmation( &self, signature: &Signature, min_confirmed_blocks: usize, ) -> TransportResult<usize>

Poll the server until the signature has been confirmed by at least min_confirmed_blocks

fn send_and_confirm_message<T: Signers + ?Sized>( &self, keypairs: &T, message: Message, ) -> TransportResult<Signature>

Create a transaction from the given message, and send it to the server, retrying as-needed.

fn send_and_confirm_instruction( &self, keypair: &Keypair, instruction: Instruction, ) -> TransportResult<Signature>

Create a transaction from a single instruction that only requires a single signer. Then send it to the server, retrying as-needed.

fn transfer_and_confirm( &self, lamports: u64, keypair: &Keypair, pubkey: &Pubkey, ) -> TransportResult<Signature>

Transfer lamports from keypair to pubkey, retrying until the transfer completes or produces and error.

fn get_account_data(&self, pubkey: &Pubkey) -> TransportResult<Option<Vec<u8>>>

Get an account or None if not found.

fn get_account(&self, pubkey: &Pubkey) -> TransportResult<Option<Account>>

Get an account or None if not found.

fn get_account_with_commitment( &self, pubkey: &Pubkey, commitment_config: CommitmentConfig, ) -> TransportResult<Option<Account>>

Get an account or None if not found. Uses explicit commitment configuration.

fn get_balance(&self, pubkey: &Pubkey) -> TransportResult<u64>

Get account balance or 0 if not found.

fn get_balance_with_commitment( &self, pubkey: &Pubkey, commitment_config: CommitmentConfig, ) -> TransportResult<u64>

Get account balance or 0 if not found. Uses explicit commitment configuration.

fn get_minimum_balance_for_rent_exemption( &self, data_len: usize, ) -> TransportResult<u64>

fn get_recent_blockhash(&self) -> TransportResult<(Hash, FeeCalculator)>

👎Deprecated since 1.9.0: Please use get_latest_blockhash instead

Get recent blockhash

fn get_recent_blockhash_with_commitment( &self, commitment_config: CommitmentConfig, ) -> TransportResult<(Hash, FeeCalculator, Slot)>

👎Deprecated since 1.9.0: Please use get_latest_blockhash_with_commitment and get_latest_blockhash_with_commitment instead

Get recent blockhash. Uses explicit commitment configuration.

fn get_fee_calculator_for_blockhash( &self, blockhash: &Hash, ) -> TransportResult<Option<FeeCalculator>>

👎Deprecated since 1.9.0: Please use get_fee_for_message or is_blockhash_valid instead

Get Some(FeeCalculator) associated with blockhash if it is still in the BlockhashQueue, otherwise None`

fn get_fee_rate_governor(&self) -> TransportResult<FeeRateGovernor>

👎Deprecated since 1.9.0: Please do not use, will no longer be available in the future

Get recent fee rate governor

fn get_signature_status( &self, signature: &Signature, ) -> TransportResult<Option<Result<()>>>

Get signature status.

fn get_signature_status_with_commitment( &self, signature: &Signature, commitment_config: CommitmentConfig, ) -> TransportResult<Option<Result<()>>>

Get signature status. Uses explicit commitment configuration.

fn get_slot(&self) -> TransportResult<u64>

Get last known slot

fn get_slot_with_commitment( &self, commitment_config: CommitmentConfig, ) -> TransportResult<u64>

Get last known slot. Uses explicit commitment configuration.

fn get_epoch_info(&self) -> TransportResult<EpochInfo>

fn get_transaction_count(&self) -> TransportResult<u64>

Get transaction count

fn get_transaction_count_with_commitment( &self, commitment_config: CommitmentConfig, ) -> TransportResult<u64>

Get transaction count. Uses explicit commitment configuration.

fn poll_for_signature(&self, signature: &Signature) -> TransportResult<()>

Poll to confirm a transaction.

fn get_new_blockhash( &self, blockhash: &Hash, ) -> TransportResult<(Hash, FeeCalculator)>

👎Deprecated since 1.9.0: Please do not use, will no longer be available in the future

fn get_latest_blockhash(&self) -> TransportResult<Hash>

Get last known blockhash

fn get_latest_blockhash_with_commitment( &self, commitment_config: CommitmentConfig, ) -> TransportResult<(Hash, u64)>

Get latest blockhash with last valid block height. Uses explicit commitment configuration.

fn is_blockhash_valid( &self, blockhash: &Hash, commitment_config: CommitmentConfig, ) -> TransportResult<bool>

Check if the blockhash is valid

fn get_fee_for_message(&self, message: &Message) -> TransportResult<u64>

Calculate the fee for a Message