Add events summary and signature lengths to trace file

Author: THenry14

Cargo.lock

@@ -115,3 +115,6 @@ derive_more = { version = "2.0.1", features = ["display"] }
 paste = "1.0.15"
 strum = "0.27"
 strum_macros = "0.27"
+
+[patch.crates-io]
+cairo-annotations = { git = "https://github.com/software-mansion/cairo-annotations.git", branch = "szymczyk/l2-gas" }

Cargo.toml

@@ -94,6 +94,7 @@ pub fn execute_call_entry_point(
             },
             &[],
             None,
+            vec![],
         );
         let tracked_resource = *context
             .tracked_resource_stack
@@ -178,6 +179,14 @@ pub fn execute_call_entry_point(
         .pop()
         .expect("Unexpected empty tracked resource.");
 
+    let entrypoint_address = entry_point.code_address.unwrap_or_default();
+    let signature = cheatnet_state
+        .get_cheated_execution_info_for_contract(entrypoint_address)
+        .tx_info
+        .signature
+        .as_value()
+        .unwrap_or_default();
+
     // region: Modified blockifier code
     match evaluate_execution_result(
         result,
@@ -199,6 +208,7 @@ pub fn execute_call_entry_point(
                 context,
                 cheatnet_state,
                 vm_trace,
+                signature,
             );
             Ok(call_info)
         }
@@ -302,6 +312,7 @@ fn remove_syscall_resources_and_exit_non_error_call(
     context: &mut EntryPointExecutionContext,
     cheatnet_state: &mut CheatnetState,
     vm_trace: Option<Vec<RelocatedTraceEntry>>,
+    signature: Vec<Felt>,
 ) {
     let versioned_constants = context.tx_context.block_context.versioned_constants();
     // We don't want the syscall resources to pollute the results
@@ -341,6 +352,7 @@ fn remove_syscall_resources_and_exit_non_error_call(
         CallResult::from_non_error(call_info),
         &call_info.execution.l2_to_l1_messages,
         vm_trace,
+        signature,
     );
 }
 
@@ -362,6 +374,7 @@ fn exit_error_call(
         CallResult::from_err(error, &identifier),
         &[],
         vm_trace,
+        vec![],
     );
 }
 

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

@@ -10,7 +10,7 @@ use crate::runtime_extensions::forge_runtime_extension::cheatcodes::cheat_execut
 };
 use crate::runtime_extensions::forge_runtime_extension::cheatcodes::spy_events::Event;
 use crate::runtime_extensions::forge_runtime_extension::cheatcodes::spy_messages_to_l1::MessageToL1;
-use blockifier::execution::call_info::OrderedL2ToL1Message;
+use blockifier::execution::call_info::{OrderedEvent, OrderedL2ToL1Message};
 use blockifier::execution::contract_class::RunnableCompiledClass;
 use blockifier::execution::entry_point::CallEntryPoint;
 use blockifier::execution::syscalls::vm_syscall_utils::SyscallUsageMap;
@@ -219,6 +219,8 @@ pub struct CallTrace {
     pub used_syscalls_sierra_gas: SyscallUsageMap,
     pub vm_trace: Option<Vec<RelocatedTraceEntry>>,
     pub gas_consumed: u64,
+    pub events: Vec<OrderedEvent>,
+    pub signature: Vec<Felt>,
 }
 
 impl CairoSerialize for CallTrace {
@@ -249,6 +251,8 @@ impl CallTrace {
             result: CallResult::Success { ret_data: vec![] },
             vm_trace: None,
             gas_consumed: u64::default(),
+            events: vec![],
+            signature: vec![],
         }
     }
 
@@ -563,6 +567,7 @@ impl TraceData {
         result: CallResult,
         l2_to_l1_messages: &[OrderedL2ToL1Message],
         vm_trace: Option<Vec<RelocatedTraceEntry>>,
+        signature: Vec<Felt>,
     ) {
         let CallStackElement {
             call_trace: last_call,
@@ -582,6 +587,7 @@ impl TraceData {
 
         last_call.result = result;
         last_call.vm_trace = vm_trace;
+        last_call.signature = signature;
     }
 
     pub fn add_deploy_without_constructor_node(&mut self) {

crates/cheatnet/src/state.rs

@@ -5,15 +5,16 @@ use blockifier::execution::syscalls::vm_syscall_utils::{
     SyscallSelector, SyscallUsage, SyscallUsageMap,
 };
 
+use blockifier::execution::call_info::OrderedEvent;
 use cairo_annotations::trace_data::{
     CairoExecutionInfo, CallEntryPoint as ProfilerCallEntryPoint,
     CallTraceNode as ProfilerCallTraceNode, CallTraceV1 as ProfilerCallTrace,
     CallType as ProfilerCallType, CasmLevelInfo, ContractAddress,
     DeprecatedSyscallSelector as ProfilerDeprecatedSyscallSelector,
     EntryPointSelector as ProfilerEntryPointSelector, EntryPointType as ProfilerEntryPointType,
-    ExecutionResources as ProfilerExecutionResources, SyscallUsage as ProfilerSyscallUsage,
-    TraceEntry as ProfilerTraceEntry, VersionedCallTrace as VersionedProfilerCallTrace,
-    VmExecutionResources,
+    ExecutionResources as ProfilerExecutionResources, SummedUpEvent,
+    SyscallUsage as ProfilerSyscallUsage, TraceEntry as ProfilerTraceEntry,
+    VersionedCallTrace as VersionedProfilerCallTrace, VmExecutionResources,
 };
 use cairo_vm::vm::runners::cairo_runner::ExecutionResources;
 use cairo_vm::vm::trace::trace_entry::RelocatedTraceEntry;
@@ -27,6 +28,7 @@ use runtime::starknet::constants::{TEST_CONTRACT_CLASS_HASH, TEST_ENTRY_POINT_SE
 use starknet::core::utils::get_selector_from_name;
 use starknet_api::contract_class::EntryPointType;
 use starknet_api::core::{ClassHash, EntryPointSelector};
+use starknet_types_core::felt::Felt;
 use std::cell::RefCell;
 use std::fs;
 use std::path::PathBuf;
@@ -45,8 +47,13 @@ pub fn build_profiler_call_trace(
 ) -> ProfilerCallTrace {
     let value = value.borrow();
 
-    let entry_point =
-        build_profiler_call_entry_point(value.entry_point.clone(), contracts_data, fork_data);
+    let entry_point = build_profiler_call_entry_point(
+        value.entry_point.clone(),
+        contracts_data,
+        fork_data,
+        &value.events,
+        &value.signature,
+    );
     let vm_trace = value
         .vm_trace
         .as_ref()
@@ -160,6 +167,8 @@ pub fn build_profiler_call_entry_point(
     value: CallEntryPoint,
     contracts_data: &ContractsData,
     fork_data: &ForkData,
+    events: &[OrderedEvent],
+    signature: &[Felt],
 ) -> ProfilerCallEntryPoint {
     let CallEntryPoint {
         class_hash,
@@ -174,6 +183,7 @@ pub fn build_profiler_call_entry_point(
     let contract_name = get_contract_name(class_hash, contracts_data);
     let function_name = get_function_name(&entry_point_selector, contracts_data, fork_data);
     let calldata_len = calldata.0.len();
+    let signature_len = signature.len();
 
     ProfilerCallEntryPoint {
         class_hash: class_hash.map(|ch| cairo_annotations::trace_data::ClassHash(ch.0)),
@@ -184,6 +194,8 @@ pub fn build_profiler_call_entry_point(
         contract_name,
         function_name,
         calldata_len: Some(calldata_len),
+        events_summary: Some(to_summed_up_events(events)),
+        signature_len: Some(signature_len),
     }
 }
 
@@ -344,3 +356,13 @@ pub fn save_trace_data(
         .context("Failed to write call trace to a file")?;
     Ok(dir_to_save_trace.join(&filename))
 }
+
+fn to_summed_up_events(events: &[OrderedEvent]) -> Vec<SummedUpEvent> {
+    events
+        .iter()
+        .map(|ev| SummedUpEvent {
+            keys_len: ev.event.keys.len(),
+            data_len: ev.event.data.0.len(),
+        })
+        .collect()
+}

crates/forge-runner/src/build_trace_data.rs

@@ -4,9 +4,9 @@ use crate::gas::calculate_used_gas;
 use crate::package_tests::with_config_resolved::{ResolvedForkConfig, TestCaseWithResolvedConfig};
 use crate::test_case_summary::{Single, TestCaseSummary};
 use anyhow::{Result, bail};
-use blockifier::execution::call_info::CallInfo;
+use blockifier::execution::call_info::{CallInfo, OrderedEvent};
 use blockifier::execution::contract_class::TrackedResource;
-use blockifier::execution::entry_point::EntryPointExecutionContext;
+use blockifier::execution::entry_point::{CallEntryPoint, EntryPointExecutionContext};
 use blockifier::execution::entry_point_execution::{prepare_call_arguments, run_entry_point};
 use blockifier::execution::errors::EntryPointExecutionError;
 use blockifier::state::cached_state::CachedState;
@@ -25,7 +25,8 @@ use cheatnet::runtime_extensions::forge_runtime_extension::{
     update_top_call_l1_resources, update_top_call_resources, update_top_call_vm_trace,
 };
 use cheatnet::state::{
-    BlockInfoReader, CallTrace, CheatnetState, EncounteredErrors, ExtendedStateReader,
+    BlockInfoReader, CallTrace, CallTraceNode, CheatnetState, EncounteredErrors,
+    ExtendedStateReader,
 };
 use execution::finalize_execution;
 use foundry_ui::UI;
@@ -35,6 +36,7 @@ use runtime::starknet::context::{build_context, set_max_steps};
 use runtime::{ExtendedRuntime, StarknetRuntime};
 use starknet_api::execution_resources::GasVector;
 use std::cell::RefCell;
+use std::collections::HashMap;
 use std::default::Default;
 use std::marker::PhantomData;
 use std::rc::Rc;
@@ -360,19 +362,22 @@ pub fn run_test_case(
         .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) => {
+            collect_and_assign_events(&result, &call_trace_ref);
+            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,
@@ -477,3 +482,36 @@ fn get_call_trace_ref(runtime: &mut ForgeRuntime) -> Rc<RefCell<CallTrace>> {
         .current_call_stack
         .top()
 }
+
+fn entry_point_key(ep: &CallEntryPoint) -> String {
+    format!("{ep:?}")
+}
+
+fn collect_events(call_info: &CallInfo, map: &mut HashMap<String, Vec<OrderedEvent>>) {
+    map.insert(
+        entry_point_key(&call_info.call),
+        call_info.execution.events.clone(),
+    );
+    for inner_info in &call_info.inner_calls {
+        collect_events(inner_info, map);
+    }
+}
+
+fn assign_events(trace_rc: &Rc<RefCell<CallTrace>>, map: &HashMap<String, Vec<OrderedEvent>>) {
+    let mut trace = trace_rc.borrow_mut();
+    if let Some(events) = map.get(&entry_point_key(&trace.entry_point)) {
+        trace.events.clone_from(events);
+    }
+
+    for nested_node in &trace.nested_calls {
+        if let CallTraceNode::EntryPointCall(nested_trace) = nested_node {
+            assign_events(nested_trace, map);
+        }
+    }
+}
+
+fn collect_and_assign_events(call_info: &CallInfo, trace_rc: &Rc<RefCell<CallTrace>>) {
+    let mut events_lookup = HashMap::new();
+    collect_events(call_info, &mut events_lookup);
+    assign_events(trace_rc, &events_lookup);
+}