Support transaction signing by heterogenous lists of keypairs (#8342)

automerge

client/src/rpc_client.rs

@@ -22,7 +22,8 @@ use solana_sdk::{
     hash::Hash,
     inflation::Inflation,
     pubkey::Pubkey,
-    signature::{KeypairUtil, Signature},
+    signature::Signature,
+    signers::Signers,
     transaction::{self, Transaction, TransactionError},
 };
 use std::{
@@ -405,10 +406,10 @@ impl RpcClient {
         })
     }
 
-    pub fn send_and_confirm_transaction<T: KeypairUtil>(
+    pub fn send_and_confirm_transaction<T: Signers>(
         &self,
         transaction: &mut Transaction,
-        signer_keys: &[&T],
+        signer_keys: &T,
     ) -> Result<String, ClientError> {
         let mut send_retries = 20;
         loop {
@@ -456,10 +457,10 @@ impl RpcClient {
         }
     }
 
-    pub fn send_and_confirm_transactions<T: KeypairUtil>(
+    pub fn send_and_confirm_transactions<T: Signers>(
         &self,
         mut transactions: Vec<Transaction>,
-        signer_keys: &[&T],
+        signer_keys: &T,
     ) -> Result<(), Box<dyn error::Error>> {
         let mut send_retries = 5;
         loop {
@@ -526,10 +527,10 @@ impl RpcClient {
         }
     }
 
-    pub fn resign_transaction<T: KeypairUtil>(
+    pub fn resign_transaction<T: Signers>(
         &self,
         tx: &mut Transaction,
-        signer_keys: &[&T],
+        signer_keys: &T,
     ) -> Result<(), ClientError> {
         let (blockhash, _fee_calculator) =
             self.get_new_blockhash(&tx.message().recent_blockhash)?;

client/src/thin_client.rs

@@ -18,6 +18,7 @@ use solana_sdk::{
     packet::PACKET_DATA_SIZE,
     pubkey::Pubkey,
     signature::{Keypair, KeypairUtil, Signature},
+    signers::Signers,
     system_instruction,
     timing::duration_as_ms,
     transaction::{self, Transaction},
@@ -202,9 +203,9 @@ impl ThinClient {
     }
 
     /// Retry sending a signed Transaction to the server for processing
-    pub fn send_and_confirm_transaction(
+    pub fn send_and_confirm_transaction<T: Signers>(
         &self,
-        keypairs: &[&Keypair],
+        keypairs: &T,
         transaction: &mut Transaction,
         tries: usize,
         pending_confirmations: usize,
@@ -351,9 +352,13 @@ impl Client for ThinClient {
 }
 
 impl SyncClient for ThinClient {
-    fn send_message(&self, keypairs: &[&Keypair], message: Message) -> TransportResult<Signature> {
+    fn send_message<T: Signers>(
+        &self,
+        keypairs: &T,
+        message: Message,
+    ) -> TransportResult<Signature> {
         let (blockhash, _fee_calculator) = self.get_recent_blockhash()?;
-        let mut transaction = Transaction::new(&keypairs, message, blockhash);
+        let mut transaction = Transaction::new(keypairs, message, blockhash);
         let signature = self.send_and_confirm_transaction(keypairs, &mut transaction, 5, 0)?;
         Ok(signature)
     }
@@ -561,13 +566,13 @@ impl AsyncClient for ThinClient {
             .send_to(&buf[..], &self.tpu_addr())?;
         Ok(transaction.signatures[0])
     }
-    fn async_send_message(
+    fn async_send_message<T: Signers>(
         &self,
-        keypairs: &[&Keypair],
+        keypairs: &T,
         message: Message,
         recent_blockhash: Hash,
     ) -> io::Result<Signature> {
-        let transaction = Transaction::new(&keypairs, message, recent_blockhash);
+        let transaction = Transaction::new(keypairs, message, recent_blockhash);
         self.async_send_transaction(transaction)
     }
     fn async_send_instruction(