From 4a980568aca51c0666be0ea0443f6db3228a765b Mon Sep 17 00:00:00 2001 From: Greg Fitzgerald Date: Thu, 9 Aug 2018 09:26:21 -0600 Subject: [PATCH] Rename sig variables to signature We'll avoid introducing three-letter terms to free up the namespace for three-letter acronyms. But recognize the term "sigverify", a verb, to verify a digital signature. --- benches/sigverify.rs | 6 ++--- src/bank.rs | 62 ++++++++++++++++++++++---------------------- src/bin/bench-tps.rs | 4 +-- src/bin/wallet.rs | 16 ++++++------ src/crdt.rs | 2 +- src/entry.rs | 2 +- src/signature.rs | 8 +++--- src/sigverify.rs | 6 ++--- src/thin_client.rs | 22 ++++++++-------- src/transaction.rs | 22 ++++++++-------- 10 files changed, 75 insertions(+), 75 deletions(-) diff --git a/benches/sigverify.rs b/benches/sigverify.rs index 0c774f1e5b..b1cf3f7466 100644 --- a/benches/sigverify.rs +++ b/benches/sigverify.rs @@ -9,7 +9,7 @@ use solana::packet::{to_packets, PacketRecycler}; use solana::sigverify; use solana::transaction::test_tx; -fn bench_sig_verify(bencher: &mut Bencher) { +fn bench_sigverify(bencher: &mut Bencher) { let tx = test_tx(); // generate packet vector @@ -23,8 +23,8 @@ fn bench_sig_verify(bencher: &mut Bencher) { } fn bench(criterion: &mut Criterion) { - criterion.bench_function("bench_sig_verify", |bencher| { - bench_sig_verify(bencher); + criterion.bench_function("bench_sigverify", |bencher| { + bench_sigverify(bencher); }); } diff --git a/src/bank.rs b/src/bank.rs index fb39f194d3..56dffa08d0 100644 --- a/src/bank.rs +++ b/src/bank.rs @@ -136,11 +136,11 @@ impl Bank { } /// Store the given signature. The bank will reject any transaction with the same signature. - fn reserve_signature(signatures: &mut HashSet, sig: &Signature) -> Result<()> { - if let Some(sig) = signatures.get(sig) { - return Err(BankError::DuplicateSignature(*sig)); + fn reserve_signature(signatures: &mut HashSet, signature: &Signature) -> Result<()> { + if let Some(signature) = signatures.get(signature) { + return Err(BankError::DuplicateSignature(*signature)); } - signatures.insert(*sig); + signatures.insert(*signature); Ok(()) } @@ -233,7 +233,7 @@ impl Bank { } let bal = option.unwrap(); - self.reserve_signature_with_last_id(&tx.sig, &tx.last_id)?; + self.reserve_signature_with_last_id(&tx.signature, &tx.last_id)?; if let Instruction::NewContract(contract) = &tx.instruction { if contract.tokens < 0 { @@ -241,7 +241,7 @@ impl Bank { } if *bal < contract.tokens { - self.forget_signature_with_last_id(&tx.sig, &tx.last_id); + self.forget_signature_with_last_id(&tx.signature, &tx.last_id); return Err(BankError::InsufficientFunds(tx.from)); } else if *bal == contract.tokens { purge = true; @@ -271,14 +271,14 @@ impl Bank { .pending .write() .expect("'pending' write lock in apply_credits"); - pending.insert(tx.sig, plan); + pending.insert(tx.signature, plan); } } Instruction::ApplyTimestamp(dt) => { let _ = self.apply_timestamp(tx.from, *dt); } - Instruction::ApplySignature(tx_sig) => { - let _ = self.apply_signature(tx.from, *tx_sig); + Instruction::ApplySignature(signature) => { + let _ = self.apply_signature(tx.from, *signature); } Instruction::NewVote(_vote) => { trace!("GOT VOTE! last_id={:?}", &tx.last_id.as_ref()[..8]); @@ -470,12 +470,12 @@ impl Bank { /// Process a Witness Signature. Any payment plans waiting on this signature /// will progress one step. - fn apply_signature(&self, from: Pubkey, tx_sig: Signature) -> Result<()> { + fn apply_signature(&self, from: Pubkey, signature: Signature) -> Result<()> { if let Occupied(mut e) = self .pending .write() .expect("write() in apply_signature") - .entry(tx_sig) + .entry(signature) { e.get_mut().apply_witness(&Witness::Signature, &from); if let Some(payment) = e.get().final_payment() { @@ -524,8 +524,8 @@ impl Bank { last_id: Hash, ) -> Result { let tx = Transaction::new(keypair, to, n, last_id); - let sig = tx.sig; - self.process_transaction(&tx).map(|_| sig) + let signature = tx.signature; + self.process_transaction(&tx).map(|_| signature) } /// Create, sign, and process a postdated Transaction from `keypair` @@ -540,8 +540,8 @@ impl Bank { last_id: Hash, ) -> Result { let tx = Transaction::new_on_date(keypair, to, dt, n, last_id); - let sig = tx.sig; - self.process_transaction(&tx).map(|_| sig) + let signature = tx.signature; + self.process_transaction(&tx).map(|_| signature) } pub fn get_balance(&self, pubkey: &Pubkey) -> i64 { @@ -692,7 +692,7 @@ mod tests { let bank = Bank::new(&mint); let pubkey = Keypair::new().pubkey(); let dt = Utc::now(); - let sig = bank + let signature = bank .transfer_on_date(1, &mint.keypair(), pubkey, dt, mint.last_id()) .unwrap(); @@ -707,14 +707,14 @@ mod tests { assert_eq!(bank.get_balance(&pubkey), 0); // Now, cancel the trancaction. Mint gets her funds back, pubkey never sees them. - bank.apply_signature(mint.pubkey(), sig).unwrap(); + bank.apply_signature(mint.pubkey(), signature).unwrap(); assert_eq!(bank.get_balance(&mint.pubkey()), 1); assert_eq!(bank.get_balance(&pubkey), 0); // Assert cancel doesn't cause count to go backward. assert_eq!(bank.transaction_count(), 1); - bank.apply_signature(mint.pubkey(), sig).unwrap(); // <-- Attack! Attempt to cancel completed transaction. + bank.apply_signature(mint.pubkey(), signature).unwrap(); // <-- Attack! Attempt to cancel completed transaction. assert_ne!(bank.get_balance(&mint.pubkey()), 2); } @@ -722,14 +722,14 @@ mod tests { fn test_duplicate_transaction_signature() { let mint = Mint::new(1); let bank = Bank::new(&mint); - let sig = Signature::default(); + let signature = Signature::default(); assert!( - bank.reserve_signature_with_last_id(&sig, &mint.last_id()) + bank.reserve_signature_with_last_id(&signature, &mint.last_id()) .is_ok() ); assert_eq!( - bank.reserve_signature_with_last_id(&sig, &mint.last_id()), - Err(BankError::DuplicateSignature(sig)) + bank.reserve_signature_with_last_id(&signature, &mint.last_id()), + Err(BankError::DuplicateSignature(signature)) ); } @@ -737,12 +737,12 @@ mod tests { fn test_forget_signature() { let mint = Mint::new(1); let bank = Bank::new(&mint); - let sig = Signature::default(); - bank.reserve_signature_with_last_id(&sig, &mint.last_id()) + let signature = Signature::default(); + bank.reserve_signature_with_last_id(&signature, &mint.last_id()) .unwrap(); - bank.forget_signature_with_last_id(&sig, &mint.last_id()); + bank.forget_signature_with_last_id(&signature, &mint.last_id()); assert!( - bank.reserve_signature_with_last_id(&sig, &mint.last_id()) + bank.reserve_signature_with_last_id(&signature, &mint.last_id()) .is_ok() ); } @@ -751,24 +751,24 @@ mod tests { fn test_has_signature() { let mint = Mint::new(1); let bank = Bank::new(&mint); - let sig = Signature::default(); - bank.reserve_signature_with_last_id(&sig, &mint.last_id()) + let signature = Signature::default(); + bank.reserve_signature_with_last_id(&signature, &mint.last_id()) .expect("reserve signature"); - assert!(bank.has_signature(&sig)); + assert!(bank.has_signature(&signature)); } #[test] fn test_reject_old_last_id() { let mint = Mint::new(1); let bank = Bank::new(&mint); - let sig = Signature::default(); + let signature = Signature::default(); for i in 0..MAX_ENTRY_IDS { let last_id = hash(&serialize(&i).unwrap()); // Unique hash bank.register_entry_id(&last_id); } // Assert we're no longer able to use the oldest entry ID. assert_eq!( - bank.reserve_signature_with_last_id(&sig, &mint.last_id()), + bank.reserve_signature_with_last_id(&signature, &mint.last_id()), Err(BankError::LastIdNotFound(mint.last_id())) ); } diff --git a/src/bin/bench-tps.rs b/src/bin/bench-tps.rs index 0dfe154896..7d6bfdb741 100644 --- a/src/bin/bench-tps.rs +++ b/src/bin/bench-tps.rs @@ -122,11 +122,11 @@ fn send_barrier_transaction(barrier_client: &mut ThinClient, last_id: &mut Hash, } *last_id = barrier_client.get_last_id(); - let sig = barrier_client + let signature = barrier_client .transfer(0, &id, id.pubkey(), last_id) .expect("Unable to send barrier transaction"); - let confirmatiom = barrier_client.poll_for_signature(&sig); + let confirmatiom = barrier_client.poll_for_signature(&signature); let duration_ms = duration_as_ms(&transfer_start.elapsed()); if confirmatiom.is_ok() { println!("barrier transaction confirmed in {}ms", duration_ms); diff --git a/src/bin/wallet.rs b/src/bin/wallet.rs index 536469ea83..9dd69ce8f5 100644 --- a/src/bin/wallet.rs +++ b/src/bin/wallet.rs @@ -191,13 +191,13 @@ fn parse_args() -> Result> { Ok(WalletCommand::Pay(tokens, to)) } ("confirm", Some(confirm_matches)) => { - let sig_vec = bs58::decode(confirm_matches.value_of("signature").unwrap()) + let signatures = bs58::decode(confirm_matches.value_of("signature").unwrap()) .into_vec() .expect("base58-encoded signature"); - if sig_vec.len() == std::mem::size_of::() { - let sig = Signature::new(&sig_vec); - Ok(WalletCommand::Confirm(sig)) + if signatures.len() == std::mem::size_of::() { + let signature = Signature::new(&signatures); + Ok(WalletCommand::Confirm(signature)) } else { eprintln!("{}", confirm_matches.usage()); Err(WalletError::BadParameter("Invalid signature".to_string())) @@ -276,12 +276,12 @@ fn process_command( // If client has positive balance, spend tokens in {balance} number of transactions WalletCommand::Pay(tokens, to) => { let last_id = client.get_last_id(); - let sig = client.transfer(tokens, &config.id, to, &last_id)?; - println!("{}", sig); + let signature = client.transfer(tokens, &config.id, to, &last_id)?; + println!("{}", signature); } // Confirm the last client transaction by signature - WalletCommand::Confirm(sig) => { - if client.check_signature(&sig) { + WalletCommand::Confirm(signature) => { + if client.check_signature(&signature) { println!("Confirmed"); } else { println!("Not found"); diff --git a/src/crdt.rs b/src/crdt.rs index c50831845d..ae825f9785 100644 --- a/src/crdt.rs +++ b/src/crdt.rs @@ -902,7 +902,7 @@ impl Crdt { ) { trace!("got updates {}", data.len()); // TODO we need to punish/spam resist here - // sig verify the whole update and slash anyone who sends a bad update + // sigverify the whole update and slash anyone who sends a bad update let mut insert_total = 0; for v in data { insert_total += self.insert(&v); diff --git a/src/entry.rs b/src/entry.rs index 1b7ad24ad0..df98f9a360 100644 --- a/src/entry.rs +++ b/src/entry.rs @@ -173,7 +173,7 @@ impl Entry { fn add_transaction_data(hash_data: &mut Vec, tx: &Transaction) { hash_data.push(0u8); - hash_data.extend_from_slice(&tx.sig.as_ref()); + hash_data.extend_from_slice(&tx.signature.as_ref()); } /// Creates the hash `num_hashes` after `start_hash`. If the transaction contains diff --git a/src/signature.rs b/src/signature.rs index 4e1cc9dcc2..b154826070 100644 --- a/src/signature.rs +++ b/src/signature.rs @@ -48,11 +48,11 @@ impl Signature { pub fn new(signature_slice: &[u8]) -> Self { Signature(GenericArray::clone_from_slice(&signature_slice)) } - pub fn verify(&self, pubkey_bytes: &[u8], msg_bytes: &[u8]) -> bool { + pub fn verify(&self, pubkey_bytes: &[u8], message_bytes: &[u8]) -> bool { let pubkey = Input::from(pubkey_bytes); - let msg = Input::from(msg_bytes); - let sig = Input::from(self.0.as_slice()); - signature::verify(&signature::ED25519, pubkey, msg, sig).is_ok() + let message = Input::from(message_bytes); + let signature = Input::from(self.0.as_slice()); + signature::verify(&signature::ED25519, pubkey, message, signature).is_ok() } } diff --git a/src/sigverify.rs b/src/sigverify.rs index 1ba7900b20..00fcd10d35 100644 --- a/src/sigverify.rs +++ b/src/sigverify.rs @@ -138,7 +138,7 @@ pub fn ed25519_verify(batches: &[SharedPackets]) -> Vec> { let count = batch_size(batches); // micro-benchmarks show GPU time for smallest batch around 15-20ms - // and CPU speed for 64-128 sig verifies around 10-20ms. 64 is a nice + // and CPU speed for 64-128 sigverifies around 10-20ms. 64 is a nice // power-of-two number around that accounting for the fact that the CPU // may be busy doing other things while being a real fullnode // TODO: dynamically adjust this crossover @@ -174,8 +174,8 @@ pub fn ed25519_verify(batches: &[SharedPackets]) -> Vec> { trace!("Starting verify num packets: {}", num); trace!("elem len: {}", elems.len() as u32); trace!("packet sizeof: {}", size_of::() as u32); - trace!("pub key: {}", (TX_OFFSET + PUB_KEY_OFFSET) as u32); - trace!("sig offset: {}", (TX_OFFSET + SIG_OFFSET) as u32); + trace!("pubkey: {}", (TX_OFFSET + PUB_KEY_OFFSET) as u32); + trace!("signature offset: {}", (TX_OFFSET + SIG_OFFSET) as u32); trace!("sign data: {}", (TX_OFFSET + SIGNED_DATA_OFFSET) as u32); trace!("len offset: {}", PACKET_DATA_SIZE as u32); unsafe { diff --git a/src/thin_client.rs b/src/thin_client.rs index b201538620..ee0c98edd0 100644 --- a/src/thin_client.rs +++ b/src/thin_client.rs @@ -92,7 +92,7 @@ impl ThinClient { let data = serialize(&tx).expect("serialize Transaction in pub fn transfer_signed"); self.transactions_socket .send_to(&data, &self.transactions_addr)?; - Ok(tx.sig) + Ok(tx.signature) } /// Creates, signs, and processes a Transaction. Useful for writing unit-tests. @@ -227,9 +227,9 @@ impl ThinClient { } /// Poll the server to confirm a transaction. - pub fn poll_for_signature(&mut self, sig: &Signature) -> io::Result<()> { + pub fn poll_for_signature(&mut self, signature: &Signature) -> io::Result<()> { let now = Instant::now(); - while !self.check_signature(sig) { + while !self.check_signature(signature) { if now.elapsed().as_secs() > 1 { // TODO: Return a better error. return Err(io::Error::new(io::ErrorKind::Other, "signature not found")); @@ -241,9 +241,9 @@ impl ThinClient { /// Check a signature in the bank. This method blocks /// until the server sends a response. - pub fn check_signature(&mut self, sig: &Signature) -> bool { + pub fn check_signature(&mut self, signature: &Signature) -> bool { trace!("check_signature"); - let req = Request::GetSignature { signature: *sig }; + let req = Request::GetSignature { signature: *signature }; let data = serialize(&req).expect("serialize GetSignature in pub fn check_signature"); let now = Instant::now(); let mut done = false; @@ -342,10 +342,10 @@ mod tests { transactions_socket, ); let last_id = client.get_last_id(); - let sig = client + let signature = client .transfer(500, &alice.keypair(), bob_pubkey, &last_id) .unwrap(); - client.poll_for_signature(&sig).unwrap(); + client.poll_for_signature(&signature).unwrap(); let balance = client.get_balance(&bob_pubkey); assert_eq!(balance.unwrap(), 500); exit.store(true, Ordering::Relaxed); @@ -405,8 +405,8 @@ mod tests { contract.tokens = 502; contract.plan = Plan::Budget(Budget::new_payment(502, bob_pubkey)); } - let sig = client.transfer_signed(&tr2).unwrap(); - client.poll_for_signature(&sig).unwrap(); + let signature = client.transfer_signed(&tr2).unwrap(); + client.poll_for_signature(&signature).unwrap(); let balance = client.get_balance(&bob_pubkey); assert_eq!(balance.unwrap(), 500); @@ -452,12 +452,12 @@ mod tests { transactions_socket, ); let last_id = client.get_last_id(); - let sig = client + let signature = client .transfer(500, &alice.keypair(), bob_pubkey, &last_id) .unwrap(); sleep(Duration::from_millis(100)); - assert!(client.check_signature(&sig)); + assert!(client.check_signature(&signature)); exit.store(true, Ordering::Relaxed); server.join().unwrap(); diff --git a/src/transaction.rs b/src/transaction.rs index 9f0914c8ef..d2793e061e 100644 --- a/src/transaction.rs +++ b/src/transaction.rs @@ -79,7 +79,7 @@ pub enum Instruction { #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)] pub struct Transaction { /// A digital signature of `instruction`, `last_id` and `fee`, signed by `Pubkey`. - pub sig: Signature, + pub signature: Signature, /// The `Pubkey` of the entity that signed the transaction data. pub from: Pubkey, @@ -104,7 +104,7 @@ impl Transaction { ) -> Self { let from = from_keypair.pubkey(); let mut tx = Transaction { - sig: Signature::default(), + signature: Signature::default(), instruction, last_id, from, @@ -144,8 +144,8 @@ impl Transaction { } /// Create and sign a new Witness Signature. Used for unit-testing. - pub fn new_signature(from_keypair: &Keypair, tx_sig: Signature, last_id: Hash) -> Self { - let instruction = Instruction::ApplySignature(tx_sig); + pub fn new_signature(from_keypair: &Keypair, signature: Signature, last_id: Hash) -> Self { + let instruction = Instruction::ApplySignature(signature); Self::new_from_instruction(from_keypair, instruction, last_id, 0) } @@ -186,13 +186,13 @@ impl Transaction { /// Sign this transaction. pub fn sign(&mut self, keypair: &Keypair) { let sign_data = self.get_sign_data(); - self.sig = Signature::new(keypair.sign(&sign_data).as_ref()); + self.signature = Signature::new(keypair.sign(&sign_data).as_ref()); } /// Verify only the transaction signature. - pub fn verify_sig(&self) -> bool { + pub fn verify_signature(&self) -> bool { warn!("transaction signature verification called"); - self.sig.verify(&self.from.as_ref(), &self.get_sign_data()) + self.signature.verify(&self.from.as_ref(), &self.get_sign_data()) } /// Verify only the payment plan. @@ -271,7 +271,7 @@ mod tests { instruction, from: Default::default(), last_id: Default::default(), - sig: Default::default(), + signature: Default::default(), fee: 0, }; let buf = serialize(&claim0).unwrap(); @@ -292,7 +292,7 @@ mod tests { } } assert!(tx.verify_plan()); - assert!(!tx.verify_sig()); + assert!(!tx.verify_signature()); } #[test] @@ -309,7 +309,7 @@ mod tests { } } assert!(tx.verify_plan()); - assert!(!tx.verify_sig()); + assert!(!tx.verify_signature()); } #[test] fn test_layout() { @@ -317,7 +317,7 @@ mod tests { let sign_data = tx.get_sign_data(); let tx_bytes = serialize(&tx).unwrap(); assert_matches!(memfind(&tx_bytes, &sign_data), Some(SIGNED_DATA_OFFSET)); - assert_matches!(memfind(&tx_bytes, &tx.sig.as_ref()), Some(SIG_OFFSET)); + assert_matches!(memfind(&tx_bytes, &tx.signature.as_ref()), Some(SIG_OFFSET)); assert_matches!(memfind(&tx_bytes, &tx.from.as_ref()), Some(PUB_KEY_OFFSET)); }