Add a query version bit.

Author: noaov1

Diff for: crates/blockifier/src/transaction/account_transaction.rs

@@ -2,6 +2,7 @@ use std::cmp::min;
 
 use cairo_vm::vm::runners::cairo_runner::ResourceTracker;
 use itertools::concat;
+use num_bigint::BigUint;
 use starknet_api::calldata;
 use starknet_api::core::{ContractAddress, EntryPointSelector};
 use starknet_api::deprecated_contract_class::EntryPointType;
@@ -10,6 +11,7 @@ use starknet_api::transaction::{
     Calldata, DeployAccountTransaction, Fee, InvokeTransaction, TransactionVersion,
 };
 
+use super::transaction_utils::felt_to_biguint;
 use crate::abi::abi_utils::selector_from_name;
 use crate::abi::constants as abi_constants;
 use crate::block_context::BlockContext;
@@ -26,6 +28,7 @@ use crate::state::cached_state::{
 };
 use crate::state::state_api::{State, StateReader};
 use crate::transaction::constants;
+use crate::transaction::constants::QUERY_VERSION_BASE_BIT;
 use crate::transaction::errors::TransactionExecutionError;
 use crate::transaction::objects::{
     AccountTransactionContext, ResourcesMapping, TransactionExecutionInfo,
@@ -34,7 +37,7 @@ use crate::transaction::objects::{
 use crate::transaction::transaction_execution::Transaction;
 use crate::transaction::transaction_types::TransactionType;
 use crate::transaction::transaction_utils::{
-    calculate_l1_gas_usage, calculate_tx_resources, update_remaining_gas,
+    biguint_to_felt, calculate_l1_gas_usage, calculate_tx_resources, update_remaining_gas,
 };
 use crate::transaction::transactions::{DeclareTransaction, Executable, ExecutableTransaction};
 
@@ -140,14 +143,33 @@ impl AccountTransaction {
         }
     }
 
-    fn get_account_transaction_context(&self) -> AccountTransactionContext {
+    fn version(&self) -> TransactionVersion {
+        match self {
+            Self::Declare(tx) => tx.tx().version(),
+            Self::DeployAccount(tx) => tx.version,
+            Self::Invoke(tx) => match tx {
+                InvokeTransaction::V0(_) => TransactionVersion(StarkFelt::from(0_u8)),
+                InvokeTransaction::V1(_) => TransactionVersion(StarkFelt::from(1_u8)),
+            },
+        }
+    }
+
+    fn get_account_transaction_context(&self, simulate: bool) -> AccountTransactionContext {
+        let mut version = self.version();
+        if simulate {
+            let query_version_base = BigUint::from(2_u8).pow(QUERY_VERSION_BASE_BIT);
+            let simulate_version = query_version_base + felt_to_biguint(version.0);
+            version = TransactionVersion(
+                biguint_to_felt(simulate_version).expect("The version should be a field element."),
+            );
+        }
         match self {
             Self::Declare(tx) => {
                 let tx = &tx.tx();
                 AccountTransactionContext {
                     transaction_hash: tx.transaction_hash(),
                     max_fee: tx.max_fee(),
-                    version: tx.version(),
+                    version,
                     signature: tx.signature(),
                     nonce: tx.nonce(),
                     sender_address: tx.sender_address(),
@@ -156,26 +178,37 @@ impl AccountTransaction {
             Self::DeployAccount(tx) => AccountTransactionContext {
                 transaction_hash: tx.transaction_hash,
                 max_fee: tx.max_fee,
-                version: tx.version,
+                version,
                 signature: tx.signature.clone(),
                 nonce: tx.nonce,
                 sender_address: tx.contract_address,
             },
             Self::Invoke(tx) => AccountTransactionContext {
                 transaction_hash: tx.transaction_hash(),
                 max_fee: tx.max_fee(),
-                version: match tx {
-                    InvokeTransaction::V0(_) => TransactionVersion(StarkFelt::from(0_u8)),
-                    InvokeTransaction::V1(_) => TransactionVersion(StarkFelt::from(1_u8)),
-                },
+                version,
                 signature: tx.signature(),
                 nonce: tx.nonce(),
                 sender_address: tx.sender_address(),
             },
         }
     }
 
-    fn verify_tx_version(&self, version: TransactionVersion) -> TransactionExecutionResult<()> {
+    fn verify_tx_version(
+        &self,
+        version: TransactionVersion,
+        simulate: bool,
+    ) -> TransactionExecutionResult<()> {
+        let version = match simulate {
+            true => {
+                let query_version_base = BigUint::from(2_u8).pow(QUERY_VERSION_BASE_BIT);
+                let version = felt_to_biguint(version.0) - query_version_base;
+                TransactionVersion(
+                    biguint_to_felt(version).expect("The version should be a field element."),
+                )
+            }
+            false => version,
+        };
         let allowed_versions: Vec<TransactionVersion> = match self {
             // Support `Declare` of version 0 in order to allow bootstrapping of a new system.
             Self::Declare(_) => {
@@ -204,7 +237,7 @@ impl AccountTransaction {
         account_tx_context: &AccountTransactionContext,
         state: &mut dyn State,
     ) -> TransactionExecutionResult<()> {
-        if account_tx_context.version == TransactionVersion(StarkFelt::from(0_u8)) {
+        if account_tx_context.is_v0() {
             return Ok(());
         }
 
@@ -229,9 +262,10 @@ impl AccountTransaction {
         remaining_gas: &mut u64,
         block_context: &BlockContext,
         validate: bool,
+        simulate: bool,
     ) -> TransactionExecutionResult<Option<CallInfo>> {
         if validate {
-            self.validate_tx(state, resources, remaining_gas, block_context)
+            self.validate_tx(state, resources, remaining_gas, block_context, simulate)
         } else {
             Ok(None)
         }
@@ -243,8 +277,9 @@ impl AccountTransaction {
         resources: &mut ExecutionResources,
         remaining_gas: &mut u64,
         block_context: &BlockContext,
+        simulate: bool,
     ) -> TransactionExecutionResult<Option<CallInfo>> {
-        let account_tx_context = self.get_account_transaction_context();
+        let account_tx_context = self.get_account_transaction_context(simulate);
         let mut context =
             EntryPointExecutionContext::new_validate(block_context, &account_tx_context);
         if context.account_tx_context.is_v0() {
@@ -306,8 +341,9 @@ impl AccountTransaction {
         &self,
         state: &mut TransactionalState<'_, S>,
         block_context: &BlockContext,
+        simulate: bool,
     ) -> TransactionExecutionResult<()> {
-        let account_tx_context = self.get_account_transaction_context();
+        let account_tx_context = self.get_account_transaction_context(simulate);
         let max_fee = account_tx_context.max_fee;
 
         // Check fee balance.
@@ -341,14 +377,15 @@ impl AccountTransaction {
         block_context: &BlockContext,
         actual_fee: Fee,
         charge_fee: bool,
+        simulate: bool,
     ) -> TransactionExecutionResult<Option<CallInfo>> {
         if !charge_fee || actual_fee == Fee(0) {
             // Fee charging is not enforced in some transaction simulations and tests.
             return Ok(None);
         }
 
         // Charge fee.
-        let account_tx_context = self.get_account_transaction_context();
+        let account_tx_context = self.get_account_transaction_context(simulate);
         let fee_transfer_call_info =
             Self::execute_fee_transfer(state, block_context, account_tx_context, actual_fee)?;
 
@@ -409,6 +446,7 @@ impl AccountTransaction {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn run_non_revertible<S: StateReader>(
         &self,
         state: &mut TransactionalState<'_, S>,
@@ -417,24 +455,37 @@ impl AccountTransaction {
         block_context: &BlockContext,
         mut execution_context: EntryPointExecutionContext,
         validate: bool,
+        simulate: bool,
     ) -> TransactionExecutionResult<ValidateExecuteCallInfo> {
         let validate_call_info: Option<CallInfo>;
         let execute_call_info: Option<CallInfo>;
         if matches!(self, Self::DeployAccount(_)) {
             // Handle `DeployAccount` transactions separately, due to different order of things.
             execute_call_info =
                 self.run_execute(state, resources, &mut execution_context, remaining_gas)?;
-            validate_call_info =
-                self.handle_validate_tx(state, resources, remaining_gas, block_context, validate)?;
+            validate_call_info = self.handle_validate_tx(
+                state,
+                resources,
+                remaining_gas,
+                block_context,
+                validate,
+                simulate,
+            )?;
         } else {
-            validate_call_info =
-                self.handle_validate_tx(state, resources, remaining_gas, block_context, validate)?;
+            validate_call_info = self.handle_validate_tx(
+                state,
+                resources,
+                remaining_gas,
+                block_context,
+                validate,
+                simulate,
+            )?;
             execute_call_info =
                 self.run_execute(state, resources, &mut execution_context, remaining_gas)?;
         }
         let state_changes = state.get_actual_state_changes_for_fee_charge(
             block_context.fee_token_address,
-            Some(self.get_account_transaction_context().sender_address),
+            Some(self.get_account_transaction_context(simulate).sender_address),
         )?;
         let (actual_fee, actual_resources) = self.calculate_actual_fee_and_resources(
             StateChangesCount::from(&state_changes),
@@ -444,6 +495,7 @@ impl AccountTransaction {
             block_context,
             false,
             0,
+            simulate,
         )?;
         Ok(ValidateExecuteCallInfo::new_accepted(
             validate_call_info,
@@ -463,11 +515,18 @@ impl AccountTransaction {
         mut execution_context: EntryPointExecutionContext,
         charge_fee: bool,
         validate: bool,
+        simulate: bool,
     ) -> TransactionExecutionResult<ValidateExecuteCallInfo> {
-        let account_tx_context = self.get_account_transaction_context();
+        let account_tx_context = self.get_account_transaction_context(simulate);
         // Run the validation, and if execution later fails, only keep the validation diff.
-        let validate_call_info =
-            self.handle_validate_tx(state, resources, remaining_gas, block_context, validate)?;
+        let validate_call_info = self.handle_validate_tx(
+            state,
+            resources,
+            remaining_gas,
+            block_context,
+            validate,
+            simulate,
+        )?;
         let validate_steps = if validate {
             validate_call_info
                 .as_ref()
@@ -535,6 +594,7 @@ impl AccountTransaction {
                     block_context,
                     false,
                     0,
+                    simulate,
                 )?;
 
                 // Check if as a result of tx execution the sender's fee token balance is maxed out,
@@ -576,6 +636,7 @@ impl AccountTransaction {
                         block_context,
                         true,
                         n_reverted_steps,
+                        simulate,
                     )?;
 
                     return Ok(ValidateExecuteCallInfo::new_reverted(
@@ -614,6 +675,7 @@ impl AccountTransaction {
                     block_context,
                     true,
                     n_reverted_steps,
+                    simulate,
                 )?;
 
                 Ok(ValidateExecuteCallInfo::new_reverted(
@@ -626,20 +688,21 @@ impl AccountTransaction {
         }
     }
 
-    fn is_non_revertible(&self) -> bool {
+    fn is_non_revertible(&self, simulate: bool) -> bool {
         // Reverting a Declare or Deploy transaction is not currently supported in the OS.
         match self {
             Self::Declare(_) => true,
             Self::DeployAccount(_) => true,
             Self::Invoke(_) => {
                 // V0 transactions do not have validation; we cannot deduct fee for execution. Thus,
                 // invoke transactions of are non-revertible iff they are of version 0.
-                self.get_account_transaction_context().is_v0()
+                self.get_account_transaction_context(simulate).is_v0()
             }
         }
     }
 
     /// Runs validation and execution.
+    #[allow(clippy::too_many_arguments)]
     fn run_or_revert<S: StateReader>(
         &self,
         state: &mut TransactionalState<'_, S>,
@@ -648,8 +711,9 @@ impl AccountTransaction {
         block_context: &BlockContext,
         charge_fee: bool,
         validate: bool,
+        simulate: bool,
     ) -> TransactionExecutionResult<ValidateExecuteCallInfo> {
-        let account_tx_context = self.get_account_transaction_context();
+        let account_tx_context = self.get_account_transaction_context(simulate);
         let execution_context = if matches!(self, Self::DeployAccount(_)) {
             // Run constructor in validate mode, since it is executed before the transaction is
             // validated.
@@ -658,14 +722,15 @@ impl AccountTransaction {
             EntryPointExecutionContext::new_invoke(block_context, &account_tx_context)
         };
 
-        if self.is_non_revertible() {
+        if self.is_non_revertible(simulate) {
             return self.run_non_revertible(
                 state,
                 resources,
                 remaining_gas,
                 block_context,
                 execution_context,
                 validate,
+                simulate,
             );
         }
 
@@ -677,6 +742,7 @@ impl AccountTransaction {
             execution_context,
             charge_fee,
             validate,
+            simulate,
         )
     }
 
@@ -690,8 +756,9 @@ impl AccountTransaction {
         block_context: &BlockContext,
         is_reverted: bool,
         n_reverted_steps: usize,
+        simulate: bool,
     ) -> TransactionExecutionResult<(Fee, ResourcesMapping)> {
-        let account_tx_context = self.get_account_transaction_context();
+        let account_tx_context = self.get_account_transaction_context(simulate);
 
         let non_optional_call_infos = vec![validate_call_info.as_ref(), execute_call_info.as_ref()]
             .into_iter()
@@ -724,16 +791,17 @@ impl<S: StateReader> ExecutableTransaction<S> for AccountTransaction {
         block_context: &BlockContext,
         charge_fee: bool,
         validate: bool,
+        simulate: bool,
     ) -> TransactionExecutionResult<TransactionExecutionInfo> {
-        let account_tx_context = self.get_account_transaction_context();
-        self.verify_tx_version(account_tx_context.version)?;
+        let account_tx_context = self.get_account_transaction_context(simulate);
+        self.verify_tx_version(account_tx_context.version, simulate)?;
 
         let mut resources = ExecutionResources::default();
         let mut remaining_gas = Transaction::initial_gas();
 
         // Nonce and fee check should be done before running user code.
         if charge_fee {
-            self.check_fee_balance(state, block_context)?;
+            self.check_fee_balance(state, block_context, simulate)?;
         }
         // Handle nonce.
         Self::handle_nonce(&account_tx_context, state)?;
@@ -752,10 +820,11 @@ impl<S: StateReader> ExecutableTransaction<S> for AccountTransaction {
             block_context,
             charge_fee,
             validate,
+            simulate,
         )?;
 
         let fee_transfer_call_info =
-            self.handle_fee(state, block_context, final_fee, charge_fee)?;
+            self.handle_fee(state, block_context, final_fee, charge_fee, simulate)?;
 
         let tx_execution_info = TransactionExecutionInfo {
             validate_call_info,