Remove `calculate-fee` callback from SVM (#5303)

* Remove calculate-fee callback from SVM

* move 0 lamports_per_sig check out of SVM

Cargo.lock

@@ -9019,6 +9019,7 @@ dependencies = [
  "solana-epoch-rewards",
  "solana-epoch-schedule",
  "solana-feature-set",
+ "solana-fee-structure",
  "solana-frozen-abi",
  "solana-frozen-abi-macro",
  "solana-hash",

compute-budget/src/compute_budget.rs

@@ -3,8 +3,9 @@ pub use solana_program_runtime::execution_budget::{
     MAX_INSTRUCTION_STACK_DEPTH, STACK_FRAME_SIZE,
 };
 use {
-    crate::compute_budget_limits::ComputeBudgetLimits, solana_fee_structure::FeeBudgetLimits,
+    crate::compute_budget_limits::ComputeBudgetLimits, solana_fee_structure::FeeDetails,
     solana_program_runtime::execution_budget::SVMTransactionExecutionAndFeeBudgetLimits,
+    std::num::NonZeroU32,
 };
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -240,13 +241,13 @@ impl ComputeBudget {
 
     pub fn get_compute_budget_and_limits(
         &self,
-        compute_budget_limits: &ComputeBudgetLimits,
+        loaded_accounts_data_size_limit: NonZeroU32,
+        fee_details: FeeDetails,
     ) -> SVMTransactionExecutionAndFeeBudgetLimits {
-        let fee_budget = FeeBudgetLimits::from(compute_budget_limits);
         SVMTransactionExecutionAndFeeBudgetLimits {
             budget: self.to_budget(),
-            loaded_accounts_data_size_limit: fee_budget.loaded_accounts_data_size_limit,
-            priority_fee: fee_budget.prioritization_fee,
+            loaded_accounts_data_size_limit,
+            fee_details,
         }
     }
 }

compute-budget/src/compute_budget_limits.rs

@@ -6,7 +6,7 @@ pub use solana_program_runtime::execution_budget::{
     MAX_LOADED_ACCOUNTS_DATA_SIZE_BYTES, MIN_HEAP_FRAME_BYTES,
 };
 use {
-    solana_fee_structure::FeeBudgetLimits,
+    solana_fee_structure::{FeeBudgetLimits, FeeDetails},
     solana_program_runtime::execution_budget::{
         SVMTransactionExecutionAndFeeBudgetLimits, SVMTransactionExecutionBudget,
     },
@@ -38,22 +38,25 @@ impl Default for ComputeBudgetLimits {
 }
 
 impl ComputeBudgetLimits {
-    pub fn default_compute_budget_and_limits() -> SVMTransactionExecutionAndFeeBudgetLimits {
-        Self::get_compute_budget_and_limits(&ComputeBudgetLimits::default())
-    }
-
-    pub fn get_compute_budget_and_limits(&self) -> SVMTransactionExecutionAndFeeBudgetLimits {
-        let fee_budget = FeeBudgetLimits::from(self);
+    pub fn get_compute_budget_and_limits(
+        &self,
+        loaded_accounts_data_size_limit: NonZeroU32,
+        fee_details: FeeDetails,
+    ) -> SVMTransactionExecutionAndFeeBudgetLimits {
         SVMTransactionExecutionAndFeeBudgetLimits {
             budget: SVMTransactionExecutionBudget {
                 compute_unit_limit: u64::from(self.compute_unit_limit),
                 heap_size: self.updated_heap_bytes,
                 ..SVMTransactionExecutionBudget::default()
             },
-            loaded_accounts_data_size_limit: fee_budget.loaded_accounts_data_size_limit,
-            priority_fee: fee_budget.prioritization_fee,
+            loaded_accounts_data_size_limit,
+            fee_details,
         }
     }
+
+    pub fn get_prioritization_fee(&self) -> u64 {
+        get_prioritization_fee(self.compute_unit_price, u64::from(self.compute_unit_limit))
+    }
 }
 
 fn get_prioritization_fee(compute_unit_price: u64, compute_unit_limit: u64) -> u64 {

program-runtime/Cargo.toml

@@ -23,6 +23,7 @@ solana-clock = { workspace = true }
 solana-epoch-rewards = { workspace = true }
 solana-epoch-schedule = { workspace = true }
 solana-feature-set = { workspace = true }
+solana-fee-structure = { workspace = true }
 solana-frozen-abi = { workspace = true, optional = true, features = [
     "frozen-abi",
 ] }

program-runtime/src/execution_budget.rs

@@ -1,4 +1,6 @@
-use {solana_program_entrypoint::HEAP_LENGTH, std::num::NonZeroU32};
+use {
+    solana_fee_structure::FeeDetails, solana_program_entrypoint::HEAP_LENGTH, std::num::NonZeroU32,
+};
 
 /// Max instruction stack depth. This is the maximum nesting of instructions that can happen during
 /// a transaction.
@@ -236,7 +238,7 @@ impl SVMTransactionExecutionCost {
 pub struct SVMTransactionExecutionAndFeeBudgetLimits {
     pub budget: SVMTransactionExecutionBudget,
     pub loaded_accounts_data_size_limit: NonZeroU32,
-    pub priority_fee: u64,
+    pub fee_details: FeeDetails,
 }
 
 #[cfg(feature = "dev-context-only-utils")]
@@ -245,7 +247,17 @@ impl Default for SVMTransactionExecutionAndFeeBudgetLimits {
         Self {
             budget: SVMTransactionExecutionBudget::default(),
             loaded_accounts_data_size_limit: MAX_LOADED_ACCOUNTS_DATA_SIZE_BYTES,
-            priority_fee: 0,
+            fee_details: FeeDetails::default(),
+        }
+    }
+}
+
+#[cfg(feature = "dev-context-only-utils")]
+impl SVMTransactionExecutionAndFeeBudgetLimits {
+    pub fn with_fee(fee_details: FeeDetails) -> Self {
+        Self {
+            fee_details,
+            ..SVMTransactionExecutionAndFeeBudgetLimits::default()
         }
     }
 }

programs/sbf/Cargo.lock

@@ -7047,6 +7047,7 @@ dependencies = [
  "solana-epoch-rewards",
  "solana-epoch-schedule",
  "solana-feature-set",
+ "solana-fee-structure",
  "solana-hash",
  "solana-instruction",
  "solana-last-restart-slot",

runtime/src/bank.rs

@@ -6953,25 +6953,6 @@ impl TransactionProcessingCallback for Bank {
             .map(|(stake, _)| (*stake))
             .unwrap_or(0)
     }
-
-    // Overrides default TransactionProcessingCallback::calculate_fee() to calculate actual transaction fee;
-    // Checking for `zero_fees_for_test` is done at callsite (eg. transaction_processor) where blockhash_queue's
-    // lamports_per_signature is checked ` == 0`.
-    fn calculate_fee(
-        &self,
-        message: &impl SVMMessage,
-        lamports_per_signature: u64,
-        prioritization_fee: u64,
-        feature_set: &FeatureSet,
-    ) -> FeeDetails {
-        solana_fee::calculate_fee_details(
-            message,
-            false, /* zero_fees_for_test */
-            lamports_per_signature,
-            prioritization_fee,
-            FeeFeatures::from(feature_set),
-        )
-    }
 }
 
 #[cfg(feature = "dev-context-only-utils")]

runtime/src/bank/check_transactions.rs

@@ -2,6 +2,8 @@ use {
     super::{Bank, BankStatusCache},
     solana_accounts_db::blockhash_queue::BlockhashQueue,
     solana_compute_budget_instruction::instructions_processor::process_compute_budget_instructions,
+    solana_feature_set::FeatureSet,
+    solana_fee::{calculate_fee_details, FeeFeatures},
     solana_perf::perf_libs,
     solana_program_runtime::execution_budget::SVMTransactionExecutionAndFeeBudgetLimits,
     solana_runtime_transaction::transaction_with_meta::TransactionWithMeta,
@@ -12,6 +14,7 @@ use {
             MAX_PROCESSING_AGE, MAX_TRANSACTION_FORWARDING_DELAY,
             MAX_TRANSACTION_FORWARDING_DELAY_GPU,
         },
+        fee::{FeeBudgetLimits, FeeDetails},
         nonce::{
             state::{
                 Data as NonceData, DurableNonce, State as NonceState, Versions as NonceVersions,
@@ -92,6 +95,9 @@ impl Bank {
             .get_lamports_per_signature(&last_blockhash)
             .unwrap();
 
+        let feature_set: &FeatureSet = &self.feature_set;
+        let fee_features = FeeFeatures::from(feature_set);
+
         sanitized_txs
             .iter()
             .zip(lock_results)
@@ -99,16 +105,30 @@ impl Bank {
                 Ok(()) => {
                     let compute_budget_and_limits = process_compute_budget_instructions(
                         tx.borrow().program_instructions_iter(),
-                        &self.feature_set,
+                        feature_set,
                     )
                     .map(|limit| {
+                        let fee_budget = FeeBudgetLimits::from(limit);
+                        let fee_details = calculate_fee_details(
+                            tx.borrow(),
+                            false,
+                            self.fee_structure.lamports_per_signature,
+                            fee_budget.prioritization_fee,
+                            fee_features,
+                        );
                         if let Some(compute_budget) = self.compute_budget {
                             // This block of code is only necessary to retain legacy behavior of the code.
                             // It should be removed along with the change to favor transaction's compute budget limits
                             // over configured compute budget in Bank.
-                            compute_budget.get_compute_budget_and_limits(&limit)
+                            compute_budget.get_compute_budget_and_limits(
+                                fee_budget.loaded_accounts_data_size_limit,
+                                fee_details,
+                            )
                         } else {
-                            limit.get_compute_budget_and_limits()
+                            limit.get_compute_budget_and_limits(
+                                fee_budget.loaded_accounts_data_size_limit,
+                                fee_details,
+                            )
                         }
                     });
                     self.check_transaction_age(
@@ -126,6 +146,28 @@ impl Bank {
             .collect()
     }
 
+    fn checked_transactions_details_with_test_override(
+        nonce: Option<NonceInfo>,
+        lamports_per_signature: u64,
+        compute_budget_and_limits: Result<
+            SVMTransactionExecutionAndFeeBudgetLimits,
+            TransactionError,
+        >,
+    ) -> CheckedTransactionDetails {
+        let compute_budget_and_limits = if lamports_per_signature == 0 {
+            // This is done to support legacy tests. The tests should be updated, and check
+            // for 0 lamports_per_signature should be removed from the code.
+            compute_budget_and_limits.map(|v| SVMTransactionExecutionAndFeeBudgetLimits {
+                budget: v.budget,
+                loaded_accounts_data_size_limit: v.loaded_accounts_data_size_limit,
+                fee_details: FeeDetails::default(),
+            })
+        } else {
+            compute_budget_and_limits
+        };
+        CheckedTransactionDetails::new(nonce, lamports_per_signature, compute_budget_and_limits)
+    }
+
     fn check_transaction_age(
         &self,
         tx: &impl SVMMessage,
@@ -138,7 +180,7 @@ impl Bank {
     ) -> TransactionCheckResult {
         let recent_blockhash = tx.recent_blockhash();
         if let Some(hash_info) = hash_queue.get_hash_info_if_valid(recent_blockhash, max_age) {
-            Ok(CheckedTransactionDetails::new(
+            Ok(Self::checked_transactions_details_with_test_override(
                 None,
                 hash_info.lamports_per_signature(),
                 compute_budget,
@@ -150,7 +192,7 @@ impl Bank {
                 next_lamports_per_signature,
             )
         {
-            Ok(CheckedTransactionDetails::new(
+            Ok(Self::checked_transactions_details_with_test_override(
                 Some(nonce),
                 previous_lamports_per_signature,
                 compute_budget,

svm/examples/Cargo.lock

@@ -6871,6 +6871,7 @@ dependencies = [
  "solana-epoch-rewards",
  "solana-epoch-schedule",
  "solana-feature-set",
+ "solana-fee-structure",
  "solana-hash",
  "solana-instruction",
  "solana-last-restart-slot",
@@ -7901,6 +7902,7 @@ dependencies = [
  "solana-bpf-loader-program",
  "solana-client",
  "solana-compute-budget",
+ "solana-fee-structure",
  "solana-logger",
  "solana-program-runtime",
  "solana-sdk",

svm/examples/paytube/Cargo.toml

@@ -9,6 +9,7 @@ publish = false
 solana-bpf-loader-program = { workspace = true }
 solana-client = { workspace = true }
 solana-compute-budget = { workspace = true }
+solana-fee-structure = "=2.2.1"
 solana-logger = { workspace = true }
 solana-program-runtime = { workspace = true, features = ["dev-context-only-utils"] }
 solana-sdk = { workspace = true }

svm/examples/paytube/src/processor.rs

@@ -3,6 +3,7 @@
 use {
     solana_bpf_loader_program::syscalls::create_program_runtime_environment_v1,
     solana_compute_budget::compute_budget_limits::ComputeBudgetLimits,
+    solana_fee_structure::FeeDetails,
     solana_program_runtime::{
         execution_budget::SVMTransactionExecutionBudget,
         loaded_programs::{BlockRelation, ForkGraph, ProgramCacheEntry},
@@ -95,11 +96,15 @@ pub(crate) fn get_transaction_check_results(
     len: usize,
     lamports_per_signature: u64,
 ) -> Vec<transaction::Result<CheckedTransactionDetails>> {
+    let compute_budget_limit = ComputeBudgetLimits::default();
     vec![
         transaction::Result::Ok(CheckedTransactionDetails::new(
             None,
             lamports_per_signature,
-            Ok(ComputeBudgetLimits::default_compute_budget_and_limits())
+            Ok(compute_budget_limit.get_compute_budget_and_limits(
+                compute_budget_limit.loaded_accounts_bytes,
+                FeeDetails::default()
+            )),
         ));
         len
     ]

svm/src/account_loader.rs

@@ -80,7 +80,7 @@ impl Default for CheckedTransactionDetails {
                 budget: SVMTransactionExecutionBudget::default(),
                 loaded_accounts_data_size_limit: NonZeroU32::new(32)
                     .expect("Failed to set loaded_accounts_bytes"),
-                priority_fee: 0,
+                fee_details: FeeDetails::default(),
             }),
         }
     }

svm/src/transaction_processing_callback.rs

@@ -1,8 +1,4 @@
-use {
-    solana_account::AccountSharedData, solana_feature_set::FeatureSet,
-    solana_fee_structure::FeeDetails, solana_pubkey::Pubkey,
-    solana_svm_transaction::svm_message::SVMMessage,
-};
+use {solana_account::AccountSharedData, solana_pubkey::Pubkey};
 
 /// Runtime callbacks for transaction processing.
 pub trait TransactionProcessingCallback {
@@ -18,15 +14,6 @@ pub trait TransactionProcessingCallback {
     fn get_current_epoch_vote_account_stake(&self, _vote_address: &Pubkey) -> u64 {
         0
     }
-    fn calculate_fee(
-        &self,
-        _message: &impl SVMMessage,
-        _lamports_per_signature: u64,
-        _prioritization_fee: u64,
-        _feature_set: &FeatureSet,
-    ) -> FeeDetails {
-        FeeDetails::default()
-    }
 }
 
 /// The state the account is in initially, before transaction processing

svm/src/transaction_processor.rs

@@ -26,7 +26,7 @@ use {
     },
     solana_clock::{Epoch, Slot},
     solana_feature_set::{remove_accounts_executable_flag_checks, FeatureSet},
-    solana_fee_structure::{FeeDetails, FeeStructure},
+    solana_fee_structure::FeeStructure,
     solana_hash::Hash,
     solana_instruction::TRANSACTION_LEVEL_STACK_HEIGHT,
     solana_log_collector::LogCollector,
@@ -411,12 +411,10 @@ impl<FG: ForkGraph> TransactionBatchProcessor<FG> {
                         tx,
                         tx_details,
                         &environment.blockhash,
-                        environment.fee_lamports_per_signature,
                         environment
                             .rent_collector
                             .unwrap_or(&RentCollector::default()),
                         &mut error_metrics,
-                        callbacks,
                     )
                 }));
             validate_fees_us = validate_fees_us.saturating_add(single_validate_fees_us);
@@ -512,10 +510,8 @@ impl<FG: ForkGraph> TransactionBatchProcessor<FG> {
         message: &impl SVMMessage,
         checked_details: CheckedTransactionDetails,
         environment_blockhash: &Hash,
-        fee_lamports_per_signature: u64,
         rent_collector: &dyn SVMRentCollector,
         error_counters: &mut TransactionErrorMetrics,
-        callbacks: &CB,
     ) -> TransactionResult<ValidatedTransactionDetails> {
         // If this is a nonce transaction, validate the nonce info.
         // This must be done for every transaction to support SIMD83 because
@@ -542,10 +538,8 @@ impl<FG: ForkGraph> TransactionBatchProcessor<FG> {
             account_loader,
             message,
             checked_details,
-            fee_lamports_per_signature,
             rent_collector,
             error_counters,
-            callbacks,
         )
     }
 
@@ -556,14 +550,12 @@ impl<FG: ForkGraph> TransactionBatchProcessor<FG> {
         account_loader: &mut AccountLoader<CB>,
         message: &impl SVMMessage,
         checked_details: CheckedTransactionDetails,
-        fee_lamports_per_signature: u64,
         rent_collector: &dyn SVMRentCollector,
         error_counters: &mut TransactionErrorMetrics,
-        callbacks: &CB,
     ) -> TransactionResult<ValidatedTransactionDetails> {
         let CheckedTransactionDetails {
             nonce,
-            lamports_per_signature,
+            lamports_per_signature: _,
             compute_budget_and_limits,
         } = checked_details;
 
@@ -588,17 +580,6 @@ impl<FG: ForkGraph> TransactionBatchProcessor<FG> {
         )
         .rent_amount;
 
-        let fee_details = if lamports_per_signature == 0 {
-            FeeDetails::default()
-        } else {
-            callbacks.calculate_fee(
-                message,
-                fee_lamports_per_signature,
-                compute_budget_and_limits.priority_fee,
-                account_loader.feature_set.as_ref(),
-            )
-        };
-
         let fee_payer_index = 0;
         validate_fee_payer(
             fee_payer_address,
@@ -606,7 +587,7 @@ impl<FG: ForkGraph> TransactionBatchProcessor<FG> {
             fee_payer_index,
             error_counters,
             rent_collector,
-            fee_details.total_fee(),
+            compute_budget_and_limits.fee_details.total_fee(),
         )?;
 
         // Capture fee-subtracted fee payer account and next nonce account state
@@ -620,7 +601,7 @@ impl<FG: ForkGraph> TransactionBatchProcessor<FG> {
         );
 
         Ok(ValidatedTransactionDetails {
-            fee_details,
+            fee_details: compute_budget_and_limits.fee_details,
             rollback_accounts,
             loaded_accounts_bytes_limit: compute_budget_and_limits.loaded_accounts_data_size_limit,
             compute_budget: compute_budget_and_limits.budget,
@@ -1205,7 +1186,7 @@ mod tests {
         solana_epoch_schedule::EpochSchedule,
         solana_feature_set::FeatureSet,
         solana_fee_calculator::FeeCalculator,
-        solana_fee_structure::{FeeDetails, FeeStructure},
+        solana_fee_structure::FeeDetails,
         solana_hash::Hash,
         solana_keypair::Keypair,
         solana_message::{LegacyMessage, Message, MessageHeader, SanitizedMessage},
@@ -1296,13 +1277,13 @@ mod tests {
                 .or_default()
                 .push((account, is_writable));
         }
+    }
 
-        fn calculate_fee(
-            &self,
+    impl MockBankCallback {
+        pub fn calculate_fee_details(
             message: &impl SVMMessage,
             lamports_per_signature: u64,
             prioritization_fee: u64,
-            _feature_set: &FeatureSet,
         ) -> FeeDetails {
             let signature_count = message
                 .num_transaction_signatures()
@@ -2178,7 +2159,7 @@ mod tests {
                 compute_unit_limit: 2000,
                 ..SVMTransactionExecutionBudget::default()
             },
-            priority_fee,
+            fee_details: FeeDetails::new(transaction_fee, priority_fee),
             ..SVMTransactionExecutionAndFeeBudgetLimits::default()
         };
         let result =
@@ -2191,10 +2172,8 @@ mod tests {
                     Ok(compute_budget_and_limits),
                 ),
                 &Hash::default(),
-                FeeStructure::default().lamports_per_signature,
                 &rent_collector,
                 &mut error_counters,
-                &mock_bank,
             );
 
         let post_validation_fee_payer_account = {
@@ -2260,7 +2239,9 @@ mod tests {
         let mut account_loader = (&mock_bank).into();
 
         let mut error_counters = TransactionErrorMetrics::default();
-        let compute_budget_and_limits = SVMTransactionExecutionAndFeeBudgetLimits::default();
+        let compute_budget_and_limits = SVMTransactionExecutionAndFeeBudgetLimits::with_fee(
+            MockBankCallback::calculate_fee_details(&message, lamports_per_signature, 0),
+        );
         let result =
             TransactionBatchProcessor::<TestForkGraph>::validate_transaction_nonce_and_fee_payer(
                 &mut account_loader,
@@ -2271,10 +2252,8 @@ mod tests {
                     Ok(compute_budget_and_limits),
                 ),
                 &Hash::default(),
-                FeeStructure::default().lamports_per_signature,
                 &rent_collector,
                 &mut error_counters,
-                &mock_bank,
             );
 
         let post_validation_fee_payer_account = {
@@ -2326,10 +2305,8 @@ mod tests {
                     Ok(SVMTransactionExecutionAndFeeBudgetLimits::default()),
                 ),
                 &Hash::default(),
-                FeeStructure::default().lamports_per_signature,
                 &RentCollector::default(),
                 &mut error_counters,
-                &mock_bank,
             );
 
         assert_eq!(error_counters.account_not_found.0, 1);
@@ -2359,13 +2336,17 @@ mod tests {
                 CheckedTransactionDetails::new(
                     None,
                     lamports_per_signature,
-                    Ok(SVMTransactionExecutionAndFeeBudgetLimits::default()),
+                    Ok(SVMTransactionExecutionAndFeeBudgetLimits::with_fee(
+                        MockBankCallback::calculate_fee_details(
+                            &message,
+                            lamports_per_signature,
+                            0,
+                        ),
+                    )),
                 ),
                 &Hash::default(),
-                FeeStructure::default().lamports_per_signature,
                 &RentCollector::default(),
                 &mut error_counters,
-                &mock_bank,
             );
 
         assert_eq!(error_counters.insufficient_funds.0, 1);
@@ -2399,13 +2380,17 @@ mod tests {
                 CheckedTransactionDetails::new(
                     None,
                     lamports_per_signature,
-                    Ok(SVMTransactionExecutionAndFeeBudgetLimits::default()),
+                    Ok(SVMTransactionExecutionAndFeeBudgetLimits::with_fee(
+                        MockBankCallback::calculate_fee_details(
+                            &message,
+                            lamports_per_signature,
+                            0,
+                        ),
+                    )),
                 ),
                 &Hash::default(),
-                FeeStructure::default().lamports_per_signature,
                 &rent_collector,
                 &mut error_counters,
-                &mock_bank,
             );
 
         assert_eq!(
@@ -2437,13 +2422,17 @@ mod tests {
                 CheckedTransactionDetails::new(
                     None,
                     lamports_per_signature,
-                    Ok(SVMTransactionExecutionAndFeeBudgetLimits::default()),
+                    Ok(SVMTransactionExecutionAndFeeBudgetLimits::with_fee(
+                        MockBankCallback::calculate_fee_details(
+                            &message,
+                            lamports_per_signature,
+                            0,
+                        ),
+                    )),
                 ),
                 &Hash::default(),
-                FeeStructure::default().lamports_per_signature,
                 &RentCollector::default(),
                 &mut error_counters,
-                &mock_bank,
             );
 
         assert_eq!(error_counters.invalid_account_for_fee.0, 1);
@@ -2474,10 +2463,8 @@ mod tests {
                     Err(DuplicateInstruction(1)),
                 ),
                 &Hash::default(),
-                FeeStructure::default().lamports_per_signature,
                 &RentCollector::default(),
                 &mut error_counters,
-                &mock_bank,
             );
 
         assert_eq!(error_counters.invalid_compute_budget.0, 1);
@@ -2498,13 +2485,13 @@ mod tests {
             Some(&Pubkey::new_unique()),
             &last_blockhash,
         ));
+        let transaction_fee = lamports_per_signature;
         let compute_budget_and_limits = SVMTransactionExecutionAndFeeBudgetLimits {
-            priority_fee: compute_unit_limit,
+            fee_details: FeeDetails::new(transaction_fee, compute_unit_limit),
             ..SVMTransactionExecutionAndFeeBudgetLimits::default()
         };
         let fee_payer_address = message.fee_payer();
         let min_balance = Rent::default().minimum_balance(nonce::state::State::size());
-        let transaction_fee = lamports_per_signature;
         let priority_fee = compute_unit_limit;
 
         // Sufficient Fees
@@ -2550,10 +2537,8 @@ mod tests {
                    &message,
                    tx_details,
                    &environment_blockhash,
-                   FeeStructure::default().lamports_per_signature,
                    &rent_collector,
                    &mut error_counters,
-                   &mock_bank,
                );
 
             let post_validation_fee_payer_account = {
@@ -2611,10 +2596,8 @@ mod tests {
                 &message,
                 CheckedTransactionDetails::new(None, lamports_per_signature, Ok(compute_budget_and_limits)),
                 &Hash::default(),
-                FeeStructure::default().lamports_per_signature,
                 &rent_collector,
                 &mut error_counters,
-                &mock_bank,
                );
 
             assert_eq!(error_counters.insufficient_funds.0, 1);
@@ -2655,13 +2638,13 @@ mod tests {
             CheckedTransactionDetails::new(
                 None,
                 5000,
-                Ok(SVMTransactionExecutionAndFeeBudgetLimits::default()),
+                Ok(SVMTransactionExecutionAndFeeBudgetLimits::with_fee(
+                    MockBankCallback::calculate_fee_details(&message, 5000, 0),
+                )),
             ),
             &Hash::default(),
-            FeeStructure::default().lamports_per_signature,
             &RentCollector::default(),
             &mut TransactionErrorMetrics::default(),
-            &mock_bank,
         )
         .unwrap();
 

svm/tests/concurrent_tests.rs

@@ -241,14 +241,23 @@ fn svm_concurrent() {
             let local_batch = batch_processor.clone();
             let local_bank = mock_bank.clone();
             let th_txs = std::mem::take(&mut transactions[idx]);
-            let check_results = vec![
-                Ok(CheckedTransactionDetails::new(
-                    None,
-                    20,
-                    Ok(SVMTransactionExecutionAndFeeBudgetLimits::default())
-                )) as TransactionCheckResult;
-                TRANSACTIONS_PER_THREAD
-            ];
+            let check_results = th_txs
+                .iter()
+                .map(|tx| {
+                    Ok(CheckedTransactionDetails::new(
+                        None,
+                        20,
+                        Ok(SVMTransactionExecutionAndFeeBudgetLimits::with_fee(
+                            MockBankCallback::calculate_fee_details(
+                                tx,
+                                TransactionProcessingEnvironment::default()
+                                    .fee_lamports_per_signature,
+                                0,
+                            ),
+                        )),
+                    )) as TransactionCheckResult
+                })
+                .collect();
             let processing_config = TransactionProcessingConfig {
                 recording_config: ExecutionRecordingConfig {
                     enable_log_recording: true,

svm/tests/integration_test.rs

@@ -9,6 +9,7 @@ use {
     },
     solana_account::PROGRAM_OWNERS,
     solana_compute_budget_instruction::instructions_processor::process_compute_budget_instructions,
+    solana_fee_structure::FeeDetails,
     solana_program_runtime::execution_budget::SVMTransactionExecutionAndFeeBudgetLimits,
     solana_sdk::{
         account::{AccountSharedData, ReadableAccount, WritableAccount},
@@ -440,8 +441,21 @@ impl SvmTestEntry {
                         SVMMessage::program_instructions_iter(&message),
                         &FeatureSet::default(),
                     );
-                    let compute_budget =
-                        compute_budget_limits.map(|v| v.get_compute_budget_and_limits());
+                    let signature_count = message
+                        .num_transaction_signatures()
+                        .saturating_add(message.num_ed25519_signatures())
+                        .saturating_add(message.num_secp256k1_signatures())
+                        .saturating_add(message.num_secp256r1_signatures());
+
+                    let compute_budget = compute_budget_limits.map(|v| {
+                        v.get_compute_budget_and_limits(
+                            v.loaded_accounts_bytes,
+                            FeeDetails::new(
+                                signature_count.saturating_mul(tx_details.lamports_per_signature),
+                                v.get_prioritization_fee(),
+                            ),
+                        )
+                    });
                     CheckedTransactionDetails::new(
                         tx_details.nonce,
                         tx_details.lamports_per_signature,

svm/tests/mock_bank.rs

@@ -110,13 +110,13 @@ impl TransactionProcessingCallback for MockBankCallback {
             .or_default()
             .push((account, is_writable));
     }
+}
 
-    fn calculate_fee(
-        &self,
+impl MockBankCallback {
+    pub fn calculate_fee_details(
         message: &impl SVMMessage,
         lamports_per_signature: u64,
         prioritization_fee: u64,
-        _feature_set: &FeatureSet,
     ) -> FeeDetails {
         let signature_count = message
             .num_transaction_signatures()
@@ -129,9 +129,7 @@ impl TransactionProcessingCallback for MockBankCallback {
             prioritization_fee,
         )
     }
-}
 
-impl MockBankCallback {
     #[allow(unused)]
     pub fn override_feature_set(&mut self, new_set: FeatureSet) {
         self.feature_set = Arc::new(new_set)