feat: use the actual class info (#269)

Currently when creating the `ClassInfo` struct from Blockifier, the values used aren't accurate.

First, the sierra version is actually the CASM compiler version. The sierra version is encoded into the `sierra_program` field of a Starknet contract class artifact. The `sierra_program` is a list of field elements and the first six elements are reserved for the compilers - first 3 for sierra compiler version and last 3 for casm compiler version. Fyi, Blockifier performs a sierra version check when executing a contract execution to determine what resource to [track].

Second, we are using mock values for both sierra program length and abi length. I'm not exactly sure what's the specification of the ABI length, but I've referenced with the official StarkWare's [implementation] and it seems to be the length of the ABI in its RPC format i.e., a string of JSON.

The implementation for getting the ABI length is not optimized and would require to be computed every time the class is fetched from database -> class cache.

These values are important for ensuring deterministic executions as they affect transaction execution as well as fees.

[track]:
https://github.com/dojoengine/sequencer/blob/3c206344dc64b5a0f150ea94cd2623b2a9a7da63/crates/blockifier/src/execution/contract_class.rs#L258
[implementation]:
https://github.com/dojoengine/sequencer/blob/3c206344dc64b5a0f150ea94cd2623b2a9a7da63/crates/apollo_rpc/src/v0_8/api/mod.rs#L453-L477

Author: kariy

crates/executor/src/implementation/blockifier/cache.rs

@@ -1,10 +1,8 @@
-use std::str::FromStr;
 use std::sync::{Arc, OnceLock};
 
 use blockifier::execution::contract_class::{CompiledClassV1, RunnableCompiledClass};
 use katana_primitives::class::{ClassHash, CompiledClass, ContractClass};
 use quick_cache::sync::Cache;
-use starknet_api::contract_class::SierraVersion;
 
 use super::utils::to_class;
 
@@ -256,11 +254,12 @@ impl ClassCache {
                 #[cfg(feature = "native")]
                 let entry_points = sierra.entry_points_by_type.clone();
 
+                let version = class.sierra_version();
+
                 let CompiledClass::Class(casm) = class.compile().unwrap() else {
                     unreachable!("cant be legacy")
                 };
 
-                let version = SierraVersion::from_str(&casm.compiler_version).unwrap();
                 let compiled = CompiledClassV1::try_from((casm, version.clone())).unwrap();
 
                 #[cfg(feature = "native")]

crates/executor/src/implementation/blockifier/call.rs

@@ -1,6 +1,8 @@
 use std::str::FromStr;
 use std::sync::Arc;
 
+use blockifier::blockifier_versioned_constants::VersionedConstants;
+use blockifier::bouncer::n_steps_to_sierra_gas;
 use blockifier::context::{BlockContext, TransactionContext};
 use blockifier::execution::call_info::CallInfo;
 use blockifier::execution::entry_point::{
@@ -15,7 +17,7 @@ use blockifier::state::cached_state::CachedState;
 use blockifier::state::state_api::StateReader;
 use blockifier::transaction::objects::{DeprecatedTransactionInfo, TransactionInfo};
 use cairo_vm::vm::runners::cairo_runner::RunResources;
-use katana_primitives::execution::FunctionCall;
+use katana_primitives::execution::{FunctionCall, TrackedResource};
 use katana_primitives::Felt;
 use starknet_api::core::EntryPointSelector;
 use starknet_api::execution_resources::GasAmount;
@@ -25,6 +27,8 @@ use super::utils::to_blk_address;
 use crate::ExecutionError;
 
 /// Perform a function call on a contract and retrieve the return values.
+///
+/// The `max_gas` is the maximum amount of Sierra gas to allocate for the call.
 pub fn execute_call<S: StateReader>(
     request: FunctionCall,
     state: &mut CachedState<S>,
@@ -39,10 +43,10 @@ fn execute_call_inner<S: StateReader>(
     request: FunctionCall,
     state: &mut CachedState<S>,
     block_context: Arc<BlockContext>,
-    max_gas: u64,
+    max_sierra_gas: u64,
 ) -> EntryPointExecutionResult<CallInfo> {
     let call = CallEntryPoint {
-        initial_gas: max_gas,
+        initial_gas: max_sierra_gas,
         calldata: Calldata(Arc::new(request.calldata)),
         storage_address: to_blk_address(request.contract_address),
         entry_point_selector: EntryPointSelector(request.entry_point_selector),
@@ -67,20 +71,30 @@ fn execute_call_inner<S: StateReader>(
         tx_info: TransactionInfo::Deprecated(DeprecatedTransactionInfo::default()),
     });
 
-    let sierra_revert_tracker = SierraGasRevertTracker::new(GasAmount(max_gas));
+    let sierra_revert_tracker = SierraGasRevertTracker::new(GasAmount(max_sierra_gas));
     let mut ctx = EntryPointExecutionContext::new_invoke(
         tx_context,
         limit_steps_by_resources,
         sierra_revert_tracker,
     );
 
-    // manually override the run resources
-    // If `initial_gas` can't fit in a usize, use the maximum.
-    ctx.vm_run_resources = RunResources::new(max_gas.try_into().unwrap_or(usize::MAX));
+    let versioned_constants = block_context.versioned_constants();
+    let l2_gas_per_step = versioned_constants.os_constants.gas_costs.base.step_gas_cost;
+
+    // Convert the sierra gas to cairo steps for the run resources.
+    //
+    // If values can't fit in a usize, use the maximum. This is to mimic the behaviour of
+    // blockifier.
+    //
+    // For reference: https://github.com/dojoengine/sequencer/blob/5d737b9c90a14bdf4483d759d1a1d4ce64aa9fd2/crates/blockifier/src/execution/entry_point.rs#L382C1-L451
+    let n_steps = max_sierra_gas.saturating_div(l2_gas_per_step);
+    let n_steps = n_steps.try_into().unwrap_or(usize::MAX);
+    ctx.vm_run_resources = RunResources::new(n_steps);
+
     let mut remaining_gas = call.initial_gas;
     let call_info = call.execute(state, &mut ctx, &mut remaining_gas)?;
 
-    // In Starknet 0.13.4 calls return error as return data (Ok variant) instead of returning as an
+    // Calls return error as the return data (Ok variant) instead of returning as an
     // Err. Refer to: https://github.com/dojoengine/sequencer/blob/5d737b9c90a14bdf4483d759d1a1d4ce64aa9fd2/crates/blockifier/src/execution/execution_utils.rs#L74
     if call_info.execution.failed {
         match call_info.execution.retdata.0.as_slice() {
@@ -102,6 +116,36 @@ fn execute_call_inner<S: StateReader>(
     Ok(call_info)
 }
 
+/// Returns the Sierra gas consumed by the contract call execution.
+///
+/// Depending on the the Sierra compiler version of the class, the resources used for the contract
+/// call execution may either be tracked as Cairo steps or Sierra gas. Note that `blockifier`
+/// doesn't store the actual tracked resource consumed value in a single variable of the `CallInfo`
+/// struct but as separate variables i.e., `gas_consumed` of [`CallExecution`] and `n_steps` of
+/// [`ExecutionResources`] for Sierra gas and Cairo steps respectively.
+///
+/// For reference: https://github.com/dojoengine/sequencer/blob/5d737b9c90a14bdf4483d759d1a1d4ce64aa9fd2/crates/blockifier/src/execution/entry_point_execution.rs#L367-L433
+///
+/// [`CallExecution`]: blockifier::execution::call_info::CallExecution
+/// [`ExecutionResources`]: cairo_vm::vm::runners::cairo_runner::ExecutionResources
+pub fn get_call_sierra_gas_consumed(
+    info: &CallInfo,
+    versioned_constant: &VersionedConstants,
+) -> u64 {
+    match info.tracked_resource {
+        // If the execution is tracked using Cairo steps, the sierra gas isn't counted
+        // ie `info.execution.gas_consumed` is set to 0. So, we have to convert the cairo
+        // steps to sierra gas.
+        //
+        // https://github.com/dojoengine/sequencer/blob/5d737b9c90a14bdf4483d759d1a1d4ce64aa9fd2/crates/blockifier/src/execution/entry_point_execution.rs#L475-L479
+        TrackedResource::CairoSteps => {
+            n_steps_to_sierra_gas(info.resources.n_steps, versioned_constant).0
+        }
+
+        TrackedResource::SierraGas => info.execution.gas_consumed,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::str::FromStr;
@@ -118,7 +162,7 @@ mod tests {
     use katana_provider::test_utils;
     use starknet::macros::selector;
 
-    use super::execute_call_inner;
+    use super::{execute_call_inner, get_call_sierra_gas_consumed};
     use crate::implementation::blockifier::state::StateProviderDb;
 
     #[test]
@@ -160,8 +204,10 @@ mod tests {
             // ~900,000 gas
             req.calldata = vec![felt!("460")];
             let info = execute_call_inner(req.clone(), &mut state, ctx.clone(), max_gas_1).unwrap();
+            let gas_consumed = get_call_sierra_gas_consumed(&info, ctx.versioned_constants());
+
             assert!(!info.execution.failed);
-            assert!(max_gas_1 >= info.execution.gas_consumed);
+            assert!(max_gas_1 >= gas_consumed);
 
             req.calldata = vec![felt!("600")];
             let result = execute_call_inner(req.clone(), &mut state, ctx.clone(), max_gas_1);
@@ -170,14 +216,16 @@ mod tests {
 
         let max_gas_2 = 10_000_000;
         {
-            // rougly equivalent to 9,000,000 gas
+            // roughly equivalent to 9,000,000 gas
             req.calldata = vec![felt!("4600")];
             let info = execute_call_inner(req.clone(), &mut state, ctx.clone(), max_gas_2).unwrap();
+            let gas_consumed = get_call_sierra_gas_consumed(&info, ctx.versioned_constants());
+
             assert!(!info.execution.failed);
-            assert!(max_gas_2 >= info.execution.gas_consumed);
-            assert!(max_gas_1 < info.execution.gas_consumed);
+            assert!(max_gas_2 >= gas_consumed);
+            assert!(max_gas_1 < gas_consumed);
 
-            req.calldata = vec![felt!("5000")];
+            req.calldata = vec![felt!("6000")];
             let result = execute_call_inner(req.clone(), &mut state, ctx.clone(), max_gas_2);
             assert!(result.is_err(), "should fail due to out of run resources")
         }
@@ -186,9 +234,11 @@ mod tests {
         {
             req.calldata = vec![felt!("47000")];
             let info = execute_call_inner(req.clone(), &mut state, ctx.clone(), max_gas_3).unwrap();
+            let gas_consumed = get_call_sierra_gas_consumed(&info, ctx.versioned_constants());
+
             assert!(!info.execution.failed);
-            assert!(max_gas_3 >= info.execution.gas_consumed);
-            assert!(max_gas_2 < info.execution.gas_consumed);
+            assert!(max_gas_3 >= gas_consumed);
+            assert!(max_gas_2 < gas_consumed);
 
             req.calldata = vec![felt!("60000")];
             let result = execute_call_inner(req.clone(), &mut state, ctx.clone(), max_gas_3);

crates/executor/src/implementation/blockifier/utils.rs

@@ -326,7 +326,7 @@ pub fn to_executor_tx(mut tx: ExecutableTxWithHash, mut flags: ExecutionFlags) -
         },
 
         ExecutableTx::Declare(tx) => {
-            let compiled = tx.class.as_ref().clone().compile().expect("failed to compile");
+            let class = tx.class.as_ref().clone();
 
             let tx = match tx.transaction {
                 DeclareTx::V0(tx) => ApiDeclareTransaction::V0(DeclareTransactionV0V1 {
@@ -384,7 +384,7 @@ pub fn to_executor_tx(mut tx: ExecutableTxWithHash, mut flags: ExecutionFlags) -
             };
 
             let tx_hash = TransactionHash(hash);
-            let class_info = to_class_info(compiled).unwrap();
+            let class_info = to_class_info(class).unwrap();
             Transaction::Account(AccountTransaction {
                 tx: ExecTx::Declare(DeclareTransaction { class_info, tx_hash, tx }),
                 execution_flags: flags.into(),
@@ -623,33 +623,27 @@ pub fn to_blk_chain_id(chain_id: katana_primitives::chain::ChainId) -> ChainId {
     }
 }
 
-pub fn to_class_info(class: class::CompiledClass) -> Result<ClassInfo, ProgramError> {
+pub fn to_class_info(class: class::ContractClass) -> Result<ClassInfo, ProgramError> {
     use starknet_api::contract_class::ContractClass;
 
-    // TODO: @kariy not sure of the variant that must be used in this case. Should we change the
-    // return type to include this case of error for contract class conversions?
-    match class {
-        class::CompiledClass::Legacy(legacy) => {
-            // For cairo 0, the sierra_program_length must be 0.
-            Ok(ClassInfo::new(&ContractClass::V0(legacy), 0, 0, SierraVersion::DEPRECATED).unwrap())
+    let sierra_version = class.sierra_version();
+    let sierra_program_len = class.sierra_program_len();
+    let abi_len = class.abi_len();
+
+    let compiled = class.compile().unwrap();
+
+    match compiled {
+        class::CompiledClass::Legacy(casm) => {
+            // It's safe to unwrap here because `ClassInfo::new` will only fail if the
+            // sierra_program_len != 0 for legacy classes and `class.sierra_program_len()` will
+            // always return 0 for legacy classes.
+            let casm = ContractClass::V0(casm);
+            Ok(ClassInfo::new(&casm, sierra_program_len, abi_len, sierra_version).unwrap())
         }
 
-        class::CompiledClass::Class(sierra) => {
-            // NOTE:
-            //
-            // Right now, we're using dummy values for the sierra class info (ie
-            // sierra_program_length, and abi_length). This value affects the fee
-            // calculation so we should use the correct values based on the sierra class itself.
-            //
-            // Make sure these values are the same over on `snos` when it re-executes the
-            // transactions as otherwise the fees would be different.
-
-            let version = SierraVersion::from_str(&sierra.compiler_version).unwrap();
-            let class = ContractClass::V1((sierra, version.clone()));
-            let sierra_program_length = 1;
-            let abi_length = 0;
-
-            Ok(ClassInfo::new(&class, sierra_program_length, abi_length, version).unwrap())
+        class::CompiledClass::Class(casm) => {
+            let class = ContractClass::V1((casm, sierra_version.clone()));
+            Ok(ClassInfo::new(&class, sierra_program_len, abi_len, sierra_version).unwrap())
         }
     }
 }

crates/primitives/src/class.rs

@@ -2,9 +2,12 @@ use std::str::FromStr;
 
 use cairo_lang_starknet_classes::abi;
 use cairo_lang_starknet_classes::casm_contract_class::StarknetSierraCompilationError;
-use cairo_lang_starknet_classes::contract_class::{ContractEntryPoint, ContractEntryPoints};
+use cairo_lang_starknet_classes::contract_class::{
+    version_id_from_serialized_sierra_program, ContractEntryPoint, ContractEntryPoints,
+};
 use serde_json_pythonic::to_string_pythonic;
 use starknet::macros::short_string;
+use starknet_api::contract_class::SierraVersion;
 use starknet_types_core::hash::{Poseidon, StarkHash};
 
 use crate::utils::{normalize_address, starknet_keccak};
@@ -98,6 +101,58 @@ impl ContractClass {
             _ => None,
         }
     }
+
+    /// Returns the version of the Sierra program of this class.
+    pub fn sierra_version(&self) -> SierraVersion {
+        match self {
+            Self::Class(class) => {
+                // The sierra program is an array of field elements and the first six elements are
+                // reserved for the compilers version. The array is structured as follows:
+                //
+                // ┌──────────────────────────────────────┐
+                // │ Idx │ Content                        │
+                // ┌──────────────────────────────────────┐
+                // │ 0   │ Sierra major version           │
+                // │ 1   │ Sierra minor version           │
+                // │ 2   │ Sierra patch version           │
+                // │ 3   │ CASM compiler major version    │
+                // │ 4   │ CASM compiler minor version    │
+                // │ 5   │ CASM compiler patch version    │
+                // │ 6+  │ Program data                   │
+                // └──────────────────────────────────────┘
+                //
+
+                let version = version_id_from_serialized_sierra_program(&class.sierra_program)
+                    .map(|(sierra_id, _)| sierra_id)
+                    .expect("invalid sierra program: failed to get version id from sierra program");
+
+                SierraVersion::new(
+                    version.major.try_into().unwrap(),
+                    version.minor.try_into().unwrap(),
+                    version.patch.try_into().unwrap(),
+                )
+            }
+
+            Self::Legacy(..) => SierraVersion::DEPRECATED,
+        }
+    }
+
+    /// Returns the length of the Sierra program.
+    pub fn sierra_program_len(&self) -> usize {
+        match self {
+            Self::Class(class) => class.sierra_program.len(),
+            // For cairo 0, the sierra_program_length must be 0.
+            Self::Legacy(..) => 0,
+        }
+    }
+
+    // TODO(kariy): document the actual definition of the ABI length here.
+    pub fn abi_len(&self) -> usize {
+        match self {
+            Self::Class(class) => to_string_pythonic(&class.abi.as_ref()).unwrap().len(),
+            Self::Legacy(..) => 0,
+        }
+    }
 }
 
 #[derive(Debug, thiserror::Error)]

crates/rpc/rpc/src/starknet/config.rs

@@ -10,6 +10,18 @@ pub struct StarknetApiConfig {
     /// If `None`, the maximum keys size is bounded by [`u64::MAX`].
     pub max_proof_keys: Option<u64>,
 
+    /// Maximum Sierra gas for contract calls.
+    ///
+    /// The maximum amount of execution resources allocated for a contract call via `starknet_call`
+    /// method. If `None,` defaults to `1,000,000,000`.
+    ///
+    /// ## Implementation Details
+    ///
+    /// If the contract call execution is tracked using Cairo steps (eg., the class is using an old
+    /// sierra compiler version), this Sierra gas value must be converted to Cairo steps. Check out
+    /// the [`call`] module for more information.
+    ///
+    /// [`call`]: katana_executor::implementation::blockifier::call
     pub max_call_gas: Option<u64>,
 
     /// The maximum number of concurrent `estimate_fee` requests allowed.