chore(blockifier): combine tx_info.enforce_fee() with charge_fee flag

crates/blockifier/src/blockifier/stateful_validator.rs

@@ -19,6 +19,7 @@ use crate::state::errors::StateError;
 use crate::state::state_api::StateReader;
 use crate::transaction::account_transaction::AccountTransaction;
 use crate::transaction::errors::{TransactionExecutionError, TransactionPreValidationError};
+use crate::transaction::objects::TransactionInfoCreator;
 use crate::transaction::transaction_execution::Transaction;
 use crate::transaction::transactions::ValidatableTransaction;
 
@@ -95,7 +96,7 @@ impl<S: StateReader> StatefulValidator<S> {
     ) -> StatefulValidatorResult<()> {
         let strict_nonce_check = false;
         // Run pre-validation in charge fee mode to perform fee and balance related checks.
-        let charge_fee = true;
+        let charge_fee = tx.create_tx_info().enforce_fee(); // aviv: new
         tx.perform_pre_validation_stage(
             self.tx_executor.block_state.as_mut().expect(BLOCK_STATE_ACCESS_ERR),
             tx_context,

crates/blockifier/src/blockifier/transaction_executor.rs

@@ -21,7 +21,7 @@ use crate::state::cached_state::{CachedState, CommitmentStateDiff, Transactional
 use crate::state::errors::StateError;
 use crate::state::state_api::StateReader;
 use crate::transaction::errors::TransactionExecutionError;
-use crate::transaction::objects::TransactionExecutionInfo;
+use crate::transaction::objects::{TransactionExecutionInfo, TransactionInfoCreator};
 use crate::transaction::transaction_execution::Transaction;
 use crate::transaction::transactions::{ExecutableTransaction, ExecutionFlags};
 
@@ -90,9 +90,11 @@ impl<S: StateReader> TransactionExecutor<S> {
         let mut transactional_state = TransactionalState::create_transactional(
             self.block_state.as_mut().expect(BLOCK_STATE_ACCESS_ERR),
         );
+        let tx_charge_fee = tx.create_tx_info().enforce_fee(); //aviv: todo: msg -> CONST?
+
         // Executing a single transaction cannot be done in a concurrent mode.
         let execution_flags =
-            ExecutionFlags { charge_fee: true, validate: true, concurrency_mode: false };
+            ExecutionFlags { charge_fee: tx_charge_fee, validate: true, concurrency_mode: false };
         let tx_execution_result =
             tx.execute_raw(&mut transactional_state, &self.block_context, execution_flags);
         match tx_execution_result {

crates/blockifier/src/concurrency/versioned_state_test.rs

@@ -266,14 +266,17 @@ fn test_run_parallel_txs(max_resource_bounds: ValidResourceBounds) {
 
     let block_context_1 = block_context.clone();
     let block_context_2 = block_context.clone();
+
     // Execute transactions
     thread::scope(|s| {
         s.spawn(move || {
-            let result = account_tx_1.execute(&mut state_1, &block_context_1, true, true);
+            let charge_fee_1 = account_tx_1.create_tx_info().enforce_fee(); // aviv: todo better implementation?
+            let result = account_tx_1.execute(&mut state_1, &block_context_1, charge_fee_1, true); // aviv: was true, true
             assert_eq!(result.is_err(), enforce_fee);
         });
         s.spawn(move || {
-            account_tx_2.execute(&mut state_2, &block_context_2, true, true).unwrap();
+            let charge_fee_2 = account_tx_2.create_tx_info().enforce_fee(); // aviv: todo better implementation?
+            account_tx_2.execute(&mut state_2, &block_context_2, charge_fee_2, true).unwrap(); // aviv: was true, true
             // Check that the constructor wrote ctor_arg to the storage.
             let storage_key = get_storage_var_address("ctor_arg", &[]);
             let deployed_contract_address = calculate_contract_address(

crates/blockifier/src/concurrency/worker_logic.rs

@@ -22,7 +22,11 @@ use crate::state::cached_state::{
     TransactionalState,
 };
 use crate::state::state_api::{StateReader, UpdatableState};
-use crate::transaction::objects::{TransactionExecutionInfo, TransactionExecutionResult};
+use crate::transaction::objects::{
+    TransactionExecutionInfo,
+    TransactionExecutionResult,
+    TransactionInfoCreator,
+};
 use crate::transaction::transaction_execution::Transaction;
 use crate::transaction::transactions::{ExecutableTransaction, ExecutionFlags};
 
@@ -127,10 +131,11 @@ impl<'a, S: StateReader> WorkerExecutor<'a, S> {
     fn execute_tx(&self, tx_index: TxIndex) {
         let mut tx_versioned_state = self.state.pin_version(tx_index);
         let tx = &self.chunk[tx_index];
+        let tx_charge_fee = tx.create_tx_info().enforce_fee(); //aviv: todo: msg -> CONST?
         let mut transactional_state =
             TransactionalState::create_transactional(&mut tx_versioned_state);
         let execution_flags =
-            ExecutionFlags { charge_fee: true, validate: true, concurrency_mode: true };
+            ExecutionFlags { charge_fee: tx_charge_fee, validate: true, concurrency_mode: true };
         let execution_result =
             tx.execute_raw(&mut transactional_state, self.block_context, execution_flags);
 

crates/blockifier/src/execution/deprecated_syscalls/deprecated_syscalls_test.rs

@@ -489,7 +489,7 @@ fn test_tx_info(#[values(false, true)] only_query: bool) {
         },
         max_fee,
     });
-    let limit_steps_by_resources = true;
+    let limit_steps_by_resources = tx_info.enforce_fee(); //aviv: was true
     let result = entry_point_call
         .execute_directly_given_tx_info(&mut state, tx_info, limit_steps_by_resources)
         .unwrap();

crates/blockifier/src/execution/entry_point.rs

@@ -183,7 +183,8 @@ impl EntryPointExecutionContext {
                 .expect("Failed to convert invoke_tx_max_n_steps (u32) to usize."),
         };
 
-        if !limit_steps_by_resources || !tx_info.enforce_fee() {
+        if !limit_steps_by_resources {
+            // aviv: need to remove '|| !tx_info.enforce_fee()'
             return block_upper_bound;
         }
 

crates/blockifier/src/execution/stack_trace_test.rs

@@ -27,6 +27,7 @@ use crate::transaction::constants::{
     VALIDATE_DEPLOY_ENTRY_POINT_NAME,
     VALIDATE_ENTRY_POINT_NAME,
 };
+use crate::transaction::objects::TransactionInfoCreator;
 use crate::transaction::test_utils::{
     account_invoke_tx,
     block_context,
@@ -620,7 +621,8 @@ Execution failed. Failure reason: 0x496e76616c6964207363656e6172696f ('Invalid s
     // Clean pc locations from the trace.
     let re = Regex::new(r"pc=0:[0-9]+").unwrap();
     let cleaned_expected_error = &re.replace_all(&expected_error, "pc=0:*");
-    let actual_error = account_tx.execute(state, block_context, true, true).unwrap_err();
+    let charge_fee = account_tx.create_tx_info().enforce_fee();
+    let actual_error = account_tx.execute(state, block_context, charge_fee, true).unwrap_err(); // aviv: was true, true
     let actual_error_str = actual_error.to_string();
     let cleaned_actual_error = &re.replace_all(&actual_error_str, "pc=0:*");
     // Compare actual trace to the expected trace (sans pc locations).
@@ -683,7 +685,8 @@ An ASSERT_EQ instruction failed: 1 != 0.
     };
 
     // Compare expected and actual error.
-    let error = deploy_account_tx.execute(state, &block_context, true, true).unwrap_err();
+    let charge_fee = deploy_account_tx.create_tx_info().enforce_fee();
+    let error = deploy_account_tx.execute(state, &block_context, charge_fee, true).unwrap_err(); // aviv: was true, true
     assert_eq!(error.to_string(), expected_error);
 }
 

crates/blockifier/src/execution/syscalls/syscall_tests/get_execution_info.rs

@@ -243,13 +243,13 @@ fn test_get_execution_info(
         ),
         ..trivial_external_entry_point_with_address(test_contract_address)
     };
-
+    // let limit_steps_by_resources = tx_info.enforce_fee(); // aviv: new
     let result = match execution_mode {
         ExecutionMode::Validate => {
-            entry_point_call.execute_directly_given_tx_info_in_validate_mode(state, tx_info, false)
+            entry_point_call.execute_directly_given_tx_info_in_validate_mode(state, tx_info, false) //aviv: was ',false)': not needed?
         }
         ExecutionMode::Execute => {
-            entry_point_call.execute_directly_given_tx_info(state, tx_info, false)
+            entry_point_call.execute_directly_given_tx_info(state, tx_info, false) //aviv: was ',false)': not needed?
         }
     };
 

crates/blockifier/src/fee/fee_checks.rs

@@ -192,7 +192,7 @@ impl PostExecutionReport {
         let TransactionReceipt { fee, .. } = tx_receipt;
 
         // If fee is not enforced, no need to check post-execution.
-        if !charge_fee || !tx_context.tx_info.enforce_fee() {
+        if !charge_fee {
             return Ok(Self(FeeCheckReport::success_report(*fee)));
         }
 

crates/blockifier/src/test_utils/prices.rs

@@ -74,7 +74,7 @@ fn fee_transfer_resources(
             &mut EntryPointExecutionContext::new(
                 Arc::new(block_context.to_tx_context(&account_invoke_tx(InvokeTxArgs::default()))),
                 ExecutionMode::Execute,
-                false,
+                false, // aviv: limit_steps_by_resources: can be enforce_fee() instead of false.?
             ),
         )
         .unwrap()

crates/blockifier/src/test_utils/struct_impls.rs

@@ -54,11 +54,9 @@ impl CallEntryPoint {
     /// Executes the call directly, without account context. Limits the number of steps by resource
     /// bounds.
     pub fn execute_directly(self, state: &mut dyn State) -> EntryPointExecutionResult<CallInfo> {
-        self.execute_directly_given_tx_info(
-            state,
-            TransactionInfo::Deprecated(DeprecatedTransactionInfo::default()),
-            true,
-        )
+        let tx_info = TransactionInfo::Deprecated(DeprecatedTransactionInfo::default());
+        let limit_steps_by_resources = tx_info.enforce_fee(); // aviv: new
+        self.execute_directly_given_tx_info(state, tx_info, limit_steps_by_resources)
     }
 
     pub fn execute_directly_given_tx_info(
@@ -80,10 +78,12 @@ impl CallEntryPoint {
         self,
         state: &mut dyn State,
     ) -> EntryPointExecutionResult<CallInfo> {
+        let tx_info = TransactionInfo::Deprecated(DeprecatedTransactionInfo::default());
+        let limit_steps_by_resources = tx_info.enforce_fee(); // aviv: new
         self.execute_directly_given_tx_info_in_validate_mode(
             state,
-            TransactionInfo::Deprecated(DeprecatedTransactionInfo::default()),
-            true,
+            tx_info,
+            limit_steps_by_resources,
         )
     }
 
@@ -93,6 +93,7 @@ impl CallEntryPoint {
         tx_info: TransactionInfo,
         limit_steps_by_resources: bool,
     ) -> EntryPointExecutionResult<CallInfo> {
+        // aviv: let limit_steps = limit_steps_by_resources && tx_info.enforce_fee();
         let tx_context =
             TransactionContext { block_context: BlockContext::create_for_testing(), tx_info };
         let mut context = EntryPointExecutionContext::new_validate(

crates/blockifier/src/transaction/account_transaction.rs

@@ -215,7 +215,7 @@ impl AccountTransaction {
         let tx_info = &tx_context.tx_info;
         Self::handle_nonce(state, tx_info, strict_nonce_check)?;
 
-        if charge_fee && tx_info.enforce_fee() {
+        if charge_fee {
             self.check_fee_bounds(tx_context)?;
 
             verify_can_pay_committed_bounds(state, tx_context)?;
@@ -399,8 +399,9 @@ impl AccountTransaction {
             // The fee-token contract is a Cairo 0 contract, hence the initial gas is irrelevant.
             initial_gas: block_context.versioned_constants.os_constants.gas_costs.initial_gas_cost,
         };
-
-        let mut context = EntryPointExecutionContext::new_invoke(tx_context, true);
+        let limit_steps_by_resources = tx_info.enforce_fee(); //aviv: new
+        let mut context =
+            EntryPointExecutionContext::new_invoke(tx_context, limit_steps_by_resources);
 
         Ok(fee_transfer_call
             .execute(state, &mut ExecutionResources::default(), &mut context)

crates/blockifier/src/transaction/account_transactions_test.rs

@@ -174,7 +174,7 @@ fn test_fee_enforcement(
 
     let account_tx = AccountTransaction::DeployAccount(deploy_account_tx);
     let enforce_fee = account_tx.create_tx_info().enforce_fee();
-    let result = account_tx.execute(state, &block_context, true, true);
+    let result = account_tx.execute(state, &block_context, enforce_fee, true); // aviv: was true, true
     assert_eq!(result.is_err(), enforce_fee);
 }
 
@@ -605,7 +605,9 @@ fn test_fail_deploy_account(
 
     let initial_balance = state.get_fee_token_balance(deploy_address, fee_token_address).unwrap();
 
-    let error = deploy_account_tx.execute(state, &block_context, true, true).unwrap_err();
+    let charge_fee = deploy_account_tx.create_tx_info().enforce_fee();
+
+    let error = deploy_account_tx.execute(state, &block_context, charge_fee, true).unwrap_err(); // aviv: was true, true
     // Check the error is as expected. Assure the error message is not nonce or fee related.
     check_transaction_execution_error_for_invalid_scenario!(cairo_version, error, false);
 
@@ -931,9 +933,11 @@ fn test_max_fee_to_max_steps_conversion(
         nonce: nonce_manager.next(account_address),
     });
     let tx_context1 = Arc::new(block_context.to_tx_context(&account_tx1));
-    let execution_context1 = EntryPointExecutionContext::new_invoke(tx_context1, true);
+    let charge_fee1 = account_tx1.create_tx_info().enforce_fee(); // aviv:  new
+    let execution_context1 = EntryPointExecutionContext::new_invoke(tx_context1, charge_fee1);
     let max_steps_limit1 = execution_context1.vm_run_resources.get_n_steps();
-    let tx_execution_info1 = account_tx1.execute(&mut state, &block_context, true, true).unwrap();
+    let tx_execution_info1 =
+        account_tx1.execute(&mut state, &block_context, charge_fee1, true).unwrap();
     let n_steps1 = tx_execution_info1.receipt.resources.vm_resources.n_steps;
     let gas_used_vector1 = tx_execution_info1
         .receipt
@@ -951,9 +955,11 @@ fn test_max_fee_to_max_steps_conversion(
         nonce: nonce_manager.next(account_address),
     });
     let tx_context2 = Arc::new(block_context.to_tx_context(&account_tx2));
-    let execution_context2 = EntryPointExecutionContext::new_invoke(tx_context2, true);
+    let charge_fee2 = account_tx2.create_tx_info().enforce_fee(); // aviv:  new
+    let execution_context2 = EntryPointExecutionContext::new_invoke(tx_context2, charge_fee2);
     let max_steps_limit2 = execution_context2.vm_run_resources.get_n_steps();
-    let tx_execution_info2 = account_tx2.execute(&mut state, &block_context, true, true).unwrap();
+    let tx_execution_info2 =
+        account_tx2.execute(&mut state, &block_context, charge_fee2, true).unwrap();
     let n_steps2 = tx_execution_info2.receipt.resources.vm_resources.n_steps;
     let gas_used_vector2 = tx_execution_info2
         .receipt

crates/blockifier/src/transaction/post_execution_test.rs

@@ -112,8 +112,9 @@ fn test_revert_on_overdraft(
         nonce: nonce_manager.next(account_address),
     });
     let tx_info = approve_tx.create_tx_info();
+    let charge_fee = tx_info.enforce_fee();
     let approval_execution_info =
-        approve_tx.execute(&mut state, &block_context, true, true).unwrap();
+        approve_tx.execute(&mut state, &block_context, charge_fee, true).unwrap(); // aviv: was true, true
     assert!(!approval_execution_info.is_reverted());
 
     // Transfer a valid amount of funds to compute the cost of a successful

crates/blockifier/src/transaction/test_utils.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use rstest::fixture;
 use starknet_api::core::{ClassHash, ContractAddress, Nonce};
 use starknet_api::test_utils::deploy_account::DeployAccountTxArgs;
@@ -292,7 +294,15 @@ pub fn run_invoke_tx(
     block_context: &BlockContext,
     invoke_args: InvokeTxArgs,
 ) -> TransactionExecutionResult<TransactionExecutionInfo> {
-    account_invoke_tx(invoke_args).execute(state, block_context, true, true)
+    let tx = account_invoke_tx(invoke_args.clone());
+    let tx_context = Arc::new(block_context.to_tx_context(&tx));
+
+    account_invoke_tx(invoke_args).execute(
+        state,
+        block_context,
+        tx_context.tx_info.enforce_fee(),
+        true,
+    ) // aviv: true, true
 }
 
 /// Creates a `ResourceBoundsMapping` with the given `max_amount` and `max_price` for L1 gas limits.

crates/blockifier/src/transaction/transaction_execution.rs

@@ -113,12 +113,13 @@ impl<U: UpdatableState> ExecutableTransaction<U> for L1HandlerTransaction {
         &self,
         state: &mut TransactionalState<'_, U>,
         block_context: &BlockContext,
-        _execution_flags: ExecutionFlags,
+        execution_flags: ExecutionFlags,
     ) -> TransactionExecutionResult<TransactionExecutionInfo> {
         let tx_context = Arc::new(block_context.to_tx_context(self));
-
+        let limit_steps_by_resources = execution_flags.charge_fee; // aviv: new
         let mut execution_resources = ExecutionResources::default();
-        let mut context = EntryPointExecutionContext::new_invoke(tx_context.clone(), true);
+        let mut context =
+            EntryPointExecutionContext::new_invoke(tx_context.clone(), limit_steps_by_resources);
         let mut remaining_gas = block_context.versioned_constants.tx_initial_gas();
         let execute_call_info =
             self.run_execute(state, &mut execution_resources, &mut context, &mut remaining_gas)?;