Multiple signatures for transactions

With multiple instructions in a TX may need
multiple signatures.

Fixes solana-labs#1531

benches/banking_stage.rs

@@ -66,7 +66,7 @@ fn bench_banking_stage_multi_accounts(bencher: &mut Bencher) {
             let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
             new.account_keys[0] = Pubkey::new(&from[0..32]);
             new.account_keys[1] = Pubkey::new(&to[0..32]);
-            new.signature = Signature::new(&sig[0..64]);
+            new.signatures = vec![Signature::new(&sig[0..64])];
             new
         }).collect();
     // fund all the accounts
@@ -128,7 +128,7 @@ fn bench_banking_stage_multi_accounts(bencher: &mut Bencher) {
 
 #[bench]
 fn bench_banking_stage_multi_programs(bencher: &mut Bencher) {
-    let progs = 5;
+    let progs = 4;
     let txes = 1000 * NUM_THREADS;
     let mint_total = 1_000_000_000_000;
     let mint = Mint::new(mint_total);
@@ -168,7 +168,7 @@ fn bench_banking_stage_multi_programs(bencher: &mut Bencher) {
                 );
             }
             assert_eq!(new.instructions.len(), progs);
-            new.signature = Signature::new(&sig[0..64]);
+            new.signatures = vec![Signature::new(&sig[0..64])];
             new
         }).collect();
     transactions.iter().for_each(|tx| {

src/bank.rs

@@ -484,7 +484,7 @@ impl Bank {
         for (i, tx) in txs.iter().enumerate() {
             Self::update_signature_status_with_last_id(
                 &mut last_ids.entries,
-                &tx.signature,
+                &tx.signatures[0],
                 &res[i],
                 &tx.last_id,
             );
@@ -498,7 +498,7 @@ impl Bank {
                     Err(_) => RpcSignatureStatus::GenericFailure,
                 };
                 if status != RpcSignatureStatus::SignatureNotFound {
-                    self.check_signature_subscriptions(&tx.signature, status);
+                    self.check_signature_subscriptions(&tx.signatures[0], status);
                 }
             }
         }
@@ -651,7 +651,8 @@ impl Bank {
 
             // There is no way to predict what contract will execute without an error
             // If a fee can pay for execution then the contract will be scheduled
-            let err = Self::reserve_signature_with_last_id(last_ids, &tx.last_id, &tx.signature);
+            let err =
+                Self::reserve_signature_with_last_id(last_ids, &tx.last_id, &tx.signatures[0]);
             if let Err(BankError::LastIdNotFound) = err {
                 error_counters.reserve_last_id += 1;
             } else if let Err(BankError::DuplicateSignature) = err {
@@ -1292,7 +1293,7 @@ impl Bank {
         last_id: Hash,
     ) -> Result<Signature> {
         let tx = Transaction::system_new(keypair, to, n, last_id);
-        let signature = tx.signature;
+        let signature = tx.signatures[0];
         self.process_transaction(&tx).map(|_| signature)
     }
 
@@ -1550,10 +1551,13 @@ mod tests {
         assert_eq!(bank.get_balance(&mint.pubkey()), 0);
         assert_eq!(bank.get_balance(&key1), 1);
         assert_eq!(bank.get_balance(&key2), 0);
-        assert_eq!(bank.get_signature(&t1.last_id, &t1.signature), Some(Ok(())));
+        assert_eq!(
+            bank.get_signature(&t1.last_id, &t1.signatures[0]),
+            Some(Ok(()))
+        );
         // TODO: Transactions that fail to pay a fee could be dropped silently
         assert_eq!(
-            bank.get_signature(&t2.last_id, &t2.signature),
+            bank.get_signature(&t2.last_id, &t2.signatures[0]),
             Some(Err(BankError::AccountInUse))
         );
     }
@@ -1579,7 +1583,7 @@ mod tests {
         ];
 
         let t1 = Transaction::new_with_instructions(
-            &mint.keypair(),
+            &[&mint.keypair()],
             &[key1, key2],
             mint.last_id(),
             0,
@@ -1593,7 +1597,7 @@ mod tests {
         assert_eq!(bank.get_balance(&key1), 0);
         assert_eq!(bank.get_balance(&key2), 0);
         assert_eq!(
-            bank.get_signature(&t1.last_id, &t1.signature),
+            bank.get_signature(&t1.last_id, &t1.signatures[0]),
             Some(Err(BankError::ResultWithNegativeTokens(1)))
         );
     }
@@ -1616,7 +1620,10 @@ mod tests {
         assert_eq!(bank.get_balance(&mint.pubkey()), 0);
         assert_eq!(bank.get_balance(&key1), 1);
         assert_eq!(bank.get_balance(&key2), 1);
-        assert_eq!(bank.get_signature(&t1.last_id, &t1.signature), Some(Ok(())));
+        assert_eq!(
+            bank.get_signature(&t1.last_id, &t1.signatures[0]),
+            Some(Ok(()))
+        );
     }
 
     // TODO: This test demonstrates that fees are not paid when a program fails.
@@ -1637,7 +1644,7 @@ mod tests {
             Pubkey::default(),
             1,
         );
-        let signature = tx.signature;
+        let signature = tx.signatures[0];
         assert!(!bank.has_signature(&signature));
         let res = bank.process_transaction(&tx);
 
@@ -2044,7 +2051,7 @@ mod tests {
         let bank_sub_id = Keypair::new().pubkey();
         let last_id = bank.last_id();
         let tx = Transaction::system_move(&mint.keypair(), alice.pubkey(), 20, last_id, 0);
-        let signature = tx.signature;
+        let signature = tx.signatures[0];
         bank.process_transaction(&tx).unwrap();
 
         let (subscriber, _id_receiver, mut transport_receiver) =

src/bin/bench-tps.rs

@@ -293,7 +293,7 @@ fn do_tx_transfers(
 
 const MAX_SPENDS_PER_TX: usize = 5;
 fn verify_transfer(client: &mut ThinClient, tx: &Transaction) -> bool {
-    if client.poll_for_signature(&tx.signature).is_err() {
+    if client.poll_for_signature(&tx.signatures[0]).is_err() {
         println!("no signature");
         return false;
     }

src/budget_transaction.rs

@@ -92,7 +92,14 @@ impl BudgetTransaction for Transaction {
             transaction::Instruction::new(1, &budget_instruction, vec![1]),
         ];
 
-        Self::new_with_instructions(from_keypair, &keys, last_id, fee, program_ids, instructions)
+        Self::new_with_instructions(
+            &[from_keypair],
+            &keys,
+            last_id,
+            fee,
+            program_ids,
+            instructions,
+        )
     }
 
     /// Create and sign a new Transaction. Used for unit-testing.
@@ -258,9 +265,10 @@ mod tests {
         let instruction = Instruction::NewBudget(expr);
         let instructions = vec![transaction::Instruction::new(0, &instruction, vec![])];
         let claim0 = Transaction {
+            signed_keys: vec![],
             account_keys: vec![],
             last_id: Default::default(),
-            signature: Default::default(),
+            signatures: vec![],
             program_ids: vec![],
             instructions,
             fee: 0,

src/rpc.rs

@@ -251,7 +251,7 @@ impl RpcSol for RpcSolImpl {
                 info!("send_transaction: send_to error: {:?}", err);
                 Error::internal_error()
             })?;
-        let signature = bs58::encode(tx.signature).into_string();
+        let signature = bs58::encode(tx.signatures[0]).into_string();
         trace!(
             "send_transaction: sent {} bytes, signature={}",
             data.len(),
@@ -504,7 +504,7 @@ mod tests {
 
         let req = format!(
             r#"{{"jsonrpc":"2.0","id":1,"method":"confirmTransaction","params":["{}"]}}"#,
-            tx.signature
+            tx.signatures[0]
         );
         let res = io.handle_request_sync(&req, meta);
         let expected = format!(r#"{{"jsonrpc":"2.0","result":true,"id":1}}"#);
@@ -523,7 +523,7 @@ mod tests {
 
         let req = format!(
             r#"{{"jsonrpc":"2.0","id":1,"method":"getSignatureStatus","params":["{}"]}}"#,
-            tx.signature
+            tx.signatures[0]
         );
         let res = io.handle_request_sync(&req, meta.clone());
         let expected = format!(r#"{{"jsonrpc":"2.0","result":"Confirmed","id":1}}"#);
@@ -537,7 +537,7 @@ mod tests {
         let tx = Transaction::system_move(&alice_keypair, bob_pubkey, 10, last_id, 0);
         let req = format!(
             r#"{{"jsonrpc":"2.0","id":1,"method":"getSignatureStatus","params":["{}"]}}"#,
-            tx.signature
+            tx.signatures[0]
         );
         let res = io.handle_request_sync(&req, meta);
         let expected = format!(r#"{{"jsonrpc":"2.0","result":"SignatureNotFound","id":1}}"#);
@@ -738,8 +738,8 @@ mod tests {
         let tx =
             Transaction::system_move(&Keypair::new(), Keypair::new().pubkey(), 20, hash(&[0]), 0);
         assert_eq!(
-            verify_signature(&tx.signature.to_string()).unwrap(),
-            tx.signature
+            verify_signature(&tx.signatures[0].to_string()).unwrap(),
+            tx.signatures[0]
         );
         let bad_signature = "a1b2c3d4";
         assert_eq!(

src/rpc_pubsub.rs

@@ -290,7 +290,7 @@ mod tests {
 
         let req = format!(
             r#"{{"jsonrpc":"2.0","id":1,"method":"signatureSubscribe","params":["{}"]}}"#,
-            tx.signature.to_string()
+            tx.signatures[0].to_string()
         );
         let res = io.handle_request_sync(&req, session.clone());
         let expected = format!(r#"{{"jsonrpc":"2.0","result":0,"id":1}}"#);
@@ -331,7 +331,7 @@ mod tests {
         let tx = Transaction::system_move(&alice.keypair(), bob_pubkey, 10, last_id, 0);
         let req = format!(
             r#"{{"jsonrpc":"2.0","id":1,"method":"signatureSubscribe","params":["{}"]}}"#,
-            tx.signature.to_string()
+            tx.signatures[0].to_string()
         );
         let res = io.handle_request_sync(&req, session.clone());
         let expected = format!(r#"{{"jsonrpc":"2.0","result":1,"id":1}}"#);
@@ -364,7 +364,7 @@ mod tests {
         let tx = Transaction::system_move(&alice.keypair(), bob_pubkey, 20, last_id, 0);
         let req = format!(
             r#"{{"jsonrpc":"2.0","id":1,"method":"signatureSubscribe","params":["{}"]}}"#,
-            tx.signature.to_string()
+            tx.signatures[0].to_string()
         );
         let _res = io.handle_request_sync(&req, session.clone());