Use bytes from unrecorded_blocks rather from the block from DA

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

@@ -1,11 +1,11 @@
+use crate::utils::cumulative_percentage_change;
 use std::{
     cmp::max,
+    collections::HashMap,
     num::NonZeroU64,
     ops::Div,
 };
 
-use crate::utils::cumulative_percentage_change;
-
 #[cfg(test)]
 mod tests;
 
@@ -19,6 +19,8 @@ pub enum Error {
     CouldNotCalculateCostPerByte { bytes: u64, cost: u64 },
     #[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 +96,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 +148,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
@@ -179,23 +184,17 @@ impl core::ops::Deref for ClampedPercentage {
 #[derive(Debug, Clone)]
 pub struct RecordedBlock {
     pub height: u32,
-    pub block_bytes: u64,
+    // 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],
     ) -> Result<(), Error> {
         for block in blocks {
-            self.da_block_update(block.height, block.block_bytes, block.block_cost)?;
+            self.da_block_update(block.height, block.block_cost)?;
         }
         self.recalculate_projected_cost();
         self.normalize_rewards_and_costs();
@@ -234,10 +233,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(())
         }
     }
@@ -372,19 +368,18 @@ impl AlgorithmUpdaterV1 {
             .saturating_div(100)
     }
 
-    fn da_block_update(
-        &mut self,
-        height: u32,
-        block_bytes: u64,
-        block_cost: u64,
-    ) -> Result<(), Error> {
+    fn da_block_update(&mut self, height: u32, block_cost: u64) -> Result<(), Error> {
         let expected = self.da_recorded_block_height.saturating_add(1);
         if height != expected {
             Err(Error::SkippedDABlock {
                 expected: self.da_recorded_block_height.saturating_add(1),
                 got: height,
             })
         } else {
+            let block_bytes = self
+                .unrecorded_blocks
+                .remove(&height)
+                .ok_or(Error::L2BlockExpectedNotFound(height))?;
             let new_cost_per_byte: u128 = (block_cost as u128)
                 .checked_div(block_bytes as u128)
                 .ok_or(Error::CouldNotCalculateCostPerByte {
@@ -402,15 +397,12 @@ impl AlgorithmUpdaterV1 {
     }
 
     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,