token-client: Make confirmation of ProgramRpcClientSendTransaction optional

single-pool/cli/src/config.rs

@@ -65,7 +65,7 @@ impl Config {
         // and program client
         let program_client = Arc::new(ProgramRpcClient::new(
             rpc_client.clone(),
-            ProgramRpcClientSendTransaction,
+            ProgramRpcClientSendTransaction::new_with_confirmation(),
         ));
 
         // resolve default signer

single-pool/cli/tests/test.rs

@@ -56,7 +56,7 @@ async fn setup(initialize: bool) -> Env {
     let rpc_client = Arc::new(validator.get_async_rpc_client());
     let program_client: PClient = Arc::new(ProgramRpcClient::new(
         rpc_client.clone(),
-        ProgramRpcClientSendTransaction,
+        ProgramRpcClientSendTransaction::new_with_confirmation(),
     ));
 
     // write the payer to disk

token-upgrade/cli/src/main.rs

@@ -89,7 +89,7 @@ async fn process_create_escrow_account(
 
     let program_client = Arc::new(ProgramRpcClient::new(
         rpc_client.clone(),
-        ProgramRpcClientSendTransaction,
+        ProgramRpcClientSendTransaction::new_with_confirmation(),
     ));
     let token = Token::new(
         program_client.clone(),
@@ -545,7 +545,7 @@ mod test {
         let rpc_client = Arc::new(test_validator.get_async_rpc_client());
         let client = Arc::new(ProgramRpcClient::new(
             rpc_client.clone(),
-            ProgramRpcClientSendTransaction,
+            ProgramRpcClientSendTransaction::new_with_confirmation(),
         ));
 
         let mint_authority = Keypair::new();
@@ -614,7 +614,7 @@ mod test {
         let rpc_client = Arc::new(test_validator.get_async_rpc_client());
         let client = Arc::new(ProgramRpcClient::new(
             rpc_client.clone(),
-            ProgramRpcClientSendTransaction,
+            ProgramRpcClientSendTransaction::new_with_confirmation(),
         ));
 
         let mint_authority = Keypair::new();
@@ -721,7 +721,7 @@ mod test {
         let rpc_client = Arc::new(test_validator.get_async_rpc_client());
         let client = Arc::new(ProgramRpcClient::new(
             rpc_client.clone(),
-            ProgramRpcClientSendTransaction,
+            ProgramRpcClientSendTransaction::new_with_confirmation(),
         ));
 
         let mint_authority = Keypair::new();

token/cli/src/config.rs

@@ -116,12 +116,12 @@ impl<'a> Config<'a> {
                 .unwrap_or_default();
             Arc::new(ProgramOfflineClient::new(
                 blockhash,
-                ProgramRpcClientSendTransaction,
+                ProgramRpcClientSendTransaction::new(),
             ))
         } else {
             Arc::new(ProgramRpcClient::new(
                 rpc_client.clone(),
-                ProgramRpcClientSendTransaction,
+                ProgramRpcClientSendTransaction::new(),
             ))
         };
         Self::new_with_clients_and_ws_url(

token/cli/tests/command.rs

@@ -190,9 +190,11 @@ fn test_config_with_default_signer<'a>(
 ) -> Config<'a> {
     let websocket_url = test_validator.rpc_pubsub_url();
     let rpc_client = Arc::new(test_validator.get_async_rpc_client());
-    let program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> = Arc::new(
-        ProgramRpcClient::new(rpc_client.clone(), ProgramRpcClientSendTransaction),
-    );
+    let program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> =
+        Arc::new(ProgramRpcClient::new(
+            rpc_client.clone(),
+            ProgramRpcClientSendTransaction::new_with_confirmation(),
+        ));
     Config {
         rpc_client,
         program_client,
@@ -219,9 +221,11 @@ fn test_config_without_default_signer<'a>(
 ) -> Config<'a> {
     let websocket_url = test_validator.rpc_pubsub_url();
     let rpc_client = Arc::new(test_validator.get_async_rpc_client());
-    let program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> = Arc::new(
-        ProgramRpcClient::new(rpc_client.clone(), ProgramRpcClientSendTransaction),
-    );
+    let program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> =
+        Arc::new(ProgramRpcClient::new(
+            rpc_client.clone(),
+            ProgramRpcClientSendTransaction::new_with_confirmation(),
+        ));
     Config {
         rpc_client,
         program_client,
@@ -3132,7 +3136,7 @@ async fn do_offline_multisig_transfer(
         let offline_program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> =
             Arc::new(ProgramOfflineClient::new(
                 blockhash,
-                ProgramRpcClientSendTransaction,
+                ProgramRpcClientSendTransaction::new_with_confirmation(),
             ));
         let mut args = vec![
             "spl-token".to_string(),
@@ -3192,9 +3196,11 @@ async fn do_offline_multisig_transfer(
         assert!(!absent_signers.contains(&token.to_string()));
 
         // now send the transaction
-        let rpc_program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> = Arc::new(
-            ProgramRpcClient::new(config.rpc_client.clone(), ProgramRpcClientSendTransaction),
-        );
+        let rpc_program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> =
+            Arc::new(ProgramRpcClient::new(
+                config.rpc_client.clone(),
+                ProgramRpcClientSendTransaction::new_with_confirmation(),
+            ));
         config.program_client = rpc_program_client;
         let mut args = vec![
             "spl-token".to_string(),
@@ -3849,9 +3855,11 @@ async fn transfer_hook(test_validator: &TestValidator, payer: &Keypair) {
     // Make sure that parsing transfer hook accounts works
     let real_program_client = config.program_client;
     let blockhash = Hash::default();
-    let program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> = Arc::new(
-        ProgramOfflineClient::new(blockhash, ProgramRpcClientSendTransaction),
-    );
+    let program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> =
+        Arc::new(ProgramOfflineClient::new(
+            blockhash,
+            ProgramRpcClientSendTransaction::new_with_confirmation(),
+        ));
     config.program_client = program_client;
     let _result = exec_test_cmd(
         &config,
@@ -3965,9 +3973,11 @@ async fn transfer_hook_with_transfer_fee(test_validator: &TestValidator, payer:
 
     // Make sure that parsing transfer hook accounts and expected-fee works
     let blockhash = Hash::default();
-    let program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> = Arc::new(
-        ProgramOfflineClient::new(blockhash, ProgramRpcClientSendTransaction),
-    );
+    let program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> =
+        Arc::new(ProgramOfflineClient::new(
+            blockhash,
+            ProgramRpcClientSendTransaction::new_with_confirmation(),
+        ));
     config.program_client = program_client;
 
     let _result = exec_test_cmd(

token/client/src/client.rs

@@ -120,7 +120,23 @@ pub trait SimulateTransactionRpc: SimulateTransaction {
 }
 
 #[derive(Debug, Clone, Copy, Default)]
-pub struct ProgramRpcClientSendTransaction;
+pub struct ProgramRpcClientSendTransaction {
+    /// Confirm the transaction after sending it
+    confirm: bool,
+}
+
+impl ProgramRpcClientSendTransaction {
+    /// Create an instance that sends the transaction **without** waiting for
+    /// confirmation.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Create an instance that sends and confirms the transaction.
+    pub fn new_with_confirmation() -> Self {
+        Self { confirm: true }
+    }
+}
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum RpcClientResponse {
@@ -139,16 +155,19 @@ impl SendTransactionRpc for ProgramRpcClientSendTransaction {
         client: &'a RpcClient,
         transaction: &'a Transaction,
     ) -> BoxFuture<'a, ProgramClientResult<Self::Output>> {
+        let confirm = self.confirm;
         Box::pin(async move {
             if !transaction.is_signed() {
                 return Err("Cannot send transaction: not fully signed".into());
             }
 
-            client
-                .send_and_confirm_transaction(transaction)
-                .await
-                .map(RpcClientResponse::Signature)
-                .map_err(Into::into)
+            if confirm {
+                client.send_and_confirm_transaction(transaction).await
+            } else {
+                client.send_transaction(transaction).await
+            }
+            .map(RpcClientResponse::Signature)
+            .map_err(Into::into)
         })
     }
 }

token/transfer-hook/cli/src/main.rs

@@ -601,7 +601,7 @@ mod test {
         let rpc_client = Arc::new(test_validator.get_async_rpc_client());
         let client = Arc::new(ProgramRpcClient::new(
             rpc_client.clone(),
-            ProgramRpcClientSendTransaction,
+            ProgramRpcClientSendTransaction::new_with_confirmation(),
         ));
 
         let token = Token::new(