Remove redundant transfer_signed

bench-tps/src/bench.rs

@@ -10,6 +10,7 @@ use solana_client::thin_client::create_client;
 use solana_client::thin_client::ThinClient;
 use solana_drone::drone::request_airdrop_transaction;
 use solana_metrics::influxdb;
+use solana_sdk::async_client::AsyncClient;
 use solana_sdk::hash::Hash;
 use solana_sdk::pubkey::Pubkey;
 use solana_sdk::signature::{Keypair, KeypairUtil};
@@ -324,7 +325,7 @@ fn send_barrier_transaction(
         let transaction =
             system_transaction::create_user_account(&source_keypair, dest_id, 0, *blockhash, 0);
         let signature = barrier_client
-            .transfer_signed(&transaction)
+            .async_send_transaction(transaction)
             .expect("Unable to send barrier transaction");
 
         let confirmatiom = barrier_client.poll_for_signature(&signature);
@@ -469,7 +470,7 @@ fn do_tx_transfers(
                 if now > tx.1 && now - tx.1 > 1000 * 30 {
                     continue;
                 }
-                client.transfer_signed(&tx.0).unwrap();
+                client.async_send_transaction(tx.0).unwrap();
             }
             shared_tx_thread_count.fetch_add(-1, Ordering::Relaxed);
             total_tx_sent_count.fetch_add(tx_len, Ordering::Relaxed);
@@ -587,7 +588,7 @@ fn fund_keys(client: &ThinClient, source: &Keypair, dests: &[Keypair], lamports:
                 });
 
                 to_fund_txs.iter().for_each(|(_, tx)| {
-                    client.transfer_signed(&tx).expect("transfer");
+                    client.async_send_transaction(tx.clone()).expect("transfer");
                 });
 
                 // retry anything that seems to have dropped through cracks
@@ -621,7 +622,7 @@ fn airdrop_lamports(client: &ThinClient, drone_addr: &SocketAddr, id: &Keypair,
         let blockhash = client.get_recent_blockhash().unwrap();
         match request_airdrop_transaction(&drone_addr, &id.pubkey(), airdrop_amount, blockhash) {
             Ok(transaction) => {
-                let signature = client.transfer_signed(&transaction).unwrap();
+                let signature = client.async_send_transaction(transaction).unwrap();
                 client.poll_for_signature(&signature).unwrap();
             }
             Err(err) => {

client/src/thin_client.rs

@@ -66,19 +66,6 @@ impl ThinClient {
         }
     }
 
-    /// Send a signed Transaction to the server for processing. This method
-    /// does not wait for a response.
-    pub fn transfer_signed(&self, transaction: &Transaction) -> io::Result<Signature> {
-        let mut buf = vec![0; serialized_size(&transaction).unwrap() as usize];
-        let mut wr = std::io::Cursor::new(&mut buf[..]);
-        serialize_into(&mut wr, &transaction)
-            .expect("serialize Transaction in pub fn transfer_signed");
-        assert!(buf.len() < PACKET_DATA_SIZE);
-        self.transactions_socket
-            .send_to(&buf[..], &self.transactions_addr)?;
-        Ok(transaction.signatures[0])
-    }
-
     /// Retry a sending a signed Transaction to the server for processing.
     pub fn retry_transfer_until_confirmed(
         &self,

core/src/replicator.rs

@@ -19,6 +19,7 @@ use rand::Rng;
 use solana_client::rpc_client::RpcClient;
 use solana_client::rpc_request::RpcRequest;
 use solana_client::thin_client::{create_client, ThinClient};
+use solana_sdk::async_client::AsyncClient;
 use solana_sdk::hash::{Hash, Hasher};
 use solana_sdk::signature::{Keypair, KeypairUtil, Signature};
 use solana_sdk::system_transaction;
@@ -428,7 +429,7 @@ impl Replicator {
                 &solana_storage_api::id(),
                 0,
             );
-            let signature = client.transfer_signed(&tx)?;
+            let signature = client.async_send_transaction(tx)?;
             client.poll_for_signature(&signature)?;
         }
         Ok(())

core/src/storage_stage.rs

@@ -13,6 +13,7 @@ use bincode::deserialize;
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaChaRng;
 use solana_client::thin_client::{create_client_with_timeout, ThinClient};
+use solana_sdk::async_client::AsyncClient;
 use solana_sdk::hash::Hash;
 use solana_sdk::pubkey::Pubkey;
 use solana_sdk::signature::{Keypair, KeypairUtil, Signature};
@@ -289,7 +290,7 @@ impl StorageStage {
                         &solana_storage_api::id(),
                         0,
                     );
-                    let signature = client.transfer_signed(&tx).unwrap();
+                    let signature = client.async_send_transaction(tx).unwrap();
                     Self::check_signature(&client, &signature, &exit)?;
                 }
             }
@@ -299,7 +300,7 @@ impl StorageStage {
                 Err(io::Error::new(io::ErrorKind::Other, "exit signaled"))?;
             }
 
-            if let Ok(signature) = client.transfer_signed(&transaction) {
+            if let Ok(signature) = client.async_send_transaction(transaction.clone()) {
                 Self::check_signature(&client, &signature, &exit)?;
                 return Ok(());
             }

tests/thin_client.rs

@@ -33,7 +33,7 @@ pub fn transfer(
         blockhash
     );
     let transaction = system_transaction::create_user_account(keypair, to, lamports, *blockhash, 0);
-    thin_client.transfer_signed(&transaction)
+    thin_client.async_send_transaction(&transaction)
 }
 
 #[test]
@@ -78,7 +78,7 @@ fn test_bad_sig() {
 
     let tx = system_transaction::create_user_account(&alice, &bob_pubkey, 500, blockhash, 0);
 
-    let _sig = client.transfer_signed(&tx).unwrap();
+    let _sig = client.async_send_transaction(&tx).unwrap();
 
     let blockhash = client.get_recent_blockhash().unwrap();
 
@@ -88,7 +88,7 @@ fn test_bad_sig() {
         *lamports = 502;
     }
     tr2.instructions[0].data = serialize(&instruction2).unwrap();
-    let signature = client.transfer_signed(&tr2).unwrap();
+    let signature = client.async_send_transaction(&tr2).unwrap();
     client.poll_for_signature(&signature).unwrap();
 
     let balance = client.get_balance(&bob_pubkey);
@@ -128,7 +128,7 @@ fn test_register_vote_account() {
         vote_instruction::create_account(&validator_keypair.pubkey(), &vote_account_id, 1);
     let transaction =
         Transaction::new_signed_instructions(&[&validator_keypair], instructions, blockhash);
-    let signature = client.transfer_signed(&transaction).unwrap();
+    let signature = client.async_send_transaction(&transaction).unwrap();
     client.poll_for_signature(&signature).unwrap();
 
     let balance = client