Remove blockhash from fee calculation (#20641)

runtime/src/accounts.rs

@@ -486,7 +486,8 @@ impl Accounts {
                                 .cloned()
                         });
                     let fee = if let Some(fee_calculator) = fee_calculator {
-                        tx.message().calculate_fee(&fee_calculator)
+                        tx.message()
+                            .calculate_fee(fee_calculator.lamports_per_signature)
                     } else {
                         return (Err(TransactionError::BlockhashNotFound), None);
                     };

runtime/src/bank.rs

@@ -3108,11 +3108,8 @@ impl Bank {
         &self.fee_rate_governor
     }
 
-    pub fn get_fee_for_message(&self, hash: &Hash, message: &SanitizedMessage) -> Option<u64> {
-        let blockhash_queue = self.blockhash_queue.read().unwrap();
-        #[allow(deprecated)]
-        let fee_calculator = blockhash_queue.get_fee_calculator(hash)?;
-        Some(message.calculate_fee(fee_calculator))
+    pub fn get_fee_for_message(&self, message: &SanitizedMessage) -> Option<u64> {
+        Some(message.calculate_fee(self.fee_rate_governor.lamports_per_signature))
     }
 
     #[deprecated(
@@ -4042,7 +4039,9 @@ impl Bank {
                     });
 
                 let fee_calculator = fee_calculator.ok_or(TransactionError::BlockhashNotFound)?;
-                let fee = tx.message().calculate_fee(&fee_calculator);
+                let fee = tx
+                    .message()
+                    .calculate_fee(fee_calculator.lamports_per_signature);
 
                 match *res {
                     Err(TransactionError::InstructionError(_, _)) => {
@@ -10920,10 +10919,7 @@ pub(crate) mod tests {
         /* Check balances */
         let mut expected_balance = 4_650_000
             - bank
-                .get_fee_for_message(
-                    &bank.last_blockhash(),
-                    &durable_tx.message.try_into().unwrap(),
-                )
+                .get_fee_for_message(&durable_tx.message.try_into().unwrap())
                 .unwrap();
         assert_eq!(bank.get_balance(&custodian_pubkey), expected_balance);
         assert_eq!(bank.get_balance(&nonce_pubkey), 250_000);
@@ -10977,10 +10973,7 @@ pub(crate) mod tests {
         );
         /* Check fee charged and nonce has advanced */
         expected_balance -= bank
-            .get_fee_for_message(
-                &bank.last_blockhash(),
-                &SanitizedMessage::try_from(durable_tx.message.clone()).unwrap(),
-            )
+            .get_fee_for_message(&SanitizedMessage::try_from(durable_tx.message.clone()).unwrap())
             .unwrap();
         assert_eq!(bank.get_balance(&custodian_pubkey), expected_balance);
         assert_ne!(nonce_hash, get_nonce_account(&bank, &nonce_pubkey).unwrap());
@@ -11044,10 +11037,7 @@ pub(crate) mod tests {
             bank.get_balance(&custodian_pubkey),
             initial_custodian_balance
                 - bank
-                    .get_fee_for_message(
-                        &bank.last_blockhash(),
-                        &durable_tx.message.try_into().unwrap()
-                    )
+                    .get_fee_for_message(&durable_tx.message.try_into().unwrap())
                     .unwrap()
         );
         assert_eq!(nonce_hash, get_nonce_account(&bank, &nonce_pubkey).unwrap());
@@ -11099,10 +11089,7 @@ pub(crate) mod tests {
             bank.get_balance(&nonce_pubkey),
             nonce_starting_balance
                 - bank
-                    .get_fee_for_message(
-                        &bank.last_blockhash(),
-                        &durable_tx.message.try_into().unwrap()
-                    )
+                    .get_fee_for_message(&durable_tx.message.try_into().unwrap())
                     .unwrap()
         );
         assert_ne!(nonce_hash, get_nonce_account(&bank, &nonce_pubkey).unwrap());

runtime/src/bank_client.rs

@@ -303,10 +303,10 @@ impl SyncClient for BankClient {
         Ok(self.bank.is_blockhash_valid(blockhash))
     }
 
-    fn get_fee_for_message(&self, blockhash: &Hash, message: &Message) -> Result<u64> {
+    fn get_fee_for_message(&self, message: &Message) -> Result<u64> {
         SanitizedMessage::try_from(message.clone())
             .ok()
-            .and_then(|message| self.bank.get_fee_for_message(blockhash, &message))
+            .and_then(|message| self.bank.get_fee_for_message(&message))
             .ok_or_else(|| {
                 TransportError::IoError(io::Error::new(
                     io::ErrorKind::Other,

runtime/src/snapshot_utils.rs

@@ -3049,9 +3049,7 @@ mod tests {
             bank2.last_blockhash(),
         ))
         .unwrap();
-        let fee = bank2
-            .get_fee_for_message(&bank2.last_blockhash(), tx.message())
-            .unwrap();
+        let fee = bank2.get_fee_for_message(tx.message()).unwrap();
         let tx = system_transaction::transfer(
             &key1,
             &key2.pubkey(),