blockifier: change input to felt_size_counts: fn encode_blake (#8686)

Author: avivg-starkware

crates/blockifier/src/execution/contract_class.rs

@@ -572,7 +572,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.large, felt_size_groups.small)
+    encode_and_blake_hash_resources(felt_size_groups)
 }
 
 /// Cost to hash a multi-segment contract:
@@ -596,7 +596,8 @@ 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(segs.len(), segs.len());
+    resources +=
+        &encode_and_blake_hash_resources(&FeltSizeCount { large: segs.len(), small: segs.len() });
 
     resources
 }

crates/blockifier/src/execution/execution_utils.rs

@@ -26,7 +26,7 @@ use crate::blockifier_versioned_constants::VersionedConstants;
 use crate::bouncer::vm_resources_to_sierra_gas;
 use crate::execution::call_info::{CallExecution, CallInfo, Retdata};
 use crate::execution::casm_hash_estimation::EstimatedExecutionResources;
-use crate::execution::contract_class::{RunnableCompiledClass, TrackedResource};
+use crate::execution::contract_class::{FeltSizeCount, RunnableCompiledClass, TrackedResource};
 use crate::execution::entry_point::{
     execute_constructor_entry_point,
     ConstructorContext,
@@ -473,27 +473,24 @@ fn count_blake_opcode(n_big_felts: usize, n_small_felts: usize) -> usize {
 /// - `usize`: number of Blake opcodes used, accounted for separately as those are not reported via
 ///   `ExecutionResources`.
 pub fn encode_and_blake_hash_resources(
-    // TODO(AvivG): Refactor to use `FeltSizeCount`.
-    n_big_felts: usize,
-    n_small_felts: usize,
+    felt_size_groups: &FeltSizeCount,
 ) -> EstimatedExecutionResources {
-    let n_steps = compute_blake_hash_steps(n_big_felts, n_small_felts);
-    let n_felts = n_big_felts + n_small_felts;
-    let builtin_instance_counter = match n_felts {
+    let n_steps = compute_blake_hash_steps(felt_size_groups.large, felt_size_groups.small);
+    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,
-            n_felts + blake_estimation::BASE_RANGE_CHECK_NON_EMPTY,
+            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: count_blake_opcode(n_big_felts, n_small_felts),
+        blake_count: count_blake_opcode(felt_size_groups.large, felt_size_groups.small),
     }
 }
 

crates/blockifier/src/execution/execution_utils_test.rs

@@ -3,6 +3,7 @@ use cairo_vm::vm::runners::cairo_runner::ExecutionResources;
 use pretty_assertions::assert_eq;
 use starknet_types_core::felt::Felt;
 
+use crate::execution::contract_class::FeltSizeCount;
 use crate::execution::execution_utils::blake_encoding::{N_U32S_BIG_FELT, N_U32S_SMALL_FELT};
 use crate::execution::execution_utils::blake_estimation::STEPS_EMPTY_INPUT;
 use crate::execution::execution_utils::{
@@ -38,7 +39,7 @@ 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(0, 0);
+    let resources = encode_and_blake_hash_resources(&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/starknet_os/src/hints/hint_implementation/blake2s/blake2s_test.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 
 use blake2s::encode_felt252_data_and_calc_blake_hash;
+use blockifier::execution::contract_class::FeltSizeCount;
 use blockifier::execution::execution_utils::encode_and_blake_hash_resources;
 use cairo_vm::types::builtin_name::BuiltinName;
 use cairo_vm::types::layout_name::LayoutName;
@@ -19,19 +20,27 @@ use crate::test_utils::cairo_runner::{
 };
 
 /// Counts the number of small and big felts in the data.
-fn data_to_felt_count(data: &[Felt]) -> (usize, usize) {
+// TODO(AvivG): use From<&[Felt]> for FeltSizeCount.
+fn data_to_felt_count(data: &[Felt]) -> FeltSizeCount {
     // TODO(AvivG): Use `Blake2Felt252::SMALL_THRESHOLD` when exposed.
     const SMALL_THRESHOLD: Felt = Felt::from_hex_unchecked("8000000000000000"); // 2^63
 
-    data.iter().fold((0, 0), |(small, big), felt| {
-        if *felt >= SMALL_THRESHOLD { (small, big + 1) } else { (small + 1, big) }
+    let felt_size_groups = FeltSizeCount::default();
+
+    data.iter().fold(felt_size_groups, |mut felt_size_groups, felt| {
+        if *felt >= SMALL_THRESHOLD {
+            felt_size_groups.large += 1;
+        } else {
+            felt_size_groups.small += 1;
+        }
+        felt_size_groups
     })
 }
 
 /// Return the estimated execution resources for Blake2s hashing.
 fn estimated_encode_and_blake_hash_execution_resources(data: &[Felt]) -> ExecutionResources {
-    let (n_small_felts, n_big_felts) = data_to_felt_count(data);
-    let estimated = encode_and_blake_hash_resources(n_big_felts, n_small_felts);
+    let felt_size_groups = data_to_felt_count(data);
+    let estimated = encode_and_blake_hash_resources(&felt_size_groups);
 
     let mut resources = estimated.resources().clone();
     resources.n_steps -= 1;