blockifier: encode_and_blake into trait

Author: avivg-starkware

crates/blockifier/src/execution/casm_hash_estimation.rs

@@ -149,7 +149,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;
 
@@ -190,19 +190,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 = 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,
+            )]),
+        };
+
+        let resources = ExecutionResources { n_steps, n_memory_holes: 0, builtin_instance_counter };
+
+        EstimatedExecutionResources::V2Hash {
+            resources,
+            blake_count: felt_size_groups.blake_opcode_count(),
+        }
     }
 }
 
@@ -267,38 +292,6 @@ fn estimate_steps_of_encode_felt252_data_and_calc_blake_hash(
     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 = 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,
-        )]),
-    };
-
-    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

@@ -9,8 +9,9 @@ use starknet_types_core::felt::Felt;
 
 use crate::execution::casm_hash_estimation::blake_estimation::STEPS_EMPTY_INPUT;
 use crate::execution::casm_hash_estimation::{
-    encode_and_blake_hash_resources,
     estimate_steps_of_encode_felt252_data_and_calc_blake_hash,
+    CasmV2HashResourceEstimate,
+    EstimateCasmHashResources,
     EstimatedExecutionResources,
 };
 use crate::execution::contract_class::FeltSizeCount;
@@ -133,7 +134,8 @@ 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::default());
+    let resources =
+        CasmV2HashResourceEstimate::estimated_resources_of_hash_function(&FeltSizeCount::default());
     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

@@ -43,10 +43,11 @@ use crate::abi::constants::{self};
 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::EstimatedExecutionResources;
 use crate::execution::casm_hash_estimation::{
     blake_execution_resources_estimation_to_gas,
-    encode_and_blake_hash_resources,
+    CasmV2HashResourceEstimate,
+    EstimateCasmHashResources,
+    EstimatedExecutionResources,
 };
 use crate::execution::entry_point::{EntryPointExecutionContext, EntryPointTypeAndSelector};
 use crate::execution::errors::PreExecutionError;
@@ -591,8 +592,7 @@ pub fn estimate_casm_poseidon_hash_computation_resources(
 
 /// Cost to hash a single flat segment of `len` felts.
 fn leaf_cost(felt_size_groups: &FeltSizeCount) -> EstimatedExecutionResources {
-    // All `len` inputs treated as “big” felts; no small-felt optimization here.
-    encode_and_blake_hash_resources(felt_size_groups)
+    CasmV2HashResourceEstimate::estimated_resources_of_hash_function(felt_size_groups)
 }
 
 /// Cost to hash a multi-segment contract:
@@ -617,7 +617,10 @@ fn node_cost(segs: &[NestedFeltCounts]) -> EstimatedExecutionResources {
     // Node‐level hash over (hash1, len1, hash2, len2, …): one segment hash (“big” felt))
     // and one segment length (“small” felt) per segment.
     resources +=
-        &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(),
+        });
 
     resources
 }

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;
@@ -40,7 +43,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;