From 71cb7d5c974d3769819a7fdb4616c240f8477a70 Mon Sep 17 00:00:00 2001 From: Greg Fitzgerald Date: Tue, 29 May 2018 10:01:40 -0600 Subject: [PATCH] Better names --- src/bank.rs | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/src/bank.rs b/src/bank.rs index 69e5c8343f..e6f05e2b73 100644 --- a/src/bank.rs +++ b/src/bank.rs @@ -158,13 +158,13 @@ impl Bank { /// Deduct tokens from the 'from' address the account has sufficient /// funds and isn't a duplicate. - fn process_transaction_debits(&self, tx: &Transaction) -> Result<()> { + fn apply_debits(&self, tx: &Transaction) -> Result<()> { if let Instruction::NewContract(contract) = &tx.instruction { trace!("Transaction {}", contract.tokens); } let bals = self.balances .read() - .expect("'balances' read lock in process_transaction_debits"); + .expect("'balances' read lock in apply_debits"); let option = bals.get(&tx.from); if option.is_none() { @@ -205,36 +205,36 @@ impl Bank { } } - fn process_transaction_credits(&self, tx: &Transaction) { + fn apply_credits(&self, tx: &Transaction) { match &tx.instruction { Instruction::NewContract(contract) => { let mut plan = contract.plan.clone(); plan.apply_witness(&Witness::Timestamp(*self.last_time .read() - .expect("timestamp creation in process_transaction_credits"))); + .expect("timestamp creation in apply_credits"))); if let Some(ref payment) = plan.final_payment() { apply_payment(&self.balances, payment); } else { let mut pending = self.pending .write() - .expect("'pending' write lock in process_transaction_credits"); + .expect("'pending' write lock in apply_credits"); pending.insert(tx.sig, plan); } } Instruction::ApplyTimestamp(dt) => { - let _ = self.process_timestamp(tx.from, *dt); + let _ = self.apply_timestamp(tx.from, *dt); } Instruction::ApplySignature(tx_sig) => { - let _ = self.process_signature(tx.from, *tx_sig); + let _ = self.apply_signature(tx.from, *tx_sig); } } } /// Process a Transaction. fn process_transaction(&self, tx: &Transaction) -> Result<()> { - self.process_transaction_debits(tx)?; - self.process_transaction_credits(tx); + self.apply_debits(tx)?; + self.apply_credits(tx); Ok(()) } @@ -244,14 +244,14 @@ impl Bank { // in parallel deterministically. info!("processing Transactions {}", trs.len()); let results: Vec<_> = trs.into_par_iter() - .map(|tx| self.process_transaction_debits(&tx).map(|_| tx)) + .map(|tx| self.apply_debits(&tx).map(|_| tx)) .collect(); // Calling collect() here forces all debits to complete before moving on. results .into_par_iter() .map(|result| { result.map(|tx| { - self.process_transaction_credits(&tx); + self.apply_credits(&tx); tx }) }) @@ -269,10 +269,10 @@ impl Bank { } /// Process a Witness Signature. - fn process_signature(&self, from: PublicKey, tx_sig: Signature) -> Result<()> { + fn apply_signature(&self, from: PublicKey, tx_sig: Signature) -> Result<()> { if let Occupied(mut e) = self.pending .write() - .expect("write() in process_signature") + .expect("write() in apply_signature") .entry(tx_sig) { e.get_mut().apply_witness(&Witness::Signature(from)); @@ -286,7 +286,7 @@ impl Bank { } /// Process a Witness Timestamp. - fn process_timestamp(&self, from: PublicKey, dt: DateTime) -> Result<()> { + fn apply_timestamp(&self, from: PublicKey, dt: DateTime) -> Result<()> { // If this is the first timestamp we've seen, it probably came from the genesis block, // so we'll trust it. if *self.last_time @@ -319,7 +319,7 @@ impl Bank { // double-spend if it enters before the modified plan is removed from 'pending'. let mut pending = self.pending .write() - .expect("'pending' write lock in process_timestamp"); + .expect("'pending' write lock in apply_timestamp"); for (key, plan) in pending.iter_mut() { plan.apply_witness(&Witness::Timestamp(*self.last_time .read() @@ -465,14 +465,14 @@ mod tests { // Now, acknowledge the time in the condition occurred and // that pubkey's funds are now available. - bank.process_timestamp(mint.pubkey(), dt).unwrap(); + bank.apply_timestamp(mint.pubkey(), dt).unwrap(); assert_eq!(bank.get_balance(&pubkey), Some(1)); // tx count is still 1, because we chose not to count timestamp transactions // tx count. assert_eq!(bank.transaction_count(), 1); - bank.process_timestamp(mint.pubkey(), dt).unwrap(); // <-- Attack! Attempt to process completed transaction. + bank.apply_timestamp(mint.pubkey(), dt).unwrap(); // <-- Attack! Attempt to process completed transaction. assert_ne!(bank.get_balance(&pubkey), Some(2)); } @@ -482,7 +482,7 @@ mod tests { let bank = Bank::new(&mint); let pubkey = KeyPair::new().pubkey(); let dt = Utc::now(); - bank.process_timestamp(mint.pubkey(), dt).unwrap(); + bank.apply_timestamp(mint.pubkey(), dt).unwrap(); // It's now past now, so this transfer should be processed immediately. bank.transfer_on_date(1, &mint.keypair(), pubkey, dt, mint.last_id()) @@ -512,14 +512,14 @@ mod tests { assert_eq!(bank.get_balance(&pubkey), None); // Now, cancel the trancaction. Mint gets her funds back, pubkey never sees them. - bank.process_signature(mint.pubkey(), sig).unwrap(); + bank.apply_signature(mint.pubkey(), sig).unwrap(); assert_eq!(bank.get_balance(&mint.pubkey()), Some(1)); assert_eq!(bank.get_balance(&pubkey), None); // Assert cancel doesn't cause count to go backward. assert_eq!(bank.transaction_count(), 1); - bank.process_signature(mint.pubkey(), sig).unwrap(); // <-- Attack! Attempt to cancel completed transaction. + bank.apply_signature(mint.pubkey(), sig).unwrap(); // <-- Attack! Attempt to cancel completed transaction. assert_ne!(bank.get_balance(&mint.pubkey()), Some(2)); }