Use bytes from unrecorded_blocks rather from the block from DA

crates/fuel-gas-price-algorithm/src/v0.rs

@@ -66,12 +66,6 @@ pub struct AlgorithmUpdaterV0 {
     pub l2_block_fullness_threshold_percent: u64,
 }
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq)]
-pub struct BlockBytes {
-    pub height: u32,
-    pub block_bytes: u64,
-}
-
 impl AlgorithmUpdaterV0 {
     pub fn new(
         new_exec_price: u64,

crates/fuel-gas-price-algorithm/src/v1.rs

@@ -1,11 +1,14 @@
+use crate::utils::cumulative_percentage_change;
 use std::{
     cmp::max,
+    collections::HashMap,
     num::NonZeroU64,
-    ops::Div,
+    ops::{
+        Div,
+        Range,
+    },
 };
 
-use crate::utils::cumulative_percentage_change;
-
 #[cfg(test)]
 mod tests;
 
@@ -16,9 +19,11 @@ pub enum Error {
     #[error("Skipped DA block update: expected {expected:?}, got {got:?}")]
     SkippedDABlock { expected: u32, got: u32 },
     #[error("Could not calculate cost per byte: {bytes:?} bytes, {cost:?} cost")]
-    CouldNotCalculateCostPerByte { bytes: u64, cost: u64 },
+    CouldNotCalculateCostPerByte { bytes: u128, cost: u128 },
     #[error("Failed to include L2 block data: {0}")]
     FailedTooIncludeL2BlockData(String),
+    #[error("L2 block expected but not found in unrecorded blocks: {0}")]
+    L2BlockExpectedNotFound(u32),
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -94,6 +99,8 @@ impl AlgorithmV1 {
 /// The DA portion also uses a moving average of the profits over the last `avg_window` blocks
 /// instead of the actual profit. Setting the `avg_window` to 1 will effectively disable the
 /// moving average.
+type Height = u32;
+type Bytes = u64;
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq)]
 pub struct AlgorithmUpdaterV1 {
     // Execution
@@ -144,8 +151,9 @@ pub struct AlgorithmUpdaterV1 {
     pub second_to_last_profit: i128,
     /// The latest known cost per byte for recording blocks on the DA chain
     pub latest_da_cost_per_byte: u128,
+
     /// The unrecorded blocks that are used to calculate the projected cost of recording blocks
-    pub unrecorded_blocks: Vec<BlockBytes>,
+    pub unrecorded_blocks: HashMap<Height, Bytes>,
 }
 
 /// A value that represents a value between 0 and 100. Higher values are clamped to 100
@@ -176,29 +184,17 @@ impl core::ops::Deref for ClampedPercentage {
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct RecordedBlock {
-    pub height: u32,
-    pub block_bytes: u64,
-    pub block_cost: u64,
-}
-
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq)]
-pub struct BlockBytes {
-    pub height: u32,
-    pub block_bytes: u64,
-}
-
 impl AlgorithmUpdaterV1 {
     pub fn update_da_record_data(
         &mut self,
-        blocks: &[RecordedBlock],
+        height_range: Range<u32>,
+        range_cost: u128,
     ) -> Result<(), Error> {
-        for block in blocks {
-            self.da_block_update(block.height, block.block_bytes, block.block_cost)?;
+        if height_range.len() != 0 {
+            self.da_block_update(height_range, range_cost)?;
+            self.recalculate_projected_cost();
+            self.normalize_rewards_and_costs();
         }
-        self.recalculate_projected_cost();
-        self.normalize_rewards_and_costs();
         Ok(())
     }
 
@@ -234,10 +230,7 @@ impl AlgorithmUpdaterV1 {
             self.update_da_gas_price();
 
             // metadata
-            self.unrecorded_blocks.push(BlockBytes {
-                height,
-                block_bytes,
-            });
+            self.unrecorded_blocks.insert(height, block_bytes);
             Ok(())
         }
     }
@@ -374,43 +367,57 @@ impl AlgorithmUpdaterV1 {
 
     fn da_block_update(
         &mut self,
-        height: u32,
-        block_bytes: u64,
-        block_cost: u64,
+        height_range: Range<u32>,
+        range_cost: u128,
     ) -> Result<(), Error> {
         let expected = self.da_recorded_block_height.saturating_add(1);
-        if height != expected {
+        let first = height_range.start;
+        if first != expected {
             Err(Error::SkippedDABlock {
-                expected: self.da_recorded_block_height.saturating_add(1),
-                got: height,
+                expected,
+                got: first,
             })
         } else {
-            let new_cost_per_byte: u128 = (block_cost as u128)
-                .checked_div(block_bytes as u128)
-                .ok_or(Error::CouldNotCalculateCostPerByte {
-                    bytes: block_bytes,
-                    cost: block_cost,
-                })?;
-            self.da_recorded_block_height = height;
+            let last = height_range.end - 1;
+            let range_bytes = self.drain_l2_block_bytes_for_range(height_range)?;
+            let new_cost_per_byte: u128 = range_cost.checked_div(range_bytes).ok_or(
+                Error::CouldNotCalculateCostPerByte {
+                    bytes: range_bytes,
+                    cost: range_cost,
+                },
+            )?;
+            self.da_recorded_block_height = last;
             let new_block_cost = self
                 .latest_known_total_da_cost_excess
-                .saturating_add(block_cost as u128);
+                .saturating_add(range_cost);
             self.latest_known_total_da_cost_excess = new_block_cost;
             self.latest_da_cost_per_byte = new_cost_per_byte;
             Ok(())
         }
     }
 
+    fn drain_l2_block_bytes_for_range(
+        &mut self,
+        height_range: Range<u32>,
+    ) -> Result<u128, Error> {
+        let mut total: u128 = 0;
+        for height in height_range {
+            let bytes = self
+                .unrecorded_blocks
+                .remove(&height)
+                .ok_or(Error::L2BlockExpectedNotFound(height))?;
+            total = total.saturating_add(bytes as u128);
+        }
+        Ok(total)
+    }
+
     fn recalculate_projected_cost(&mut self) {
-        // remove all blocks that have been recorded
-        self.unrecorded_blocks
-            .retain(|block| block.height > self.da_recorded_block_height);
         // add the cost of the remaining blocks
         let projection_portion: u128 = self
             .unrecorded_blocks
             .iter()
-            .map(|block| {
-                (block.block_bytes as u128).saturating_mul(self.latest_da_cost_per_byte)
+            .map(|(_, &bytes)| {
+                (bytes as u128).saturating_mul(self.latest_da_cost_per_byte)
             })
             .sum();
         self.projected_total_da_cost = self

crates/fuel-gas-price-algorithm/src/v1/tests.rs

@@ -2,10 +2,7 @@
 #![allow(clippy::arithmetic_side_effects)]
 #![allow(clippy::cast_possible_truncation)]
 
-use crate::v1::{
-    AlgorithmUpdaterV1,
-    BlockBytes,
-};
+use crate::v1::AlgorithmUpdaterV1;
 
 #[cfg(test)]
 mod algorithm_v1_tests;
@@ -14,6 +11,12 @@ mod update_da_record_data_tests;
 #[cfg(test)]
 mod update_l2_block_data_tests;
 
+#[derive(Debug, Clone)]
+pub struct BlockBytes {
+    pub height: u32,
+    pub block_bytes: u64,
+}
+
 pub struct UpdaterBuilder {
     min_exec_gas_price: u64,
     min_da_gas_price: u64,
@@ -175,7 +178,11 @@ impl UpdaterBuilder {
             latest_da_cost_per_byte: self.da_cost_per_byte,
             projected_total_da_cost: self.project_total_cost,
             latest_known_total_da_cost_excess: self.latest_known_total_cost,
-            unrecorded_blocks: self.unrecorded_blocks,
+            unrecorded_blocks: self
+                .unrecorded_blocks
+                .iter()
+                .map(|b| (b.height, b.block_bytes))
+                .collect(),
             last_profit: self.last_profit,
             second_to_last_profit: self.second_to_last_profit,
             min_da_gas_price: self.min_da_gas_price,