starknet_os: os resources test - support virtual builtins, add sha256 (#14141)

dorimedini-starkware · web-flow · commit 1c0a5daa1791 · 2026-06-11T20:28:23.000Z
diff --git a/crates/apollo_starknet_os_program/src/cairo/starkware/starknet/core/os/constants.cairo b/crates/apollo_starknet_os_program/src/cairo/starkware/starknet/core/os/constants.cairo
@@ -72,7 +72,7 @@ const ALLOWED_VIRTUAL_OS_PROGRAM_HASHES_1 = (
     0x06ecb73d21c7d98ddd4148f5bcd91cc2747c65364245fbf32a63b05cca1685c2
 );
 const ALLOWED_VIRTUAL_OS_PROGRAM_HASHES_2 = (
-    0x0552611434744d19772e04249521f0a3d00d85906c9a600082aaa9339788f8d5
+    0x04373ade67a35a6ae0466730e5807b828a5db813010d6070bb1db85f99682dcb
 );
 const ALLOWED_VIRTUAL_OS_PROGRAM_HASHES_LEN = 3;
 
@@ -137,7 +137,7 @@ const SECP256R1_NEW_GAS_COST = 61630;
 
 const KECCAK_GAS_COST = 10000;
 const KECCAK_ROUND_COST_GAS_COST = 165137;
-const SHA256_PROCESS_BLOCK_GAS_COST = 841295;
+const SHA256_PROCESS_BLOCK_GAS_COST = 839995;
 const SHA512_PROCESS_BLOCK_GAS_COST = 2413810;
 
 // Cairo 1.0 error codes.
diff --git a/crates/apollo_starknet_os_program/src/program_hash.json b/crates/apollo_starknet_os_program/src/program_hash.json
@@ -1,6 +1,6 @@
 {
-  "os": "0x30d60f71b7401f270197f0d50658849403bc9d786c2f7b38535cf7f9a389f66",
-  "virtual_os": "0x552611434744d19772e04249521f0a3d00d85906c9a600082aaa9339788f8d5",
+  "os": "0x3b23e69c999017f0a08ca8080de329bf80922aaa8bd364f1bf3b5445b38f989",
+  "virtual_os": "0x4373ade67a35a6ae0466730e5807b828a5db813010d6070bb1db85f99682dcb",
   "aggregator": "0x700786d51b3854af43d8e12180380bda3029be6c1767e007858de6ca2edac40",
   "aggregator_with_prefix": "0xe08d300e3f5996e43d6d7cc5a20068e0e58cf1309089f2348317ac580f6c1f"
 }
diff --git a/crates/blockifier/resources/blockifier_versioned_constants_0_14_4.json b/crates/blockifier/resources/blockifier_versioned_constants_0_14_4.json
@@ -129,7 +129,7 @@
         "allowed_virtual_os_program_hashes": [
             "0x3e98c2d7703b03a7edb73ed7f075f97f1dcbaa8f717cdf6e1a57bf058265473",
             "0x6ecb73d21c7d98ddd4148f5bcd91cc2747c65364245fbf32a63b05cca1685c2",
-            "0x552611434744d19772e04249521f0a3d00d85906c9a600082aaa9339788f8d5"
+            "0x4373ade67a35a6ae0466730e5807b828a5db813010d6070bb1db85f99682dcb"
         ],
         "constructor_entry_point_selector": "0x28ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194",
         "default_entry_point_selector": "0x0",
@@ -462,7 +462,7 @@
                 }
             },
             "Sha256ProcessBlock": {
-                "n_steps": 1867,
+                "n_steps": 1854,
                 "n_memory_holes": 0,
                 "builtin_instance_counter": {
                     "range_check_builtin": 65,
diff --git a/crates/blockifier/resources/versioned_constants_diff_regression/0.14.3_0.14.4.txt b/crates/blockifier/resources/versioned_constants_diff_regression/0.14.3_0.14.4.txt
@@ -1,4 +1,4 @@
-+ /os_constants/allowed_virtual_os_program_hashes/2: "0x552611434744d19772e04249521f0a3d00d85906c9a600082aaa9339788f8d5"
++ /os_constants/allowed_virtual_os_program_hashes/2: "0x4373ade67a35a6ae0466730e5807b828a5db813010d6070bb1db85f99682dcb"
 ~ /os_resources/execute_syscalls/CallContract/n_steps: 901
 ~ /os_resources/execute_syscalls/EmitEvent/n_steps: 47
 ~ /os_resources/execute_syscalls/GetBlockHash/builtin_instance_counter/range_check_builtin: 3
@@ -9,3 +9,4 @@
 ~ /os_resources/execute_syscalls/KeccakRound/n_steps: 223
 ~ /os_resources/execute_syscalls/LibraryCall/n_steps: 874
 ~ /os_resources/execute_syscalls/MetaTxV0/constant/n_steps: 1307
+~ /os_resources/execute_syscalls/Sha256ProcessBlock/n_steps: 1854
diff --git a/crates/blockifier/src/execution/syscalls/syscall_tests/sha256.rs b/crates/blockifier/src/execution/syscalls/syscall_tests/sha256.rs
@@ -37,7 +37,7 @@ fn test_sha256(runnable_version: RunnableCairo1) {
             l2_to_l1_messages: [],
             cairo_native: false,
             failed: false,
-            gas_consumed: 851745,
+            gas_consumed: 850445,
         }
     "#]]
     .assert_debug_eq(&execution);
diff --git a/crates/blockifier/src/versioned_constants_test.rs b/crates/blockifier/src/versioned_constants_test.rs
@@ -229,7 +229,7 @@ fn test_latest_no_panic() {
 fn test_syscall_gas_cost_calculation() {
     const EXPECTED_CALL_CONTRACT_GAS_COST: Expect = expect!["91360"];
     const EXPECTED_SECP256K1MUL_GAS_COST: Expect = expect!["8143850"];
-    const EXPECTED_SHA256PROCESSBLOCK_GAS_COST: Expect = expect!["841295"];
+    const EXPECTED_SHA256PROCESSBLOCK_GAS_COST: Expect = expect!["839995"];
 
     let versioned_constants = VersionedConstants::latest_constants().clone();
 
diff --git a/crates/blockifier_test_utils/resources/feature_contracts/cairo1/os_resources_test_contract.cairo b/crates/blockifier_test_utils/resources/feature_contracts/cairo1/os_resources_test_contract.cairo
@@ -1,10 +1,12 @@
 // Contract for measuring per-syscall OS resource costs.
 #[starknet::contract(account)]
 mod OsResourcesTestContract {
+    use box::BoxTrait;
+    use core::sha256::{SHA256_INITIAL_STATE, sha256_state_handle_init};
     use starknet::info::SyscallResultTrait;
     use starknet::syscalls::{
         call_contract_syscall, deploy_syscall, emit_event_syscall, get_execution_info_v3_syscall,
-        keccak_syscall, library_call_syscall,
+        keccak_syscall, library_call_syscall, sha256_process_block_syscall,
     };
     use starknet::{ClassHash, ContractAddress, get_block_hash_syscall, get_class_hash_at_syscall};
 
@@ -115,5 +117,10 @@ mod OsResourcesTestContract {
             input.append(1_u64);
         }
         keccak_syscall(input.span()).unwrap_syscall();
+
+        // sha256.
+        let mut input = BoxTrait::new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+        let mut state = sha256_state_handle_init(BoxTrait::new(SHA256_INITIAL_STATE));
+        let _ = sha256_process_block_syscall(state, input).unwrap_syscall();
     }
 }
diff --git a/crates/starknet_os/src/hint_processor/constants.rs b/crates/starknet_os/src/hint_processor/constants.rs
@@ -3,19 +3,18 @@ use std::sync::LazyLock;
 
 use cairo_vm::types::builtin_name::BuiltinName;
 
-pub(crate) static BUILTIN_INSTANCE_SIZES: LazyLock<HashMap<BuiltinName, usize>> =
-    LazyLock::new(|| {
-        HashMap::from([
-            (BuiltinName::pedersen, 3),
-            (BuiltinName::range_check, 1),
-            (BuiltinName::ecdsa, 2),
-            (BuiltinName::bitwise, 5),
-            (BuiltinName::ec_op, 7),
-            (BuiltinName::poseidon, 6),
-            (BuiltinName::segment_arena, 3),
-            (BuiltinName::range_check96, 1),
-            (BuiltinName::add_mod, 7),
-            (BuiltinName::mul_mod, 7),
-            (BuiltinName::keccak, 16),
-        ])
-    });
+pub static BUILTIN_INSTANCE_SIZES: LazyLock<HashMap<BuiltinName, usize>> = LazyLock::new(|| {
+    HashMap::from([
+        (BuiltinName::pedersen, 3),
+        (BuiltinName::range_check, 1),
+        (BuiltinName::ecdsa, 2),
+        (BuiltinName::bitwise, 5),
+        (BuiltinName::ec_op, 7),
+        (BuiltinName::poseidon, 6),
+        (BuiltinName::segment_arena, 3),
+        (BuiltinName::range_check96, 1),
+        (BuiltinName::add_mod, 7),
+        (BuiltinName::mul_mod, 7),
+        (BuiltinName::keccak, 16),
+    ])
+});
diff --git a/crates/starknet_os/src/resource_utils_test.rs b/crates/starknet_os/src/resource_utils_test.rs
@@ -17,7 +17,11 @@ use crate::test_utils::cairo_runner::{
     ImplicitArg,
     ValueArg,
 };
-use crate::test_utils::{SHA256_BATCH_RESOURCES_CONSTANT, SHA256_BATCH_RESOURCES_LINEAR};
+use crate::test_utils::{
+    SHA256_BATCH_RESOURCES_CONSTANT,
+    SHA256_BATCH_RESOURCES_LINEAR,
+    SHA256_BATCH_SIZE,
+};
 
 /// SHA-256 block compression: takes 8 u32 state words and 16 u32 message words, returns the
 /// new 8 u32 state. Wraps `sha2::compress256` (message words are big-endian per the SHA-256 spec).
@@ -98,11 +102,10 @@ fn run_finalize_sha256(number_of_blocks: usize) -> ExecutionResources {
 fn test_finalize_sha256() {
     // Sha256 batching resources has a factor that is linear in the number of rounds, and a constant
     // factor. Sample the execution at two points to compute both factors.
-    let blocks_in_round = 7_usize;
     let number_of_blocks_1 = 8_usize;
-    let number_of_rounds_1 = (number_of_blocks_1 - 1) / blocks_in_round + 1;
-    let number_of_blocks_2 = number_of_blocks_1 + blocks_in_round;
-    let number_of_rounds_2 = (number_of_blocks_2 - 1) / blocks_in_round + 1;
+    let number_of_rounds_1 = (number_of_blocks_1 - 1) / SHA256_BATCH_SIZE + 1;
+    let number_of_blocks_2 = number_of_blocks_1 + SHA256_BATCH_SIZE;
+    let number_of_rounds_2 = (number_of_blocks_2 - 1) / SHA256_BATCH_SIZE + 1;
     let resources_1 = run_finalize_sha256(number_of_blocks_1);
     let resources_2 = run_finalize_sha256(number_of_blocks_2);
 
diff --git a/crates/starknet_os/src/test_utils.rs b/crates/starknet_os/src/test_utils.rs
@@ -19,21 +19,25 @@ pub mod validations;
 mod resource_utils_test;
 
 // Resources consumed by the SHA-256 batch phase, separated into linear and constant factors.
-pub static SHA256_BATCH_RESOURCES_LINEAR: LazyLock<ExecutionResources> =
+pub const SHA256_BATCH_SIZE: usize = 7;
+pub static SHA256_BATCH_RESOURCES_LINEAR_UNSCALED: LazyLock<ExecutionResources> =
     LazyLock::new(|| ExecutionResources {
         n_steps: 11822,
         n_memory_holes: 0,
         builtin_instance_counter: BTreeMap::from([
-            (
-                BuiltinName::bitwise,
-                7800 / BUILTIN_INSTANCE_SIZES.get(&BuiltinName::bitwise).unwrap(),
-            ),
-            (
-                BuiltinName::range_check,
-                448 / BUILTIN_INSTANCE_SIZES.get(&BuiltinName::range_check).unwrap(),
-            ),
+            (BuiltinName::bitwise, 7800),
+            (BuiltinName::range_check, 448),
         ]),
     });
+pub static SHA256_BATCH_RESOURCES_LINEAR: LazyLock<ExecutionResources> = LazyLock::new(|| {
+    let mut resources = SHA256_BATCH_RESOURCES_LINEAR_UNSCALED.clone();
+    resources.builtin_instance_counter = resources
+        .builtin_instance_counter
+        .iter()
+        .map(|(builtin, count)| (*builtin, count / BUILTIN_INSTANCE_SIZES.get(builtin).unwrap()))
+        .collect();
+    resources
+});
 pub static SHA256_BATCH_RESOURCES_CONSTANT: LazyLock<ExecutionResources> =
     LazyLock::new(|| ExecutionResources {
         n_steps: 49,
diff --git a/crates/starknet_os_flow_tests/src/os_resources_test.rs b/crates/starknet_os_flow_tests/src/os_resources_test.rs
@@ -26,6 +26,7 @@ use starknet_api::transaction::fields::ContractAddressSalt;
 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_os::test_utils::{SHA256_BATCH_RESOURCES_LINEAR_UNSCALED, SHA256_BATCH_SIZE};
 use starknet_types_core::felt::Felt;
 use strum::IntoEnumIterator;
 
@@ -46,7 +47,7 @@ use crate::test_manager::{
 use crate::tests::NON_TRIVIAL_RESOURCE_BOUNDS;
 
 // TODO(Dori): Delete this, or at least reduce it to a minimal set of unmeasurable syscalls.
-const UNMEASURABLE_SYSCALLS: [Selector; 26] = [
+const UNMEASURABLE_SYSCALLS: [Selector; 25] = [
     Selector::DelegateCall,
     Selector::DelegateL1Handler,
     Selector::GetBlockNumber,
@@ -56,7 +57,6 @@ const UNMEASURABLE_SYSCALLS: [Selector; 26] = [
     Selector::GetSequencerAddress,
     Selector::GetTxInfo,
     Selector::GetTxSignature,
-    Selector::Sha256ProcessBlock,
     Selector::Sha512ProcessBlock,
     Selector::LibraryCallL1Handler,
     Selector::ReplaceClass,
@@ -97,6 +97,11 @@ static SYSCALLS_WITH_LINEAR_FACTOR: LazyLock<HashMap<Selector, usize>> = LazyLoc
 });
 const LARGE_INPUT_LENGTH: usize = 100;
 
+/// Syscalls that are implemented using virtual builtins. Such syscalls have their "heavy lifting"
+/// executed after the execute_syscalls part of the OS, so the consumed resources are not captured
+/// by the OsLogger.
+const SYSCALLS_WITH_VIRTUAL_BUILTINS: [Selector; 1] = [Selector::Sha256ProcessBlock];
+
 /// 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] = [
@@ -112,6 +117,20 @@ const FEE_TRANSFER_SYSCALLS: [Selector; 10] = [
     Selector::EmitEvent,
 ];
 
+/// See [SYSCALLS_WITH_VIRTUAL_BUILTINS] for why this function is needed.
+fn update_resources_for_virtual_builtin_syscall(
+    selector: Selector,
+    measured_base: ExecutionResources,
+) -> ExecutionResources {
+    assert!(SYSCALLS_WITH_VIRTUAL_BUILTINS.contains(&selector));
+    match selector {
+        Selector::Sha256ProcessBlock => (&measured_base
+            + &SHA256_BATCH_RESOURCES_LINEAR_UNSCALED.div_ceil(SHA256_BATCH_SIZE))
+            .filter_unused_builtins(),
+        _ => panic!("Resource update not implemented for virtual builtin syscall: {selector:?}."),
+    }
+}
+
 /// Regression test for the list of syscalls called during the fee transfer phase of a transaction.
 #[tokio::test]
 async fn test_fee_transfer_syscalls() {
@@ -339,9 +358,14 @@ async fn test_os_resources_regression() {
 
         // If this syscall incurs an inner call, it should be the next inner call in the
         // iterator.
-        let resources =
+        let mut resources =
             maybe_deduct_inner(syscall_trace.get_resources().unwrap().clone(), selector);
 
+        // Virtual builtins require adjustment.
+        if SYSCALLS_WITH_VIRTUAL_BUILTINS.contains(&selector) {
+            resources = update_resources_for_virtual_builtin_syscall(selector, resources);
+        }
+
         // If this is a syscall with a linear factor, the next syscall should be an invocation of
         // the same syscall with +1 linear element.
         if let Some(linear_count_in_base) = SYSCALLS_WITH_LINEAR_FACTOR.get(&selector) {

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`		`- "os": "0x30d60f71b7401f270197f0d50658849403bc9d786c2f7b38535cf7f9a389f66",`
`3`		`- "virtual_os": "0x552611434744d19772e04249521f0a3d00d85906c9a600082aaa9339788f8d5",`
	`2`	`+ "os": "0x3b23e69c999017f0a08ca8080de329bf80922aaa8bd364f1bf3b5445b38f989",`
	`3`	`+ "virtual_os": "0x4373ade67a35a6ae0466730e5807b828a5db813010d6070bb1db85f99682dcb",`
`4`	`4`	`"aggregator": "0x700786d51b3854af43d8e12180380bda3029be6c1767e007858de6ca2edac40",`
`5`	`5`	`"aggregator_with_prefix": "0xe08d300e3f5996e43d6d7cc5a20068e0e58cf1309089f2348317ac580f6c1f"`
`6`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ fn test_sha256(runnable_version: RunnableCairo1) {`
`37`	`37`	`l2_to_l1_messages: [],`
`38`	`38`	`cairo_native: false,`
`39`	`39`	`failed: false,`
`40`		`- gas_consumed: 851745,`
	`40`	`+ gas_consumed: 850445,`
`41`	`41`	`}`
`42`	`42`	`"#]]`
`43`	`43`	`.assert_debug_eq(&execution);`