Rianhughes/fix sim txn (#2517)

* derive sierra version directly from sierra code, and introduce fix in binary search

Co-authored-by: Daniil Ankushin <[email protected]>
Signed-off-by: Rian Hughes <[email protected]>

Signed-off-by: Rian Hughes <[email protected]>
Co-authored-by: AnkushinDaniil <[email protected]>

Author: rianhughes

vm/class.go

@@ -4,9 +4,12 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"strconv"
+	"strings"
 
 	"github.com/NethermindEth/juno/adapters/core2sn"
 	"github.com/NethermindEth/juno/core"
+	"github.com/NethermindEth/juno/core/felt"
 )
 
 func marshalClassInfo(class core.Class) (json.RawMessage, error) {
@@ -37,9 +40,48 @@ func marshalClassInfo(class core.Class) (json.RawMessage, error) {
 		classInfo.Class = core2sn.AdaptCompiledClass(c.Compiled)
 		classInfo.AbiLength = uint32(len(c.Abi))
 		classInfo.SierraLength = uint32(len(c.Program))
-		classInfo.SierraVersion = c.Compiled.CompilerVersion
+		sierraVersion, err := parseSierraVersion(c.Program)
+		if err != nil {
+			return nil, err
+		}
+		classInfo.SierraVersion = sierraVersion
 	default:
 		return nil, fmt.Errorf("unsupported class type %T", c)
 	}
 	return json.Marshal(classInfo)
 }
+
+// Parse Sierra version from the JSON representation of the program.
+//
+// Sierra programs contain the version number in two possible formats.
+// For pre-1.0-rc0 Cairo versions the program contains the Sierra version
+// "0.1.0" as a shortstring in its first Felt (0x302e312e30 = "0.1.0").
+// For all subsequent versions the version number is the first three felts
+// representing the three parts of a semantic version number.
+// TODO: There should be an implementation in the blockifier. If there is, move it to the rust part.
+func parseSierraVersion(prog []*felt.Felt) (string, error) {
+	if len(prog) == 0 {
+		return "", errors.New("failed to parse sierra version in classInfo")
+	}
+
+	pre01, err := new(felt.Felt).SetString("0x302e312e30")
+	if err != nil {
+		return "", err
+	}
+
+	if prog[0].Equal(pre01) {
+		return "0.1.0", nil
+	}
+
+	if len(prog) < 3 {
+		return "", errors.New("failed to parse sierra version in classInfo")
+	}
+
+	parts := []string{
+		strconv.FormatUint(prog[0].Uint64(), 10),
+		strconv.FormatUint(prog[1].Uint64(), 10),
+		strconv.FormatUint(prog[2].Uint64(), 10),
+	}
+
+	return strings.Join(parts, "."), nil
+}

vm/rust/src/execution.rs

@@ -50,6 +50,7 @@ pub fn is_l2_gas_accounting_enabled(
         return Ok(false);
     }
 
+  
     let min_sierra_version = &block_context
         .versioned_constants()
         .min_sierra_version_for_sierra_gas;
@@ -106,14 +107,24 @@ fn get_gas_vector_computation_mode<S>(
 where
     S: UpdatableState,
 {
-    let original_tx = transaction.clone();
     let initial_gas_limit = extract_l2_gas_limit(transaction);
+    let mut original_transaction = transaction.clone();
 
     // Simulate transaction execution with maximum possible gas to get actual gas usage.
     set_l2_gas_limit(transaction, GasAmount::MAX);
+// TODO: Consider getting the upper bound from the balance and not changing the execution flags
+    match transaction {
+        Transaction::Account(account_transaction) => {
+            account_transaction.execution_flags.charge_fee = false;
+            account_transaction.execution_flags.validate = false;
+        }
+        _ =>{},
+    };
     let (simulation_result, _) = match simulate_execution(transaction, state, block_context) {
         Ok(info) => info,
-        Err(SimulationError::ExecutionError(error)) => return Err(error),
+        Err(SimulationError::ExecutionError(error)) => {
+            return Err(error);
+        }
         Err(SimulationError::OutOfGas(gas)) => {
             return Err(TransactionExecutionError::FeeCheckError(
                 FeeCheckError::MaxGasAmountExceeded {
@@ -131,7 +142,7 @@ where
     let l2_gas_adjusted = GasAmount(gas_used.saturating_add(gas_used / 10));
     set_l2_gas_limit(transaction, l2_gas_adjusted);
 
-    let (l2_gas_limit, mut execution_info, tx_state) =
+    let (l2_gas_limit, _, tx_state) =
         match simulate_execution(transaction, state, block_context) {
             Ok((tx_info, tx_state)) => {
                 // If 110% of the actual transaction gas fee is enough, we use that
@@ -179,17 +190,25 @@ where
             }
             Err(SimulationError::ExecutionError(error)) => return Err(error),
         };
+    tx_state.abort();
 
     // If the computed gas limit exceeds the initial limit, revert the transaction.
+    // The L2 gas limit is set to zero to prevent the transaction execution from succeeding
+    // in the case where the user defined gas limit is less than the required gas limit
     if l2_gas_limit > initial_gas_limit {
-        return original_tx.execute(state, block_context);
+        set_l2_gas_limit(&mut original_transaction, GasAmount(0));
+        return original_transaction.execute(state, block_context);
     }
 
+    set_l2_gas_limit(&mut original_transaction, initial_gas_limit);
+    let mut simulated_state = CachedState::<_>::create_transactional(state);
+    let mut exec_info =  original_transaction.execute(&mut simulated_state, block_context)?;
+
     // Execute the transaction with the determined gas limit and update the estimate.
-    tx_state.commit();
-    execution_info.receipt.gas.l2_gas = l2_gas_limit;
+    simulated_state.commit();
+    exec_info.receipt.gas.l2_gas = l2_gas_limit;
 
-    Ok(execution_info)
+    Ok(exec_info)
 }
 
 fn calculate_midpoint(a: GasAmount, b: GasAmount) -> GasAmount {