Better names

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<Utc>) -> Result<()> {
+    fn apply_timestamp(&self, from: PublicKey, dt: DateTime<Utc>) -> 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));
     }