Merge branch 'master' into 2210_prevent_overflow_in_abs

crates/fuel-gas-price-algorithm/gas-price-analysis/src/charts.rs

@@ -4,6 +4,8 @@ use std::{
     path::PathBuf,
 };
 
+const ONE_GWEI: u64 = 1_000_000_000;
+
 pub fn draw_chart(
     results: SimulationResults,
     p_comp: i64,
@@ -76,19 +78,24 @@ pub fn draw_gas_prices(
     da_gas_prices: &[u64],
     title: &str,
 ) -> anyhow::Result<()> {
+    let gas_prices_gwei: Vec<_> = gas_prices.into_iter().map(|x| x / ONE_GWEI).collect();
+    let _exec_gas_prices_gwei: Vec<_> =
+        _exec_gas_prices.into_iter().map(|x| x / ONE_GWEI).collect();
+    let da_gas_prices_gwei: Vec<_> =
+        da_gas_prices.into_iter().map(|x| x / ONE_GWEI).collect();
     // const GAS_PRICE_COLOR: RGBColor = BLACK;
     // const EXEC_GAS_PRICE_COLOR: RGBColor = RED;
     const DA_GAS_PRICE_COLOR: RGBColor = BLUE;
     let min = 0;
-    let max = *da_gas_prices.iter().max().unwrap();
+    let max = *da_gas_prices_gwei.iter().max().unwrap();
 
     let mut chart = ChartBuilder::on(drawing_area)
         .caption(title, ("sans-serif", 50).into_font())
         .margin(5)
         .x_label_area_size(40)
         .y_label_area_size(100)
         .right_y_label_area_size(100)
-        .build_cartesian_2d(0..gas_prices.len(), min..max)?;
+        .build_cartesian_2d(0..gas_prices_gwei.len(), min..max)?;
 
     chart
         .configure_mesh()
@@ -120,7 +127,7 @@ pub fn draw_gas_prices(
     // Draw the da gas prices
     chart
         .draw_series(LineSeries::new(
-            da_gas_prices.iter().enumerate().map(|(x, y)| (x, *y)),
+            da_gas_prices_gwei.iter().enumerate().map(|(x, y)| (x, *y)),
             DA_GAS_PRICE_COLOR,
         ))?
         .label("DA Gas Price")
@@ -189,10 +196,11 @@ pub fn draw_bytes_and_cost_per_block(
     const BYTES_PER_BLOCK_COLOR: RGBColor = BLACK;
     let (bytes, costs): (Vec<u64>, Vec<u64>) =
         bytes_and_costs_per_block.iter().cloned().unzip();
+    let costs_gwei: Vec<_> = costs.into_iter().map(|x| x / ONE_GWEI).collect();
 
     let min = 0;
     let max_left = *bytes.iter().max().unwrap();
-    let max_right = *costs.iter().max().unwrap();
+    let max_right = *costs_gwei.iter().max().unwrap();
 
     let mut chart = ChartBuilder::on(drawing_area)
         .caption(title, ("sans-serif", 50).into_font())
@@ -230,7 +238,7 @@ pub fn draw_bytes_and_cost_per_block(
 
     chart
         .draw_secondary_series(LineSeries::new(
-            costs.iter().enumerate().map(|(x, y)| (x, *y)),
+            costs_gwei.iter().enumerate().map(|(x, y)| (x, *y)),
             RED,
         ))
         .unwrap()
@@ -257,22 +265,35 @@ pub fn draw_profit(
     const ACTUAL_PROFIT_COLOR: RGBColor = BLACK;
     const PROJECTED_PROFIT_COLOR: RGBColor = RED;
     const PESSIMISTIC_BLOCK_COST_COLOR: RGBColor = BLUE;
+    let actual_profit_gwei: Vec<_> = actual_profit
+        .into_iter()
+        .map(|x| x / ONE_GWEI as i128)
+        .collect();
+    let projected_profit_gwei: Vec<_> = projected_profit
+        .into_iter()
+        .map(|x| x / ONE_GWEI as i128)
+        .collect();
+    let pessimistic_block_costs_gwei: Vec<_> = pessimistic_block_costs
+        .into_iter()
+        .map(|x| x / ONE_GWEI as u128)
+        .collect();
     let min = *std::cmp::min(
-        actual_profit
+        actual_profit_gwei
             .iter()
             .min()
             .ok_or(anyhow::anyhow!("Path has no parent"))?,
-        projected_profit
+        projected_profit_gwei
             .iter()
             .min()
             .ok_or(anyhow::anyhow!("Path has no parent"))?,
     );
+
     let max = *std::cmp::max(
-        actual_profit
+        actual_profit_gwei
             .iter()
             .max()
             .ok_or(anyhow::anyhow!("Path has no parent"))?,
-        projected_profit
+        projected_profit_gwei
             .iter()
             .max()
             .ok_or(anyhow::anyhow!("Path has no parent"))?,
@@ -284,27 +305,27 @@ pub fn draw_profit(
         .x_label_area_size(40)
         .y_label_area_size(100)
         .right_y_label_area_size(100)
-        .build_cartesian_2d(0..actual_profit.len(), min..max)
+        .build_cartesian_2d(0..actual_profit_gwei.len(), min..max)
         .unwrap()
         .set_secondary_coord(
-            0..actual_profit.len(),
-            0..*pessimistic_block_costs.iter().max().unwrap(),
+            0..actual_profit_gwei.len(),
+            0..*pessimistic_block_costs_gwei.iter().max().unwrap(),
         );
 
     chart
         .configure_mesh()
-        .y_desc("Profit")
+        .y_desc("Profit (Gwei)")
         .x_desc("Block")
         .draw()?;
 
     chart
         .configure_secondary_axes()
-        .y_desc("Pessimistic cost")
+        .y_desc("Pessimistic cost (Gwei)")
         .draw()?;
 
     chart
         .draw_series(LineSeries::new(
-            actual_profit.iter().enumerate().map(|(x, y)| (x, *y)),
+            actual_profit_gwei.iter().enumerate().map(|(x, y)| (x, *y)),
             ACTUAL_PROFIT_COLOR,
         ))?
         .label("Actual Profit")
@@ -314,7 +335,10 @@ pub fn draw_profit(
 
     chart
         .draw_series(LineSeries::new(
-            projected_profit.iter().enumerate().map(|(x, y)| (x, *y)),
+            projected_profit_gwei
+                .iter()
+                .enumerate()
+                .map(|(x, y)| (x, *y)),
             PROJECTED_PROFIT_COLOR,
         ))?
         .label("Projected Profit")
@@ -325,7 +349,7 @@ pub fn draw_profit(
     // draw the block bytes
     chart
         .draw_secondary_series(LineSeries::new(
-            pessimistic_block_costs
+            pessimistic_block_costs_gwei
                 .iter()
                 .enumerate()
                 .map(|(x, y)| (x, *y)),

crates/fuel-gas-price-algorithm/gas-price-analysis/src/simulation.rs

@@ -117,13 +117,14 @@ impl Simulator {
             da_gas_prices.push(updater.new_scaled_da_gas_price);
             let gas_price = updater.algorithm().calculate();
             gas_prices.push(gas_price);
+            let total_fee = gas_price * fullness;
             updater
                 .update_l2_block_data(
                     height,
                     fullness,
                     capacity.try_into().unwrap(),
                     bytes,
-                    gas_price,
+                    total_fee,
                 )
                 .unwrap();
             pessimistic_costs

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

@@ -208,7 +208,7 @@ impl AlgorithmUpdaterV1 {
         used: u64,
         capacity: NonZeroU64,
         block_bytes: u64,
-        _gas_price: u64,
+        fee_wei: u64,
     ) -> Result<(), Error> {
         let expected = self.l2_block_height.saturating_add(1);
         if height != expected {
@@ -220,19 +220,12 @@ impl AlgorithmUpdaterV1 {
             self.l2_block_height = height;
 
             // rewards
-            let block_da_reward = used.saturating_mul(self.descaled_da_price());
-            self.total_da_rewards_excess = self
-                .total_da_rewards_excess
-                .saturating_add(block_da_reward.into());
-            let rewards = self.total_da_rewards_excess.try_into().unwrap_or(i128::MAX);
+            self.update_rewards(fee_wei);
+            let rewards = self.clamped_rewards_as_i128();
 
             // costs
-            let block_projected_da_cost =
-                (block_bytes as u128).saturating_mul(self.latest_da_cost_per_byte);
-            self.projected_total_da_cost = self
-                .projected_total_da_cost
-                .saturating_add(block_projected_da_cost);
-            let projected_total_da_cost = self.projected_cost_as_i128();
+            self.update_projected_cost(block_bytes);
+            let projected_total_da_cost = self.clamped_projected_cost_as_i128();
             let last_profit = rewards.saturating_sub(projected_total_da_cost);
             self.update_last_profit(last_profit);
 
@@ -243,11 +236,43 @@ impl AlgorithmUpdaterV1 {
         }
     }
 
-    // We are assuming that the difference between u128::MAX and i128::MAX is negligible
-    fn projected_cost_as_i128(&self) -> i128 {
+    fn update_rewards(&mut self, fee_wei: u64) {
+        let block_da_reward = self.da_portion_of_fee(fee_wei);
+        self.total_da_rewards_excess = self
+            .total_da_rewards_excess
+            .saturating_add(block_da_reward.into());
+    }
+
+    fn update_projected_cost(&mut self, block_bytes: u64) {
+        let block_projected_da_cost =
+            (block_bytes as u128).saturating_mul(self.latest_da_cost_per_byte);
+        self.projected_total_da_cost = self
+            .projected_total_da_cost
+            .saturating_add(block_projected_da_cost);
+    }
+
+    // Take the `fee_wei` and return the portion of the fee that should be used for paying DA costs
+    fn da_portion_of_fee(&self, fee_wei: u64) -> u64 {
+        // fee_wei * (da_price / (exec_price + da_price))
+        let numerator = fee_wei.saturating_mul(self.descaled_da_price());
+        let denominator = self
+            .descaled_exec_price()
+            .saturating_add(self.descaled_da_price());
+        if denominator == 0 {
+            0
+        } else {
+            numerator.div_ceil(denominator)
+        }
+    }
+
+    fn clamped_projected_cost_as_i128(&self) -> i128 {
         i128::try_from(self.projected_total_da_cost).unwrap_or(i128::MAX)
     }
 
+    fn clamped_rewards_as_i128(&self) -> i128 {
+        i128::try_from(self.total_da_rewards_excess).unwrap_or(i128::MAX)
+    }
+
     fn update_last_profit(&mut self, new_profit: i128) {
         self.second_to_last_profit = self.last_profit;
         self.last_profit = new_profit;

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

@@ -44,8 +44,8 @@ impl UpdaterBuilder {
         Self {
             min_exec_gas_price: 0,
             min_da_gas_price: 0,
-            starting_exec_gas_price: 0,
-            starting_da_gas_price: 0,
+            starting_exec_gas_price: 1,
+            starting_da_gas_price: 1,
             exec_gas_price_change_percent: 0,
             max_change_percent: u16::MAX,