blockifier: move logic inside casm_v2hash_resource_estimate

Author: avivg-starkware

crates/blockifier/src/execution/casm_hash_estimation.rs

@@ -172,7 +172,7 @@ pub 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 {
@@ -211,15 +211,16 @@ impl EstimateCasmHashResources for CasmV2HashResourceEstimate {
     fn estimated_resources_of_hash_function(
         felt_size_groups: &FeltSizeCount,
     ) -> EstimatedExecutionResources {
-        let n_steps = compute_blake_hash_steps(felt_size_groups);
+        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() + blake_estimation::BASE_RANGE_CHECK_NON_EMPTY,
+                felt_size_groups.n_felts() + Self::BASE_RANGE_CHECK_NON_EMPTY,
             )]),
         };
 
@@ -232,90 +233,81 @@ impl EstimateCasmHashResources for CasmV2HashResourceEstimate {
     }
 }
 
-// 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.
+
+    // Applied when the input is completely empty.
     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
-    }
-}
+    /// 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;
+        }
 
-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")
-}
+        // 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
+        };
 
-/// 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;
+        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")
-}
-
-/// 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),
-    )
+    /// 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),
+        )
+    }
 }

crates/blockifier/src/execution/casm_hash_estimation_test.rs

@@ -7,9 +7,7 @@ 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,
     CasmV2HashResourceEstimate,
     EstimateCasmHashResources,
     EstimatedExecutionResources,
@@ -123,8 +121,15 @@ 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();
@@ -136,7 +141,10 @@ fn test_zero_inputs() {
             large: 0,
             small: 0,
         });
-    let expected = ExecutionResources { n_steps: STEPS_EMPTY_INPUT, ..Default::default() };
+    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,7 +43,6 @@ 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,
     CasmV2HashResourceEstimate,
     EstimateCasmHashResources,
 };
@@ -596,7 +595,7 @@ fn leaf_cost(
     // TODO(AvivG): Call `estimated_resources_of_hash_function` directly, and perform the
     // resource→gas conversion only after `estimate_casm_blake_hash_computation_resources`
     // executes.
-    blake_execution_resources_estimation_to_gas(
+    CasmV2HashResourceEstimate::blake_execution_resources_estimation_to_gas(
         CasmV2HashResourceEstimate::estimated_resources_of_hash_function(felt_size_groups),
         versioned_constants,
         blake_opcode_gas,
@@ -635,7 +634,7 @@ fn node_cost(
     // 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 = blake_execution_resources_estimation_to_gas(
+    let node_hash_cost = CasmV2HashResourceEstimate::blake_execution_resources_estimation_to_gas(
         CasmV2HashResourceEstimate::estimated_resources_of_hash_function(&FeltSizeCount {
             large: segs.len(),
             small: segs.len(),