starknet_os: os resources test - add meta tx

Author: dorimedini-starkware

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

@@ -117,7 +117,7 @@ const STORAGE_READ_GAS_COST = 24070;
 const STORAGE_WRITE_GAS_COST = 59970;
 const EMIT_EVENT_GAS_COST = 10000;
 const SEND_MESSAGE_TO_L1_GAS_COST = 14470;
-const META_TX_V0_GAS_COST = 167950;
+const META_TX_V0_GAS_COST = 186850;
 const META_TX_V0_CALLDATA_FACTOR_GAS_COST = 4850;
 
 // Note the the following costs include `SYSCALL_BASE_GAS_COST` implicitly.

crates/apollo_starknet_os_program/src/program_hash.json

@@ -1,5 +1,5 @@
 {
-  "os": "0x461af643b9206b0b94aa080b26242e9269bc49fc36ed856b2e74a92ad3c64c4",
+  "os": "0xad3b2efb91d0a035ca3acde2c0428869e997a1cf9631d6d947433aa91f71ec",
   "virtual_os": "0x4fb8c0cb28349d61091f3fc633493c01385f77cd0d4ebfd577251b3941d49b9",
   "aggregator": "0x700786d51b3854af43d8e12180380bda3029be6c1767e007858de6ca2edac40",
   "aggregator_with_prefix": "0xe08d300e3f5996e43d6d7cc5a20068e0e58cf1309089f2348317ac580f6c1f"

crates/blockifier/resources/blockifier_versioned_constants_0_14_3.json

@@ -360,11 +360,11 @@
             },
             "MetaTxV0": {
                 "constant": {
-                    "n_steps": 1301,
+                    "n_steps": 1328,
                     "n_memory_holes": 0,
                     "builtin_instance_counter": {
                         "range_check_builtin": 20,
-                        "pedersen_builtin": 9
+                        "pedersen_builtin": 13
                     }
                 },
                 "calldata_factor": {

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

@@ -1,11 +1,13 @@
 // Contract for measuring per-syscall OS resource costs.
 #[starknet::contract(account)]
 mod OsResourcesTestContract {
+    use starknet::class_hash::ClassHashZero;
     use starknet::info::SyscallResultTrait;
     use starknet::syscalls::{call_contract_syscall, deploy_syscall, library_call_syscall};
     use starknet::{ClassHash, ContractAddress};
 
     const EMPTY_FUNCTION_SELECTOR: felt252 = selector!("empty_function");
+    const EXECUTE_FUNCTION_SELECTOR: felt252 = selector!("__execute__");
 
     #[storage]
     struct Storage {}
@@ -23,18 +25,32 @@ mod OsResourcesTestContract {
         self_class_hash: ClassHash,
         self_address: ContractAddress,
         deployable_class_hash: ClassHash,
+        extra_args: Span<felt252>,
     ) -> felt252 {
         starknet::VALIDATED
     }
 
+    extern fn meta_tx_v0_syscall(
+        address: ContractAddress,
+        entry_point_selector: felt252,
+        calldata: Span<felt252>,
+        signature: Span<felt252>,
+    ) -> starknet::SyscallResult<Span<felt252>> implicits(GasBuiltin, System) nopanic;
+
     // Calls every measured syscall in order.
     #[external(v0)]
     fn __execute__(
         ref self: ContractState,
         self_class_hash: ClassHash,
         self_address: ContractAddress,
         deployable_class_hash: ClassHash,
+        extra_args: Span<felt252>,
     ) {
+        // If called from the meta-tx-v0 syscall, just return.
+        if self_class_hash == ClassHashZero::zero() {
+            return;
+        }
+
         // call_contract syscall — calls empty_function on self.
         call_contract_syscall(self_address, EMPTY_FUNCTION_SELECTOR, ArrayTrait::new().span())
             .unwrap_syscall();
@@ -43,6 +59,25 @@ mod OsResourcesTestContract {
         library_call_syscall(self_class_hash, EMPTY_FUNCTION_SELECTOR, ArrayTrait::new().span())
             .unwrap_syscall();
 
+        // meta_tx_v0 syscall - base.
+        meta_tx_v0_syscall(
+            address: self_address,
+            entry_point_selector: EXECUTE_FUNCTION_SELECTOR,
+            // class hash, address, deployable class hash, extra args len.
+            calldata: array![0, 0, 0, 0].span(),
+            signature: array![].span(),
+        )
+            .unwrap_syscall();
+        // meta_tx_v0 syscall - linear factor.
+        meta_tx_v0_syscall(
+            address: self_address,
+            entry_point_selector: EXECUTE_FUNCTION_SELECTOR,
+            // class hash, address, deployable class hash, extra args len, extra arg.
+            calldata: array![0, 0, 0, 1, 0].span(),
+            signature: array![].span(),
+        )
+            .unwrap_syscall();
+
         // deploy syscall. The resources this syscall consumes can vary depending on the deployed
         // contract address, in a non-trivial way (see `normalize_address` in the cairo0 core). For
         // this reason we deploy from zero, and choose a specific salt.

crates/starknet_os_flow_tests/src/os_resources_test.rs

@@ -24,6 +24,7 @@ use starknet_api::test_utils::invoke::invoke_tx;
 use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
 use starknet_api::{calldata, declare_tx_args, invoke_tx_args};
 use starknet_os::hint_processor::os_logger::ResourceFinalizer;
+use starknet_types_core::felt::Felt;
 use strum::IntoEnumIterator;
 
 use crate::initial_state::create_default_initial_state_data;
@@ -36,7 +37,7 @@ 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; 32] = [
+const UNMEASURABLE_SYSCALLS: [Selector; 31] = [
     Selector::DelegateCall,
     Selector::DelegateL1Handler,
     Selector::EmitEvent,
@@ -54,7 +55,6 @@ const UNMEASURABLE_SYSCALLS: [Selector; 32] = [
     Selector::KeccakRound,
     Selector::Sha256ProcessBlock,
     Selector::LibraryCallL1Handler,
-    Selector::MetaTxV0,
     Selector::ReplaceClass,
     Selector::Secp256k1Add,
     Selector::Secp256k1GetPointFromX,
@@ -168,7 +168,10 @@ async fn test_os_resources_regression() {
         invoke_tx(invoke_tx_args! {
             sender_address: os_resources_contract_address,
             calldata: calldata![
-                *os_resources_class_hash, **os_resources_contract_address, *deployable_class_hash
+                *os_resources_class_hash,
+                **os_resources_contract_address,
+                *deployable_class_hash,
+                Felt::ZERO
             ],
             resource_bounds: *NON_TRIVIAL_RESOURCE_BOUNDS,
         }),
@@ -209,7 +212,12 @@ async fn test_os_resources_regression() {
     let mut fetch_inner_resources = |selector: Selector| -> ExecutionResources {
         if selector.is_calling_syscall() {
             // TODO(Dori): Take opcodes (like blake) into account.
-            inner_calls_iter.next().unwrap().resources.vm_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.
+            let mut inner_resources = inner_calls_iter.next().unwrap().resources.vm_resources;
+            inner_resources.n_memory_holes = 0;
+            inner_resources
         } else {
             ExecutionResources::default()
         }