Remove ThinClient::transfer()

bench-tps/src/bench.rs

@@ -120,8 +120,11 @@ pub fn send_barrier_transaction(
         }
 
         *blockhash = barrier_client.get_recent_blockhash();
+
+        let transaction =
+            SystemTransaction::new_account(&source_keypair, dest_id, 0, *blockhash, 0);
         let signature = barrier_client
-            .transfer(0, &source_keypair, dest_id, blockhash)
+            .transfer_signed(&transaction)
             .expect("Unable to send barrier transaction");
 
         let confirmatiom = barrier_client.poll_for_signature(&signature);

client/src/thin_client.rs

@@ -11,8 +11,7 @@ use solana_metrics::influxdb;
 use solana_sdk::hash::Hash;
 use solana_sdk::packet::PACKET_DATA_SIZE;
 use solana_sdk::pubkey::Pubkey;
-use solana_sdk::signature::{Keypair, KeypairUtil, Signature};
-use solana_sdk::system_transaction::SystemTransaction;
+use solana_sdk::signature::{Keypair, Signature};
 use solana_sdk::timing;
 use solana_sdk::transaction::Transaction;
 use std::error;
@@ -103,36 +102,6 @@ impl ThinClient {
         ))
     }
 
-    /// Creates, signs, and processes a Transaction. Useful for writing unit-tests.
-    pub fn transfer(
-        &self,
-        lamports: u64,
-        keypair: &Keypair,
-        to: &Pubkey,
-        blockhash: &Hash,
-    ) -> io::Result<Signature> {
-        debug!(
-            "transfer: lamports={} from={:?} to={:?} blockhash={:?}",
-            lamports,
-            keypair.pubkey(),
-            to,
-            blockhash
-        );
-        let now = Instant::now();
-        let transaction = SystemTransaction::new_account(keypair, to, lamports, *blockhash, 0);
-        let result = self.transfer_signed(&transaction);
-        solana_metrics::submit(
-            influxdb::Point::new("thinclient")
-                .add_tag("op", influxdb::Value::String("transfer".to_string()))
-                .add_field(
-                    "duration_ms",
-                    influxdb::Value::Integer(timing::duration_as_ms(&now.elapsed()) as i64),
-                )
-                .to_owned(),
-        );
-        result
-    }
-
     pub fn get_account_data(&self, pubkey: &Pubkey) -> io::Result<Vec<u8>> {
         self.rpc_client.get_account_data(pubkey)
     }

tests/thin_client.rs

@@ -6,7 +6,9 @@ use solana::gossip_service::discover;
 use solana_client::thin_client::create_client;
 use solana_client::thin_client::{retry_get_balance, ThinClient};
 use solana_logger;
-use solana_sdk::signature::{Keypair, KeypairUtil};
+use solana_sdk::hash::Hash;
+use solana_sdk::pubkey::Pubkey;
+use solana_sdk::signature::{Keypair, KeypairUtil, Signature};
 use solana_sdk::system_instruction::SystemInstruction;
 use solana_sdk::system_transaction::SystemTransaction;
 use solana_vote_api::vote_state::VoteState;
@@ -16,6 +18,24 @@ use std::net::UdpSocket;
 use std::thread::sleep;
 use std::time::Duration;
 
+pub fn transfer(
+    thin_client: &ThinClient,
+    lamports: u64,
+    keypair: &Keypair,
+    to: &Pubkey,
+    blockhash: &Hash,
+) -> std::io::Result<Signature> {
+    debug!(
+        "transfer: lamports={} from={:?} to={:?} blockhash={:?}",
+        lamports,
+        keypair.pubkey(),
+        to,
+        blockhash
+    );
+    let transaction = SystemTransaction::new_account(keypair, to, lamports, *blockhash, 0);
+    thin_client.transfer_signed(&transaction)
+}
+
 #[test]
 fn test_thin_client_basic() {
     solana_logger::setup();
@@ -31,9 +51,7 @@ fn test_thin_client_basic() {
     let blockhash = client.get_recent_blockhash();
     info!("test_thin_client blockhash: {:?}", blockhash);
 
-    let signature = client
-        .transfer(500, &alice, &bob_pubkey, &blockhash)
-        .unwrap();
+    let signature = transfer(&client, 500, &alice, &bob_pubkey, &blockhash).unwrap();
     info!("test_thin_client signature: {:?}", signature);
     client.poll_for_signature(&signature).unwrap();
 
@@ -90,9 +108,14 @@ fn test_register_vote_account() {
     // Create the validator account, transfer some lamports to that account
     let validator_keypair = Keypair::new();
     let blockhash = client.get_recent_blockhash();
-    let signature = client
-        .transfer(500, &alice, &validator_keypair.pubkey(), &blockhash)
-        .unwrap();
+    let signature = transfer(
+        &client,
+        500,
+        &alice,
+        &validator_keypair.pubkey(),
+        &blockhash,
+    )
+    .unwrap();
 
     client.poll_for_signature(&signature).unwrap();
 
@@ -162,18 +185,14 @@ fn test_zero_balance_after_nonzero() {
     info!("Alice has {} lamports", starting_alice_balance);
 
     info!("Give Bob 500 lamports");
-    let signature = client
-        .transfer(500, &alice, &bob_keypair.pubkey(), &blockhash)
-        .unwrap();
+    let signature = transfer(&client, 500, &alice, &bob_keypair.pubkey(), &blockhash).unwrap();
     client.poll_for_signature(&signature).unwrap();
 
     let bob_balance = client.poll_get_balance(&bob_keypair.pubkey());
     assert_eq!(bob_balance.unwrap(), 500);
 
     info!("Take Bob's 500 lamports away");
-    let signature = client
-        .transfer(500, &bob_keypair, &alice.pubkey(), &blockhash)
-        .unwrap();
+    let signature = transfer(&client, 500, &bob_keypair, &alice.pubkey(), &blockhash).unwrap();
     client.poll_for_signature(&signature).unwrap();
     let alice_balance = client.poll_get_balance(&alice.pubkey()).unwrap();
     assert_eq!(alice_balance, starting_alice_balance);