starknet_os: os resources test - remove all fee transfer syscalls

Author: dorimedini-starkware

crates/blockifier_test_utils/resources/feature_contracts/cairo1/os_resources_test_contract.cairo

@@ -39,6 +39,11 @@ mod OsResourcesTestContract {
     fn __execute__(
         ref self: ContractState, stable_class_hash: ClassHash, stable_address: ContractAddress,
     ) {
+        // Skip everything if inputs are zero.
+        if stable_class_hash.is_zero() && stable_address.is_zero() {
+            return;
+        }
+
         // call_contract syscall — calls external function on stable contract.
         call_contract_syscall(
             stable_address, STABLE_EXTERNAL_ENTRY_POINT_SELECTOR, array![0].span(),

crates/starknet_os_flow_tests/src/os_resources_test.rs

@@ -96,6 +96,62 @@ const UNMEASURABLE_SYSCALLS: [Selector; 31] = [
 static SYSCALLS_WITH_LINEAR_FACTOR: LazyLock<HashMap<Selector, usize>> =
     LazyLock::new(|| HashMap::from([(Selector::Deploy, 1), (Selector::MetaTxV0, 1)]));
 
+/// Expected syscalls in the fee transfer call. Should be removed from the list of syscalls during
+/// measurement iteration - only the syscalls called during __execute__ should be measured.
+const FEE_TRANSFER_SYSCALLS: [Selector; 10] = [
+    Selector::GetExecutionInfo,
+    Selector::StorageRead,
+    Selector::StorageRead,
+    Selector::StorageWrite,
+    Selector::StorageWrite,
+    Selector::StorageRead,
+    Selector::StorageRead,
+    Selector::StorageWrite,
+    Selector::StorageWrite,
+    Selector::EmitEvent,
+];
+
+/// Regression test for the list of syscalls called during the fee transfer phase of a transaction.
+#[tokio::test]
+async fn test_fee_transfer_syscalls() {
+    let os_resources_contract = FeatureContract::OsResourcesTest(RunnableCairo1::Casm);
+    let (mut builder, [os_resources_contract_address]) =
+        TestBuilder::create_standard([(os_resources_contract, calldata![])]).await;
+
+    // Fund the contract - it will be used as the account.
+    // Then, move on to the next block, so the syscall-measurement tx is in it's own block.
+    builder.add_fund_address_tx_with_default_amount(os_resources_contract_address);
+
+    // Invoke from the OS resources contract, with zeros as calldata, to make the __execute__ do
+    // nothing. All resulting events should be from the fee transfer call.
+    builder.add_invoke_tx(
+        InvokeTransaction::create(
+            invoke_tx(invoke_tx_args! {
+                sender_address: os_resources_contract_address,
+                calldata: calldata![Felt::ZERO, Felt::ZERO],
+                resource_bounds: *NON_TRIVIAL_RESOURCE_BOUNDS,
+            }),
+            &builder.chain_id(),
+        )
+        .unwrap(),
+        None,
+        None,
+    );
+
+    // Build, run, and get the syscalls list.
+    let test_output = builder.build_and_run().await;
+    let syscalls = test_output
+        .runner_output
+        .txs_trace
+        .last()
+        .unwrap()
+        .get_syscalls()
+        .iter()
+        .map(|syscall_trace| syscall_trace.get_selector())
+        .collect::<Vec<_>>();
+    assert_eq!(syscalls, FEE_TRANSFER_SYSCALLS.to_vec());
+}
+
 /// Measure the OS overhead for each syscall, and compare the results with the latest VC.
 ///
 /// This test relies on the [starknet_os::hint_processor::os_logger::OsLogger] to capture the
@@ -231,25 +287,23 @@ async fn test_os_resources_regression() {
     let mut inner_calls_iter = inner_calls.into_iter();
 
     // Extract syscall resources consumed per syscall.
-    // There should be two events emitted: the first is the syscall we are measuring, and the second
-    // is the last syscall in the tx, emitted from the fee transfer. Pop the second event.
-    let mut syscall_traces =
-        test_output.runner_output.txs_trace.last().unwrap().get_syscalls().clone();
-    assert!(!UNMEASURABLE_SYSCALLS.contains(&Selector::EmitEvent));
+    // Remove the fee transfer syscalls from the list by splitting the iterator into two. The second
+    // part is the last `FEE_TRANSFER_SYSCALLS.len()` syscalls, and the first part should be the
+    // rest.
+    let all_syscalls = test_output.runner_output.txs_trace.last().unwrap().get_syscalls().clone();
+    let (syscall_traces, fee_transfer_syscall_traces) =
+        all_syscalls.split_at(all_syscalls.len() - FEE_TRANSFER_SYSCALLS.len());
     assert_eq!(
-        syscall_traces
+        fee_transfer_syscall_traces
             .iter()
-            .filter(|syscall_trace| syscall_trace.get_selector() == Selector::EmitEvent)
-            .count(),
-        2
+            .map(|syscall_trace| syscall_trace.get_selector())
+            .collect::<Vec<_>>(),
+        FEE_TRANSFER_SYSCALLS.to_vec()
     );
-    assert_eq!(syscall_traces.pop().unwrap().get_selector(), Selector::EmitEvent);
 
     // Measure each syscall overhead. If the syscall incurs an inner call, subtract the inner call
     // overhead.
-    let mut syscalls_iter = syscall_traces
-        .iter()
-        .filter(|syscall_trace| !UNMEASURABLE_SYSCALLS.contains(&syscall_trace.get_selector()));
+    let mut syscalls_iter = syscall_traces.iter();
     let mut measurements: IndexMap<Selector, VariableResourceParams> = IndexMap::new();
     // If the syscall incurs an inner call, subtract the inner call overhead.
     let mut maybe_deduct_inner =