Add a query version bit.

Author: noaov1

crates/blockifier/src/transaction/account_transaction.rs

@@ -101,7 +101,7 @@ fn create_test_init_data(
     );
 
     let account_tx = AccountTransaction::DeployAccount(deploy_account_tx);
-    account_tx.execute(&mut state, &block_context, true, true).unwrap();
+    account_tx.execute(&mut state, &block_context, true, true, false).unwrap();
 
     // Declare a contract.
     let contract_class = ContractClassV0::from_file(TEST_CONTRACT_CAIRO0_PATH).into();
@@ -116,7 +116,7 @@ fn create_test_init_data(
         )
         .unwrap(),
     );
-    account_tx.execute(&mut state, &block_context, true, true).unwrap();
+    account_tx.execute(&mut state, &block_context, true, true, false).unwrap();
 
     // Deploy a contract using syscall deploy.
     let entry_point_selector = selector_from_name("deploy_contract");
@@ -171,7 +171,7 @@ fn test_fee_enforcement(
 
         let account_tx = AccountTransaction::DeployAccount(deploy_account_tx);
         let enforce_fee = account_tx.enforce_fee();
-        let result = account_tx.execute(&mut state, &block_context, true, true);
+        let result = account_tx.execute(&mut state, &block_context, true, true, false);
         assert_eq!(result.is_err(), enforce_fee);
     }
 }
@@ -306,7 +306,8 @@ fn test_revert_invoke(
     );
 
     let account_tx = AccountTransaction::DeployAccount(deploy_account_tx);
-    let deploy_execution_info = account_tx.execute(&mut state, &block_context, true, true).unwrap();
+    let deploy_execution_info =
+        account_tx.execute(&mut state, &block_context, true, true, false).unwrap();
 
     // Invoke a function from the newly deployed contract, that changes the state.
     let storage_key = stark_felt!(9_u8);
@@ -374,7 +375,7 @@ fn test_fail_deploy_account(block_context: BlockContext) {
         &mut NonceManager::default(),
     );
     let deploy_address = deploy_account_tx.get_address_of_deploy().unwrap();
-    deploy_account_tx.execute(&mut state, &block_context, true, true).unwrap_err();
+    deploy_account_tx.execute(&mut state, &block_context, true, true, false).unwrap_err();
 
     // Assert nonce and balance are unchanged, and that no contract was deployed at the address.
     assert_eq!(state.get_nonce_at(deployed_account_address).unwrap(), Nonce(stark_felt!(0_u8)));
@@ -416,7 +417,7 @@ fn test_fail_declare(max_fee: Fee, #[from(create_test_init_data)] init_data: Tes
     );
 
     // Fail execution, assert nonce and balance are unchanged.
-    declare_account_tx.execute(&mut state, &block_context, true, true).unwrap_err();
+    declare_account_tx.execute(&mut state, &block_context, true, true, false).unwrap_err();
     assert_eq!(state.get_nonce_at(account_address).unwrap(), next_nonce);
     assert_eq!(
         state.get_fee_token_balance(&block_context, &account_address).unwrap(),
@@ -670,6 +671,7 @@ fn test_max_fee_to_max_steps_conversion(
         stark_felt!(1_u8),                // Calldata length.
         stark_felt!(25_u8)                // Calldata: arg.
     ];
+    let simulate = false;
 
     // First invocation of `with_arg` gets the exact pre-calculated actual fee as max_fee.
     let account_tx1 = account_invoke_tx(
@@ -680,10 +682,11 @@ fn test_max_fee_to_max_steps_conversion(
     );
     let execution_context1 = EntryPointExecutionContext::new_invoke(
         &block_context,
-        &account_tx1.get_account_transaction_context(),
+        &account_tx1.get_account_transaction_context(simulate),
     );
     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, true, true, simulate).unwrap();
     let n_steps1 = tx_execution_info1.actual_resources.0.get("n_steps").unwrap();
 
     // Second invocation of `with_arg` gets twice the pre-calculated actual fee as max_fee.
@@ -695,10 +698,11 @@ fn test_max_fee_to_max_steps_conversion(
     );
     let execution_context2 = EntryPointExecutionContext::new_invoke(
         &block_context,
-        &account_tx2.get_account_transaction_context(),
+        &account_tx2.get_account_transaction_context(simulate),
     );
     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, true, true, simulate).unwrap();
     let n_steps2 = tx_execution_info2.actual_resources.0.get("n_steps").unwrap();
 
     // Test that steps limit doubles as max_fee doubles, but actual consumed steps and fee remains.
@@ -799,7 +803,7 @@ fn write_and_transfer(
         *block_context.fee_token_address.0.key()
     ];
     let account_tx = account_invoke_tx(execute_calldata, account_address, nonce_manager, max_fee);
-    account_tx.execute(state, block_context, true, true).unwrap()
+    account_tx.execute(state, block_context, true, true, false).unwrap()
 }
 
 /// Tests that when a transaction drains an account's balance before fee transfer, the execution is
@@ -845,7 +849,7 @@ fn test_revert_on_overdraft(
     let approve_tx: AccountTransaction =
         account_invoke_tx(approve_calldata, account_address, &mut nonce_manager, max_fee);
     let approval_execution_info =
-        approve_tx.execute(&mut state, &block_context, true, true).unwrap();
+        approve_tx.execute(&mut state, &block_context, true, true, false).unwrap();
     assert!(!approval_execution_info.is_reverted());
 
     // Transfer a valid amount of funds to compute the cost of a successful

crates/blockifier/src/transaction/account_transactions_test.rs

@@ -12,3 +12,7 @@ pub const FELT_TRUE: u64 = 1;
 
 // Expected return value of a `validate` entry point: `VALID`.
 pub const VALIDATE_RETDATA: &str = "0x56414c4944";
+
+// TODO(Noa, 14/11/2023): Replace SIMULATE_VERSION_BASE_BIT with a lazy calculation.
+//      pub static SIMULATE_VERSION_BASE: Lazy<BigUint> = ...
+pub const SIMULATE_VERSION_BASE_BIT: u32 = 128;

crates/blockifier/src/transaction/constants.rs

@@ -1,12 +1,15 @@
 use std::collections::{HashMap, HashSet};
 
 use itertools::concat;
+use num_bigint::BigUint;
 use starknet_api::core::{ClassHash, ContractAddress, Nonce};
 use starknet_api::hash::StarkFelt;
 use starknet_api::stark_felt;
 use starknet_api::transaction::{Fee, TransactionHash, TransactionSignature, TransactionVersion};
 
+use super::transaction_utils::biguint_to_felt;
 use crate::execution::entry_point::CallInfo;
+use crate::transaction::constants::SIMULATE_VERSION_BASE_BIT;
 use crate::transaction::errors::TransactionExecutionError;
 
 pub type TransactionExecutionResult<T> = Result<T, TransactionExecutionError>;
@@ -25,6 +28,11 @@ pub struct AccountTransactionContext {
 impl AccountTransactionContext {
     pub fn is_v0(&self) -> bool {
         self.version == TransactionVersion(stark_felt!(0_u8))
+            || self.version
+                == TransactionVersion(
+                    biguint_to_felt(BigUint::from(2_u8).pow(SIMULATE_VERSION_BASE_BIT))
+                        .expect("`SIMULATE_VERSION_BASE should` be a valid TransactionVersion"),
+                )
     }
 }
 

crates/blockifier/src/transaction/objects.rs

@@ -196,5 +196,6 @@ pub fn run_invoke_tx(
         block_context,
         true,
         true,
+        false,
     )
 }

crates/blockifier/src/transaction/test_utils.rs

@@ -69,6 +69,7 @@ impl<S: StateReader> ExecutableTransaction<S> for L1HandlerTransaction {
         block_context: &BlockContext,
         _charge_fee: bool,
         _validate: bool,
+        _simulate: bool,
     ) -> TransactionExecutionResult<TransactionExecutionInfo> {
         let tx = &self.tx;
         let tx_context = AccountTransactionContext {
@@ -124,13 +125,14 @@ impl<S: StateReader> ExecutableTransaction<S> for Transaction {
         block_context: &BlockContext,
         charge_fee: bool,
         validate: bool,
+        simulate: bool,
     ) -> TransactionExecutionResult<TransactionExecutionInfo> {
         match self {
             Self::AccountTransaction(account_tx) => {
-                account_tx.execute_raw(state, block_context, charge_fee, validate)
+                account_tx.execute_raw(state, block_context, charge_fee, validate, simulate)
             }
             Self::L1HandlerTransaction(tx) => {
-                tx.execute_raw(state, block_context, charge_fee, validate)
+                tx.execute_raw(state, block_context, charge_fee, validate, simulate)
             }
         }
     }

crates/blockifier/src/transaction/transaction_execution.rs

@@ -1,6 +1,8 @@
 use std::collections::HashMap;
 
 use cairo_vm::vm::runners::builtin_runner::SEGMENT_ARENA_BUILTIN_NAME;
+use num_bigint::BigUint;
+use starknet_api::hash::StarkFelt;
 
 use crate::abi::constants;
 use crate::execution::entry_point::{CallInfo, ExecutionResources};
@@ -62,3 +64,14 @@ pub fn calculate_tx_resources(
 pub fn update_remaining_gas(remaining_gas: &mut u64, call_info: &CallInfo) {
     *remaining_gas -= call_info.execution.gas_consumed;
 }
+
+// TODO: Convert to a `TryFrom` cast and put in starknet-api (In StarkFelt).
+pub fn biguint_to_felt(biguint: BigUint) -> TransactionExecutionResult<StarkFelt> {
+    let biguint_hex = format!("{biguint:#x}");
+    Ok(StarkFelt::try_from(&*biguint_hex)?)
+}
+
+// TODO: Convert to a `Into` cast and put in starknet-api (In StarkFelt).
+pub fn felt_to_biguint(felt: StarkFelt) -> BigUint {
+    BigUint::from_bytes_be(felt.bytes())
+}

crates/blockifier/src/transaction/transaction_utils.rs

@@ -33,11 +33,17 @@ pub trait ExecutableTransaction<S: StateReader>: Sized {
         block_context: &BlockContext,
         charge_fee: bool,
         validate: bool,
+        simulate: bool,
     ) -> TransactionExecutionResult<TransactionExecutionInfo> {
         log::debug!("Executing Transaction...");
         let mut transactional_state = CachedState::create_transactional(state);
-        let execution_result =
-            self.execute_raw(&mut transactional_state, block_context, charge_fee, validate);
+        let execution_result = self.execute_raw(
+            &mut transactional_state,
+            block_context,
+            charge_fee,
+            validate,
+            simulate,
+        );
 
         match execution_result {
             Ok(value) => {
@@ -61,6 +67,7 @@ pub trait ExecutableTransaction<S: StateReader>: Sized {
         block_context: &BlockContext,
         charge_fee: bool,
         validate: bool,
+        simulate: bool,
     ) -> TransactionExecutionResult<TransactionExecutionInfo>;
 }