starknet_os: os resources test - invoke tx constant factor

Author: dorimedini-starkware

crates/blockifier/resources/blockifier_versioned_constants_0_14_4.json

@@ -526,12 +526,12 @@
             },
             "InvokeFunction": {
                 "constant": {
-                    "n_steps": 4348,
+                    "n_steps": 4779,
                     "n_memory_holes": 0,
                     "builtin_instance_counter": {
-                        "range_check_builtin": 90,
+                        "range_check_builtin": 110,
                         "pedersen_builtin": 4,
-                        "poseidon_builtin": 12
+                        "poseidon_builtin": 11
                     }
                 },
                 "calldata_factor": {

crates/starknet_os_flow_tests/src/os_resources_test.rs

@@ -1,7 +1,8 @@
 use std::collections::{HashMap, HashSet};
-use std::sync::LazyLock;
+use std::sync::{Arc, LazyLock};
 
 use blockifier::blockifier_versioned_constants::{
+    CallDataFactor,
     RawStepGasCost,
     RawVersionedConstants,
     ResourcesParams,
@@ -12,6 +13,7 @@ use blockifier::blockifier_versioned_constants::{
 use blockifier::context::BlockContext;
 use blockifier::execution::deprecated_syscalls::DeprecatedSyscallSelector as Selector;
 use blockifier::test_utils::dict_state_reader::DictStateReader;
+use blockifier::transaction::objects::ExecutionResourcesTraits;
 use blockifier_test_utils::cairo_versions::RunnableCairo1;
 use blockifier_test_utils::contracts::FeatureContract;
 use cairo_vm::vm::runners::cairo_runner::ExecutionResources;
@@ -20,9 +22,9 @@ use indexmap::IndexMap;
 use starknet_api::block::StarknetVersion;
 use starknet_api::contract_class::SierraVersion;
 use starknet_api::core::{ClassHash, ContractAddress, EthAddress};
-use starknet_api::executable_transaction::InvokeTransaction;
+use starknet_api::executable_transaction::{InvokeTransaction, TransactionType};
 use starknet_api::test_utils::invoke::invoke_tx;
-use starknet_api::transaction::fields::ContractAddressSalt;
+use starknet_api::transaction::fields::{Calldata, ContractAddressSalt};
 use starknet_api::transaction::{L2ToL1Payload, MessageToL1};
 use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
 use starknet_api::{calldata, declare_tx_args, invoke_tx_args};
@@ -180,7 +182,7 @@ async fn setup_test_builder(raw_vc: Option<&RawVersionedConstants>) -> OsResourc
     );
     test_builder.add_fund_address_tx_with_default_amount(os_resources_contract_address);
 
-    // Declare and deploy an instance of the stable contract.
+    // Declare and deploy an instance of the stable contract. Also, fund it.
     let stable_contract_sierra = &DEPLOYABLE_FOR_RESOURCE_MEASUREMENT_CONTRACT_SIERRA;
     let stable_contract_casm = &DEPLOYABLE_FOR_RESOURCE_MEASUREMENT_CONTRACT_CASM;
     let stable_contract_class_hash = stable_contract_sierra.calculate_class_hash();
@@ -206,6 +208,7 @@ async fn setup_test_builder(raw_vc: Option<&RawVersionedConstants>) -> OsResourc
             deploy_from_zero,
         );
     test_builder.add_invoke_tx(deploy_tx, None, None);
+    test_builder.add_fund_address_tx_with_default_amount(stable_contract_address);
 
     // Move on to the next block, so the measurement txs are in their own block.
     test_builder.move_to_next_block();
@@ -218,6 +221,13 @@ async fn setup_test_builder(raw_vc: Option<&RawVersionedConstants>) -> OsResourc
     }
 }
 
+/// Utility method to create dummy calldata to a cairo Span argument.
+fn span_calldata(n_elements: usize) -> Calldata {
+    let mut calldata = vec![Felt::from(n_elements)];
+    calldata.extend(vec![Felt::ZERO; n_elements]);
+    Calldata(Arc::new(calldata))
+}
+
 /// Regression test for the list of syscalls called during the fee transfer phase of a transaction.
 #[tokio::test]
 async fn test_fee_transfer_syscalls() {
@@ -485,3 +495,123 @@ async fn test_os_resources_regression() {
     expect_file![VersionedConstants::json_path(&version).unwrap()]
         .assert_eq(&raw_vc.to_string_pretty());
 }
+
+/// Measures the per-transaction-type overhead of `execute_transaction_inner` in the OS and
+/// compares it against the versioned constants.
+///
+/// Methodology:
+/// - Run a minimal transaction of the given type through the full OS.
+/// - Compute: overhead = OS trace resources − blockifier business-logic resources
+///   (execute_call_info + validate_call_info).
+/// - The remainder is the pure OS scaffolding cost stored under `execute_txs_inner`.
+#[tokio::test]
+async fn test_execute_txs_inner_resources() {
+    let version = StarknetVersion::LATEST;
+    let mut raw_vc: RawVersionedConstants =
+        serde_json::from_str(VersionedConstants::json_str(&version).unwrap()).unwrap();
+    // TODO(Dori): Declare, DeployAccount, L1Handler.
+    const N_TXS: usize = 2;
+
+    // For linear factor measurements, it's not enough to just add one more calldata element; the
+    // increase is not the same per element. The linear scale is on average.
+    const INVOKE_SCALING_FACTOR: usize = 2;
+    const INVOKE_EXTRA_ARGS: usize = 10;
+
+    let OsResourcesTestSetup { stable_contract_address, mut test_builder, .. } =
+        setup_test_builder(Some(&raw_vc)).await;
+
+    // Invoke.
+    let invoke_args = invoke_tx_args! {
+        sender_address: stable_contract_address,
+        calldata: calldata![Felt::ZERO],
+        resource_bounds: *NON_TRIVIAL_RESOURCE_BOUNDS,
+        nonce: test_builder.next_nonce(stable_contract_address),
+    };
+    test_builder.add_invoke_tx(
+        InvokeTransaction::create(invoke_tx(invoke_args), &test_builder.chain_id()).unwrap(),
+        None,
+        None,
+    );
+    // Invoke: scale-factor more calldata elements.
+    let invoke_args = invoke_tx_args! {
+        sender_address: stable_contract_address,
+        calldata: span_calldata(INVOKE_EXTRA_ARGS),
+        resource_bounds: *NON_TRIVIAL_RESOURCE_BOUNDS,
+        nonce: test_builder.next_nonce(stable_contract_address),
+    };
+    test_builder.add_invoke_tx(
+        InvokeTransaction::create(invoke_tx(invoke_args), &test_builder.chain_id()).unwrap(),
+        None,
+        None,
+    );
+
+    // Execute the business logic and extract the business logic resources for each tx.
+    let test_runner = test_builder.build().await;
+    let business_logic_resources: [ExecutionResources; N_TXS] = test_runner
+        .os_hints
+        .os_input
+        .os_block_inputs
+        .last()
+        .unwrap()
+        .tx_execution_infos
+        .iter()
+        .map(|exec_info| {
+            let mut business_logic_resources =
+                [exec_info.execute_call_info.as_ref(), exec_info.validate_call_info.as_ref()]
+                    .into_iter()
+                    .flatten()
+                    .map(|ci| ci.resources.vm_resources.clone())
+                    .fold(ExecutionResources::default(), |acc, resources| &acc + &resources);
+            // TODO(Dori): Consider supporting memory-hole counting in the OsLogger. Until then, we
+            //   cannot subtract inner calls with positive memory-hole counts from the OsLogger
+            //   resources.
+            business_logic_resources.n_memory_holes = 0;
+            business_logic_resources
+        })
+        .collect::<Vec<_>>()
+        .try_into()
+        .unwrap();
+
+    // Run the OS part.
+    let test_output = test_runner.run();
+    test_output.perform_default_validations();
+
+    // Fetch the OS resources for each tx.
+    let [invoke_first, invoke_second]: [ExecutionResources; N_TXS] = test_output
+        .runner_output
+        .txs_trace
+        .iter()
+        .rev()
+        .take(N_TXS)
+        .rev()
+        .map(|trace| trace.get_resources().unwrap().clone())
+        .zip(business_logic_resources)
+        .map(|(os_resources, business_logic_resources)| {
+            (&os_resources - &business_logic_resources).filter_unused_builtins()
+        })
+        .collect::<Vec<_>>()
+        .try_into()
+        .unwrap();
+
+    // Update the VC with the measurements.
+    // For transaction types with linear factors, the first call has one linear element (calldata
+    // length, of zero), so one linear cost must be subtracted from the first measurement to get the
+    // base cost.
+    let invoke_linear_factor = (&(&invoke_second - &invoke_first).filter_unused_builtins()
+        * INVOKE_SCALING_FACTOR)
+        .div_ceil(INVOKE_EXTRA_ARGS);
+    raw_vc.os_resources.execute_txs_inner.extend([(
+        TransactionType::InvokeFunction,
+        VariableResourceParams::WithFactor(ResourcesParams {
+            constant: (&invoke_first - &invoke_linear_factor).filter_unused_builtins(),
+            calldata_factor: VariableCallDataFactor::Scaled(CallDataFactor {
+                resources: invoke_linear_factor,
+                scaling_factor: INVOKE_SCALING_FACTOR,
+            }),
+        }),
+    )]);
+
+    // Verify computation.
+    expect_file![VersionedConstants::json_path(&version).unwrap()]
+        .assert_eq(&raw_vc.to_string_pretty());
+}