feat(blockifier): add syscall counting logic for native

crates/blockifier/src/execution/native/entry_point_execution.rs

@@ -1,7 +1,6 @@
 use cairo_native::execution_result::ContractExecutionResult;
 use cairo_vm::vm::runners::cairo_runner::ExecutionResources;
 use num_traits::ToPrimitive;
-use starknet_api::execution_resources::GasAmount;
 
 use crate::execution::call_info::{CallExecution, CallInfo, ChargedResources, Retdata};
 use crate::execution::contract_class::TrackedResource;
@@ -71,12 +70,7 @@ fn create_callinfo(
             failed: call_result.failure_flag,
             gas_consumed,
         },
-        // todo(rodrigo): execution resources rely heavily on how the VM work, therefore
-        // the dummy values
-        charged_resources: ChargedResources {
-            vm_resources: ExecutionResources::default(),
-            gas_for_fee: GasAmount(gas_consumed),
-        },
+        charged_resources: ChargedResources::default(),
         inner_calls: syscall_handler.inner_calls,
         storage_read_values: syscall_handler.read_values,
         accessed_storage_keys: syscall_handler.accessed_keys,

crates/blockifier/src/execution/native/syscall_handler.rs

@@ -17,7 +17,8 @@ use starknet_types_core::felt::Felt;
 use crate::execution::call_info::{CallInfo, OrderedEvent, OrderedL2ToL1Message, Retdata};
 use crate::execution::entry_point::{CallEntryPoint, EntryPointExecutionContext};
 use crate::execution::native::utils::encode_str_as_felts;
-use crate::execution::syscalls::hint_processor::OUT_OF_GAS_ERROR;
+use crate::execution::syscalls::hint_processor::{SyscallCounter, OUT_OF_GAS_ERROR};
+use crate::execution::syscalls::SyscallSelector;
 use crate::state::state_api::State;
 
 pub struct NativeSyscallHandler<'state> {
@@ -32,6 +33,8 @@ pub struct NativeSyscallHandler<'state> {
     pub l2_to_l1_messages: Vec<OrderedL2ToL1Message>,
     pub inner_calls: Vec<CallInfo>,
 
+    pub syscall_counter: SyscallCounter,
+
     // Additional information gathered during execution.
     pub read_values: Vec<Felt>,
     pub accessed_keys: HashSet<StorageKey, RandomState>,
@@ -52,11 +55,18 @@ impl<'state> NativeSyscallHandler<'state> {
             events: Vec::new(),
             l2_to_l1_messages: Vec::new(),
             inner_calls: Vec::new(),
+            syscall_counter: SyscallCounter::new(),
             read_values: Vec::new(),
             accessed_keys: HashSet::new(),
         }
     }
 
+    #[allow(dead_code)]
+    fn increment_syscall_count_by(&mut self, selector: &SyscallSelector, n: usize) {
+        let syscall_count = self.syscall_counter.entry(*selector).or_default();
+        *syscall_count += n
+    }
+
     #[allow(dead_code)]
     fn execute_inner_call(
         &mut self,
@@ -84,15 +94,22 @@ impl<'state> NativeSyscallHandler<'state> {
         Ok(retdata)
     }
 
-    // Handles gas related logic when executing a syscall. Required because Native calls the
-    // syscalls directly unlike the VM where the `execute_syscall` method perform this operation
-    // first.
+    /// Performs a similar role to what the `execute_syscall` method does for the VM (i.e.
+    /// handling all gas-related logics and additional metadata such as `SyscallCounter`). The
+    /// difference for native execution is that we need to explicitly call this method at the
+    /// beginning of each syscall.
     #[allow(dead_code)]
-    fn substract_syscall_gas_cost(
+    fn pre_execute_syscall(
         &mut self,
         remaining_gas: &mut u128,
+        syscall_selector: SyscallSelector,
         syscall_gas_cost: u64,
     ) -> SyscallResult<()> {
+        // Syscall count for Keccak is done differently
+        if syscall_selector != SyscallSelector::Keccak {
+            self.increment_syscall_count_by(&syscall_selector, 1);
+        }
+
         // Refund `SYSCALL_BASE_GAS_COST` as it was pre-charged.
         let required_gas =
             u128::from(syscall_gas_cost - self.context.gas_costs().syscall_base_gas_cost);