Get gas resources from CallInfo

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/cheatcodes/mod.rs

@@ -10,7 +10,6 @@ pub mod cheat_caller_address;
 pub mod cheat_execution_info;
 pub mod cheat_sequencer_address;
 pub mod declare;
-pub mod deploy;
 pub mod generate_random_felt;
 pub mod get_class_hash;
 pub mod l1_handler_execute;

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,
@@ -187,7 +183,7 @@ impl<'a> ExtensionLogic for ForgeExtension<'a> {
 
                 let contract_name: String = input_reader.read::<ByteArray>()?.to_string();
 
-                handle_declare_deploy_result(declare(*state, &contract_name, self.contracts_data))
+                handle_declare_result(declare(*state, &contract_name, self.contracts_data))
             }
             // Internal cheatcode used to pass a contract address when calling `deploy_at`.
             "set_deploy_at_address" => {
@@ -554,7 +550,7 @@ enum SignError {
     HashOutOfRange,
 }
 
-fn handle_declare_deploy_result<T: CairoSerialize>(
+fn handle_declare_result<T: CairoSerialize>(
     declare_result: Result<T, CheatcodeError>,
 ) -> Result<CheatcodeHandlingResult, EnhancedHintError> {
     let result = match declare_result {
@@ -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,
     }
 }