Remove dead code that still fetches lamports-per-signature from nonce or from blockhash_queue

banks-server/src/banks_server.rs

@@ -419,7 +419,7 @@ impl Banks for BanksServer {
     ) -> Option<u64> {
         let bank = self.bank(commitment);
         let sanitized_message = SanitizedMessage::try_from(message).ok()?;
-        bank.get_fee_for_message(&sanitized_message)
+        Some(bank.get_fee_for_message(&sanitized_message))
     }
 }
 

core/src/banking_stage/consumer.rs

@@ -714,7 +714,6 @@ impl Consumer {
             process_compute_budget_instructions(message.program_instructions_iter())?.into();
         let fee = bank.fee_structure.calculate_fee(
             message,
-            bank.get_lamports_per_signature(),
             &budget_limits,
             bank.feature_set.is_active(
                 &feature_set::include_loaded_accounts_data_size_in_fee_calculation::id(),

programs/sbf/tests/programs.rs

@@ -16,7 +16,7 @@ use {
         parse_bpf_upgradeable_loader, BpfUpgradeableLoaderAccountType,
     },
     solana_accounts_db::transaction_results::{
-        DurableNonceFee, InnerInstruction, TransactionExecutionDetails, TransactionExecutionResult,
+        InnerInstruction, TransactionExecutionDetails, TransactionExecutionResult,
         TransactionResults,
     },
     solana_ledger::token_balances::collect_token_balances,
@@ -190,25 +190,13 @@ fn execute_transactions(
                         status,
                         log_messages,
                         inner_instructions,
-                        durable_nonce_fee,
                         return_data,
                         executed_units,
                         ..
                     } = details;
 
-                    let lamports_per_signature = match durable_nonce_fee {
-                        Some(DurableNonceFee::Valid(lamports_per_signature)) => {
-                            Some(lamports_per_signature)
-                        }
-                        Some(DurableNonceFee::Invalid) => None,
-                        None => bank.get_lamports_per_signature_for_blockhash(
-                            &tx.message().recent_blockhash,
-                        ),
-                    }
-                    .expect("lamports_per_signature must be available");
-                    let fee = bank.get_fee_for_message_with_lamports_per_signature(
+                    let fee = bank.get_fee_for_message(
                         &SanitizedMessage::try_from(tx.message().clone()).unwrap(),
-                        lamports_per_signature,
                     );
 
                     let inner_instructions = inner_instructions.map(|inner_instructions| {
@@ -3985,7 +3973,6 @@ fn test_program_fees() {
     let sanitized_message = SanitizedMessage::try_from(message.clone()).unwrap();
     let expected_normal_fee = fee_structure.calculate_fee(
         &sanitized_message,
-        congestion_multiplier,
         &process_compute_budget_instructions(sanitized_message.program_instructions_iter())
             .unwrap_or_default()
             .into(),
@@ -4008,7 +3995,6 @@ fn test_program_fees() {
     let sanitized_message = SanitizedMessage::try_from(message.clone()).unwrap();
     let expected_prioritized_fee = fee_structure.calculate_fee(
         &sanitized_message,
-        congestion_multiplier,
         &process_compute_budget_instructions(sanitized_message.program_instructions_iter())
             .unwrap_or_default()
             .into(),

rpc/src/rpc.rs

@@ -4017,7 +4017,7 @@ pub mod rpc_full {
                 .map_err(|err| {
                     Error::invalid_params(format!("invalid transaction message: {err}"))
                 })?;
-            let fee = bank.get_fee_for_message(&sanitized_message);
+            let fee = Some(bank.get_fee_for_message(&sanitized_message));
             Ok(new_response(bank, fee))
         }
 

rpc/src/transaction_status_service.rs

@@ -2,7 +2,7 @@ use {
     crate::transaction_notifier_interface::TransactionNotifierArc,
     crossbeam_channel::{Receiver, RecvTimeoutError},
     itertools::izip,
-    solana_accounts_db::transaction_results::{DurableNonceFee, TransactionExecutionDetails},
+    solana_accounts_db::transaction_results::TransactionExecutionDetails,
     solana_ledger::{
         blockstore::Blockstore,
         blockstore_processor::{TransactionStatusBatch, TransactionStatusMessage},
@@ -99,25 +99,11 @@ impl TransactionStatusService {
                             status,
                             log_messages,
                             inner_instructions,
-                            durable_nonce_fee,
                             return_data,
                             executed_units,
                             ..
                         } = details;
-                        let lamports_per_signature = match durable_nonce_fee {
-                            Some(DurableNonceFee::Valid(lamports_per_signature)) => {
-                                Some(lamports_per_signature)
-                            }
-                            Some(DurableNonceFee::Invalid) => None,
-                            None => bank.get_lamports_per_signature_for_blockhash(
-                                transaction.message().recent_blockhash(),
-                            ),
-                        }
-                        .expect("lamports_per_signature must be available");
-                        let fee = bank.get_fee_for_message_with_lamports_per_signature(
-                            transaction.message(),
-                            lamports_per_signature,
-                        );
+                        let fee = bank.get_fee_for_message(transaction.message());
                         let tx_account_locks = transaction.get_account_locks_unchecked();
 
                         let inner_instructions = inner_instructions.map(|inner_instructions| {
@@ -215,6 +201,7 @@ pub(crate) mod tests {
         solana_accounts_db::{
             nonce_info::{NonceFull, NoncePartial},
             rent_debits::RentDebits,
+            transaction_results::DurableNonceFee,
         },
         solana_ledger::{genesis_utils::create_genesis_config, get_tmp_ledger_path_auto_delete},
         solana_runtime::bank::{Bank, TransactionBalancesSet},

runtime/src/bank.rs

@@ -4013,20 +4013,6 @@ impl Bank {
         &self.fee_rate_governor
     }
 
-    pub fn get_fee_for_message(&self, message: &SanitizedMessage) -> Option<u64> {
-        let lamports_per_signature = {
-            let blockhash_queue = self.blockhash_queue.read().unwrap();
-            blockhash_queue.get_lamports_per_signature(message.recent_blockhash())
-        }
-        .or_else(|| {
-            self.check_message_for_nonce(message)
-                .and_then(|(address, account)| {
-                    NoncePartial::new(address, account).lamports_per_signature()
-                })
-        })?;
-        Some(self.get_fee_for_message_with_lamports_per_signature(message, lamports_per_signature))
-    }
-
     /// Returns true when startup accounts hash verification has completed or never had to run in background.
     pub fn get_startup_verification_complete(&self) -> &Arc<AtomicBool> {
         &self
@@ -4058,14 +4044,9 @@ impl Bank {
             .verification_complete()
     }
 
-    pub fn get_fee_for_message_with_lamports_per_signature(
-        &self,
-        message: &SanitizedMessage,
-        lamports_per_signature: u64,
-    ) -> u64 {
+    pub fn get_fee_for_message(&self, message: &SanitizedMessage) -> u64 {
         self.fee_structure.calculate_fee(
             message,
-            lamports_per_signature,
             &process_compute_budget_instructions(message.program_instructions_iter())
                 .unwrap_or_default()
                 .into(),
@@ -5236,7 +5217,6 @@ impl Bank {
             &self.ancestors,
             sanitized_txs,
             check_results,
-            &self.blockhash_queue.read().unwrap(),
             error_counters,
             &self.rent_collector,
             &self.feature_set,
@@ -5540,7 +5520,7 @@ impl Bank {
                     TransactionExecutionResult::NotExecuted(err) => Err(err.clone()),
                 }?;
 
-                let (lamports_per_signature, is_nonce) = durable_nonce_fee
+                let (_lamports_per_signature, is_nonce) = durable_nonce_fee
                     .map(|durable_nonce_fee| durable_nonce_fee.lamports_per_signature())
                     .map(|maybe_lamports_per_signature| (maybe_lamports_per_signature, true))
                     .unwrap_or_else(|| {
@@ -5550,12 +5530,7 @@ impl Bank {
                         )
                     });
 
-                let lamports_per_signature =
-                    lamports_per_signature.ok_or(TransactionError::BlockhashNotFound)?;
-                let fee = self.get_fee_for_message_with_lamports_per_signature(
-                    tx.message(),
-                    lamports_per_signature,
-                );
+                let fee = self.get_fee_for_message(tx.message());
 
                 // In case of instruction error, even though no accounts
                 // were stored we still need to charge the payer the