Get gas resources from CallInfo

commit-id:7967ca03

Author: ddoktorski

crates/cheatnet/src/runtime_extensions/call_to_blockifier_runtime_extension/rpc.rs

@@ -5,6 +5,7 @@ use crate::runtime_extensions::{
     },
     common::create_execute_calldata,
 };
+use blockifier::execution::call_info::ExecutionSummary;
 use blockifier::execution::{
     call_info::CallInfo,
     entry_point::{CallType, EntryPointExecutionResult},
@@ -18,22 +19,21 @@ use blockifier::state::errors::StateError;
 use cairo_vm::vm::runners::cairo_runner::ExecutionResources;
 use conversions::{byte_array::ByteArray, serde::serialize::CairoSerialize, string::IntoHexStr};
 use shared::utils::build_readable_text;
+use starknet_api::core::EntryPointSelector;
 use starknet_api::execution_resources::GasAmount;
 use starknet_api::{
     contract_class::EntryPointType,
     core::{ClassHash, ContractAddress},
 };
-use starknet_api::{core::EntryPointSelector, transaction::EventContent};
 use starknet_types_core::felt::Felt;
 
 #[derive(Clone, Debug, Default)]
 pub struct UsedResources {
     pub syscall_usage: SyscallUsageMap,
     pub execution_resources: ExecutionResources,
     pub gas_consumed: GasAmount,
-    pub l2_to_l1_payload_lengths: Vec<usize>,
+    pub execution_summary: ExecutionSummary,
     pub l1_handler_payload_lengths: Vec<usize>,
-    pub events: Vec<EventContent>,
 }
 
 /// Enum representing possible call execution result, along with the data

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

@@ -1,6 +1,6 @@
 use self::contracts_data::ContractsData;
 use crate::runtime_extensions::call_to_blockifier_runtime_extension::rpc::UsedResources;
-use crate::runtime_extensions::common::{get_syscalls_gas_consumed, sum_syscall_usage};
+use crate::runtime_extensions::common::sum_syscall_usage;
 use crate::runtime_extensions::forge_runtime_extension::cheatcodes::replace_bytecode::ReplaceBytecodeError;
 use crate::runtime_extensions::{
     call_to_blockifier_runtime_extension::{
@@ -19,27 +19,23 @@ use crate::runtime_extensions::{
 };
 use crate::state::{CallTrace, CallTraceNode};
 use anyhow::{Context, Result, anyhow};
-use blockifier::blockifier_versioned_constants::VersionedConstants;
 use blockifier::bouncer::vm_resources_to_sierra_gas;
 use blockifier::context::TransactionContext;
-use blockifier::execution::call_info::{CallExecution, CallInfo};
+use blockifier::execution::call_info::CallInfo;
 use blockifier::execution::contract_class::TrackedResource;
-use blockifier::execution::entry_point::CallEntryPoint;
 use blockifier::execution::syscalls::vm_syscall_utils::{SyscallSelector, SyscallUsageMap};
 use blockifier::state::errors::StateError;
 use cairo_vm::vm::runners::cairo_runner::CairoRunner;
 use cairo_vm::vm::{
     errors::hint_errors::HintError, runners::cairo_runner::ExecutionResources,
     vm_core::VirtualMachine,
 };
-use conversions::IntoConv;
 use conversions::byte_array::ByteArray;
 use conversions::felt::{ToShortString, TryInferFormat};
 use conversions::serde::deserialize::BufferReader;
 use conversions::serde::serialize::CairoSerialize;
 use data_transformer::cairo_types::CairoU256;
 use rand::prelude::StdRng;
-use runtime::starknet::constants::TEST_CONTRACT_CLASS_HASH;
 use runtime::{
     CheatcodeHandlingResult, EnhancedHintError, ExtendedRuntime, ExtensionLogic,
     SyscallHandlingResult,
@@ -730,15 +726,6 @@ pub fn update_top_call_vm_trace(runtime: &mut ForgeRuntime, cairo_runner: &mut C
             Some(get_relocated_vm_trace(cairo_runner));
     }
 }
-fn add_syscall_execution_resources(
-    versioned_constants: &VersionedConstants,
-    execution_resources: &ExecutionResources,
-    syscall_usage: &SyscallUsageMap,
-) -> ExecutionResources {
-    let mut total_vm_usage = execution_resources.filter_unused_builtins();
-    total_vm_usage += &versioned_constants.get_additional_os_syscall_resources(syscall_usage);
-    total_vm_usage
-}
 
 fn add_sierra_gas_resources(top_call: &Rc<RefCell<CallTrace>>) -> u64 {
     let mut gas_consumed = top_call.borrow().gas_consumed;
@@ -766,78 +753,23 @@ fn add_execution_resources(top_call: Rc<RefCell<CallTrace>>) -> ExecutionResourc
 
 #[must_use]
 pub fn get_all_used_resources(
-    runtime: ForgeRuntime,
+    call_info: &CallInfo,
+    trace: &Rc<RefCell<CallTrace>>,
     transaction_context: &TransactionContext,
-    tracked_resource: TrackedResource,
 ) -> UsedResources {
-    let starknet_runtime = runtime.extended_runtime.extended_runtime.extended_runtime;
-    let top_call_l2_to_l1_messages = starknet_runtime.hint_handler.base.l2_to_l1_messages;
-    let top_call_events = starknet_runtime.hint_handler.base.events;
-
     let versioned_constants = transaction_context.block_context.versioned_constants();
 
-    // used just to obtain payloads of L2 -> L1 messages
-    let runtime_call_info = CallInfo {
-        execution: CallExecution {
-            l2_to_l1_messages: top_call_l2_to_l1_messages,
-            events: top_call_events,
-            ..Default::default()
-        },
-        call: CallEntryPoint {
-            class_hash: Some(Felt::from_hex(TEST_CONTRACT_CLASS_HASH).unwrap().into_()),
-            ..Default::default()
-        },
-        inner_calls: starknet_runtime.hint_handler.base.inner_calls,
-        tracked_resource,
-        ..Default::default()
-    };
-    let summary = runtime_call_info.summarize(versioned_constants);
-    let l2_to_l1_payload_lengths = summary.l2_to_l1_payload_lengths;
-
-    let l1_handler_payload_lengths =
-        get_l1_handlers_payloads_lengths(&runtime_call_info.inner_calls);
+    let summary = call_info.summarize(versioned_constants);
 
-    // call representing the test code
-    let top_call = runtime
-        .extended_runtime
-        .extended_runtime
-        .extension
-        .cheatnet_state
-        .trace_data
-        .current_call_stack
-        .top();
+    let l1_handler_payload_lengths = get_l1_handlers_payloads_lengths(&call_info.inner_calls);
 
-    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().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
-        .flat_map(|call_info| {
-            call_info
-                .execution
-                .events
-                .iter()
-                .map(|evt| evt.event.clone())
-        })
-        .collect();
+    let top_call_syscalls = trace.borrow().get_total_used_syscalls();
 
     UsedResources {
-        events,
         syscall_usage: top_call_syscalls,
-        execution_resources,
-        gas_consumed: GasAmount::from(sierra_gas_consumed),
+        execution_resources: call_info.resources.clone(),
+        gas_consumed: GasAmount::from(call_info.execution.gas_consumed),
+        execution_summary: summary,
         l1_handler_payload_lengths,
-        l2_to_l1_payload_lengths,
     }
 }

crates/forge-runner/src/gas.rs

@@ -9,13 +9,11 @@ use blockifier::fee::resources::{
 use blockifier::state::cached_state::CachedState;
 use blockifier::state::errors::StateError;
 use blockifier::transaction::objects::HasRelatedFeeType;
-use blockifier::utils::u64_from_usize;
 use cairo_vm::vm::runners::cairo_runner::ExecutionResources;
 use cheatnet::runtime_extensions::call_to_blockifier_runtime_extension::rpc::UsedResources;
 use cheatnet::runtime_extensions::forge_config_extension::config::RawAvailableResourceBoundsConfig;
 use cheatnet::state::ExtendedStateReader;
 use starknet_api::execution_resources::{GasAmount, GasVector};
-use starknet_api::transaction::EventContent;
 use starknet_api::transaction::fields::GasVectorComputationMode;
 
 pub fn calculate_used_gas(
@@ -26,13 +24,14 @@ pub fn calculate_used_gas(
     let versioned_constants = transaction_context.block_context.versioned_constants();
 
     let message_resources = get_messages_resources(
-        &resources.l2_to_l1_payload_lengths,
+        &resources.execution_summary.l2_to_l1_payload_lengths,
         &resources.l1_handler_payload_lengths,
     );
 
     let state_resources = get_state_resources(transaction_context, state)?;
 
-    let archival_data_resources = get_archival_data_resources(resources.events);
+    let archival_data_resources =
+        get_archival_data_resources(resources.execution_summary.event_summary);
 
     let starknet_resources = StarknetResources {
         archival_data: archival_data_resources,
@@ -63,17 +62,7 @@ pub fn calculate_used_gas(
     ))
 }
 
-fn get_archival_data_resources(events: Vec<EventContent>) -> ArchivalDataResources {
-    // Based on from https://github.com/starkware-libs/sequencer/blob/fc0f06a07f3338ae1e11612dcaed9c59373bca37/crates/blockifier/src/execution/call_info.rs#L222
-    let mut event_summary = EventSummary {
-        n_events: events.len(),
-        ..Default::default()
-    };
-    for event in events {
-        event_summary.total_event_data_size += u64_from_usize(event.data.0.len());
-        event_summary.total_event_keys += u64_from_usize(event.keys.len());
-    }
-
+fn get_archival_data_resources(event_summary: EventSummary) -> ArchivalDataResources {
     // calldata length, signature length and code size are set to 0, because
     // we don't include them in estimations
     // ref: https://github.com/foundry-rs/starknet-foundry/blob/5ce15b029135545452588c00aae580c05eb11ca8/docs/src/testing/gas-and-resource-estimation.md?plain=1#L73

crates/forge-runner/src/running.rs

@@ -273,7 +273,7 @@ pub fn run_test_case(
         program_segment_size,
     ) {
         Ok(()) => {
-            let call_info = finalize_execution(
+            let mut call_info = finalize_execution(
                 &mut runner,
                 &mut forge_runtime
                     .extended_runtime
@@ -285,7 +285,12 @@ pub fn run_test_case(
                 tracked_resource,
             )?;
 
-            // TODO(#3292) this can be done better, we can take gas directly from call info
+            // TODO: Investigate why top call gas consumed is not always aggregated from inner calls
+            update_top_call_gas_consumed(&mut call_info);
+
+            // dbg!(&call_info);
+
+            // TODO(#3292): Confirm if this is needed for the profiler
             let vm_resources_without_inner_calls = runner
                 .get_execution_resources()
                 .expect("Execution resources missing")
@@ -332,34 +337,38 @@ pub fn run_test_case(
         .clone();
 
     let transaction_context = get_context(&forge_runtime).tx_context.clone();
-    let used_resources =
-        get_all_used_resources(forge_runtime, &transaction_context, tracked_resource);
-    let gas_used = calculate_used_gas(
-        &transaction_context,
-        &mut cached_state,
-        used_resources.clone(),
-    )?;
 
     let fork_data = cached_state
         .state
         .fork_state_reader
+        .as_ref()
         .map(|fork_state_reader| ForkData::new(&fork_state_reader.compiled_contract_class_map()))
         .unwrap_or_default();
 
     Ok(match result {
-        Ok(result) => RunResult::Completed(Box::new(RunCompleted {
-            status: if result.execution.failed {
-                RunStatus::Panic(result.execution.retdata.0)
-            } else {
-                RunStatus::Success(result.execution.retdata.0)
-            },
-            call_trace: call_trace_ref,
-            gas_used,
-            used_resources,
-            encountered_errors,
-            fuzzer_args,
-            fork_data,
-        })),
+        Ok(result) => {
+            let used_resources =
+                get_all_used_resources(&result, &call_trace_ref, &transaction_context);
+            let gas_used = calculate_used_gas(
+                &transaction_context,
+                &mut cached_state,
+                used_resources.clone(),
+            )?;
+
+            RunResult::Completed(Box::new(RunCompleted {
+                status: if result.execution.failed {
+                    RunStatus::Panic(result.execution.retdata.0)
+                } else {
+                    RunStatus::Success(result.execution.retdata.0)
+                },
+                call_trace: call_trace_ref,
+                gas_used,
+                used_resources,
+                encountered_errors,
+                fuzzer_args,
+                fork_data,
+            }))
+        }
         Err(error) => RunResult::Error(RunError {
             error: Box::new(error),
             call_trace: call_trace_ref,
@@ -462,3 +471,9 @@ fn get_call_trace_ref(runtime: &mut ForgeRuntime) -> Rc<RefCell<CallTrace>> {
         .current_call_stack
         .top()
 }
+
+fn update_top_call_gas_consumed(call_info: &mut CallInfo) {
+    for call in call_info.inner_calls.clone() {
+        call_info.execution.gas_consumed += call.execution.gas_consumed;
+    }
+}

crates/forge-runner/src/running/copied_code.rs

@@ -60,6 +60,11 @@ pub fn get_call_result(
         TrackedResource::CairoSteps => 0,
         TrackedResource::SierraGas => syscall_handler.base.call.initial_gas - gas,
     };
+
+    // let remaining = gas - gas_consumed;
+    // dbg!(remaining);
+    // dbg!((i64::MAX as u64) - remaining);
+
     Ok(CallResult {
         failed,
         retdata: read_execution_retdata(runner, retdata_size, retdata_start)?,

crates/forge-runner/src/test_case_summary.rs

@@ -125,6 +125,7 @@ impl TestType for Single {
 }
 
 /// Summary of running a single test case
+#[expect(clippy::large_enum_variant)]
 #[derive(Debug, Clone)]
 pub enum TestCaseSummary<T: TestType> {
     /// Test case passed