Refactor thin client (#30229)

Make client/thin_client a thin wrapper and forward calls to the thin-client/thin_client

bench-tps/src/main.rs

@@ -116,7 +116,7 @@ fn create_client(
                         rpc_client,
                         websocket_url,
                         TpuClientConfig::default(),
-                        Arc::new(cache),
+                        cache,
                     )
                     .unwrap_or_else(|err| {
                         eprintln!("Could not create TpuClient {err:?}");
@@ -128,7 +128,7 @@ fn create_client(
                         rpc_client,
                         websocket_url,
                         TpuClientConfig::default(),
-                        Arc::new(cache),
+                        cache,
                     )
                     .unwrap_or_else(|err| {
                         eprintln!("Could not create TpuClient {err:?}");

cli/src/program.rs

@@ -2168,7 +2168,7 @@ fn send_deploy_messages(
                     rpc_client.clone(),
                     &config.websocket_url,
                     TpuClientConfig::default(),
-                    Arc::new(cache),
+                    cache,
                 )?
                 .send_and_confirm_messages_with_spinner(
                     write_messages,
@@ -2178,7 +2178,7 @@ fn send_deploy_messages(
                     rpc_client.clone(),
                     &config.websocket_url,
                     TpuClientConfig::default(),
-                    Arc::new(cache),
+                    cache,
                 )?
                 .send_and_confirm_messages_with_spinner(
                     write_messages,

client/src/connection_cache.rs

@@ -25,8 +25,8 @@ const DEFAULT_CONNECTION_CACHE_USE_QUIC: bool = true;
 /// construction of the ConnectionCache for code dealing both with udp and quic.
 /// For the scenario only using udp or quic, use connection-cache/ConnectionCache directly.
 pub enum ConnectionCache {
-    Quic(BackendConnectionCache<QuicPool, QuicConnectionManager, QuicConfig>),
+    Quic(Arc<BackendConnectionCache<QuicPool, QuicConnectionManager, QuicConfig>>),
-    Udp(BackendConnectionCache<UdpPool, UdpConnectionManager, UdpConfig>),
+    Udp(Arc<BackendConnectionCache<UdpPool, UdpConnectionManager, UdpConfig>>),
 }
 
 type QuicBaseClientConnection = <QuicPool as ConnectionPool>::BaseClientConnection;
@@ -71,7 +71,7 @@ impl ConnectionCache {
         }
         let connection_manager = QuicConnectionManager::new_with_connection_config(config);
         let cache = BackendConnectionCache::new(connection_manager, connection_pool_size).unwrap();
-        Self::Quic(cache)
+        Self::Quic(Arc::new(cache))
     }
 
     #[deprecated(
@@ -102,7 +102,7 @@ impl ConnectionCache {
         let connection_pool_size = 1.max(connection_pool_size);
         let connection_manager = UdpConnectionManager::default();
         let cache = BackendConnectionCache::new(connection_manager, connection_pool_size).unwrap();
-        Self::Udp(cache)
+        Self::Udp(Arc::new(cache))
     }
 
     pub fn use_quic(&self) -> bool {

client/src/nonblocking/tpu_client.rs

@@ -85,7 +85,7 @@ impl TpuClient<QuicPool, QuicConnectionManager, QuicConfig> {
         config: TpuClientConfig,
     ) -> Result<Self> {
         let connection_cache = match ConnectionCache::default() {
-            ConnectionCache::Quic(cache) => Arc::new(cache),
+            ConnectionCache::Quic(cache) => cache,
             ConnectionCache::Udp(_) => {
                 return Err(TpuSenderError::Custom(String::from(
                     "Invalid default connection cache",

client/src/thin_client.rs

@@ -5,15 +5,13 @@
 
 use {
     crate::connection_cache::ConnectionCache,
-    log::*,
+    solana_quic_client::{QuicConfig, QuicConnectionManager, QuicPool},
-    rayon::iter::{IntoParallelIterator, ParallelIterator},
-    solana_connection_cache::client_connection::ClientConnection,
     solana_rpc_client::rpc_client::RpcClient,
-    solana_rpc_client_api::{config::RpcProgramAccountsConfig, response::Response},
+    solana_rpc_client_api::config::RpcProgramAccountsConfig,
     solana_sdk::{
         account::Account,
         client::{AsyncClient, Client, SyncClient},
-        clock::{Slot, MAX_PROCESSING_AGE},
+        clock::Slot,
         commitment_config::CommitmentConfig,
         epoch_info::EpochInfo,
         fee_calculator::{FeeCalculator, FeeRateGovernor},
@@ -21,28 +19,77 @@ use {
         instruction::Instruction,
         message::Message,
         pubkey::Pubkey,
-        signature::{Keypair, Signature, Signer},
+        signature::{Keypair, Signature},
         signers::Signers,
-        system_instruction,
-        timing::duration_as_ms,
         transaction::{self, Transaction, VersionedTransaction},
         transport::Result as TransportResult,
     },
-    solana_thin_client::thin_client::temporary_pub::*,
+    solana_thin_client::thin_client::ThinClient as BackendThinClient,
-    std::{
+    solana_udp_client::{UdpConfig, UdpConnectionManager, UdpPool},
-        io,
+    std::{net::SocketAddr, sync::Arc, time::Duration},
-        net::SocketAddr,
-        sync::Arc,
-        time::{Duration, Instant},
-    },
 };
 
-/// An object for querying and sending transactions to the network.
+/// A thin wrapper over thin-client/ThinClient to ease
-pub struct ThinClient {
+/// construction of the ThinClient for code dealing both with udp and quic.
-    rpc_clients: Vec<RpcClient>,
+/// For the scenario only using udp or quic, use thin-client/ThinClient directly.
-    tpu_addrs: Vec<SocketAddr>,
+pub enum ThinClient {
-    optimizer: ClientOptimizer,
+    Quic(BackendThinClient<QuicPool, QuicConnectionManager, QuicConfig>),
-    connection_cache: Arc<ConnectionCache>,
+    Udp(BackendThinClient<UdpPool, UdpConnectionManager, UdpConfig>),
+}
+
+/// Macros easing the forwarding calls to the BackendThinClient
+macro_rules! dispatch {
+    /*  Regular version */
+    ($vis:vis fn $name:ident(&self $(, $arg:ident : $ty:ty)*) $(-> $out:ty)?) => {
+        #[inline]
+        $vis fn $name(&self $(, $arg:$ty)*) $(-> $out)? {
+            match self {
+                Self::Quic(this) => this.$name($($arg),*),
+                Self::Udp(this) => this.$name($($arg),*),
+            }
+        }
+    };
+
+    /* The self is a mut */
+    ($vis:vis fn $name:ident(&mut self $(, $arg:ident : $ty:ty)*) $(-> $out:ty)?) => {
+        #[inline]
+        $vis fn $name(&mut self $(, $arg:$ty)*) $(-> $out)? {
+            match self {
+                Self::Quic(this) => this.$name($($arg),*),
+                Self::Udp(this) => this.$name($($arg),*),
+            }
+        }
+    };
+
+    /* There is a type parameter */
+    ($vis:vis fn $name:ident<T: Signers>(&self $(, $arg:ident : $ty:ty)*) $(-> $out:ty)?) => {
+        #[inline]
+        $vis fn $name<T: Signers>(&self $(, $arg:$ty)*) $(-> $out)? {
+            match self {
+                Self::Quic(this) => this.$name($($arg),*),
+                Self::Udp(this) => this.$name($($arg),*),
+            }
+        }
+    };
+}
+
+/// Macro forwarding calls to BackendThinClient with deprecated functions
+macro_rules! dispatch_allow_deprecated {
+    ($vis:vis fn $name:ident(&self $(, $arg:ident : $ty:ty)*) $(-> $out:ty)?) => {
+        #[inline]
+        $vis fn $name(&self $(, $arg:$ty)*) $(-> $out)? {
+            match self {
+                Self::Quic(this) => {
+                    #[allow(deprecated)]
+                    this.$name($($arg),*)
+                }
+                Self::Udp(this) => {
+                    #[allow(deprecated)]
+                    this.$name($($arg),*)
+                }
+            }
+        }
+    };
 }
 
 impl ThinClient {
@@ -54,7 +101,18 @@ impl ThinClient {
         tpu_addr: SocketAddr,
         connection_cache: Arc<ConnectionCache>,
     ) -> Self {
-        Self::new_from_client(RpcClient::new_socket(rpc_addr), tpu_addr, connection_cache)
+        match &*connection_cache {
+            ConnectionCache::Quic(connection_cache) => {
+                let thin_client =
+                    BackendThinClient::new(rpc_addr, tpu_addr, connection_cache.clone());
+                ThinClient::Quic(thin_client)
+            }
+            ConnectionCache::Udp(connection_cache) => {
+                let thin_client =
+                    BackendThinClient::new(rpc_addr, tpu_addr, connection_cache.clone());
+                ThinClient::Udp(thin_client)
+            }
+        }
     }
 
     pub fn new_socket_with_timeout(
@@ -63,20 +121,25 @@ impl ThinClient {
         timeout: Duration,
         connection_cache: Arc<ConnectionCache>,
     ) -> Self {
-        let rpc_client = RpcClient::new_socket_with_timeout(rpc_addr, timeout);
+        match &*connection_cache {
-        Self::new_from_client(rpc_client, tpu_addr, connection_cache)
+            ConnectionCache::Quic(connection_cache) => {
-    }
+                let thin_client = BackendThinClient::new_socket_with_timeout(
-
+                    rpc_addr,
-    fn new_from_client(
+                    tpu_addr,
-        rpc_client: RpcClient,
+                    timeout,
-        tpu_addr: SocketAddr,
+                    connection_cache.clone(),
-        connection_cache: Arc<ConnectionCache>,
+                );
-    ) -> Self {
+                ThinClient::Quic(thin_client)
-        Self {
+            }
-            rpc_clients: vec![rpc_client],
+            ConnectionCache::Udp(connection_cache) => {
-            tpu_addrs: vec![tpu_addr],
+                let thin_client = BackendThinClient::new_socket_with_timeout(
-            optimizer: ClientOptimizer::new(0),
+                    rpc_addr,
-            connection_cache,
+                    tpu_addr,
+                    timeout,
+                    connection_cache.clone(),
+                );
+                ThinClient::Udp(thin_client)
+            }
         }
     }
 
@@ -85,470 +148,199 @@ impl ThinClient {
         tpu_addrs: Vec<SocketAddr>,
         connection_cache: Arc<ConnectionCache>,
     ) -> Self {
-        assert!(!rpc_addrs.is_empty());
+        match &*connection_cache {
-        assert_eq!(rpc_addrs.len(), tpu_addrs.len());
+            ConnectionCache::Quic(connection_cache) => {
-
+                let thin_client = BackendThinClient::new_from_addrs(
-        let rpc_clients: Vec<_> = rpc_addrs.into_iter().map(RpcClient::new_socket).collect();
+                    rpc_addrs,
-        let optimizer = ClientOptimizer::new(rpc_clients.len());
+                    tpu_addrs,
-        Self {
+                    connection_cache.clone(),
-            rpc_clients,
+                );
-            tpu_addrs,
+                ThinClient::Quic(thin_client)
-            optimizer,
+            }
-            connection_cache,
+            ConnectionCache::Udp(connection_cache) => {
+                let thin_client = BackendThinClient::new_from_addrs(
+                    rpc_addrs,
+                    tpu_addrs,
+                    connection_cache.clone(),
+                );
+                ThinClient::Udp(thin_client)
+            }
         }
     }
 
-    fn tpu_addr(&self) -> &SocketAddr {
+    dispatch!(pub fn rpc_client(&self) -> &RpcClient);
-        &self.tpu_addrs[self.optimizer.best()]
-    }
 
-    pub fn rpc_client(&self) -> &RpcClient {
+    dispatch!(pub fn retry_transfer_until_confirmed(&self, keypair: &Keypair, transaction: &mut Transaction, tries: usize, min_confirmed_blocks: usize) -> TransportResult<Signature>);
-        &self.rpc_clients[self.optimizer.best()]
-    }
 
-    /// Retry a sending a signed Transaction to the server for processing.
+    dispatch!(pub fn retry_transfer(
-    pub fn retry_transfer_until_confirmed(
         &self,
         keypair: &Keypair,
         transaction: &mut Transaction,
-        tries: usize,
+        tries: usize
-        min_confirmed_blocks: usize,
+    ) -> TransportResult<Signature>);
-    ) -> TransportResult<Signature> {
-        self.send_and_confirm_transaction(&[keypair], transaction, tries, min_confirmed_blocks)
-    }
 
-    /// Retry sending a signed Transaction with one signing Keypair to the server for processing.
+    dispatch!(pub fn send_and_confirm_transaction<T: Signers>(
-    pub fn retry_transfer(
-        &self,
-        keypair: &Keypair,
-        transaction: &mut Transaction,
-        tries: usize,
-    ) -> TransportResult<Signature> {
-        self.send_and_confirm_transaction(&[keypair], transaction, tries, 0)
-    }
-
-    pub fn send_and_confirm_transaction<T: Signers>(
         &self,
         keypairs: &T,
         transaction: &mut Transaction,
         tries: usize,
-        pending_confirmations: usize,
+        pending_confirmations: usize
-    ) -> TransportResult<Signature> {
+    ) -> TransportResult<Signature>);
-        for x in 0..tries {
-            let now = Instant::now();
-            let mut num_confirmed = 0;
-            let mut wait_time = MAX_PROCESSING_AGE;
-            // resend the same transaction until the transaction has no chance of succeeding
-            let wire_transaction =
-                bincode::serialize(&transaction).expect("transaction serialization failed");
-            while now.elapsed().as_secs() < wait_time as u64 {
-                if num_confirmed == 0 {
-                    let conn = self.connection_cache.get_connection(self.tpu_addr());
-                    // Send the transaction if there has been no confirmation (e.g. the first time)
-                    #[allow(clippy::needless_borrow)]
-                    conn.send_data(&wire_transaction)?;
-                }
 
-                if let Ok(confirmed_blocks) = self.poll_for_signature_confirmation(
+    dispatch!(pub fn poll_get_balance(&self, pubkey: &Pubkey) -> TransportResult<u64>);
-                    &transaction.signatures[0],
-                    pending_confirmations,
-                ) {
-                    num_confirmed = confirmed_blocks;
-                    if confirmed_blocks >= pending_confirmations {
-                        return Ok(transaction.signatures[0]);
-                    }
-                    // Since network has seen the transaction, wait longer to receive
-                    // all pending confirmations. Resending the transaction could result into
-                    // extra transaction fees
-                    wait_time = wait_time.max(
-                        MAX_PROCESSING_AGE * pending_confirmations.saturating_sub(num_confirmed),
-                    );
-                }
-            }
-            info!("{} tries failed transfer to {}", x, self.tpu_addr());
-            let blockhash = self.get_latest_blockhash()?;
-            transaction.sign(keypairs, blockhash);
-        }
-        Err(io::Error::new(
-            io::ErrorKind::Other,
-            format!("retry_transfer failed in {tries} retries"),
-        )
-        .into())
-    }
 
-    pub fn poll_get_balance(&self, pubkey: &Pubkey) -> TransportResult<u64> {
+    dispatch!(pub fn poll_get_balance_with_commitment(
-        self.poll_get_balance_with_commitment(pubkey, CommitmentConfig::default())
-    }
-
-    pub fn poll_get_balance_with_commitment(
         &self,
         pubkey: &Pubkey,
-        commitment_config: CommitmentConfig,
+        commitment_config: CommitmentConfig
-    ) -> TransportResult<u64> {
+    ) -> TransportResult<u64>);
-        self.rpc_client()
-            .poll_get_balance_with_commitment(pubkey, commitment_config)
-            .map_err(|e| e.into())
-    }
 
-    pub fn wait_for_balance(&self, pubkey: &Pubkey, expected_balance: Option<u64>) -> Option<u64> {
+    dispatch!(pub fn wait_for_balance(&self, pubkey: &Pubkey, expected_balance: Option<u64>) -> Option<u64>);
-        self.rpc_client().wait_for_balance_with_commitment(
-            pubkey,
-            expected_balance,
-            CommitmentConfig::default(),
-        )
-    }
 
-    pub fn get_program_accounts_with_config(
+    dispatch!(pub fn get_program_accounts_with_config(
         &self,
         pubkey: &Pubkey,
-        config: RpcProgramAccountsConfig,
+        config: RpcProgramAccountsConfig
-    ) -> TransportResult<Vec<(Pubkey, Account)>> {
+    ) -> TransportResult<Vec<(Pubkey, Account)>>);
-        self.rpc_client()
-            .get_program_accounts_with_config(pubkey, config)
-            .map_err(|e| e.into())
-    }
 
-    pub fn wait_for_balance_with_commitment(
+    dispatch!(pub fn wait_for_balance_with_commitment(
         &self,
         pubkey: &Pubkey,
         expected_balance: Option<u64>,
-        commitment_config: CommitmentConfig,
+        commitment_config: CommitmentConfig
-    ) -> Option<u64> {
+    ) -> Option<u64>);
-        self.rpc_client().wait_for_balance_with_commitment(
-            pubkey,
-            expected_balance,
-            commitment_config,
-        )
-    }
 
-    pub fn poll_for_signature_with_commitment(
+    dispatch!(pub fn poll_for_signature_with_commitment(
         &self,
         signature: &Signature,
-        commitment_config: CommitmentConfig,
+        commitment_config: CommitmentConfig
-    ) -> TransportResult<()> {
+    ) -> TransportResult<()>);
-        self.rpc_client()
-            .poll_for_signature_with_commitment(signature, commitment_config)
-            .map_err(|e| e.into())
-    }
 
-    pub fn get_num_blocks_since_signature_confirmation(
+    dispatch!(pub fn get_num_blocks_since_signature_confirmation(
         &mut self,
-        sig: &Signature,
+        sig: &Signature
-    ) -> TransportResult<usize> {
+    ) -> TransportResult<usize>);
-        self.rpc_client()
-            .get_num_blocks_since_signature_confirmation(sig)
-            .map_err(|e| e.into())
-    }
 }
 
 impl Client for ThinClient {
-    fn tpu_addr(&self) -> String {
+    dispatch!(fn tpu_addr(&self) -> String);
-        self.tpu_addr().to_string()
-    }
 }
 
 impl SyncClient for ThinClient {
-    fn send_and_confirm_message<T: Signers>(
+    dispatch!(fn send_and_confirm_message<T: Signers>(
         &self,
         keypairs: &T,
-        message: Message,
+        message: Message
-    ) -> TransportResult<Signature> {
+    ) -> TransportResult<Signature>);
-        let blockhash = self.get_latest_blockhash()?;
-        let mut transaction = Transaction::new(keypairs, message, blockhash);
-        let signature = self.send_and_confirm_transaction(keypairs, &mut transaction, 5, 0)?;
-        Ok(signature)
-    }
 
-    fn send_and_confirm_instruction(
+    dispatch!(fn send_and_confirm_instruction(
         &self,
         keypair: &Keypair,
-        instruction: Instruction,
+        instruction: Instruction
-    ) -> TransportResult<Signature> {
+    ) -> TransportResult<Signature>);
-        let message = Message::new(&[instruction], Some(&keypair.pubkey()));
-        self.send_and_confirm_message(&[keypair], message)
-    }
 
-    fn transfer_and_confirm(
+    dispatch!(fn transfer_and_confirm(
         &self,
         lamports: u64,
         keypair: &Keypair,
-        pubkey: &Pubkey,
+        pubkey: &Pubkey
-    ) -> TransportResult<Signature> {
+    ) -> TransportResult<Signature>);
-        let transfer_instruction =
-            system_instruction::transfer(&keypair.pubkey(), pubkey, lamports);
-        self.send_and_confirm_instruction(keypair, transfer_instruction)
-    }
 
-    fn get_account_data(&self, pubkey: &Pubkey) -> TransportResult<Option<Vec<u8>>> {
+    dispatch!(fn get_account_data(&self, pubkey: &Pubkey) -> TransportResult<Option<Vec<u8>>>);
-        Ok(self.rpc_client().get_account_data(pubkey).ok())
-    }
 
-    fn get_account(&self, pubkey: &Pubkey) -> TransportResult<Option<Account>> {
+    dispatch!(fn get_account(&self, pubkey: &Pubkey) -> TransportResult<Option<Account>>);
-        let account = self.rpc_client().get_account(pubkey);
-        match account {
-            Ok(value) => Ok(Some(value)),
-            Err(_) => Ok(None),
-        }
-    }
 
-    fn get_account_with_commitment(
+    dispatch!(fn get_account_with_commitment(
         &self,
         pubkey: &Pubkey,
-        commitment_config: CommitmentConfig,
+        commitment_config: CommitmentConfig
-    ) -> TransportResult<Option<Account>> {
+    ) -> TransportResult<Option<Account>>);
-        self.rpc_client()
-            .get_account_with_commitment(pubkey, commitment_config)
-            .map_err(|e| e.into())
-            .map(|r| r.value)
-    }
 
-    fn get_balance(&self, pubkey: &Pubkey) -> TransportResult<u64> {
+    dispatch!(fn get_balance(&self, pubkey: &Pubkey) -> TransportResult<u64>);
-        self.rpc_client().get_balance(pubkey).map_err(|e| e.into())
-    }
 
-    fn get_balance_with_commitment(
+    dispatch!(fn get_balance_with_commitment(
         &self,
         pubkey: &Pubkey,
-        commitment_config: CommitmentConfig,
+        commitment_config: CommitmentConfig
-    ) -> TransportResult<u64> {
+    ) -> TransportResult<u64>);
-        self.rpc_client()
-            .get_balance_with_commitment(pubkey, commitment_config)
-            .map_err(|e| e.into())
-            .map(|r| r.value)
-    }
 
-    fn get_minimum_balance_for_rent_exemption(&self, data_len: usize) -> TransportResult<u64> {
+    dispatch!(fn get_minimum_balance_for_rent_exemption(&self, data_len: usize) -> TransportResult<u64>);
-        self.rpc_client()
-            .get_minimum_balance_for_rent_exemption(data_len)
-            .map_err(|e| e.into())
-    }
 
-    fn get_recent_blockhash(&self) -> TransportResult<(Hash, FeeCalculator)> {
+    dispatch_allow_deprecated!(fn get_recent_blockhash(&self) -> TransportResult<(Hash, FeeCalculator)>);
-        #[allow(deprecated)]
-        let (blockhash, fee_calculator, _last_valid_slot) =
-            self.get_recent_blockhash_with_commitment(CommitmentConfig::default())?;
-        Ok((blockhash, fee_calculator))
-    }
 
-    fn get_recent_blockhash_with_commitment(
+    dispatch_allow_deprecated!(fn get_recent_blockhash_with_commitment(
         &self,
-        commitment_config: CommitmentConfig,
+        commitment_config: CommitmentConfig
-    ) -> TransportResult<(Hash, FeeCalculator, Slot)> {
+    ) -> TransportResult<(Hash, FeeCalculator, Slot)>);
-        let index = self.optimizer.experiment();
-        let now = Instant::now();
-        #[allow(deprecated)]
-        let recent_blockhash =
-            self.rpc_clients[index].get_recent_blockhash_with_commitment(commitment_config);
-        match recent_blockhash {
-            Ok(Response { value, .. }) => {
-                self.optimizer.report(index, duration_as_ms(&now.elapsed()));
-                Ok((value.0, value.1, value.2))
-            }
-            Err(e) => {
-                self.optimizer.report(index, std::u64::MAX);
-                Err(e.into())
-            }
-        }
-    }
 
-    fn get_fee_calculator_for_blockhash(
+    dispatch_allow_deprecated!(fn get_fee_calculator_for_blockhash(
+        &self,
+        blockhash: &Hash
+    ) -> TransportResult<Option<FeeCalculator>>);
+
+    dispatch_allow_deprecated!(fn get_fee_rate_governor(&self) -> TransportResult<FeeRateGovernor>);
+
+    dispatch!(fn get_signature_status(
+        &self,
+        signature: &Signature
+    ) -> TransportResult<Option<transaction::Result<()>>>);
+
+    dispatch!(fn get_signature_status_with_commitment(
+        &self,
+        signature: &Signature,
+        commitment_config: CommitmentConfig
+    ) -> TransportResult<Option<transaction::Result<()>>>);
+
+    dispatch!(fn get_slot(&self) -> TransportResult<u64>);
+
+    dispatch!(fn get_slot_with_commitment(
+        &self,
+        commitment_config: CommitmentConfig
+    ) -> TransportResult<u64>);
+
+    dispatch!(fn get_epoch_info(&self) -> TransportResult<EpochInfo>);
+
+    dispatch!(fn get_transaction_count(&self) -> TransportResult<u64>);
+
+    dispatch!(fn get_transaction_count_with_commitment(
+        &self,
+        commitment_config: CommitmentConfig
+    ) -> TransportResult<u64>);
+
+    dispatch!(fn poll_for_signature_confirmation(
+        &self,
+        signature: &Signature,
+        min_confirmed_blocks: usize
+    ) -> TransportResult<usize>);
+
+    dispatch!(fn poll_for_signature(&self, signature: &Signature) -> TransportResult<()>);
+
+    dispatch_allow_deprecated!(fn get_new_blockhash(&self, blockhash: &Hash) -> TransportResult<(Hash, FeeCalculator)>);
+
+    dispatch!(fn get_latest_blockhash(&self) -> TransportResult<Hash>);
+
+    dispatch!(fn get_latest_blockhash_with_commitment(
+        &self,
+        commitment_config: CommitmentConfig
+    ) -> TransportResult<(Hash, u64)>);
+
+    dispatch!(fn is_blockhash_valid(
         &self,
         blockhash: &Hash,
-    ) -> TransportResult<Option<FeeCalculator>> {
+        commitment_config: CommitmentConfig
-        #[allow(deprecated)]
+    ) -> TransportResult<bool>);
-        self.rpc_client()
-            .get_fee_calculator_for_blockhash(blockhash)
-            .map_err(|e| e.into())
-    }
 
-    fn get_fee_rate_governor(&self) -> TransportResult<FeeRateGovernor> {
+    dispatch!(fn get_fee_for_message(&self, message: &Message) -> TransportResult<u64>);
-        #[allow(deprecated)]
-        self.rpc_client()
-            .get_fee_rate_governor()
-            .map_err(|e| e.into())
-            .map(|r| r.value)
-    }
-
-    fn get_signature_status(
-        &self,
-        signature: &Signature,
-    ) -> TransportResult<Option<transaction::Result<()>>> {
-        let status = self
-            .rpc_client()
-            .get_signature_status(signature)
-            .map_err(|err| {
-                io::Error::new(
-                    io::ErrorKind::Other,
-                    format!("send_transaction failed with error {err:?}"),
-                )
-            })?;
-        Ok(status)
-    }
-
-    fn get_signature_status_with_commitment(
-        &self,
-        signature: &Signature,
-        commitment_config: CommitmentConfig,
-    ) -> TransportResult<Option<transaction::Result<()>>> {
-        let status = self
-            .rpc_client()
-            .get_signature_status_with_commitment(signature, commitment_config)
-            .map_err(|err| {
-                io::Error::new(
-                    io::ErrorKind::Other,
-                    format!("send_transaction failed with error {err:?}"),
-                )
-            })?;
-        Ok(status)
-    }
-
-    fn get_slot(&self) -> TransportResult<u64> {
-        self.get_slot_with_commitment(CommitmentConfig::default())
-    }
-
-    fn get_slot_with_commitment(
-        &self,
-        commitment_config: CommitmentConfig,
-    ) -> TransportResult<u64> {
-        let slot = self
-            .rpc_client()
-            .get_slot_with_commitment(commitment_config)
-            .map_err(|err| {
-                io::Error::new(
-                    io::ErrorKind::Other,
-                    format!("send_transaction failed with error {err:?}"),
-                )
-            })?;
-        Ok(slot)
-    }
-
-    fn get_epoch_info(&self) -> TransportResult<EpochInfo> {
-        self.rpc_client().get_epoch_info().map_err(|e| e.into())
-    }
-
-    fn get_transaction_count(&self) -> TransportResult<u64> {
-        let index = self.optimizer.experiment();
-        let now = Instant::now();
-        match self.rpc_client().get_transaction_count() {
-            Ok(transaction_count) => {
-                self.optimizer.report(index, duration_as_ms(&now.elapsed()));
-                Ok(transaction_count)
-            }
-            Err(e) => {
-                self.optimizer.report(index, std::u64::MAX);
-                Err(e.into())
-            }
-        }
-    }
-
-    fn get_transaction_count_with_commitment(
-        &self,
-        commitment_config: CommitmentConfig,
-    ) -> TransportResult<u64> {
-        let index = self.optimizer.experiment();
-        let now = Instant::now();
-        match self
-            .rpc_client()
-            .get_transaction_count_with_commitment(commitment_config)
-        {
-            Ok(transaction_count) => {
-                self.optimizer.report(index, duration_as_ms(&now.elapsed()));
-                Ok(transaction_count)
-            }
-            Err(e) => {
-                self.optimizer.report(index, std::u64::MAX);
-                Err(e.into())
-            }
-        }
-    }
-
-    /// Poll the server until the signature has been confirmed by at least `min_confirmed_blocks`
-    fn poll_for_signature_confirmation(
-        &self,
-        signature: &Signature,
-        min_confirmed_blocks: usize,
-    ) -> TransportResult<usize> {
-        self.rpc_client()
-            .poll_for_signature_confirmation(signature, min_confirmed_blocks)
-            .map_err(|e| e.into())
-    }
-
-    fn poll_for_signature(&self, signature: &Signature) -> TransportResult<()> {
-        self.rpc_client()
-            .poll_for_signature(signature)
-            .map_err(|e| e.into())
-    }
-
-    fn get_new_blockhash(&self, blockhash: &Hash) -> TransportResult<(Hash, FeeCalculator)> {
-        #[allow(deprecated)]
-        self.rpc_client()
-            .get_new_blockhash(blockhash)
-            .map_err(|e| e.into())
-    }
-
-    fn get_latest_blockhash(&self) -> TransportResult<Hash> {
-        let (blockhash, _) =
-            self.get_latest_blockhash_with_commitment(CommitmentConfig::default())?;
-        Ok(blockhash)
-    }
-
-    fn get_latest_blockhash_with_commitment(
-        &self,
-        commitment_config: CommitmentConfig,
-    ) -> TransportResult<(Hash, u64)> {
-        let index = self.optimizer.experiment();
-        let now = Instant::now();
-        match self.rpc_clients[index].get_latest_blockhash_with_commitment(commitment_config) {
-            Ok((blockhash, last_valid_block_height)) => {
-                self.optimizer.report(index, duration_as_ms(&now.elapsed()));
-                Ok((blockhash, last_valid_block_height))
-            }
-            Err(e) => {
-                self.optimizer.report(index, std::u64::MAX);
-                Err(e.into())
-            }
-        }
-    }
-
-    fn is_blockhash_valid(
-        &self,
-        blockhash: &Hash,
-        commitment_config: CommitmentConfig,
-    ) -> TransportResult<bool> {
-        self.rpc_client()
-            .is_blockhash_valid(blockhash, commitment_config)
-            .map_err(|e| e.into())
-    }
-
-    fn get_fee_for_message(&self, message: &Message) -> TransportResult<u64> {
-        self.rpc_client()
-            .get_fee_for_message(message)
-            .map_err(|e| e.into())
-    }
 }
 
 impl AsyncClient for ThinClient {
-    fn async_send_versioned_transaction(
+    dispatch!(fn async_send_versioned_transaction(
         &self,
-        transaction: VersionedTransaction,
+        transaction: VersionedTransaction
-    ) -> TransportResult<Signature> {
+    ) -> TransportResult<Signature>);
-        let conn = self.connection_cache.get_connection(self.tpu_addr());
-        let wire_transaction =
-            bincode::serialize(&transaction).expect("serialize Transaction in send_batch");
-        conn.send_data(&wire_transaction)?;
-        Ok(transaction.signatures[0])
-    }
 
-    fn async_send_versioned_transaction_batch(
+    dispatch!(fn async_send_versioned_transaction_batch(
         &self,
-        batch: Vec<VersionedTransaction>,
+        batch: Vec<VersionedTransaction>
-    ) -> TransportResult<()> {
+    ) -> TransportResult<()>);
-        let conn = self.connection_cache.get_connection(self.tpu_addr());
-        let buffers = batch
-            .into_par_iter()
-            .map(|tx| bincode::serialize(&tx).expect("serialize Transaction in send_batch"))
-            .collect::<Vec<_>>();
-        conn.send_data_batch(&buffers)?;
-        Ok(())
-    }
 }

client/src/tpu_client.rs

@@ -77,7 +77,7 @@ impl TpuClient<QuicPool, QuicConnectionManager, QuicConfig> {
         config: TpuClientConfig,
     ) -> Result<Self> {
         let connection_cache = match ConnectionCache::default() {
-            ConnectionCache::Quic(cache) => Arc::new(cache),
+            ConnectionCache::Quic(cache) => cache,
             ConnectionCache::Udp(_) => {
                 return Err(TpuSenderError::Custom(String::from(
                     "Invalid default connection cache",

rpc-test/tests/rpc.rs

@@ -472,7 +472,7 @@ fn run_tpu_send_transaction(tpu_use_quic: bool) {
             rpc_client.clone(),
             &test_validator.rpc_pubsub_url(),
             TpuClientConfig::default(),
-            Arc::new(cache),
+            cache,
         )
         .unwrap()
         .send_transaction(&tx),
@@ -480,7 +480,7 @@ fn run_tpu_send_transaction(tpu_use_quic: bool) {
             rpc_client.clone(),
             &test_validator.rpc_pubsub_url(),
             TpuClientConfig::default(),
-            Arc::new(cache),
+            cache,
         )
         .unwrap()
         .send_transaction(&tx),