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..9df0fcc716c 100644 --- a/crates/blockifier/src/execution/call_info.rs +++ b/crates/blockifier/src/execution/call_info.rs @@ -200,6 +200,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: 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 59bcfda18fb..ef1bfe1f551 100644 --- a/crates/blockifier/src/execution/entry_point_execution.rs +++ b/crates/blockifier/src/execution/entry_point_execution.rs @@ -378,6 +378,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: 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 66687e9773c..b637daa23b5 100644 --- a/crates/blockifier/src/execution/native/entry_point_execution.rs +++ b/crates/blockifier/src/execution/native/entry_point_execution.rs @@ -1,5 +1,7 @@ use cairo_native::execution_result::ContractExecutionResult; use cairo_native::utils::BuiltinCosts; +#[cfg(feature = "block-composition")] +use {crate::execution::native::syscall_handler::SYSCALL_COUNTER, std::sync::atomic::Ordering}; use crate::execution::call_info::{CallExecution, CallInfo, Retdata}; use crate::execution::contract_class::TrackedResource; @@ -64,7 +66,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( @@ -86,7 +93,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 syscall_counts = SYSCALL_COUNTER.load(Ordering::Relaxed); + 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/syscall_handler.rs b/crates/blockifier/src/execution/native/syscall_handler.rs index ea5ce0f0f2a..b84c4f938ad 100644 --- a/crates/blockifier/src/execution/native/syscall_handler.rs +++ b/crates/blockifier/src/execution/native/syscall_handler.rs @@ -1,5 +1,7 @@ use std::convert::From; use std::fmt; +#[cfg(feature = "block-composition")] +use std::sync::atomic::{AtomicU64, Ordering}; use std::sync::Arc; use ark_ec::short_weierstrass::{Affine, Projective, SWCurveConfig}; @@ -45,6 +47,10 @@ 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: AtomicU64 = AtomicU64::new(0); + pub struct NativeSyscallHandler<'state> { pub base: Box>, @@ -239,6 +245,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { block_number: u64, remaining_gas: &mut u64, ) -> SyscallResult { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.get_block_hash.base_syscall_cost(), @@ -251,6 +260,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { } fn get_execution_info(&mut self, remaining_gas: &mut u64) -> SyscallResult { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.get_execution_info.base_syscall_cost(), @@ -270,6 +282,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { contract_address: Felt, remaining_gas: &mut u64, ) -> SyscallResult { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.get_class_hash_at.base_syscall_cost(), @@ -285,6 +300,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { } fn get_execution_info_v2(&mut self, remaining_gas: &mut u64) -> SyscallResult { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.get_execution_info.base_syscall_cost(), @@ -307,6 +325,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { deploy_from_zero: bool, remaining_gas: &mut u64, ) -> SyscallResult<(Felt, Vec)> { + #[cfg(feature = "block-composition")] + 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 = @@ -330,6 +350,8 @@ 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.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.replace_class.base_syscall_cost(), @@ -348,6 +370,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { calldata: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult> { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.library_call.base_syscall_cost(), @@ -392,6 +416,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { calldata: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult> { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.call_contract.base_syscall_cost(), @@ -448,6 +475,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { address: Felt, remaining_gas: &mut u64, ) -> SyscallResult { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.storage_read.base_syscall_cost(), @@ -473,6 +503,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { value: Felt, remaining_gas: &mut u64, ) -> SyscallResult<()> { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.storage_write.base_syscall_cost(), @@ -497,6 +530,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { data: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult<()> { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.emit_event.base_syscall_cost(), @@ -517,6 +553,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { payload: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult<()> { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.send_message_to_l1.base_syscall_cost(), @@ -530,6 +569,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { } fn keccak(&mut self, input: &[u64], remaining_gas: &mut u64) -> SyscallResult { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.keccak.base_syscall_cost(), @@ -550,6 +592,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { y: U256, remaining_gas: &mut u64, ) -> SyscallResult> { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256k1_new.base_syscall_cost(), @@ -566,6 +611,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { p1: Secp256k1Point, remaining_gas: &mut u64, ) -> SyscallResult { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256k1_add.base_syscall_cost(), @@ -580,6 +627,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { m: U256, remaining_gas: &mut u64, ) -> SyscallResult { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256k1_mul.base_syscall_cost(), @@ -594,6 +644,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { y_parity: bool, remaining_gas: &mut u64, ) -> SyscallResult> { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256k1_get_point_from_x.base_syscall_cost(), @@ -609,6 +662,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { p: Secp256k1Point, remaining_gas: &mut u64, ) -> SyscallResult<(U256, U256)> { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256k1_get_xy.base_syscall_cost(), @@ -623,6 +678,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { y: U256, remaining_gas: &mut u64, ) -> SyscallResult> { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256r1_new.base_syscall_cost(), @@ -639,6 +697,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { p1: Secp256r1Point, remaining_gas: &mut u64, ) -> SyscallResult { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256r1_add.base_syscall_cost(), @@ -652,6 +713,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { m: U256, remaining_gas: &mut u64, ) -> SyscallResult { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256r1_mul.base_syscall_cost(), @@ -666,6 +730,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { y_parity: bool, remaining_gas: &mut u64, ) -> SyscallResult> { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256r1_get_point_from_x.base_syscall_cost(), @@ -681,6 +748,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { p: Secp256r1Point, remaining_gas: &mut u64, ) -> SyscallResult<(U256, U256)> { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.secp256r1_get_xy.base_syscall_cost(), @@ -695,6 +765,9 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { current_block: &[u32; 16], remaining_gas: &mut u64, ) -> SyscallResult<()> { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); + self.pre_execute_syscall( remaining_gas, self.gas_costs().syscalls.sha256_process_block.base_syscall_cost(), @@ -720,6 +793,8 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> { signature: &[Felt], remaining_gas: &mut u64, ) -> SyscallResult> { + #[cfg(feature = "block-composition")] + SYSCALL_COUNTER.fetch_add(1, Ordering::Relaxed); todo!( "implement meta_tx_v0 {:?}", (address, entry_point_selector, calldata, signature, remaining_gas)