chore: price algo plus price changes

committer/src/api.rs

@@ -90,9 +90,17 @@ async fn metrics(registry: web::Data<Arc<Registry>>) -> impl Responder {
     std::result::Result::<_, InternalError<_>>::Ok(text)
 }
 
+#[derive(Deserialize)]
+#[serde(rename_all = "lowercase")]
+enum HeightVariant {
+    Latest,
+    Specific,
+}
+
 #[derive(Deserialize)]
 struct CostQueryParams {
-    from_height: u32,
+    variant: HeightVariant,
+    value: Option<u32>,
     limit: Option<usize>,
 }
 
@@ -103,8 +111,18 @@ async fn costs(
 ) -> impl Responder {
     let limit = query.limit.unwrap_or(100);
 
-    match data.get_costs(query.from_height, limit).await {
-        Ok(bundle_costs) => HttpResponse::Ok().json(bundle_costs),
+    let response = match query.variant {
+        HeightVariant::Latest => data.get_latest_costs(limit).await,
+        HeightVariant::Specific => match query.value {
+            Some(height) => data.get_costs(height, limit).await,
+            None => Err(services::Error::Other(
+                "height value is required".to_string(),
+            )),
+        },
+    };
+
+    match response {
+        Ok(costs) => HttpResponse::Ok().json(costs),
         Err(services::Error::Other(e)) => {
             HttpResponse::from_error(InternalError::new(e, StatusCode::BAD_REQUEST))
         }

committer/src/config.rs

@@ -1,6 +1,6 @@
 use std::{
     net::Ipv4Addr,
-    num::{NonZeroU32, NonZeroUsize},
+    num::{NonZeroU32, NonZeroU64, NonZeroUsize},
     str::FromStr,
     time::Duration,
 };
@@ -93,6 +93,9 @@ pub struct App {
     /// How often to check for finalized l1 txs
     #[serde(deserialize_with = "human_readable_duration")]
     pub tx_finalization_check_interval: Duration,
+    /// How often to check for l1 prices
+    #[serde(deserialize_with = "human_readable_duration")]
+    pub l1_prices_check_interval: Duration,
     /// Number of L1 blocks that need to pass to accept the tx as finalized
     pub num_blocks_to_finalize_tx: u64,
     /// Interval after which to bump a pending tx
@@ -111,6 +114,30 @@ pub struct App {
     /// How often to run state pruner
     #[serde(deserialize_with = "human_readable_duration")]
     pub state_pruner_run_interval: Duration,
+    /// Configuration for the fee algorithm used by the StateCommitter
+    pub fee_algo: FeeAlgoConfig,
+}
+
+/// Configuration for the fee algorithm used by the StateCommitter
+#[derive(Debug, Clone, Deserialize)]
+pub struct FeeAlgoConfig {
+    /// Short-term period for Simple Moving Average (SMA) in block numbers
+    pub short_sma_blocks: NonZeroU64,
+
+    /// Long-term period for Simple Moving Average (SMA) in block numbers
+    pub long_sma_blocks: NonZeroU64,
+
+    /// Maximum number of unposted L2 blocks before sending a transaction regardless of fees
+    pub max_l2_blocks_behind: NonZeroU32,
+
+    /// Starting discount percentage applied we try to achieve if we're 0 l2 blocks behind
+    pub start_discount_percentage: f64,
+
+    /// Premium percentage we're willing to pay if we're max_l2_blocks_behind - 1 blocks behind
+    pub end_premium_percentage: f64,
+
+    /// A fee that is always acceptable regardless of other conditions
+    pub always_acceptable_fee: u64,
 }
 
 /// Configuration settings for managing fuel block bundling and fragment submission operations.

committer/src/main.rs

@@ -7,6 +7,7 @@ mod setup;
 use api::launch_api_server;
 use errors::{Result, WithContext};
 use metrics::prometheus::Registry;
+use services::fee_tracker::port::cache::CachingApi;
 use setup::last_finalization_metric;
 use tokio_util::sync::CancellationToken;
 
@@ -72,13 +73,22 @@ async fn main() -> Result<()> {
             &metrics_registry,
         );
 
+        let (fee_tracker, fee_tracker_handle) = setup::fee_tracker(
+            ethereum_rpc.clone(),
+            cancel_token.clone(),
+            &config,
+            &metrics_registry,
+        )?;
+
         let state_committer_handle = setup::state_committer(
             fuel_adapter.clone(),
             ethereum_rpc.clone(),
             storage.clone(),
             cancel_token.clone(),
             &config,
-        );
+            &metrics_registry,
+            fee_tracker,
+        )?;
 
         let state_importer_handle =
             setup::block_importer(fuel_adapter, storage.clone(), cancel_token.clone(), &config);
@@ -105,6 +115,7 @@ async fn main() -> Result<()> {
         handles.push(state_importer_handle);
         handles.push(block_bundler);
         handles.push(state_listener_handle);
+        handles.push(fee_tracker_handle);
         // Enable pruner once the issue is resolved
         //TODO: https://github.com/FuelLabs/fuel-block-committer/issues/173
         // handles.push(state_pruner_handle);

committer/src/setup.rs

@@ -9,6 +9,10 @@ use metrics::{
 };
 use services::{
     block_committer::{port::l1::Contract, service::BlockCommitter},
+    fee_tracker::{
+        port::cache::CachingApi,
+        service::{FeeThresholds, FeeTracker, SmaPeriods},
+    },
     state_committer::port::Storage,
     state_listener::service::StateListener,
     state_pruner::service::StatePruner,
@@ -117,7 +121,9 @@ pub fn state_committer(
     storage: Database,
     cancel_token: CancellationToken,
     config: &config::Config,
-) -> tokio::task::JoinHandle<()> {
+    registry: &Registry,
+    fee_tracker: FeeTracker<CachingApi<L1>>,
+) -> Result<tokio::task::JoinHandle<()>> {
     let state_committer = services::StateCommitter::new(
         l1,
         fuel,
@@ -127,17 +133,19 @@ pub fn state_committer(
             fragment_accumulation_timeout: config.app.bundle.fragment_accumulation_timeout,
             fragments_to_accumulate: config.app.bundle.fragments_to_accumulate,
             gas_bump_timeout: config.app.gas_bump_timeout,
-            tx_max_fee: config.app.tx_max_fee as u128,
         },
         SystemClock,
+        fee_tracker,
     );
 
-    schedule_polling(
+    state_committer.register_metrics(registry);
+
+    Ok(schedule_polling(
         config.app.tx_finalization_check_interval,
         state_committer,
         "State Committer",
         cancel_token,
-    )
+    ))
 }
 
 pub fn block_importer(
@@ -316,3 +324,41 @@ pub async fn shut_down(
     storage.close().await;
     Ok(())
 }
+
+pub fn fee_tracker(
+    l1: L1,
+    cancel_token: CancellationToken,
+    config: &config::Config,
+    registry: &Registry,
+) -> Result<(FeeTracker<CachingApi<L1>>, tokio::task::JoinHandle<()>)> {
+    let fee_tracker = FeeTracker::new(
+        CachingApi::new(l1, 24 * 3600 / 12),
+        services::fee_tracker::service::Config {
+            sma_periods: SmaPeriods {
+                short: config.app.fee_algo.short_sma_blocks,
+                long: config.app.fee_algo.long_sma_blocks,
+            },
+            fee_thresholds: FeeThresholds {
+                max_l2_blocks_behind: config.app.fee_algo.max_l2_blocks_behind,
+                start_discount_percentage: config
+                    .app
+                    .fee_algo
+                    .start_discount_percentage
+                    .try_into()?,
+                end_premium_percentage: config.app.fee_algo.end_premium_percentage.try_into()?,
+                always_acceptable_fee: config.app.fee_algo.always_acceptable_fee as u128,
+            },
+        },
+    );
+
+    fee_tracker.register_metrics(registry);
+
+    let handle = schedule_polling(
+        config.app.tx_finalization_check_interval,
+        fee_tracker.clone(),
+        "Fee Tracker",
+        cancel_token,
+    );
+
+    Ok((fee_tracker, handle))
+}