Fix resources from syscalls in nested calls (#3506)

<!-- Reference any GitHub issues resolved by this PR -->

Closes #3473 

## Introduced changes

Fix bug calculation of resources from nested calls syscalls. The reason
of malformed calculations was that during subtracting syscalls'
resources in `remove_syscall_resources_and_exit_non_error_call`, they
were only from current call and didn't include the ones from nested
calls.


## Checklist

<!-- Make sure all of these are complete -->

- [x] Linked relevant issue
- [x] Updated relevant documentation
- [x] Added relevant tests
- [x] Performed self-review of the code
- [x] Added changes to `CHANGELOG.md`

Author: franciszekjob

CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Forge
+
+#### Fixed
+
+- Bug where syscall execution resources from nested calls were being calculated twice
+
 ### Cast
 
 #### Changed

crates/cheatnet/src/runtime_extensions/call_to_blockifier_runtime_extension/execution/cairo1_execution.rs

@@ -5,12 +5,13 @@ use crate::runtime_extensions::call_to_blockifier_runtime_extension::execution::
 };
 use crate::runtime_extensions::cheatable_starknet_runtime_extension::CheatableStarknetRuntimeExtension;
 use crate::runtime_extensions::common::get_relocated_vm_trace;
-use blockifier::execution::contract_class::CompiledClassV1;
+use blockifier::execution::contract_class::{CompiledClassV1, TrackedResource};
 use blockifier::execution::entry_point::ExecutableCallEntryPoint;
 use blockifier::execution::entry_point_execution::{
     ExecutionRunnerMode, VmExecutionContext, finalize_execution,
     initialize_execution_context_with_runner_mode, prepare_call_arguments,
 };
+use blockifier::execution::syscalls::hint_processor::SyscallUsageMap;
 use blockifier::{
     execution::{
         contract_class::EntryPointV1, entry_point::EntryPointExecutionContext,
@@ -93,6 +94,8 @@ pub(crate) fn execute_entry_point_call_cairo1(
     })?;
 
     let trace = get_relocated_vm_trace(&mut runner);
+
+    // Syscall usage here is flat, meaning it only includes syscalls from current call
     let syscall_usage = cheatable_runtime
         .extended_runtime
         .hint_handler
@@ -124,9 +127,15 @@ pub(crate) fn execute_entry_point_call_cairo1(
             .register_error(class_hash, pcs);
     }
 
+    let (syscall_usage_vm_resources, syscall_usage_sierra_gas) = match tracked_resource {
+        TrackedResource::CairoSteps => (syscall_usage, SyscallUsageMap::default()),
+        TrackedResource::SierraGas => (SyscallUsageMap::default(), syscall_usage),
+    };
+
     Ok(CallInfoWithExecutionData {
         call_info,
-        syscall_usage,
+        syscall_usage_vm_resources,
+        syscall_usage_sierra_gas,
         vm_trace: Some(trace),
     })
     // endregion

crates/cheatnet/src/runtime_extensions/call_to_blockifier_runtime_extension/execution/deprecated/cairo0_execution.rs

@@ -14,6 +14,7 @@ use blockifier::execution::deprecated_entry_point_execution::{
 use blockifier::execution::entry_point::{EntryPointExecutionContext, ExecutableCallEntryPoint};
 use blockifier::execution::errors::EntryPointExecutionError;
 use blockifier::execution::execution_utils::Args;
+use blockifier::execution::syscalls::hint_processor::SyscallUsageMap;
 use blockifier::state::state_api::State;
 use cairo_vm::hint_processor::hint_processor_definition::HintProcessor;
 use cairo_vm::vm::runners::cairo_runner::{CairoArg, CairoRunner};
@@ -82,7 +83,8 @@ pub(crate) fn execute_entry_point_call_cairo0(
 
     Ok(CallInfoWithExecutionData {
         call_info: execution_result,
-        syscall_usage,
+        syscall_usage_vm_resources: syscall_usage,
+        syscall_usage_sierra_gas: SyscallUsageMap::default(),
         vm_trace: None,
     })
     // endregion

crates/cheatnet/src/runtime_extensions/call_to_blockifier_runtime_extension/execution/entry_point.rs

@@ -3,7 +3,8 @@ use crate::runtime_extensions::call_to_blockifier_runtime_extension::execution::
 use crate::runtime_extensions::call_to_blockifier_runtime_extension::rpc::{AddressOrClassHash, CallResult};
 use crate::runtime_extensions::call_to_blockifier_runtime_extension::CheatnetState;
 use crate::runtime_extensions::common::{get_relocated_vm_trace, get_syscalls_gas_consumed, sum_syscall_usage};
-use crate::state::{CallTrace, CallTraceNode, CheatStatus};
+use crate::runtime_extensions::forge_runtime_extension::{get_nested_calls_syscalls_sierra_gas, get_nested_calls_syscalls_vm_resources};
+use crate::state::{CheatStatus};
 use blockifier::execution::call_info::{CallExecution, Retdata};
 use blockifier::execution::contract_class::{RunnableCompiledClass, TrackedResource};
 use blockifier::execution::syscalls::hint_processor::{SyscallUsageMap, ENTRYPOINT_NOT_FOUND_ERROR, OUT_OF_GAS_ERROR};
@@ -28,9 +29,7 @@ use starknet_api::{
     transaction::{fields::Calldata, TransactionVersion},
 };
 use starknet_types_core::felt::Felt;
-use std::cell::RefCell;
 use std::collections::{HashMap, HashSet};
-use std::rc::Rc;
 use blockifier::execution::entry_point::{EntryPointRevertInfo, ExecutableCallEntryPoint};
 use blockifier::execution::stack_trace::{extract_trailing_cairo1_revert_trace, Cairo1RevertHeader};
 use thiserror::Error;
@@ -42,7 +41,8 @@ pub(crate) type ContractClassEntryPointExecutionResult =
 
 pub(crate) struct CallInfoWithExecutionData {
     pub call_info: CallInfo,
-    pub syscall_usage: SyscallUsageMap,
+    pub syscall_usage_vm_resources: SyscallUsageMap,
+    pub syscall_usage_sierra_gas: SyscallUsageMap,
     pub vm_trace: Option<Vec<RelocatedTraceEntry>>,
 }
 
@@ -82,7 +82,8 @@ pub fn execute_call_entry_point(
             cheatnet_state.trace_data.exit_nested_call(
                 ExecutionResources::default(),
                 u64::default(),
-                HashMap::default(),
+                SyscallUsageMap::default(),
+                SyscallUsageMap::default(),
                 CallResult::Success {
                     ret_data: ret_data_f252,
                 },
@@ -93,6 +94,7 @@ pub fn execute_call_entry_point(
                 .tracked_resource_stack
                 .last()
                 .expect("Unexpected empty tracked resource.");
+
             return Ok(mocked_call_info(
                 entry_point.clone(),
                 ret_data.clone(),
@@ -193,16 +195,17 @@ pub fn execute_call_entry_point(
     ) {
         Ok(CallInfoWithExecutionData {
             call_info,
-            syscall_usage,
+            syscall_usage_vm_resources,
+            syscall_usage_sierra_gas,
             vm_trace,
         }) => {
             remove_syscall_resources_and_exit_non_error_call(
                 &call_info,
-                &syscall_usage,
+                &syscall_usage_vm_resources,
+                &syscall_usage_sierra_gas,
                 context,
                 cheatnet_state,
                 vm_trace,
-                current_tracked_resource,
             );
             Ok(call_info)
         }
@@ -291,40 +294,55 @@ fn call_info_from_pre_execution_error(
             tracked_resource: current_tracked_resource,
             ..Default::default()
         },
-        syscall_usage: SyscallUsageMap::default(),
+        syscall_usage_vm_resources: SyscallUsageMap::default(),
+        syscall_usage_sierra_gas: SyscallUsageMap::default(),
         vm_trace: None,
     }
 }
 
 fn remove_syscall_resources_and_exit_non_error_call(
     call_info: &CallInfo,
-    syscall_usage: &SyscallUsageMap,
+    syscall_usage_vm_resources: &SyscallUsageMap,
+    syscall_usage_sierra_gas: &SyscallUsageMap,
     context: &mut EntryPointExecutionContext,
     cheatnet_state: &mut CheatnetState,
     vm_trace: Option<Vec<RelocatedTraceEntry>>,
-    current_tracked_resource: TrackedResource,
 ) {
     let versioned_constants = context.tx_context.block_context.versioned_constants();
     // We don't want the syscall resources to pollute the results
     let mut resources = call_info.resources.clone();
     let mut gas_consumed = call_info.execution.gas_consumed;
 
-    match current_tracked_resource {
-        TrackedResource::CairoSteps => {
-            resources -= &versioned_constants.get_additional_os_syscall_resources(syscall_usage);
-        }
-        TrackedResource::SierraGas => {
-            gas_consumed -= get_syscalls_gas_consumed(syscall_usage, versioned_constants);
-        }
-    }
+    // Remove resources consumed by syscalls from the current call
+    // `syscall_usage_vm_resources` and `syscall_usage_sierra_gas` are flat, meaning they only include syscalls from the specific call
+    resources -=
+        &versioned_constants.get_additional_os_syscall_resources(syscall_usage_vm_resources);
+    gas_consumed -= get_syscalls_gas_consumed(syscall_usage_sierra_gas, versioned_constants);
+
+    // Below syscall usages are cumulative.
+    let nested_syscall_usage_vm_resources =
+        get_nested_calls_syscalls_vm_resources(&cheatnet_state.trace_data.current_call_stack.top());
+    let nested_syscall_usage_sierra_gas =
+        get_nested_calls_syscalls_sierra_gas(&cheatnet_state.trace_data.current_call_stack.top());
+
+    // Remove resources consumed by syscalls from nested calls
+    resources -= &versioned_constants
+        .get_additional_os_syscall_resources(&nested_syscall_usage_vm_resources);
+    gas_consumed -=
+        get_syscalls_gas_consumed(&nested_syscall_usage_sierra_gas, versioned_constants);
+
+    let syscall_usage_vm_resources = sum_syscall_usage(
+        nested_syscall_usage_vm_resources,
+        syscall_usage_vm_resources,
+    );
+    let syscall_usage_sierra_gas =
+        sum_syscall_usage(nested_syscall_usage_sierra_gas, syscall_usage_sierra_gas);
 
-    let nested_syscall_usage_sum =
-        aggregate_nested_syscall_usage(&cheatnet_state.trace_data.current_call_stack.top());
-    let syscall_usage = sum_syscall_usage(nested_syscall_usage_sum, syscall_usage);
     cheatnet_state.trace_data.exit_nested_call(
         resources,
         gas_consumed,
-        syscall_usage,
+        syscall_usage_vm_resources,
+        syscall_usage_sierra_gas,
         CallResult::from_non_error(call_info),
         &call_info.execution.l2_to_l1_messages,
         vm_trace,
@@ -344,7 +362,8 @@ fn exit_error_call(
     cheatnet_state.trace_data.exit_nested_call(
         ExecutionResources::default(),
         u64::default(),
-        HashMap::default(),
+        SyscallUsageMap::default(),
+        SyscallUsageMap::default(),
         CallResult::from_err(error, &identifier),
         &[],
         vm_trace,
@@ -435,28 +454,6 @@ fn mocked_call_info(
     }
 }
 
-fn aggregate_nested_syscall_usage(trace: &Rc<RefCell<CallTrace>>) -> SyscallUsageMap {
-    let mut result = SyscallUsageMap::new();
-    for nested_call_node in &trace.borrow().nested_calls {
-        if let CallTraceNode::EntryPointCall(nested_call) = nested_call_node {
-            let sub_trace_counter = aggregate_syscall_usage(nested_call);
-            result = sum_syscall_usage(result, &sub_trace_counter);
-        }
-    }
-    result
-}
-
-fn aggregate_syscall_usage(trace: &Rc<RefCell<CallTrace>>) -> SyscallUsageMap {
-    let mut result = trace.borrow().used_syscalls.clone();
-    for nested_call_node in &trace.borrow().nested_calls {
-        if let CallTraceNode::EntryPointCall(nested_call) = nested_call_node {
-            let sub_trace_counter = aggregate_nested_syscall_usage(nested_call);
-            result = sum_syscall_usage(result, &sub_trace_counter);
-        }
-    }
-    result
-}
-
 #[derive(Debug, Error)]
 #[error("{}", source)]
 pub struct EntryPointExecutionErrorWithTrace {

crates/cheatnet/src/runtime_extensions/forge_runtime_extension/mod.rs

@@ -602,7 +602,10 @@ pub fn add_resources_to_top_call(
     }
 }
 
-pub fn update_top_call_resources(runtime: &mut ForgeRuntime) {
+pub fn update_top_call_resources(
+    runtime: &mut ForgeRuntime,
+    top_call_tracked_resource: TrackedResource,
+) {
     // call representing the test code
     let top_call = runtime
         .extended_runtime
@@ -616,10 +619,15 @@ pub fn update_top_call_resources(runtime: &mut ForgeRuntime) {
     let all_execution_resources = add_execution_resources(top_call.clone());
     let all_sierra_gas_consumed = add_sierra_gas_resources(&top_call);
 
+    // Below syscall usages are cumulative, meaning they include syscalls from their inner calls.
+    let nested_calls_syscalls_vm_resources = get_nested_calls_syscalls_vm_resources(&top_call);
+    let nested_calls_syscalls_sierra_gas = get_nested_calls_syscalls_sierra_gas(&top_call);
+
     let mut top_call = top_call.borrow_mut();
     top_call.used_execution_resources = all_execution_resources;
     top_call.gas_consumed = all_sierra_gas_consumed;
 
+    // Syscall usage here is flat, meaning it only includes syscalls from current call (in this case the top-level call)
     let top_call_syscalls = runtime
         .extended_runtime
         .extended_runtime
@@ -628,16 +636,49 @@ pub fn update_top_call_resources(runtime: &mut ForgeRuntime) {
         .syscalls_usage
         .clone();
 
+    let mut total_syscalls_vm_resources = nested_calls_syscalls_vm_resources.clone();
+    let mut total_syscalls_sierra_gas = nested_calls_syscalls_sierra_gas.clone();
+
+    // Based on the tracked resource of top call, we add the syscall usage to respective totals.
+    match top_call_tracked_resource {
+        TrackedResource::CairoSteps => {
+            total_syscalls_vm_resources =
+                sum_syscall_usage(total_syscalls_vm_resources, &top_call_syscalls);
+        }
+        TrackedResource::SierraGas => {
+            total_syscalls_sierra_gas =
+                sum_syscall_usage(total_syscalls_sierra_gas, &top_call_syscalls);
+        }
+    }
+
+    top_call.used_syscalls_vm_resources = total_syscalls_vm_resources;
+    top_call.used_syscalls_sierra_gas = total_syscalls_sierra_gas;
+}
+
+/// Calculates the total syscall usage from nested calls where the tracked resource is Cairo steps.
+pub fn get_nested_calls_syscalls_vm_resources(trace: &Rc<RefCell<CallTrace>>) -> SyscallUsageMap {
     // Only sum 1-level since these include syscalls from inner calls
-    let nested_calls_syscalls = top_call
+    trace
+        .borrow()
         .nested_calls
         .iter()
         .filter_map(CallTraceNode::extract_entry_point_call)
         .fold(SyscallUsageMap::new(), |syscalls, trace| {
-            sum_syscall_usage(syscalls, &trace.borrow().used_syscalls)
-        });
+            sum_syscall_usage(syscalls, &trace.borrow().used_syscalls_vm_resources)
+        })
+}
 
-    top_call.used_syscalls = sum_syscall_usage(top_call_syscalls, &nested_calls_syscalls);
+/// Calculates the total syscall usage from nested calls where the tracked resource is Sierra gas.
+pub fn get_nested_calls_syscalls_sierra_gas(trace: &Rc<RefCell<CallTrace>>) -> SyscallUsageMap {
+    // Only sum 1-level since these include syscalls from inner calls
+    trace
+        .borrow()
+        .nested_calls
+        .iter()
+        .filter_map(CallTraceNode::extract_entry_point_call)
+        .fold(SyscallUsageMap::new(), |syscalls, trace| {
+            sum_syscall_usage(syscalls, &trace.borrow().used_syscalls_sierra_gas)
+        })
 }
 
 // Only top-level is considered relevant since we can't have l1 handlers deeper than 1 level of nesting
@@ -769,21 +810,17 @@ pub fn get_all_used_resources(
 
     let mut execution_resources = top_call.borrow().used_execution_resources.clone();
     let mut sierra_gas_consumed = top_call.borrow().gas_consumed;
-    let top_call_syscalls = top_call.borrow().used_syscalls.clone();
-
-    match tracked_resource {
-        TrackedResource::CairoSteps => {
-            execution_resources = add_syscall_execution_resources(
-                versioned_constants,
-                &execution_resources,
-                &top_call_syscalls,
-            );
-        }
-        TrackedResource::SierraGas => {
-            sierra_gas_consumed +=
-                get_syscalls_gas_consumed(&top_call_syscalls, versioned_constants);
-        }
-    }
+    let top_call_syscalls = top_call.borrow().get_total_used_syscalls();
+
+    execution_resources = add_syscall_execution_resources(
+        versioned_constants,
+        &execution_resources,
+        &top_call.borrow().used_syscalls_vm_resources,
+    );
+    sierra_gas_consumed += get_syscalls_gas_consumed(
+        &top_call.borrow().used_syscalls_sierra_gas,
+        versioned_constants,
+    );
 
     let events = runtime_call_info
         .iter() // This method iterates over inner calls as well