blockifier: encode_and_blake into trait

Author: avivg-starkware

crates/blockifier/src/execution/casm_hash_estimation.rs

@@ -14,7 +14,7 @@ use crate::execution::contract_class::{
     FeltSizeCount,
     NestedFeltCounts,
 };
-use crate::execution::execution_utils::{encode_and_blake_hash_resources, poseidon_hash_many_cost};
+use crate::execution::execution_utils::poseidon_hash_many_cost;
 use crate::utils::u64_from_usize;
 
 #[cfg(test)]
@@ -148,7 +148,7 @@ 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 trait EstimateCasmHashResources {
     /// Specifies the hash function variant that the estimate is for.
     fn hash_version(&self) -> HashVersion;
 
@@ -191,17 +191,44 @@ impl EstimateCasmHashResources for CasmV1HashResourceEstimate {
 
 // TODO(AvivG): Remove allow once used.
 #[allow(unused)]
-struct CasmV2HashResourceEstimate {}
+pub 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(
         felt_size_groups: &FeltSizeCount,
     ) -> EstimatedExecutionResources {
-        encode_and_blake_hash_resources(felt_size_groups)
+        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(),
+        }
     }
 }
 
@@ -264,38 +291,6 @@ fn compute_blake_hash_steps(felt_size_groups: &FeltSizeCount) -> usize {
     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

crates/blockifier/src/execution/casm_hash_estimation_test.rs

@@ -10,7 +10,8 @@ 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;
@@ -130,7 +131,11 @@ fn test_zero_inputs() {
     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 resources =
+        CasmV2HashResourceEstimate::estimated_resources_of_hash_function(&FeltSizeCount {
+            large: 0,
+            small: 0,
+        });
     let expected = ExecutionResources { n_steps: 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

@@ -44,7 +44,8 @@ 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 +593,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.
+    // 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(
-        encode_and_blake_hash_resources(felt_size_groups),
+        CasmV2HashResourceEstimate::estimated_resources_of_hash_function(felt_size_groups),
         versioned_constants,
         blake_opcode_gas,
     )
@@ -630,10 +632,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.
+    // 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(
-        encode_and_blake_hash_resources(&FeltSizeCount { large: segs.len(), small: segs.len() }),
+        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;