blockifier: move logic inside casm_v2hash_resource_estimate

Author: avivg-starkware

crates/blockifier/src/execution/casm_hash_estimation.rs

@@ -148,15 +148,14 @@ impl From<(ExecutionResources, HashVersion)> for EstimatedExecutionResources {
 /// This provides resource estimates rather than exact values.
 // TODO(AvivG): Remove allow once used.
 #[allow(unused)]
-trait EstimateCasmHashResources {
+pub(crate) trait EstimateCasmHashResources {
     /// Specifies the hash function variant that the estimate is for.
     fn hash_version(&self) -> HashVersion;
 
     /// Estimates the Cairo execution resources used when applying the hash function during CASM
     /// hashing.
     fn estimated_resources_of_hash_function(
-        &mut self,
-        _felt_count: FeltSizeCount,
+        _felt_size_groups: &FeltSizeCount,
     ) -> EstimatedExecutionResources;
 
     /// Estimates the Cairo execution resources for `compiled_class_hash` in the
@@ -173,158 +172,142 @@ trait EstimateCasmHashResources {
 
 // TODO(AvivG): Remove allow once used.
 #[allow(unused)]
-struct CasmV1HashResourceEstimate {}
+pub(crate) struct CasmV1HashResourceEstimate {}
 
 impl EstimateCasmHashResources for CasmV1HashResourceEstimate {
     fn hash_version(&self) -> HashVersion {
         HashVersion::V1
     }
 
     fn estimated_resources_of_hash_function(
-        &mut self,
-        felt_count: FeltSizeCount,
+        felt_size_groups: &FeltSizeCount,
     ) -> EstimatedExecutionResources {
         EstimatedExecutionResources::V1Hash {
             // TODO(AvivG): Consider inlining `poseidon_hash_many_cost` logic here.
-            resources: poseidon_hash_many_cost(felt_count.n_felts()),
+            resources: poseidon_hash_many_cost(felt_size_groups.n_felts()),
         }
     }
 }
 
 // TODO(AvivG): Remove allow once used.
 #[allow(unused)]
-struct CasmV2HashResourceEstimate {}
+pub(crate) struct CasmV2HashResourceEstimate {}
 
 impl EstimateCasmHashResources for CasmV2HashResourceEstimate {
     fn hash_version(&self) -> HashVersion {
         HashVersion::V2
     }
 
+    /// Estimates resource usage for `encode_felt252_data_and_calc_blake_hash` in the Starknet OS.
+    ///
+    /// # Encoding Details
+    /// - Small felts → 2 `u32`s each; Big felts → 8 `u32`s each.
+    /// - Each felt requires one `range_check` operation.
+    ///
+    /// # Returns:
+    /// - `ExecutionResources`: VM resource usage (e.g., n_steps, range checks).
+    /// - `usize`: number of Blake opcodes used, accounted for separately as those are not reported
+    ///   via `ExecutionResources`.
     fn estimated_resources_of_hash_function(
-        &mut self,
-        _felt_count: FeltSizeCount,
+        felt_size_groups: &FeltSizeCount,
     ) -> EstimatedExecutionResources {
-        // TODO(AvivG): Use `cost_of_encode_felt252_data_and_calc_blake_hash` once it returns ER.
-        EstimatedExecutionResources::new(HashVersion::V2)
+        let n_steps =
+            Self::estimate_steps_of_encode_felt252_data_and_calc_blake_hash(felt_size_groups);
+        let builtin_instance_counter = match felt_size_groups.n_felts() {
+            // The empty case does not use builtins at all.
+            0 => HashMap::new(),
+            // One `range_check` per input felt to validate its size + Overhead for the non empty
+            // case.
+            _ => HashMap::from([(
+                BuiltinName::range_check,
+                felt_size_groups.n_felts() + Self::BASE_RANGE_CHECK_NON_EMPTY,
+            )]),
+        };
+
+        let resources = ExecutionResources { n_steps, n_memory_holes: 0, builtin_instance_counter };
+
+        EstimatedExecutionResources::V2Hash {
+            resources,
+            blake_count: felt_size_groups.blake_opcode_count(),
+        }
     }
 }
 
-// Constants used for estimating the cost of BLAKE hashing inside Starknet OS.
-// These values are based on empirical measurement by running
-// `encode_felt252_data_and_calc_blake_hash` on various combinations of big and small felts.
-mod blake_estimation {
-    // Per-felt step cost (measured).
-    pub const STEPS_BIG_FELT: usize = 45;
-    pub const STEPS_SMALL_FELT: usize = 15;
+impl CasmV2HashResourceEstimate {
+    // Constants used for estimating the VM execution resources of BLAKE hashing in the Starknet OS.
+    // Values were obtained empirically by running
+    // `encode_felt252_data_and_calc_blake_hash` on various combinations of large and small felts.
 
-    // One-time overhead.
-    // Overhead when input fills a full Blake message (16 u32s).
+    // Per-felt contribution.
+    pub const STEPS_PER_LARGE_FELT: usize = 45;
+    pub const STEPS_PER_SMALL_FELT: usize = 15;
+
+    // One-time overheads for `encode_felt252_data_and_calc_blake_hash` execution.
+    // Applied when the input fills an exact Blake message (16-u32).
     pub const BASE_STEPS_FULL_MSG: usize = 217;
-    // Overhead when input results in a partial message (remainder < 16 u32s).
+    // Applied when the input leaves a remainder (< 16 u32s).
     pub const BASE_STEPS_PARTIAL_MSG: usize = 195;
-    // Extra steps per 2-u32 remainder in partial messages.
+    // Extra steps added per 2-u32 remainder in partial messages.
     pub const STEPS_PER_2_U32_REMINDER: usize = 3;
-    // Overhead when input for `encode_felt252_data_and_calc_blake_hash` is non-empty.
+    // Additional `range_check` instances required when the input is non-empty.
     pub const BASE_RANGE_CHECK_NON_EMPTY: usize = 3;
-    // Empty input steps.
-    pub const STEPS_EMPTY_INPUT: usize = 170;
-}
 
-fn base_steps_for_blake_hash(n_u32s: usize) -> usize {
-    let rem_u32s = n_u32s % FeltSizeCount::U32_WORDS_PER_MESSAGE;
-    if rem_u32s == 0 {
-        blake_estimation::BASE_STEPS_FULL_MSG
-    } else {
-        // This computation is based on running blake2s with different inputs.
-        // Note: all inputs expand to an even number of u32s --> `rem_u32s` is always even.
-        blake_estimation::BASE_STEPS_PARTIAL_MSG
-            + (rem_u32s / 2) * blake_estimation::STEPS_PER_2_U32_REMINDER
-    }
-}
+    // Applied when the input is completely empty.
+    pub const STEPS_EMPTY_INPUT: usize = 170;
 
-fn felts_steps(n_big_felts: usize, n_small_felts: usize) -> usize {
-    let big_steps = n_big_felts
-        .checked_mul(blake_estimation::STEPS_BIG_FELT)
-        .expect("Overflow computing big felt steps");
-    let small_steps = n_small_felts
-        .checked_mul(blake_estimation::STEPS_SMALL_FELT)
-        .expect("Overflow computing small felt steps");
-    big_steps.checked_add(small_steps).expect("Overflow computing total felt steps")
-}
+    /// Estimates the total number of VM steps needed to hash the given felts with Blake in the
+    /// Starknet OS.
+    fn estimate_steps_of_encode_felt252_data_and_calc_blake_hash(
+        felt_size_groups: &FeltSizeCount,
+    ) -> usize {
+        let encoded_u32_len = felt_size_groups.encoded_u32_len();
+        if encoded_u32_len == 0 {
+            // The empty input case is a special case.
+            return Self::STEPS_EMPTY_INPUT;
+        }
 
-/// Estimates the number of VM steps needed to hash the given felts with Blake in Starknet OS.
-/// Each small felt unpacks into 2 u32s, and each big felt into 8 u32s.
-/// Adds a base cost depending on whether the total fits exactly into full 16-u32 messages.
-fn compute_blake_hash_steps(felt_size_groups: &FeltSizeCount) -> usize {
-    let total_u32s = felt_size_groups.encoded_u32_len();
-    if total_u32s == 0 {
-        // The empty input case is a special case.
-        return blake_estimation::STEPS_EMPTY_INPUT;
+        // Adds a base cost depending on whether the total fits exactly into full 16-u32 messages.
+        let base_steps = if encoded_u32_len % FeltSizeCount::U32_WORDS_PER_MESSAGE == 0 {
+            Self::BASE_STEPS_FULL_MSG
+        } else {
+            // This computation is based on running blake2s with different inputs.
+            // Note: all inputs expand to an even number of u32s --> `rem_u32s` is always even.
+            Self::BASE_STEPS_PARTIAL_MSG
+                + (encoded_u32_len % FeltSizeCount::U32_WORDS_PER_MESSAGE / 2)
+                    * Self::STEPS_PER_2_U32_REMINDER
+        };
+
+        base_steps
+            + felt_size_groups.large * Self::STEPS_PER_LARGE_FELT
+            + felt_size_groups.small * Self::STEPS_PER_SMALL_FELT
     }
 
-    let base_steps = base_steps_for_blake_hash(total_u32s);
-    let felt_steps = felts_steps(felt_size_groups.large, felt_size_groups.small);
-
-    base_steps.checked_add(felt_steps).expect("Overflow computing total Blake hash steps")
-}
-
-/// Estimates resource usage for `encode_felt252_data_and_calc_blake_hash` in the Starknet OS.
-///
-/// # Encoding Details
-/// - Small felts → 2 `u32`s each; Big felts → 8 `u32`s each.
-/// - Each felt requires one `range_check` operation.
-///
-/// # Returns:
-/// - `ExecutionResources`: VM resource usage (e.g., n_steps, range checks).
-/// - `usize`: number of Blake opcodes used, accounted for separately as those are not reported via
-///   `ExecutionResources`.
-pub fn encode_and_blake_hash_resources(
-    felt_size_groups: &FeltSizeCount,
-) -> EstimatedExecutionResources {
-    let n_steps = compute_blake_hash_steps(felt_size_groups);
-    let builtin_instance_counter = match felt_size_groups.n_felts() {
-        // The empty case does not use builtins at all.
-        0 => HashMap::new(),
-        // One `range_check` per input felt to validate its size + Overhead for the non empty case.
-        _ => HashMap::from([(
-            BuiltinName::range_check,
-            felt_size_groups.n_felts() + blake_estimation::BASE_RANGE_CHECK_NON_EMPTY,
-        )]),
-    };
-
-    let resources = ExecutionResources { n_steps, n_memory_holes: 0, builtin_instance_counter };
-
-    EstimatedExecutionResources::V2Hash {
-        resources,
-        blake_count: felt_size_groups.blake_opcode_count(),
+    /// Converts the execution resources and blake opcode count to L2 gas.
+    ///
+    /// Used for both Stwo ("proving_gas") and Stone ("sierra_gas") estimations, which differ in
+    /// builtin costs. This unified logic is valid because only the `range_check` builtin is used,
+    /// and its cost is identical across provers (see `bouncer.get_tx_weights`).
+    // TODO(AvivG): Move inside blake estimation struct.
+    pub(crate) fn blake_execution_resources_estimation_to_gas(
+        resources: EstimatedExecutionResources,
+        versioned_constants: &VersionedConstants,
+        blake_opcode_gas: usize,
+    ) -> GasAmount {
+        // TODO(AvivG): Remove this once gas computation is separated from resource estimation.
+        assert!(
+            resources
+                .resources()
+                .builtin_instance_counter
+                .keys()
+                .all(|&k| k == BuiltinName::range_check),
+            "Expected either empty builtins or only `range_check` builtin, got: {:?}. This breaks \
+             the assumption that builtin costs are identical between provers.",
+            resources.resources().builtin_instance_counter.keys().collect::<Vec<_>>()
+        );
+
+        resources.to_sierra_gas(
+            |resources| vm_resources_to_sierra_gas(resources, versioned_constants),
+            Some(blake_opcode_gas),
+        )
     }
 }
-
-/// Converts the execution resources and blake opcode count to L2 gas.
-///
-/// Used for both Stwo ("proving_gas") and Stone ("sierra_gas") estimations, which differ in
-/// builtin costs. This unified logic is valid because only the `range_check` builtin is used,
-/// and its cost is identical across provers (see `bouncer.get_tx_weights`).
-// TODO(AvivG): Move inside blake estimation struct.
-pub fn blake_execution_resources_estimation_to_gas(
-    resources: EstimatedExecutionResources,
-    versioned_constants: &VersionedConstants,
-    blake_opcode_gas: usize,
-) -> GasAmount {
-    // TODO(AvivG): Remove this once gas computation is separated from resource estimation.
-    assert!(
-        resources
-            .resources()
-            .builtin_instance_counter
-            .keys()
-            .all(|&k| k == BuiltinName::range_check),
-        "Expected either empty builtins or only `range_check` builtin, got: {:?}. This breaks the \
-         assumption that builtin costs are identical between provers.",
-        resources.resources().builtin_instance_counter.keys().collect::<Vec<_>>()
-    );
-
-    resources.to_sierra_gas(
-        |resources| vm_resources_to_sierra_gas(resources, versioned_constants),
-        Some(blake_opcode_gas),
-    )
-}

crates/blockifier/src/execution/casm_hash_estimation_test.rs

@@ -7,10 +7,9 @@ use pretty_assertions::assert_eq;
 use rstest::rstest;
 use starknet_types_core::felt::Felt;
 
-use crate::execution::casm_hash_estimation::blake_estimation::STEPS_EMPTY_INPUT;
 use crate::execution::casm_hash_estimation::{
-    compute_blake_hash_steps,
-    encode_and_blake_hash_resources,
+    CasmV2HashResourceEstimate,
+    EstimateCasmHashResources,
     EstimatedExecutionResources,
 };
 use crate::execution::contract_class::FeltSizeCount;
@@ -122,16 +121,30 @@ fn test_u32_constants() {
 #[test]
 fn test_zero_inputs() {
     // logic was written.
-    let steps = compute_blake_hash_steps(&FeltSizeCount { large: 0, small: 0 });
-    assert_eq!(steps, STEPS_EMPTY_INPUT, "Unexpected base step cost for zero inputs");
+    let steps =
+        CasmV2HashResourceEstimate::estimate_steps_of_encode_felt252_data_and_calc_blake_hash(
+            &FeltSizeCount { large: 0, small: 0 },
+        );
+    assert_eq!(
+        steps,
+        CasmV2HashResourceEstimate::STEPS_EMPTY_INPUT,
+        "Unexpected base step cost for zero inputs"
+    );
 
     // No opcodes should be emitted.
     let opcodes = FeltSizeCount { large: 0, small: 0 }.blake_opcode_count();
     assert_eq!(opcodes, 0, "Expected zero BLAKE opcodes for zero inputs");
 
     // Should result in base cost only (no opcode cost).
-    let resources = encode_and_blake_hash_resources(&FeltSizeCount { large: 0, small: 0 });
-    let expected = ExecutionResources { n_steps: STEPS_EMPTY_INPUT, ..Default::default() };
+    let resources =
+        CasmV2HashResourceEstimate::estimated_resources_of_hash_function(&FeltSizeCount {
+            large: 0,
+            small: 0,
+        });
+    let expected = ExecutionResources {
+        n_steps: CasmV2HashResourceEstimate::STEPS_EMPTY_INPUT,
+        ..Default::default()
+    };
     assert_eq!(resources.resources(), &expected, "Unexpected resources values for zero-input hash");
     assert_eq!(resources.blake_count(), 0, "Expected zero BLAKE opcodes for zero inputs");
 }

crates/blockifier/src/execution/contract_class.rs

@@ -43,8 +43,8 @@ use crate::blockifier_versioned_constants::VersionedConstants;
 use crate::bouncer::vm_resources_to_sierra_gas;
 use crate::execution::call_info::BuiltinCounterMap;
 use crate::execution::casm_hash_estimation::{
-    blake_execution_resources_estimation_to_gas,
-    encode_and_blake_hash_resources,
+    CasmV2HashResourceEstimate,
+    EstimateCasmHashResources,
 };
 use crate::execution::entry_point::{EntryPointExecutionContext, EntryPointTypeAndSelector};
 use crate::execution::errors::PreExecutionError;
@@ -592,10 +592,11 @@ fn leaf_cost(
     blake_opcode_gas: usize,
 ) -> GasAmount {
     // All `len` inputs treated as “big” felts; no small-felt optimization here.
-    // TODO(AvivG): Call `encode_and_blake_hash_resources` directly, and perform the resource→gas
-    // conversion only after `estimate_casm_blake_hash_computation_resources` executes.
-    blake_execution_resources_estimation_to_gas(
-        encode_and_blake_hash_resources(felt_size_groups),
+    // TODO(AvivG): Call `estimated_resources_of_hash_function` directly, and perform the
+    // resource→gas conversion only after `estimate_casm_blake_hash_computation_resources`
+    // executes.
+    CasmV2HashResourceEstimate::blake_execution_resources_estimation_to_gas(
+        CasmV2HashResourceEstimate::estimated_resources_of_hash_function(felt_size_groups),
         versioned_constants,
         blake_opcode_gas,
     )
@@ -630,10 +631,14 @@ fn node_cost(
 
     // Node‐level hash over (hash1, len1, hash2, len2, …): one segment hash (“big” felt))
     // and one segment length (“small” felt) per segment.
-    // TODO(AvivG): Call `encode_and_blake_hash_resources` directly, and perform the resource→gas
-    // conversion only after `estimate_casm_blake_hash_computation_resources` executes.
-    let node_hash_cost = blake_execution_resources_estimation_to_gas(
-        encode_and_blake_hash_resources(&FeltSizeCount { large: segs.len(), small: segs.len() }),
+    // TODO(AvivG): Call `estimated_resources_of_hash_function` directly, and perform the
+    // resource→gas conversion only after `estimate_casm_blake_hash_computation_resources`
+    // executes.
+    let node_hash_cost = CasmV2HashResourceEstimate::blake_execution_resources_estimation_to_gas(
+        CasmV2HashResourceEstimate::estimated_resources_of_hash_function(&FeltSizeCount {
+            large: segs.len(),
+            small: segs.len(),
+        }),
         versioned_constants,
         blake_opcode_gas,
     );

crates/starknet_os/src/hints/hint_implementation/blake2s/blake2s_test.rs

@@ -1,7 +1,10 @@
 use std::collections::HashMap;
 
 use blake2s::encode_felt252_data_and_calc_blake_hash;
-use blockifier::execution::casm_hash_estimation::encode_and_blake_hash_resources;
+use blockifier::execution::casm_hash_estimation::{
+    CasmV2HashResourceEstimate,
+    EstimateCasmHashResources,
+};
 use blockifier::execution::contract_class::FeltSizeCount;
 use cairo_vm::types::builtin_name::BuiltinName;
 use cairo_vm::types::layout_name::LayoutName;
@@ -39,7 +42,8 @@ fn data_to_felt_count(data: &[Felt]) -> FeltSizeCount {
 /// Return the estimated execution resources for Blake2s hashing.
 fn estimated_encode_and_blake_hash_execution_resources(data: &[Felt]) -> ExecutionResources {
     let felt_size_groups = data_to_felt_count(data);
-    let estimated = encode_and_blake_hash_resources(&felt_size_groups);
+    let estimated =
+        CasmV2HashResourceEstimate::estimated_resources_of_hash_function(&felt_size_groups);
 
     let mut resources = estimated.resources().clone();
     resources.n_steps -= 1;