Struct solana_tpu_client::tpu_client::TpuClient

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

Client which sends transactions directly to the current leader’s TPU port over UDP. The client uses RPC to determine the current leader and fetch node contact info

Implementations

impl<P, M, C> TpuClient<P, M, C>

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

pub fn send_transaction(&self, transaction: &Transaction) -> bool

Serialize and send transaction to the current and upcoming leader TPUs according to fanout size

pub fn send_wire_transaction(&self, wire_transaction: Vec<u8>) -> bool

Send a wire transaction to the current and upcoming leader TPUs according to fanout size

pub fn try_send_transaction( &self, transaction: &Transaction, ) -> TransportResult<()>

Serialize and send transaction to the current and upcoming leader TPUs according to fanout size Returns the last error if all sends fail

pub fn send_transaction_to_upcoming_leaders( &self, transaction: &Transaction, ) -> TransportResult<()>

Serialize and send transaction to the current and upcoming leader TPUs according to fanout NOTE: send_wire_transaction() and try_send_transaction() above both fail in a specific case when used in LocalCluster They both invoke the nonblocking TPUClient and both fail when calling “transfer_with_client()” multiple times I do not full understand WHY the nonblocking TPUClient fails in this specific case. But the method defined below does work although it has only been tested in LocalCluster integration tests

pub fn try_send_transaction_batch( &self, transactions: &[Transaction], ) -> TransportResult<()>

Serialize and send a batch of transactions to the current and upcoming leader TPUs according to fanout size Returns the last error if all sends fail

pub fn try_send_wire_transaction( &self, wire_transaction: Vec<u8>, ) -> TransportResult<()>

Send a wire transaction to the current and upcoming leader TPUs according to fanout size Returns the last error if all sends fail

pub fn try_send_wire_transaction_batch( &self, wire_transactions: Vec<Vec<u8>>, ) -> TransportResult<()>

pub fn new( name: &'static str, rpc_client: Arc<RpcClient>, websocket_url: &str, config: TpuClientConfig, connection_manager: M, ) -> Result<Self>

Create a new client that disconnects when dropped

pub fn new_with_connection_cache( rpc_client: Arc<RpcClient>, websocket_url: &str, config: TpuClientConfig, connection_cache: Arc<ConnectionCache<P, M, C>>, ) -> Result<Self>

Create a new client that disconnects when dropped

pub fn send_and_confirm_messages_with_spinner<T: Signers + ?Sized>( &self, messages: &[Message], signers: &T, ) -> Result<Vec<Option<TransactionError>>>

pub fn rpc_client(&self) -> &RpcClient

Trait Implementations

impl<P, M, C> AsyncClient for TpuClient<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.