From a591e99a84a726aaa4342fed832e0b74baea73fb Mon Sep 17 00:00:00 2001 From: FrancoGiachetta Date: Tue, 3 Jun 2025 15:56:28 -0300 Subject: [PATCH 1/7] add syscall_counting --- crates/blockifier/Cargo.toml | 1 + crates/blockifier/src/execution/call_info.rs | 3 + .../execution/native/entry_point_execution.rs | 7 +- .../src/execution/native/executor.rs | 9 ++- .../src/execution/native/syscall_handler.rs | 79 ++++++++++++++++++- 5 files changed, 96 insertions(+), 3 deletions(-) diff --git a/crates/blockifier/Cargo.toml b/crates/blockifier/Cargo.toml index df98bb03fae..727894dbe9c 100644 --- a/crates/blockifier/Cargo.toml +++ b/crates/blockifier/Cargo.toml @@ -12,6 +12,7 @@ workspace = true [features] cairo_native = ["dep:cairo-native", "starknet_sierra_multicompile/cairo_native", "dep:sierra-emu"] with-trace-dump = ["cairo_native", "cairo-native/with-trace-dump"] +block-composition = [] jemalloc = ["dep:tikv-jemallocator"] native_blockifier = [] node_api = [] diff --git a/crates/blockifier/src/execution/call_info.rs b/crates/blockifier/src/execution/call_info.rs index 56d126ca048..506b7eb4401 100644 --- a/crates/blockifier/src/execution/call_info.rs +++ b/crates/blockifier/src/execution/call_info.rs @@ -13,6 +13,7 @@ use starknet_types_core::felt::Felt; use crate::execution::contract_class::TrackedResource; use crate::execution::entry_point::CallEntryPoint; +use crate::execution::native::syscall_handler::SyscallCounts; use crate::state::cached_state::StorageEntry; use crate::utils::u64_from_usize; use crate::versioned_constants::VersionedConstants; @@ -200,6 +201,8 @@ impl AddAssign<&ChargedResources> for ChargedResources { #[cfg_attr(feature = "transaction_serde", derive(serde::Deserialize))] #[derive(Debug, Default, Eq, PartialEq, Serialize)] pub struct CallInfo { + #[cfg(feature = "block_composition")] + pub syscall_counts: SyscallCounts, pub call: CallEntryPoint, pub execution: CallExecution, pub inner_calls: Vec, diff --git a/crates/blockifier/src/execution/native/entry_point_execution.rs b/crates/blockifier/src/execution/native/entry_point_execution.rs index 66687e9773c..bb6b26d7ea7 100644 --- a/crates/blockifier/src/execution/native/entry_point_execution.rs +++ b/crates/blockifier/src/execution/native/entry_point_execution.rs @@ -10,7 +10,7 @@ use crate::execution::entry_point::{ }; use crate::execution::errors::{EntryPointExecutionError, PostExecutionError, PreExecutionError}; use crate::execution::native::contract_class::NativeCompiledClassV1; -use crate::execution::native::syscall_handler::NativeSyscallHandler; +use crate::execution::native::syscall_handler::{NativeSyscallHandler, SYSCALL_COUNTER}; use crate::state::state_api::State; // todo(rodrigo): add an `entry point not found` test for Native @@ -86,7 +86,12 @@ fn create_callinfo( let gas_consumed = syscall_handler.base.call.initial_gas - remaining_gas; let vm_resources = CallInfo::summarize_vm_resources(syscall_handler.base.inner_calls.iter()); + #[cfg(feature = "block_composition")] + let syscalls_coutnts = *SYSCALL_COUNTER.lock().unwrap(); + Ok(CallInfo { + #[cfg(feature = "block_composition")] + syscall_counts, call: syscall_handler.base.call.into(), execution: CallExecution { retdata: Retdata(call_result.return_values), diff --git a/crates/blockifier/src/execution/native/executor.rs b/crates/blockifier/src/execution/native/executor.rs index 778f253be34..711f5791b7d 100644 --- a/crates/blockifier/src/execution/native/executor.rs +++ b/crates/blockifier/src/execution/native/executor.rs @@ -16,6 +16,7 @@ use sierra_emu::VirtualMachine; use starknet_types_core::felt::Felt; use super::syscall_handler::NativeSyscallHandler; +use crate::execution::native::syscall_handler::{SyscallCounts, SYSCALL_COUNTER}; #[derive(Debug)] pub enum ContractExecutor { @@ -48,7 +49,13 @@ impl ContractExecutor { ) -> cairo_native::error::Result { match self { ContractExecutor::Aot(aot_contract_executor) => { - aot_contract_executor.run(selector, args, gas, builtin_costs, syscall_handler) + let result = + aot_contract_executor.run(selector, args, gas, builtin_costs, syscall_handler); + + #[cfg(feature = "block_composition")] + SYSCALL_COUNTER.set(SyscallCounts::default())?; + + result } ContractExecutor::Emu((program, entrypoints, version)) => { let mut virtual_machine = diff --git a/crates/blockifier/src/execution/native/syscall_handler.rs b/crates/blockifier/src/execution/native/syscall_handler.rs index ea5ce0f0f2a..53f4abf74c9 100644 --- a/crates/blockifier/src/execution/native/syscall_handler.rs +++ b/crates/blockifier/src/execution/native/syscall_handler.rs @@ -1,6 +1,6 @@ use std::convert::From; use std::fmt; -use std::sync::Arc; +use std::sync::{Arc, LazyLock, Mutex}; use ark_ec::short_weierstrass::{Affine, Projective, SWCurveConfig}; use ark_ff::{BigInt, PrimeField}; @@ -45,6 +45,39 @@ use crate::versioned_constants::GasCosts; pub const CALL_CONTRACT_SELECTOR_NAME: &str = "call_contract"; pub const LIBRARY_CALL_SELECTOR_NAME: &str = "library_call"; + +pub static SYSCALL_COUNTER: LazyLock> = + LazyLock::new(|| Mutex::new(SyscallCounts::default())); + +#[derive(Default, Clone, Copy)] +pub struct SyscallCounts { + pub get_block_hash: u64, + pub get_execution_info: u64, + pub get_execution_info_v2: u64, + pub deploy: u64, + pub replace_class: u64, + pub library_call: u64, + pub call_contract: u64, + pub storage_read: u64, + pub storage_write: u64, + pub emit_event: u64, + pub send_message_to_l1: u64, + pub keccak: u64, + pub secp256k1_new: u64, + pub secp256k1_add: u64, + pub secp256k1_mul: u64, + pub secp256k1_get_point_from_x: u64, + pub secp256k1_get_xy: u64, + pub secp256r1_new: u64, + pub secp256r1_add: u64, + pub secp256r1_mul: u64, + pub secp256r1_get_point_from_x: u64, + pub secp256r1_get_xy: u64, + pub sha256_process_block: u64, + pub get_class_hash_at: u64, + pub meta_tx_v0: u64, +} + pub struct NativeSyscallHandler<'state> { pub base: Box>, @@ -239,6 +272,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { block_number: u64, remaining_gas: &mut u64, ) -> SyscallResult { + SYSCALL_COUNTER.lock().unwrap().get_block_hash += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.get_block_hash.base_syscall_cost(), @@ -251,6 +286,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { } fn get_execution_info(&mut self, remaining_gas: &mut u64) -> SyscallResult { + SYSCALL_COUNTER.lock().unwrap().get_execution_info += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.get_execution_info.base_syscall_cost(), @@ -270,6 +307,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { contract_address: Felt, remaining_gas: &mut u64, ) -> SyscallResult { + SYSCALL_COUNTER.lock().unwrap().get_class_hash_at += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.get_class_hash_at.base_syscall_cost(), @@ -285,6 +324,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { } fn get_execution_info_v2(&mut self, remaining_gas: &mut u64) -> SyscallResult { + SYSCALL_COUNTER.lock().unwrap().get_execution_info_v2 += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.get_execution_info.base_syscall_cost(), @@ -307,6 +348,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { deploy_from_zero: bool, remaining_gas: &mut u64, ) -> SyscallResult<(Felt, Vec)> { + SYSCALL_COUNTER.lock().unwrap().deploy += 1; // The cost of deploying a contract is the base cost plus the linear cost of the calldata // len. let total_gas_cost = @@ -330,6 +372,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { Ok((Felt::from(deployed_contract_address), constructor_retdata)) } fn replace_class(&mut self, class_hash: Felt, remaining_gas: &mut u64) -> SyscallResult<()> { + SYSCALL_COUNTER.lock().unwrap().replace_class += 1; self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.replace_class.base_syscall_cost(), @@ -348,6 +391,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { calldata: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult> { + SYSCALL_COUNTER.lock().unwrap().library_call += 1; self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.library_call.base_syscall_cost(), @@ -392,6 +436,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { calldata: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult> { + SYSCALL_COUNTER.lock().unwrap().call_contract += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.call_contract.base_syscall_cost(), @@ -448,6 +494,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { address: Felt, remaining_gas: &mut u64, ) -> SyscallResult { + SYSCALL_COUNTER.lock().unwrap().storage_read += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.storage_read.base_syscall_cost(), @@ -473,6 +521,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { value: Felt, remaining_gas: &mut u64, ) -> SyscallResult<()> { + SYSCALL_COUNTER.lock().unwrap().storage_write += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.storage_write.base_syscall_cost(), @@ -497,6 +547,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { data: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult<()> { + SYSCALL_COUNTER.lock().unwrap().emit_event += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.emit_event.base_syscall_cost(), @@ -517,6 +569,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { payload: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult<()> { + SYSCALL_COUNTER.lock().unwrap().send_message_to_l1 += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.send_message_to_l1.base_syscall_cost(), @@ -530,6 +584,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { } fn keccak(&mut self, input: &[u64], remaining_gas: &mut u64) -> SyscallResult { + SYSCALL_COUNTER.lock().unwrap().keccak += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.keccak.base_syscall_cost(), @@ -550,6 +606,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { y: U256, remaining_gas: &mut u64, ) -> SyscallResult> { + SYSCALL_COUNTER.lock().unwrap().secp256k1_new += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256k1_new.base_syscall_cost(), @@ -566,6 +624,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { p1: Secp256k1Point, remaining_gas: &mut u64, ) -> SyscallResult { + SYSCALL_COUNTER.lock().unwrap().secp256k1_add += 1; self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256k1_add.base_syscall_cost(), @@ -580,6 +639,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { m: U256, remaining_gas: &mut u64, ) -> SyscallResult { + SYSCALL_COUNTER.lock().unwrap().secp256k1_mul += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256k1_mul.base_syscall_cost(), @@ -594,6 +655,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { y_parity: bool, remaining_gas: &mut u64, ) -> SyscallResult> { + SYSCALL_COUNTER.lock().unwrap().secp256k1_get_point_from_x += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256k1_get_point_from_x.base_syscall_cost(), @@ -609,6 +672,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { p: Secp256k1Point, remaining_gas: &mut u64, ) -> SyscallResult<(U256, U256)> { + SYSCALL_COUNTER.lock().unwrap().secp256k1_get_xy += 1; self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256k1_get_xy.base_syscall_cost(), @@ -623,6 +687,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { y: U256, remaining_gas: &mut u64, ) -> SyscallResult> { + SYSCALL_COUNTER.lock().unwrap().secp256r1_new += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256r1_new.base_syscall_cost(), @@ -639,6 +705,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { p1: Secp256r1Point, remaining_gas: &mut u64, ) -> SyscallResult { + SYSCALL_COUNTER.lock().unwrap().secp256r1_add += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256r1_add.base_syscall_cost(), @@ -652,6 +720,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { m: U256, remaining_gas: &mut u64, ) -> SyscallResult { + SYSCALL_COUNTER.lock().unwrap().secp256r1_mul += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256r1_mul.base_syscall_cost(), @@ -666,6 +736,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { y_parity: bool, remaining_gas: &mut u64, ) -> SyscallResult> { + SYSCALL_COUNTER.lock().unwrap().secp256r1_get_point_from_x += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256r1_get_point_from_x.base_syscall_cost(), @@ -681,6 +753,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { p: Secp256r1Point, remaining_gas: &mut u64, ) -> SyscallResult<(U256, U256)> { + SYSCALL_COUNTER.lock().unwrap().secp256r1_get_xy += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256r1_get_xy.base_syscall_cost(), @@ -695,6 +769,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { current_block: &[u32; 16], remaining_gas: &mut u64, ) -> SyscallResult<()> { + SYSCALL_COUNTER.lock().unwrap().sha256_process_block += 1; + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.sha256_process_block.base_syscall_cost(), @@ -720,6 +796,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { signature: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult> { + SYSCALL_COUNTER.lock().unwrap().meta_tx_v0 += 1; todo!( "implement meta_tx_v0 {:?}", (address, entry_point_selector, calldata, signature, remaining_gas) From c40fcd35c1ac1faf7706a39d514a13281c2c713d Mon Sep 17 00:00:00 2001 From: FrancoGiachetta Date: Tue, 3 Jun 2025 16:49:39 -0300 Subject: [PATCH 2/7] add Debug and Serialize traits to SyscallCounts --- crates/blockifier/src/execution/native/syscall_handler.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/crates/blockifier/src/execution/native/syscall_handler.rs b/crates/blockifier/src/execution/native/syscall_handler.rs index 53f4abf74c9..733938fb337 100644 --- a/crates/blockifier/src/execution/native/syscall_handler.rs +++ b/crates/blockifier/src/execution/native/syscall_handler.rs @@ -17,6 +17,7 @@ use cairo_native::starknet::{ U256, }; use num_bigint::BigUint; +use serde::Serialize; use starknet_api::contract_class::EntryPointType; use starknet_api::core::{ClassHash, ContractAddress, EntryPointSelector, EthAddress}; use starknet_api::execution_resources::GasAmount; @@ -49,7 +50,7 @@ pub const LIBRARY_CALL_SELECTOR_NAME: &str = "library_call"; pub static SYSCALL_COUNTER: LazyLock> = LazyLock::new(|| Mutex::new(SyscallCounts::default())); -#[derive(Default, Clone, Copy)] +#[derive(Debug, Default, Clone, Copy, Serialize)] pub struct SyscallCounts { pub get_block_hash: u64, pub get_execution_info: u64, From eb2b8e85f56f4b63d0ea9c7f064e4d0ee88ef72b Mon Sep 17 00:00:00 2001 From: FrancoGiachetta Date: Tue, 3 Jun 2025 17:23:53 -0300 Subject: [PATCH 3/7] count syscalls only when block-composition is active --- .../src/execution/native/syscall_handler.rs | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/crates/blockifier/src/execution/native/syscall_handler.rs b/crates/blockifier/src/execution/native/syscall_handler.rs index 733938fb337..9067011fb89 100644 --- a/crates/blockifier/src/execution/native/syscall_handler.rs +++ b/crates/blockifier/src/execution/native/syscall_handler.rs @@ -47,9 +47,11 @@ use crate::versioned_constants::GasCosts; pub const CALL_CONTRACT_SELECTOR_NAME: &str = "call_contract"; pub const LIBRARY_CALL_SELECTOR_NAME: &str = "library_call"; +#[cfg(feature = "block-composition")] pub static SYSCALL_COUNTER: LazyLock> = LazyLock::new(|| Mutex::new(SyscallCounts::default())); +#[cfg(feature = "block-composition")] #[derive(Debug, Default, Clone, Copy, Serialize)] pub struct SyscallCounts { pub get_block_hash: u64, @@ -273,6 +275,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { block_number: u64, remaining_gas: &mut u64, ) -> SyscallResult { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().get_block_hash += 1; self.pre_execute_syscall( @@ -287,6 +290,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { } fn get_execution_info(&mut self, remaining_gas: &mut u64) -> SyscallResult { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().get_execution_info += 1; self.pre_execute_syscall( @@ -308,6 +312,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { contract_address: Felt, remaining_gas: &mut u64, ) -> SyscallResult { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().get_class_hash_at += 1; self.pre_execute_syscall( @@ -325,6 +330,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { } fn get_execution_info_v2(&mut self, remaining_gas: &mut u64) -> SyscallResult { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().get_execution_info_v2 += 1; self.pre_execute_syscall( @@ -349,6 +355,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { deploy_from_zero: bool, remaining_gas: &mut u64, ) -> SyscallResult<(Felt, Vec)> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().deploy += 1; // The cost of deploying a contract is the base cost plus the linear cost of the calldata // len. @@ -373,6 +380,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { Ok((Felt::from(deployed_contract_address), constructor_retdata)) } fn replace_class(&mut self, class_hash: Felt, remaining_gas: &mut u64) -> SyscallResult<()> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().replace_class += 1; self.pre_execute_syscall( remaining_gas, @@ -392,6 +400,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { calldata: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().library_call += 1; self.pre_execute_syscall( remaining_gas, @@ -437,6 +446,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { calldata: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().call_contract += 1; self.pre_execute_syscall( @@ -495,6 +505,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { address: Felt, remaining_gas: &mut u64, ) -> SyscallResult { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().storage_read += 1; self.pre_execute_syscall( @@ -522,6 +533,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { value: Felt, remaining_gas: &mut u64, ) -> SyscallResult<()> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().storage_write += 1; self.pre_execute_syscall( @@ -548,6 +560,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { data: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult<()> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().emit_event += 1; self.pre_execute_syscall( @@ -570,6 +583,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { payload: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult<()> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().send_message_to_l1 += 1; self.pre_execute_syscall( @@ -585,6 +599,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { } fn keccak(&mut self, input: &[u64], remaining_gas: &mut u64) -> SyscallResult { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().keccak += 1; self.pre_execute_syscall( @@ -607,6 +622,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { y: U256, remaining_gas: &mut u64, ) -> SyscallResult> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().secp256k1_new += 1; self.pre_execute_syscall( @@ -625,6 +641,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { p1: Secp256k1Point, remaining_gas: &mut u64, ) -> SyscallResult { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().secp256k1_add += 1; self.pre_execute_syscall( remaining_gas, @@ -640,6 +657,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { m: U256, remaining_gas: &mut u64, ) -> SyscallResult { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().secp256k1_mul += 1; self.pre_execute_syscall( @@ -656,6 +674,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { y_parity: bool, remaining_gas: &mut u64, ) -> SyscallResult> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().secp256k1_get_point_from_x += 1; self.pre_execute_syscall( @@ -673,6 +692,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { p: Secp256k1Point, remaining_gas: &mut u64, ) -> SyscallResult<(U256, U256)> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().secp256k1_get_xy += 1; self.pre_execute_syscall( remaining_gas, @@ -688,6 +708,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { y: U256, remaining_gas: &mut u64, ) -> SyscallResult> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().secp256r1_new += 1; self.pre_execute_syscall( @@ -706,6 +727,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { p1: Secp256r1Point, remaining_gas: &mut u64, ) -> SyscallResult { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().secp256r1_add += 1; self.pre_execute_syscall( @@ -721,6 +743,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { m: U256, remaining_gas: &mut u64, ) -> SyscallResult { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().secp256r1_mul += 1; self.pre_execute_syscall( @@ -737,6 +760,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { y_parity: bool, remaining_gas: &mut u64, ) -> SyscallResult> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().secp256r1_get_point_from_x += 1; self.pre_execute_syscall( @@ -754,6 +778,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { p: Secp256r1Point, remaining_gas: &mut u64, ) -> SyscallResult<(U256, U256)> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().secp256r1_get_xy += 1; self.pre_execute_syscall( @@ -770,6 +795,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { current_block: &[u32; 16], remaining_gas: &mut u64, ) -> SyscallResult<()> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().sha256_process_block += 1; self.pre_execute_syscall( @@ -797,6 +823,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { signature: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult> { + #[cfg(feature = "block-composition")] SYSCALL_COUNTER.lock().unwrap().meta_tx_v0 += 1; todo!( "implement meta_tx_v0 {:?}", From 802a5020b2eda02e26290aaa9890ab82bbf4f4d7 Mon Sep 17 00:00:00 2001 From: FrancoGiachetta Date: Tue, 3 Jun 2025 17:29:40 -0300 Subject: [PATCH 4/7] fix feature flag --- crates/blockifier/src/execution/call_info.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/blockifier/src/execution/call_info.rs b/crates/blockifier/src/execution/call_info.rs index 506b7eb4401..bebd18f28a3 100644 --- a/crates/blockifier/src/execution/call_info.rs +++ b/crates/blockifier/src/execution/call_info.rs @@ -201,7 +201,7 @@ impl AddAssign<&ChargedResources> for ChargedResources { #[cfg_attr(feature = "transaction_serde", derive(serde::Deserialize))] #[derive(Debug, Default, Eq, PartialEq, Serialize)] pub struct CallInfo { - #[cfg(feature = "block_composition")] + #[cfg(feature = "block-composition")] pub syscall_counts: SyscallCounts, pub call: CallEntryPoint, pub execution: CallExecution, From 89f98373456dc7f13829458a397dffa9437d14de Mon Sep 17 00:00:00 2001 From: FrancoGiachetta Date: Tue, 3 Jun 2025 18:03:35 -0300 Subject: [PATCH 5/7] make SyscallCounts an individual counter --- crates/blockifier/src/execution/call_info.rs | 19 +++- .../src/execution/entry_point_execution.rs | 4 + .../execution/native/entry_point_execution.rs | 6 +- .../src/execution/native/executor.rs | 6 +- .../src/execution/native/syscall_handler.rs | 88 +++++++------------ 5 files changed, 57 insertions(+), 66 deletions(-) diff --git a/crates/blockifier/src/execution/call_info.rs b/crates/blockifier/src/execution/call_info.rs index bebd18f28a3..7113b39aa32 100644 --- a/crates/blockifier/src/execution/call_info.rs +++ b/crates/blockifier/src/execution/call_info.rs @@ -3,6 +3,8 @@ use std::iter::Sum; use std::ops::{Add, AddAssign}; use cairo_vm::vm::runners::cairo_runner::ExecutionResources; +#[cfg(feature = "block-composition")] +use serde::Deserialize; use serde::Serialize; use starknet_api::core::{ClassHash, ContractAddress, EthAddress}; use starknet_api::execution_resources::{GasAmount, GasVector}; @@ -13,7 +15,6 @@ use starknet_types_core::felt::Felt; use crate::execution::contract_class::TrackedResource; use crate::execution::entry_point::CallEntryPoint; -use crate::execution::native::syscall_handler::SyscallCounts; use crate::state::cached_state::StorageEntry; use crate::utils::u64_from_usize; use crate::versioned_constants::VersionedConstants; @@ -196,13 +197,27 @@ impl AddAssign<&ChargedResources> for ChargedResources { } } +#[cfg(feature = "block-composition")] +#[derive(PartialEq, Eq, Default, Debug, Clone, Copy, Serialize, Deserialize)] +pub struct SyscallCount(pub u64); + +impl SyscallCount { + pub fn increase(&mut self) { + self.0 += 1; + } + + pub fn clear(&mut self) { + self.0 = 0; + } +} + /// Represents the full effects of executing an entry point, including the inner calls it invoked. #[cfg_attr(any(test, feature = "testing"), derive(Clone))] #[cfg_attr(feature = "transaction_serde", derive(serde::Deserialize))] #[derive(Debug, Default, Eq, PartialEq, Serialize)] pub struct CallInfo { #[cfg(feature = "block-composition")] - pub syscall_counts: SyscallCounts, + pub syscall_counts: SyscallCount, pub call: CallEntryPoint, pub execution: CallExecution, pub inner_calls: Vec, diff --git a/crates/blockifier/src/execution/entry_point_execution.rs b/crates/blockifier/src/execution/entry_point_execution.rs index 59bcfda18fb..8719171c88d 100644 --- a/crates/blockifier/src/execution/entry_point_execution.rs +++ b/crates/blockifier/src/execution/entry_point_execution.rs @@ -10,6 +10,8 @@ use cairo_vm::vm::security::verify_secure_runner; use num_traits::{ToPrimitive, Zero}; use starknet_types_core::felt::Felt; +#[cfg(feature = "block-composition")] +use crate::execution::call_info::SyscallCount; use crate::execution::call_info::{CallExecution, CallInfo, Retdata}; use crate::execution::contract_class::{CompiledClassV1, EntryPointV1, TrackedResource}; use crate::execution::entry_point::{ @@ -378,6 +380,8 @@ pub fn finalize_execution( + &CallInfo::summarize_vm_resources(syscall_handler.base.inner_calls.iter()); let syscall_handler_base = syscall_handler.base; Ok(CallInfo { + #[cfg(feature = "block-composition")] + syscall_counts: SyscallCount(0), call: syscall_handler_base.call.into(), execution: CallExecution { retdata: call_result.retdata, diff --git a/crates/blockifier/src/execution/native/entry_point_execution.rs b/crates/blockifier/src/execution/native/entry_point_execution.rs index bb6b26d7ea7..ad8fe8247ac 100644 --- a/crates/blockifier/src/execution/native/entry_point_execution.rs +++ b/crates/blockifier/src/execution/native/entry_point_execution.rs @@ -86,11 +86,11 @@ fn create_callinfo( let gas_consumed = syscall_handler.base.call.initial_gas - remaining_gas; let vm_resources = CallInfo::summarize_vm_resources(syscall_handler.base.inner_calls.iter()); - #[cfg(feature = "block_composition")] - let syscalls_coutnts = *SYSCALL_COUNTER.lock().unwrap(); + #[cfg(feature = "block-composition")] + let syscall_counts = *SYSCALL_COUNTER.lock().unwrap(); Ok(CallInfo { - #[cfg(feature = "block_composition")] + #[cfg(feature = "block-composition")] syscall_counts, call: syscall_handler.base.call.into(), execution: CallExecution { diff --git a/crates/blockifier/src/execution/native/executor.rs b/crates/blockifier/src/execution/native/executor.rs index 711f5791b7d..c23e3f964fd 100644 --- a/crates/blockifier/src/execution/native/executor.rs +++ b/crates/blockifier/src/execution/native/executor.rs @@ -16,7 +16,7 @@ use sierra_emu::VirtualMachine; use starknet_types_core::felt::Felt; use super::syscall_handler::NativeSyscallHandler; -use crate::execution::native::syscall_handler::{SyscallCounts, SYSCALL_COUNTER}; +use crate::execution::native::syscall_handler::SYSCALL_COUNTER; #[derive(Debug)] pub enum ContractExecutor { @@ -52,8 +52,8 @@ impl ContractExecutor { let result = aot_contract_executor.run(selector, args, gas, builtin_costs, syscall_handler); - #[cfg(feature = "block_composition")] - SYSCALL_COUNTER.set(SyscallCounts::default())?; + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.lock().unwrap().clear(); result } diff --git a/crates/blockifier/src/execution/native/syscall_handler.rs b/crates/blockifier/src/execution/native/syscall_handler.rs index 9067011fb89..3b3f7e1844e 100644 --- a/crates/blockifier/src/execution/native/syscall_handler.rs +++ b/crates/blockifier/src/execution/native/syscall_handler.rs @@ -17,7 +17,6 @@ use cairo_native::starknet::{ U256, }; use num_bigint::BigUint; -use serde::Serialize; use starknet_api::contract_class::EntryPointType; use starknet_api::core::{ClassHash, ContractAddress, EntryPointSelector, EthAddress}; use starknet_api::execution_resources::GasAmount; @@ -26,6 +25,8 @@ use starknet_api::transaction::fields::{Calldata, ContractAddressSalt}; use starknet_api::transaction::{EventContent, EventData, EventKey, L2ToL1Payload}; use starknet_types_core::felt::Felt; +#[cfg(feature = "block-composition")] +use crate::execution::call_info::SyscallCount; use crate::execution::call_info::{MessageToL1, Retdata}; use crate::execution::common_hints::ExecutionMode; use crate::execution::entry_point::{ @@ -48,38 +49,8 @@ pub const CALL_CONTRACT_SELECTOR_NAME: &str = "call_contract"; pub const LIBRARY_CALL_SELECTOR_NAME: &str = "library_call"; #[cfg(feature = "block-composition")] -pub static SYSCALL_COUNTER: LazyLock> = - LazyLock::new(|| Mutex::new(SyscallCounts::default())); - -#[cfg(feature = "block-composition")] -#[derive(Debug, Default, Clone, Copy, Serialize)] -pub struct SyscallCounts { - pub get_block_hash: u64, - pub get_execution_info: u64, - pub get_execution_info_v2: u64, - pub deploy: u64, - pub replace_class: u64, - pub library_call: u64, - pub call_contract: u64, - pub storage_read: u64, - pub storage_write: u64, - pub emit_event: u64, - pub send_message_to_l1: u64, - pub keccak: u64, - pub secp256k1_new: u64, - pub secp256k1_add: u64, - pub secp256k1_mul: u64, - pub secp256k1_get_point_from_x: u64, - pub secp256k1_get_xy: u64, - pub secp256r1_new: u64, - pub secp256r1_add: u64, - pub secp256r1_mul: u64, - pub secp256r1_get_point_from_x: u64, - pub secp256r1_get_xy: u64, - pub sha256_process_block: u64, - pub get_class_hash_at: u64, - pub meta_tx_v0: u64, -} +pub static SYSCALL_COUNTER: LazyLock> = + LazyLock::new(|| Mutex::new(SyscallCount(0))); pub struct NativeSyscallHandler<'state> { pub base: Box>, @@ -276,7 +247,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().get_block_hash += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -291,7 +262,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { fn get_execution_info(&mut self, remaining_gas: &mut u64) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().get_execution_info += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); + self.pre_execute_syscall( remaining_gas, @@ -313,7 +285,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().get_class_hash_at += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -331,7 +303,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { fn get_execution_info_v2(&mut self, remaining_gas: &mut u64) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().get_execution_info_v2 += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -356,7 +328,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult<(Felt, Vec)> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().deploy += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); // The cost of deploying a contract is the base cost plus the linear cost of the calldata // len. let total_gas_cost = @@ -381,7 +353,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { } fn replace_class(&mut self, class_hash: Felt, remaining_gas: &mut u64) -> SyscallResult<()> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().replace_class += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.replace_class.base_syscall_cost(), @@ -401,7 +373,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().library_call += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.library_call.base_syscall_cost(), @@ -447,7 +419,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().call_contract += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -506,7 +478,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().storage_read += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -534,7 +506,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult<()> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().storage_write += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -561,7 +533,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult<()> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().emit_event += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -584,7 +556,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult<()> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().send_message_to_l1 += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -600,7 +572,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { fn keccak(&mut self, input: &[u64], remaining_gas: &mut u64) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().keccak += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -623,7 +595,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().secp256k1_new += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -642,7 +614,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().secp256k1_add += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256k1_add.base_syscall_cost(), @@ -658,7 +630,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().secp256k1_mul += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -675,7 +647,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().secp256k1_get_point_from_x += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -693,7 +665,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult<(U256, U256)> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().secp256k1_get_xy += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256k1_get_xy.base_syscall_cost(), @@ -709,7 +681,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().secp256r1_new += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -728,7 +700,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().secp256r1_add += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -744,7 +716,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().secp256r1_mul += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -761,7 +733,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().secp256r1_get_point_from_x += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -779,7 +751,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult<(U256, U256)> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().secp256r1_get_xy += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -796,7 +768,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult<()> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().sha256_process_block += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); self.pre_execute_syscall( remaining_gas, @@ -824,7 +796,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().meta_tx_v0 += 1; + SYSCALL_COUNTER.lock().unwrap().increase(); todo!( "implement meta_tx_v0 {:?}", (address, entry_point_selector, calldata, signature, remaining_gas) From 608105dbaa3cdac7af85f09e56ddd1f99f4534cb Mon Sep 17 00:00:00 2001 From: FrancoGiachetta Date: Tue, 3 Jun 2025 18:30:14 -0300 Subject: [PATCH 6/7] change to AtomicU64 --- crates/blockifier/src/execution/call_info.rs | 18 +----- .../src/execution/entry_point_execution.rs | 4 +- .../execution/native/entry_point_execution.rs | 5 +- .../src/execution/native/executor.rs | 4 +- .../src/execution/native/syscall_handler.rs | 60 +++++++++---------- 5 files changed, 38 insertions(+), 53 deletions(-) diff --git a/crates/blockifier/src/execution/call_info.rs b/crates/blockifier/src/execution/call_info.rs index 7113b39aa32..9df0fcc716c 100644 --- a/crates/blockifier/src/execution/call_info.rs +++ b/crates/blockifier/src/execution/call_info.rs @@ -3,8 +3,6 @@ use std::iter::Sum; use std::ops::{Add, AddAssign}; use cairo_vm::vm::runners::cairo_runner::ExecutionResources; -#[cfg(feature = "block-composition")] -use serde::Deserialize; use serde::Serialize; use starknet_api::core::{ClassHash, ContractAddress, EthAddress}; use starknet_api::execution_resources::{GasAmount, GasVector}; @@ -197,27 +195,13 @@ impl AddAssign<&ChargedResources> for ChargedResources { } } -#[cfg(feature = "block-composition")] -#[derive(PartialEq, Eq, Default, Debug, Clone, Copy, Serialize, Deserialize)] -pub struct SyscallCount(pub u64); - -impl SyscallCount { - pub fn increase(&mut self) { - self.0 += 1; - } - - pub fn clear(&mut self) { - self.0 = 0; - } -} - /// Represents the full effects of executing an entry point, including the inner calls it invoked. #[cfg_attr(any(test, feature = "testing"), derive(Clone))] #[cfg_attr(feature = "transaction_serde", derive(serde::Deserialize))] #[derive(Debug, Default, Eq, PartialEq, Serialize)] pub struct CallInfo { #[cfg(feature = "block-composition")] - pub syscall_counts: SyscallCount, + pub syscall_counts: u64, pub call: CallEntryPoint, pub execution: CallExecution, pub inner_calls: Vec, diff --git a/crates/blockifier/src/execution/entry_point_execution.rs b/crates/blockifier/src/execution/entry_point_execution.rs index 8719171c88d..ef1bfe1f551 100644 --- a/crates/blockifier/src/execution/entry_point_execution.rs +++ b/crates/blockifier/src/execution/entry_point_execution.rs @@ -10,8 +10,6 @@ use cairo_vm::vm::security::verify_secure_runner; use num_traits::{ToPrimitive, Zero}; use starknet_types_core::felt::Felt; -#[cfg(feature = "block-composition")] -use crate::execution::call_info::SyscallCount; use crate::execution::call_info::{CallExecution, CallInfo, Retdata}; use crate::execution::contract_class::{CompiledClassV1, EntryPointV1, TrackedResource}; use crate::execution::entry_point::{ @@ -381,7 +379,7 @@ pub fn finalize_execution( let syscall_handler_base = syscall_handler.base; Ok(CallInfo { #[cfg(feature = "block-composition")] - syscall_counts: SyscallCount(0), + syscall_counts: 0, call: syscall_handler_base.call.into(), execution: CallExecution { retdata: call_result.retdata, diff --git a/crates/blockifier/src/execution/native/entry_point_execution.rs b/crates/blockifier/src/execution/native/entry_point_execution.rs index ad8fe8247ac..6839fdc826a 100644 --- a/crates/blockifier/src/execution/native/entry_point_execution.rs +++ b/crates/blockifier/src/execution/native/entry_point_execution.rs @@ -1,3 +1,6 @@ +#[cfg(feature = "block-composition")] +use std::sync::atomic::Ordering; + use cairo_native::execution_result::ContractExecutionResult; use cairo_native::utils::BuiltinCosts; @@ -87,7 +90,7 @@ fn create_callinfo( let vm_resources = CallInfo::summarize_vm_resources(syscall_handler.base.inner_calls.iter()); #[cfg(feature = "block-composition")] - let syscall_counts = *SYSCALL_COUNTER.lock().unwrap(); + let syscall_counts = SYSCALL_COUNTER.load(Ordering::Relaxed); Ok(CallInfo { #[cfg(feature = "block-composition")] diff --git a/crates/blockifier/src/execution/native/executor.rs b/crates/blockifier/src/execution/native/executor.rs index c23e3f964fd..ff12126935e 100644 --- a/crates/blockifier/src/execution/native/executor.rs +++ b/crates/blockifier/src/execution/native/executor.rs @@ -2,6 +2,8 @@ use std::fs::{self, File}; use std::io::Write; use std::path::PathBuf; use std::sync::atomic::AtomicU64; +#[cfg(feature = "block-composition")] +use std::sync::atomic::Ordering; use std::sync::Arc; use cairo_lang_sierra::program::Program; @@ -53,7 +55,7 @@ impl ContractExecutor { aot_contract_executor.run(selector, args, gas, builtin_costs, syscall_handler); #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().clear(); + SYSCALL_COUNTER.fetch_and(0, Ordering::Relaxed); result } diff --git a/crates/blockifier/src/execution/native/syscall_handler.rs b/crates/blockifier/src/execution/native/syscall_handler.rs index 3b3f7e1844e..b84c4f938ad 100644 --- a/crates/blockifier/src/execution/native/syscall_handler.rs +++ b/crates/blockifier/src/execution/native/syscall_handler.rs @@ -1,6 +1,8 @@ use std::convert::From; use std::fmt; -use std::sync::{Arc, LazyLock, Mutex}; +#[cfg(feature = "block-composition")] +use std::sync::atomic::{AtomicU64, Ordering}; +use std::sync::Arc; use ark_ec::short_weierstrass::{Affine, Projective, SWCurveConfig}; use ark_ff::{BigInt, PrimeField}; @@ -25,8 +27,6 @@ use starknet_api::transaction::fields::{Calldata, ContractAddressSalt}; use starknet_api::transaction::{EventContent, EventData, EventKey, L2ToL1Payload}; use starknet_types_core::felt::Felt; -#[cfg(feature = "block-composition")] -use crate::execution::call_info::SyscallCount; use crate::execution::call_info::{MessageToL1, Retdata}; use crate::execution::common_hints::ExecutionMode; use crate::execution::entry_point::{ @@ -49,8 +49,7 @@ pub const CALL_CONTRACT_SELECTOR_NAME: &str = "call_contract"; pub const LIBRARY_CALL_SELECTOR_NAME: &str = "library_call"; #[cfg(feature = "block-composition")] -pub static SYSCALL_COUNTER: LazyLock> = - LazyLock::new(|| Mutex::new(SyscallCount(0))); +pub static SYSCALL_COUNTER: AtomicU64 = AtomicU64::new(0); pub struct NativeSyscallHandler<'state> { pub base: Box>, @@ -247,7 +246,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -262,8 +261,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { fn get_execution_info(&mut self, remaining_gas: &mut u64) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); - + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -285,7 +283,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -303,7 +301,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { fn get_execution_info_v2(&mut self, remaining_gas: &mut u64) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -328,7 +326,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult<(Felt, Vec)> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); // The cost of deploying a contract is the base cost plus the linear cost of the calldata // len. let total_gas_cost = @@ -353,7 +351,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { } fn replace_class(&mut self, class_hash: Felt, remaining_gas: &mut u64) -> SyscallResult<()> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.replace_class.base_syscall_cost(), @@ -373,7 +371,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.library_call.base_syscall_cost(), @@ -419,7 +417,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -478,7 +476,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -506,7 +504,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult<()> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -533,7 +531,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult<()> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -556,7 +554,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult<()> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -572,7 +570,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { fn keccak(&mut self, input: &[u64], remaining_gas: &mut u64) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -595,7 +593,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -614,7 +612,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256k1_add.base_syscall_cost(), @@ -630,7 +628,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -647,7 +645,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -665,7 +663,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult<(U256, U256)> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256k1_get_xy.base_syscall_cost(), @@ -681,7 +679,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -700,7 +698,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -716,7 +714,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -733,7 +731,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -751,7 +749,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult<(U256, U256)> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -768,7 +766,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult<()> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, @@ -796,7 +794,7 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { remaining_gas: &mut u64, ) -> SyscallResult> { #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.lock().unwrap().increase(); + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); todo!( "implement meta_tx_v0 {:?}", (address, entry_point_selector, calldata, signature, remaining_gas) From 68af2ff83545ed0f8a1421864eb0bc5ba570320b Mon Sep 17 00:00:00 2001 From: FrancoGiachetta Date: Wed, 4 Jun 2025 11:36:26 -0300 Subject: [PATCH 7/7] fix syscall counting --- Cargo.lock | 4 ++-- Cargo.toml | 4 ++-- .../src/execution/native/entry_point_execution.rs | 7 ++++++- crates/blockifier/src/execution/native/executor.rs | 11 +---------- crates/blockifier/src/test_utils/struct_impls.rs | 1 + 5 files changed, 12 insertions(+), 15 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index a6e26e356cc..a2b013733b9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2430,7 +2430,7 @@ dependencies = [ [[package]] name = "cairo-native" version = "0.5.0-rc.5" -source = "git+https://github.com/lambdaclass/cairo_native?rev=a51d1b527a235a51dcdb6168c881eafa76bf15e1#a51d1b527a235a51dcdb6168c881eafa76bf15e1" +source = "git+https://github.com/lambdaclass/cairo_native?rev=52cf76f469e4b4efe92203d31ff374b7d2c539ee#52cf76f469e4b4efe92203d31ff374b7d2c539ee" dependencies = [ "anyhow", "aquamarine", @@ -10356,7 +10356,7 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" [[package]] name = "sierra-emu" version = "0.1.0" -source = "git+https://github.com/lambdaclass/cairo_native?rev=a51d1b527a235a51dcdb6168c881eafa76bf15e1#a51d1b527a235a51dcdb6168c881eafa76bf15e1" +source = "git+https://github.com/lambdaclass/cairo_native?rev=52cf76f469e4b4efe92203d31ff374b7d2c539ee#52cf76f469e4b4efe92203d31ff374b7d2c539ee" dependencies = [ "cairo-lang-compiler", "cairo-lang-filesystem", diff --git a/Cargo.toml b/Cargo.toml index 24734c69976..45d2045487d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -100,8 +100,8 @@ cairo-lang-sierra = "2.12.0-dev.1" cairo-lang-sierra-to-casm = "2.12.0-dev.1" cairo-lang-starknet-classes = "2.12.0-dev.1" cairo-lang-utils = "2.12.0-dev.1" -cairo-native = { git = "https://github.com/lambdaclass/cairo_native", rev = "a51d1b527a235a51dcdb6168c881eafa76bf15e1" } -sierra-emu = { git = "https://github.com/lambdaclass/cairo_native", rev = "a51d1b527a235a51dcdb6168c881eafa76bf15e1" } +cairo-native = { git = "https://github.com/lambdaclass/cairo_native", rev = "52cf76f469e4b4efe92203d31ff374b7d2c539ee" } +sierra-emu = { git = "https://github.com/lambdaclass/cairo_native", rev = "52cf76f469e4b4efe92203d31ff374b7d2c539ee" } cairo-vm = "2.0.1" camelpaste = "0.1.0" chrono = "0.4.26" diff --git a/crates/blockifier/src/execution/native/entry_point_execution.rs b/crates/blockifier/src/execution/native/entry_point_execution.rs index 6839fdc826a..f8a6793d46f 100644 --- a/crates/blockifier/src/execution/native/entry_point_execution.rs +++ b/crates/blockifier/src/execution/native/entry_point_execution.rs @@ -67,7 +67,12 @@ pub fn execute_entry_point_call( return Err(EntryPointExecutionError::NativeUnrecoverableError(Box::new(error))); } - create_callinfo(call_result, syscall_handler) + let result = create_callinfo(call_result, syscall_handler); + + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_and(0, Ordering::Relaxed); + + result } fn create_callinfo( diff --git a/crates/blockifier/src/execution/native/executor.rs b/crates/blockifier/src/execution/native/executor.rs index ff12126935e..778f253be34 100644 --- a/crates/blockifier/src/execution/native/executor.rs +++ b/crates/blockifier/src/execution/native/executor.rs @@ -2,8 +2,6 @@ use std::fs::{self, File}; use std::io::Write; use std::path::PathBuf; use std::sync::atomic::AtomicU64; -#[cfg(feature = "block-composition")] -use std::sync::atomic::Ordering; use std::sync::Arc; use cairo_lang_sierra::program::Program; @@ -18,7 +16,6 @@ use sierra_emu::VirtualMachine; use starknet_types_core::felt::Felt; use super::syscall_handler::NativeSyscallHandler; -use crate::execution::native::syscall_handler::SYSCALL_COUNTER; #[derive(Debug)] pub enum ContractExecutor { @@ -51,13 +48,7 @@ impl ContractExecutor { ) -> cairo_native::error::Result { match self { ContractExecutor::Aot(aot_contract_executor) => { - let result = - aot_contract_executor.run(selector, args, gas, builtin_costs, syscall_handler); - - #[cfg(feature = "block-composition")] - SYSCALL_COUNTER.fetch_and(0, Ordering::Relaxed); - - result + aot_contract_executor.run(selector, args, gas, builtin_costs, syscall_handler) } ContractExecutor::Emu((program, entrypoints, version)) => { let mut virtual_machine = diff --git a/crates/blockifier/src/test_utils/struct_impls.rs b/crates/blockifier/src/test_utils/struct_impls.rs index 0be977a463c..c4c7dbdc918 100644 --- a/crates/blockifier/src/test_utils/struct_impls.rs +++ b/crates/blockifier/src/test_utils/struct_impls.rs @@ -259,6 +259,7 @@ impl NativeCompiledClassV1 { &sierra_contract_class.entry_points_by_type, sierra_version.clone().into(), cairo_native::OptLevel::Default, + None ) .expect("Cannot compile sierra into native");