starknet_os: initial test, measure call contract resources

Author: dorimedini-starkware

Cargo.lock

@@ -104,7 +104,7 @@ const ENTRY_POINT_INITIAL_BUDGET = 10000;
 const SYSCALL_BASE_GAS_COST = 10000;
 
 // Syscall gas costs.
-const CALL_CONTRACT_GAS_COST = 91560;
+const CALL_CONTRACT_GAS_COST = 91160;
 const DEPLOY_GAS_COST = 147120;
 const DEPLOY_CALLDATA_FACTOR_GAS_COST = 4850;
 const GET_BLOCK_HASH_GAS_COST = 10840;

crates/apollo_starknet_os_program/src/cairo/starkware/starknet/core/os/constants.cairo

@@ -1,6 +1,6 @@
 {
-  "os": "0x2a4b5650b64c1a13a4d2754353ddd85d4b970766063220253a4f96643ba23f6",
-  "virtual_os": "0x39f55918423cade9e95a6a52286b56bed1c5c9b6fe39aa00301361457a3c604",
+  "os": "0x1569abd39792bd43ec8d3ff0bf9baf4c8dab6e0528ffdf7b6f2c57a1e7e3188",
+  "virtual_os": "0x1c3f2f4f0a1b23ec07e236928c02ae3b13cb0137af1c8e3048994401b4b8e74",
   "aggregator": "0x700786d51b3854af43d8e12180380bda3029be6c1767e007858de6ca2edac40",
   "aggregator_with_prefix": "0xe08d300e3f5996e43d6d7cc5a20068e0e58cf1309089f2348317ac580f6c1f"
 }

crates/apollo_starknet_os_program/src/program_hash.json

@@ -225,7 +225,7 @@
     "os_resources": {
         "execute_syscalls": {
             "CallContract": {
-                "n_steps": 903,
+                "n_steps": 899,
                 "n_memory_holes": 0,
                 "builtin_instance_counter": {
                     "range_check_builtin": 18

crates/blockifier/resources/blockifier_versioned_constants_0_14_3.json

@@ -99,7 +99,7 @@ pub struct RawVersionedConstants {
 
 #[cfg(any(test, feature = "testing"))]
 impl RawVersionedConstants {
-    fn to_string_pretty(&self) -> String {
+    pub fn to_string_pretty(&self) -> String {
         let mut buffer = Vec::new();
         let formatter = serde_json::ser::PrettyFormatter::with_indent(b"    ");
         let mut serializer = serde_json::Serializer::with_formatter(&mut buffer, formatter);

crates/blockifier/src/blockifier_versioned_constants.rs

@@ -25,6 +25,9 @@ pub trait VersionedConstantsTrait: Debug {
     /// Gets the first version with versioned constants.
     fn first_version() -> StarknetVersion;
 
+    /// Gets the path to the JSON file for the specified Starknet version.
+    fn json_path(version: &StarknetVersion) -> Result<String, Self::Error>;
+
     /// Gets the contents of the JSON file for the specified Starknet version.
     fn json_str(version: &StarknetVersion) -> Result<&'static str, Self::Error>;
 
@@ -161,6 +164,17 @@ macro_rules! define_versioned_constants_inner {
                 $first_version
             }
 
+            fn json_path(version: &StarknetVersion) -> Result<String, Self::Error> {
+                Ok(format!(
+                    "{}/src/{}",
+                    env!("CARGO_MANIFEST_DIR"),
+                    match version {
+                        $(StarknetVersion::$variant => $path_to_json.to_string(),)*
+                        _ => return Err(Self::Error::InvalidStarknetVersion(*version)),
+                    }
+                ))
+            }
+
             fn json_str(
                 version: &starknet_api::block::StarknetVersion
             ) -> Result<&'static str, Self::Error> {

crates/starknet_api/src/versioned_constants_logic.rs

@@ -96,6 +96,11 @@ impl SyscallTrace {
     pub fn push_inner_syscall(&mut self, inner: SyscallTrace) {
         self.inner_syscalls.push(inner);
     }
+
+    #[cfg(any(test, feature = "testing"))]
+    pub fn get_selector(&self) -> SyscallSelector {
+        self.selector
+    }
 }
 
 impl ResourceFinalizer for SyscallTrace {
@@ -156,6 +161,11 @@ impl OsTransactionTrace {
     pub fn push_syscall(&mut self, syscall: SyscallTrace) {
         self.syscalls.push(syscall);
     }
+
+    #[cfg(any(test, feature = "testing"))]
+    pub fn get_syscalls(&self) -> &Vec<SyscallTrace> {
+        &self.syscalls
+    }
 }
 
 impl ResourceFinalizer for OsTransactionTrace {

crates/starknet_os/src/hint_processor/os_logger.rs

@@ -21,6 +21,7 @@ cairo-lang-starknet-classes.workspace = true
 cairo-vm.workspace = true
 chrono.workspace = true
 expect-test.workspace = true
+indexmap.workspace = true
 itertools.workspace = true
 rand.workspace = true
 rand_chacha.workspace = true

crates/starknet_os_flow_tests/Cargo.toml

@@ -2,6 +2,7 @@
 
 pub(crate) mod fuzz_tests;
 pub(crate) mod initial_state;
+pub(crate) mod os_resources_test;
 pub(crate) mod special_contracts;
 pub(crate) mod test_manager;
 pub(crate) mod tests;

crates/starknet_os_flow_tests/src/lib.rs

@@ -0,0 +1,195 @@
+use std::collections::HashSet;
+
+use blockifier::blockifier_versioned_constants::{
+    RawVersionedConstants,
+    VariableResourceParams,
+    VersionedConstants,
+};
+use blockifier::context::BlockContext;
+use blockifier::execution::deprecated_syscalls::DeprecatedSyscallSelector as Selector;
+use blockifier::test_utils::dict_state_reader::DictStateReader;
+use blockifier_test_utils::cairo_versions::RunnableCairo1;
+use blockifier_test_utils::contracts::FeatureContract;
+use cairo_vm::vm::runners::cairo_runner::ExecutionResources;
+use expect_test::expect_file;
+use indexmap::IndexMap;
+use starknet_api::block::StarknetVersion;
+use starknet_api::contract_class::SierraVersion;
+use starknet_api::executable_transaction::InvokeTransaction;
+use starknet_api::test_utils::invoke::invoke_tx;
+use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
+use starknet_api::{calldata, invoke_tx_args};
+use starknet_os::hint_processor::os_logger::ResourceFinalizer;
+use strum::IntoEnumIterator;
+
+use crate::initial_state::create_default_initial_state_data;
+use crate::test_manager::{TestBuilder, TestBuilderConfig};
+use crate::tests::NON_TRIVIAL_RESOURCE_BOUNDS;
+use crate::utils::get_class_hash_of_feature_contract;
+
+// TODO(Dori): Delete this, or at least reduce it to a minimal set of unmeasurable syscalls.
+const UNMEASURABLE_SYSCALLS: [Selector; 34] = [
+    Selector::DelegateCall,
+    Selector::DelegateL1Handler,
+    Selector::Deploy,
+    Selector::EmitEvent,
+    Selector::GetBlockHash,
+    Selector::GetBlockNumber,
+    Selector::GetBlockTimestamp,
+    Selector::GetCallerAddress,
+    Selector::GetClassHashAt,
+    Selector::GetContractAddress,
+    Selector::GetExecutionInfo,
+    Selector::GetSequencerAddress,
+    Selector::GetTxInfo,
+    Selector::GetTxSignature,
+    Selector::Keccak,
+    Selector::KeccakRound,
+    Selector::Sha256ProcessBlock,
+    Selector::LibraryCall,
+    Selector::LibraryCallL1Handler,
+    Selector::MetaTxV0,
+    Selector::ReplaceClass,
+    Selector::Secp256k1Add,
+    Selector::Secp256k1GetPointFromX,
+    Selector::Secp256k1GetXy,
+    Selector::Secp256k1Mul,
+    Selector::Secp256k1New,
+    Selector::Secp256r1Add,
+    Selector::Secp256r1GetPointFromX,
+    Selector::Secp256r1GetXy,
+    Selector::Secp256r1Mul,
+    Selector::Secp256r1New,
+    Selector::SendMessageToL1,
+    Selector::StorageRead,
+    Selector::StorageWrite,
+];
+
+#[tokio::test]
+async fn test_os_resources_regression() {
+    let os_resources_contract = FeatureContract::OsResourcesTest(RunnableCairo1::Casm);
+    let os_resources_class_hash = get_class_hash_of_feature_contract(os_resources_contract);
+
+    // Setup the test initial state and test builder.
+    // Need to explicitly set up the state to be able to override the minimal sierra version for gas
+    // tracking, in order to force step tracking mode.
+    let (mut initial_state_data, [os_resources_contract_address]) =
+        create_default_initial_state_data::<DictStateReader, 1>([(
+            os_resources_contract,
+            calldata![],
+        )])
+        .await;
+    initial_state_data.initial_state.block_context = {
+        let block_context = &initial_state_data.initial_state.block_context;
+        let mut vc = block_context.versioned_constants().clone();
+        vc.min_sierra_version_for_sierra_gas = SierraVersion::new(99, 99, 99);
+        BlockContext::new(
+            block_context.block_info().clone(),
+            block_context.chain_info().clone(),
+            vc,
+            block_context.bouncer_config.clone(),
+        )
+    };
+    let virtual_os = false;
+    let mut test_builder = TestBuilder::new_with_initial_state_data(
+        initial_state_data,
+        TestBuilderConfig::default(),
+        virtual_os,
+    );
+
+    // 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.
+    test_builder.add_fund_address_tx_with_default_amount(os_resources_contract_address);
+    test_builder.move_to_next_block();
+
+    // Add the syscall-measurement tx.
+    let tx = InvokeTransaction::create(
+        invoke_tx(invoke_tx_args! {
+            sender_address: os_resources_contract_address,
+            calldata: calldata![*os_resources_class_hash, **os_resources_contract_address],
+            resource_bounds: *NON_TRIVIAL_RESOURCE_BOUNDS,
+        }),
+        &test_builder.chain_id(),
+    )
+    .unwrap();
+    test_builder.add_invoke_tx(tx, None, None);
+
+    // Run test. Grab the execution info from the runner (for later) before consuming it.
+    let test_runner = test_builder.build().await;
+    let inner_calls = test_runner
+        .os_hints
+        .os_input
+        .os_block_inputs
+        .last()
+        .unwrap()
+        .tx_execution_infos
+        .last()
+        .unwrap()
+        .execute_call_info
+        .as_ref()
+        .unwrap()
+        .inner_calls
+        .clone();
+    let test_output = test_runner.run();
+    test_output.perform_default_validations();
+
+    // Extract syscall resources consumed, per (measurable) syscall.
+    let syscall_traces = test_output.runner_output.txs_trace.last().unwrap().get_syscalls();
+
+    // Measure each syscall overhead. If the syscall incurs an inner call, subtract the inner call
+    // overhead.
+    let mut inner_calls_iter = inner_calls.into_iter();
+    let mut visited_syscalls = HashSet::new();
+    let measurements: IndexMap<Selector, ExecutionResources> = syscall_traces
+        .iter()
+        .filter_map(|syscall_trace| {
+            let selector = syscall_trace.get_selector();
+            if UNMEASURABLE_SYSCALLS.contains(&selector) {
+                return None;
+            }
+
+            // Ensure we don't visit the same syscall twice.
+            assert!(
+                !visited_syscalls.contains(&selector),
+                "Syscall {selector:?} was visited twice."
+            );
+            visited_syscalls.insert(selector);
+
+            // If this syscall incurs an inner call, it should be the next inner call in the
+            // iterator.
+            let inner_overhead = if selector.is_calling_syscall() {
+                inner_calls_iter.next().unwrap().resources.vm_resources
+            } else {
+                ExecutionResources::default()
+            };
+
+            Some((
+                selector,
+                (syscall_trace.get_resources().unwrap() - &inner_overhead).filter_unused_builtins(),
+            ))
+        })
+        .collect();
+
+    // Make sure we covered all syscalls we expect to.
+    assert_eq!(
+        visited_syscalls,
+        Selector::iter()
+            .collect::<HashSet<_>>()
+            .difference(&UNMEASURABLE_SYSCALLS.iter().cloned().collect::<HashSet<_>>())
+            .copied()
+            .collect::<HashSet<_>>()
+    );
+
+    // Compare the measurements with the expected values on the latest VC.
+    let version = StarknetVersion::LATEST;
+    let mut raw_vc: RawVersionedConstants =
+        serde_json::from_str(VersionedConstants::json_str(&version).unwrap()).unwrap();
+    for (syscall, resources) in measurements {
+        raw_vc
+            .os_resources
+            .execute_syscalls
+            .insert(syscall, VariableResourceParams::Constant(resources));
+    }
+    expect_file![VersionedConstants::json_path(&version).unwrap()]
+        .assert_eq(&raw_vc.to_string_pretty());
+}