Don't use move semantics if not needed (#8793)

sdk/src/fee_calculator.rs

@@ -183,7 +183,7 @@ mod tests {
     #[test]
     fn test_fee_calculator_calculate_fee() {
         // Default: no fee.
-        let message = Message::new(vec![]);
+        let message = Message::new(&[]);
         assert_eq!(FeeCalculator::default().calculate_fee(&message), 0);
 
         // No signature, no fee.
@@ -193,13 +193,13 @@ mod tests {
         let pubkey0 = Pubkey::new(&[0; 32]);
         let pubkey1 = Pubkey::new(&[1; 32]);
         let ix0 = system_instruction::transfer(&pubkey0, &pubkey1, 1);
-        let message = Message::new(vec![ix0]);
+        let message = Message::new(&[ix0]);
         assert_eq!(FeeCalculator::new(2).calculate_fee(&message), 2);
 
         // Two signatures, double the fee.
         let ix0 = system_instruction::transfer(&pubkey0, &pubkey1, 1);
         let ix1 = system_instruction::transfer(&pubkey1, &pubkey0, 1);
-        let message = Message::new(vec![ix0, ix1]);
+        let message = Message::new(&[ix0, ix1]);
         assert_eq!(FeeCalculator::new(2).calculate_fee(&message), 4);
     }
 

sdk/src/message.rs

@@ -13,7 +13,7 @@ fn position(keys: &[Pubkey], key: &Pubkey) -> u8 {
     keys.iter().position(|k| k == key).unwrap() as u8
 }
 
-fn compile_instruction(ix: Instruction, keys: &[Pubkey]) -> CompiledInstruction {
+fn compile_instruction(ix: &Instruction, keys: &[Pubkey]) -> CompiledInstruction {
     let accounts: Vec<_> = ix
         .accounts
         .iter()
@@ -27,10 +27,8 @@ fn compile_instruction(ix: Instruction, keys: &[Pubkey]) -> CompiledInstruction
     }
 }
 
-fn compile_instructions(ixs: Vec<Instruction>, keys: &[Pubkey]) -> Vec<CompiledInstruction> {
-    ixs.into_iter()
-        .map(|ix| compile_instruction(ix, keys))
-        .collect()
+fn compile_instructions(ixs: &[Instruction], keys: &[Pubkey]) -> Vec<CompiledInstruction> {
+    ixs.iter().map(|ix| compile_instruction(ix, keys)).collect()
 }
 
 /// A helper struct to collect pubkeys referenced by a set of instructions and read-only counts
@@ -185,17 +183,17 @@ impl Message {
         }
     }
 
-    pub fn new(instructions: Vec<Instruction>) -> Self {
+    pub fn new(instructions: &[Instruction]) -> Self {
         Self::new_with_payer(instructions, None)
     }
 
-    pub fn new_with_payer(instructions: Vec<Instruction>, payer: Option<&Pubkey>) -> Self {
+    pub fn new_with_payer(instructions: &[Instruction], payer: Option<&Pubkey>) -> Self {
         let InstructionKeys {
             mut signed_keys,
             unsigned_keys,
             num_readonly_signed_accounts,
             num_readonly_unsigned_accounts,
-        } = get_keys(&instructions, payer);
+        } = get_keys(instructions, payer);
         let num_required_signatures = signed_keys.len() as u8;
         signed_keys.extend(&unsigned_keys);
         let instructions = compile_instructions(instructions, &signed_keys);
@@ -220,7 +218,7 @@ impl Message {
             &nonce_authority_pubkey,
         );
         instructions.insert(0, nonce_ix);
-        Self::new_with_payer(instructions, payer)
+        Self::new_with_payer(&instructions, payer)
     }
 
     pub fn serialize(&self) -> Vec<u8> {
@@ -430,11 +428,11 @@ mod tests {
         let program_id = Pubkey::default();
         let id0 = Pubkey::default();
         let ix = Instruction::new(program_id, &0, vec![AccountMeta::new(id0, false)]);
-        let message = Message::new(vec![ix]);
+        let message = Message::new(&[ix]);
         assert_eq!(message.header.num_required_signatures, 0);
 
         let ix = Instruction::new(program_id, &0, vec![AccountMeta::new(id0, true)]);
-        let message = Message::new(vec![ix]);
+        let message = Message::new(&[ix]);
         assert_eq!(message.header.num_required_signatures, 1);
     }
 
@@ -467,7 +465,7 @@ mod tests {
         let id0 = Pubkey::default();
         let keypair1 = Keypair::new();
         let id1 = keypair1.pubkey();
-        let message = Message::new(vec![
+        let message = Message::new(&[
             Instruction::new(program_id0, &0, vec![AccountMeta::new(id0, false)]),
             Instruction::new(program_id1, &0, vec![AccountMeta::new(id1, true)]),
             Instruction::new(program_id0, &0, vec![AccountMeta::new(id1, false)]),
@@ -493,11 +491,11 @@ mod tests {
         let id0 = Pubkey::default();
 
         let ix = Instruction::new(program_id, &0, vec![AccountMeta::new(id0, false)]);
-        let message = Message::new_with_payer(vec![ix], Some(&payer));
+        let message = Message::new_with_payer(&[ix], Some(&payer));
         assert_eq!(message.header.num_required_signatures, 1);
 
         let ix = Instruction::new(program_id, &0, vec![AccountMeta::new(id0, true)]);
-        let message = Message::new_with_payer(vec![ix], Some(&payer));
+        let message = Message::new_with_payer(&[ix], Some(&payer));
         assert_eq!(message.header.num_required_signatures, 2);
 
         let ix = Instruction::new(
@@ -505,7 +503,7 @@ mod tests {
             &0,
             vec![AccountMeta::new(payer, true), AccountMeta::new(id0, true)],
         );
-        let message = Message::new_with_payer(vec![ix], Some(&payer));
+        let message = Message::new_with_payer(&[ix], Some(&payer));
         assert_eq!(message.header.num_required_signatures, 2);
     }
 
@@ -532,7 +530,7 @@ mod tests {
         let program_id0 = Pubkey::default();
         let program_id1 = Pubkey::new_rand();
         let id = Pubkey::new_rand();
-        let message = Message::new(vec![
+        let message = Message::new(&[
             Instruction::new(program_id0, &0, vec![AccountMeta::new(id, false)]),
             Instruction::new(program_id1, &0, vec![AccountMeta::new(id, true)]),
         ]);
@@ -575,7 +573,7 @@ mod tests {
         let id1 = Pubkey::new_rand();
         let id2 = Pubkey::new_rand();
         let id3 = Pubkey::new_rand();
-        let message = Message::new(vec![
+        let message = Message::new(&[
             Instruction::new(program_id, &0, vec![AccountMeta::new(id0, false)]),
             Instruction::new(program_id, &0, vec![AccountMeta::new(id1, true)]),
             Instruction::new(program_id, &0, vec![AccountMeta::new_readonly(id2, false)]),

sdk/src/transaction.rs

@@ -92,7 +92,7 @@ impl Transaction {
     }
 
     pub fn new_with_payer(instructions: Vec<Instruction>, payer: Option<&Pubkey>) -> Self {
-        let message = Message::new_with_payer(instructions, payer);
+        let message = Message::new_with_payer(&instructions, payer);
         Self::new_unsigned(message)
     }
 
@@ -102,7 +102,7 @@ impl Transaction {
         signing_keypairs: &T,
         recent_blockhash: Hash,
     ) -> Self {
-        let message = Message::new_with_payer(instructions, payer);
+        let message = Message::new_with_payer(&instructions, payer);
         Self::new(signing_keypairs, message, recent_blockhash)
     }
 
@@ -123,7 +123,7 @@ impl Transaction {
     }
 
     pub fn new_unsigned_instructions(instructions: Vec<Instruction>) -> Self {
-        let message = Message::new(instructions);
+        let message = Message::new(&instructions);
         Self::new_unsigned(message)
     }
 
@@ -142,7 +142,7 @@ impl Transaction {
         instructions: Vec<Instruction>,
         recent_blockhash: Hash,
     ) -> Transaction {
-        let message = Message::new(instructions);
+        let message = Message::new(&instructions);
         Self::new(from_keypairs, message, recent_blockhash)
     }
 
@@ -482,7 +482,7 @@ mod tests {
             AccountMeta::new(to, false),
         ];
         let instruction = Instruction::new(program_id, &(1u8, 2u8, 3u8), account_metas);
-        let message = Message::new(vec![instruction]);
+        let message = Message::new(&[instruction]);
         Transaction::new(&[&keypair], message, Hash::default())
     }
 
@@ -513,7 +513,7 @@ mod tests {
         let expected_instruction_size = 1 + 1 + ix.accounts.len() + 1 + expected_data_size;
         assert_eq!(expected_instruction_size, 17);
 
-        let message = Message::new(vec![ix]);
+        let message = Message::new(&[ix]);
         assert_eq!(
             serialized_size(&message.instructions[0]).unwrap() as usize,
             expected_instruction_size,