blockifier: blake estimation use mutable resources

Author: avivg-starkware

crates/blockifier/src/execution/contract_class.rs

@@ -442,16 +442,21 @@ pub fn estimate_casm_poseidon_hash_computation_resources(
 }
 
 /// Cost to hash a single flat segment of `len` felts.
-fn leaf_cost(len: usize) -> (ExecutionResources, usize) {
+fn leaf_cost(len: usize, resources: &mut ExecutionResources, blake_opcodes: &mut usize) {
     // All `len` inputs treated as “big” felts; no small-felt optimization here.
-    cost_of_encode_felt252_data_and_calc_blake_hash(len, 0)
+    let (added_resources, added_blake_opcode_count) =
+        cost_of_encode_felt252_data_and_calc_blake_hash(len, 0);
+    *resources += &added_resources;
+    *blake_opcodes += added_blake_opcode_count;
 }
 
 /// Cost to hash a multi-segment contract:
-fn node_cost(segs: &[NestedIntList]) -> (ExecutionResources, usize) {
+fn node_cost(
+    segs: &[NestedIntList],
+    resources: &mut ExecutionResources,
+    blake_opcodes: &mut usize,
+) {
     // TODO(AvivG): Add base estimation for node.
-    let mut resources = ExecutionResources::default();
-    let mut blake_opcodes = 0;
 
     // TODO(AvivG): Add base estimation of each segment. Could this be part of 'leaf_cost'?
     let segment_overhead = ExecutionResources::default();
@@ -460,10 +465,8 @@ fn node_cost(segs: &[NestedIntList]) -> (ExecutionResources, usize) {
     for seg in segs {
         match seg {
             NestedIntList::Leaf(len) => {
-                let (leaf_resources, blake_opcode_count) = leaf_cost(*len);
-                resources += &leaf_resources;
-                resources += &segment_overhead;
-                blake_opcodes += blake_opcode_count;
+                leaf_cost(*len, resources, blake_opcodes);
+                *resources += &segment_overhead;
             }
             _ => panic!("Estimating hash cost only supports at most one level of segmentation."),
         }
@@ -473,10 +476,8 @@ fn node_cost(segs: &[NestedIntList]) -> (ExecutionResources, usize) {
     // and one segment length (“small” felt) per segment.
     let (node_hash_resources, node_blake_opcode_count) =
         cost_of_encode_felt252_data_and_calc_blake_hash(segs.len(), segs.len());
-    resources += &node_hash_resources;
-    blake_opcodes += node_blake_opcode_count;
-
-    (resources, blake_opcodes)
+    *resources += &node_hash_resources;
+    *blake_opcodes += node_blake_opcode_count;
 }
 
 /// Estimates the VM resources to compute the CASM Blake hash for a Cairo-1 contract.
@@ -530,15 +531,12 @@ pub fn estimate_casm_blake_hash_computation_resources_inner(
     let mut blake_opcodes = 0;
 
     // Add leaf vs node cost
-    let (bytecode_resources, bytecode_blake_opcode_count) = match bytecode_segment_lengths {
+    match bytecode_segment_lengths {
         // Single-segment contract (e.g., older Sierra contracts).
-        NestedIntList::Leaf(len) => leaf_cost(*len),
-        NestedIntList::Node(segs) => node_cost(segs),
+        NestedIntList::Leaf(len) => leaf_cost(*len, &mut resources, &mut blake_opcodes),
+        NestedIntList::Node(segs) => node_cost(segs, &mut resources, &mut blake_opcodes),
     };
 
-    resources += &bytecode_resources;
-    blake_opcodes += bytecode_blake_opcode_count;
-
     (resources, blake_opcodes)
 }