Struct solana_client::thin_client::ThinClient

pub struct ThinClient { /* fields omitted */ }

An object for querying and sending transactions to the network.

Methods

impl ThinClient

pub fn new(
    rpc_addr: SocketAddr,
    tpu_addr: SocketAddr,
    transactions_socket: UdpSocket
) -> 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 UDP.

pub fn new_socket_with_timeout(
    rpc_addr: SocketAddr,
    tpu_addr: SocketAddr,
    transactions_socket: UdpSocket,
    timeout: Duration
) -> Self

pub fn new_from_addrs(
    rpc_addrs: Vec<SocketAddr>,
    tpu_addrs: Vec<SocketAddr>,
    transactions_socket: UdpSocket
) -> Self

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

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

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

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

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

Retry sending a signed Transaction to the server for processing

pub fn poll_balance_with_timeout_and_commitment(
    &self,
    pubkey: &Pubkey,
    polling_frequency: &Duration,
    timeout: &Duration,
    commitment_config: CommitmentConfig
) -> Result<u64>

pub fn poll_balance_with_timeout(
    &self,
    pubkey: &Pubkey,
    polling_frequency: &Duration,
    timeout: &Duration
) -> Result<u64>

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

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

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

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 check_signature(&self, signature: &Signature) -> bool

Check a signature in the bank. This method blocks until the server sends a response.

pub fn validator_exit(&self) -> Result<bool>

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

Trait Implementations

impl AsyncClient for ThinClient

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

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

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

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>

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>

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

impl Client for ThinClient

fn tpu_addr(&self) -> String

impl SyncClient for ThinClient

fn send_message<T: Signers>(
    &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_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(
    &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_recent_blockhash(&self) -> TransportResult<(Hash, FeeCalculator)>

Get recent blockhash

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

Get recent blockhash. Uses explicit commitment configuration.

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_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_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 poll_for_signature(&self, signature: &Signature) -> TransportResult<()>

Poll to confirm a transaction.

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