Add Gas Price Updater Service

CHANGELOG.md

@@ -6,6 +6,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Added
+- [#1889](https://github.com/FuelLabs/fuel-core/pull/1889): Add new `FuelGasPriceProvider` that receives the gas price algorithm from a `GasPriceService`
+
 ### Changed
 - [#1942](https://github.com/FuelLabs/fuel-core/pull/1942): Sequential relayer's commits.
 

Cargo.toml

@@ -17,6 +17,7 @@ members = [
   "crates/services/consensus_module/bft",
   "crates/services/consensus_module/poa",
   "crates/services/executor",
+  "crates/services/gas_price_service",
   "crates/services/importer",
   "crates/services/p2p",
   "crates/services/producer",
@@ -67,6 +68,7 @@ fuel-core-bft = { version = "0.28.0", path = "./crates/services/consensus_module
 fuel-core-poa = { version = "0.28.0", path = "./crates/services/consensus_module/poa" }
 fuel-core-executor = { version = "0.28.0", path = "./crates/services/executor", default-features = false }
 fuel-core-importer = { version = "0.28.0", path = "./crates/services/importer" }
+fuel-core-gas-price-service = { version = "0.28.0", path = "crates/services/gas_price_service" }
 fuel-core-p2p = { version = "0.28.0", path = "./crates/services/p2p" }
 fuel-core-producer = { version = "0.28.0", path = "./crates/services/producer" }
 fuel-core-relayer = { version = "0.28.0", path = "./crates/services/relayer" }

crates/fuel-core/Cargo.toml

@@ -24,6 +24,7 @@ fuel-core-chain-config = { workspace = true, features = ["std"] }
 fuel-core-consensus-module = { workspace = true }
 fuel-core-database = { workspace = true }
 fuel-core-executor = { workspace = true, features = ["std"] }
+fuel-core-gas-price-service = { workspace = true }
 fuel-core-importer = { workspace = true }
 fuel-core-metrics = { workspace = true }
 fuel-core-p2p = { workspace = true, optional = true }

crates/fuel-core/src/service.rs

@@ -325,9 +325,9 @@ mod tests {
             i += 1;
         }
 
-        // current services: graphql, graphql worker, txpool, PoA
+        // current services: graphql, graphql worker, txpool, PoA, gas price service
         #[allow(unused_mut)]
-        let mut expected_services = 5;
+        let mut expected_services = 6;
 
         // Relayer service is disabled with `Config::local_node`.
         // #[cfg(feature = "relayer")]

crates/fuel-core/src/service/adapters.rs

@@ -39,6 +39,8 @@ pub mod relayer;
 pub mod sync;
 pub mod txpool;
 
+pub mod fuel_gas_price_provider;
+
 #[derive(Debug, Clone)]
 pub struct ConsensusParametersProvider {
     shared_state: consensus_parameters_provider::SharedState,

crates/fuel-core/src/service/adapters/fuel_gas_price_provider.rs

@@ -0,0 +1,93 @@
+use crate::fuel_core_graphql_api::ports::GasPriceEstimate as GraphqlGasPriceEstimate;
+use fuel_core_gas_price_service::{
+    GasPriceAlgorithm,
+    SharedGasPriceAlgo,
+};
+use fuel_core_producer::block_producer::gas_price::GasPriceProvider as ProducerGasPriceProvider;
+use fuel_core_txpool::ports::GasPriceProvider as TxPoolGasPricProvider;
+use fuel_core_types::{
+    fuel_types::BlockHeight,
+    services::txpool::Result as TxPoolResult,
+};
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("Requested height is too high. Requested: {requested_height}, latest: {latest_height}")]
+    AlgorithmNotUpToDate {
+        requested_height: BlockHeight,
+        latest_height: BlockHeight,
+    },
+    #[error("Latest block height past requested height. Requested: {requested_height}, latest: {latest_height}")]
+    RequestedOldBlockHeight {
+        requested_height: BlockHeight,
+        latest_height: BlockHeight,
+    },
+}
+
+#[cfg(test)]
+mod tests;
+
+#[derive(Debug)]
+/// Receives the next gas price algorithm via a shared `BlockGasPriceAlgo` instance
+pub struct FuelGasPriceProvider<A> {
+    algorithm: SharedGasPriceAlgo<A>,
+}
+
+impl<A> Clone for FuelGasPriceProvider<A> {
+    fn clone(&self) -> Self {
+        Self {
+            algorithm: self.algorithm.clone(),
+        }
+    }
+}
+
+impl<A> FuelGasPriceProvider<A> {
+    pub fn new(algorithm: SharedGasPriceAlgo<A>) -> Self {
+        Self { algorithm }
+    }
+}
+
+impl<A> FuelGasPriceProvider<A>
+where
+    A: GasPriceAlgorithm + Send + Sync,
+{
+    async fn next_gas_price(&self, block_bytes: u64) -> u64 {
+        self.algorithm.next_gas_price(block_bytes).await
+    }
+
+    async fn last_gas_price(&self) -> u64 {
+        self.algorithm.last_gas_price().await
+    }
+}
+
+#[async_trait::async_trait]
+impl<A> ProducerGasPriceProvider for FuelGasPriceProvider<A>
+where
+    A: GasPriceAlgorithm + Send + Sync,
+{
+    async fn next_gas_price(&self, block_bytes: u64) -> anyhow::Result<u64> {
+        Ok(self.next_gas_price(block_bytes).await)
+    }
+}
+
+#[async_trait::async_trait]
+impl<A> TxPoolGasPricProvider for FuelGasPriceProvider<A>
+where
+    A: GasPriceAlgorithm + Send + Sync,
+{
+    async fn last_gas_price(&self) -> TxPoolResult<u64> {
+        Ok(self.last_gas_price().await)
+    }
+}
+
+#[async_trait::async_trait]
+impl<A> GraphqlGasPriceEstimate for FuelGasPriceProvider<A>
+where
+    A: GasPriceAlgorithm + Send + Sync,
+{
+    async fn worst_case_gas_price(&self, height: BlockHeight) -> u64 {
+        self.algorithm.worst_case_gas_price(height).await
+    }
+}

crates/fuel-core/src/service/adapters/fuel_gas_price_provider/tests.rs

@@ -0,0 +1,53 @@
+#![allow(non_snake_case)]
+
+use super::*;
+
+#[cfg(test)]
+mod producer_gas_price_tests;
+
+#[cfg(test)]
+mod tx_pool_gas_price_tests;
+
+#[cfg(test)]
+mod graph_ql_gas_price_estimate_tests;
+
+#[derive(Debug, Clone, Copy)]
+pub struct TestGasPriceAlgorithm {
+    last: u64,
+    multiply: u64,
+}
+
+impl Default for TestGasPriceAlgorithm {
+    fn default() -> Self {
+        Self {
+            last: 100,
+            multiply: 2,
+        }
+    }
+}
+
+impl GasPriceAlgorithm for TestGasPriceAlgorithm {
+    fn last_gas_price(&self) -> u64 {
+        self.last
+    }
+
+    fn next_gas_price(&self, block_bytes: u64) -> u64 {
+        self.multiply.saturating_mul(block_bytes)
+    }
+
+    fn worst_case_gas_price(&self, _block_height: BlockHeight) -> u64 {
+        self.multiply.saturating_mul(10_000_000) // Arbitrary fake bytes
+    }
+}
+
+fn build_provider<A>(algorithm: A) -> FuelGasPriceProvider<A>
+where
+    A: Send + Sync,
+{
+    let algorithm = SharedGasPriceAlgo::new(algorithm);
+    FuelGasPriceProvider::new(algorithm)
+}
+
+#[ignore]
+#[test]
+fn dummy() {}

crates/fuel-core/src/service/adapters/fuel_gas_price_provider/tests/graph_ql_gas_price_estimate_tests.rs

@@ -0,0 +1,16 @@
+use super::*;
+
+#[tokio::test]
+async fn estimate_gas_price__happy_path() {
+    // given
+    let next_height = 432.into();
+    let algo = TestGasPriceAlgorithm::default();
+    let gas_price_provider = build_provider(algo);
+
+    // when
+    let expected_price = algo.worst_case_gas_price(next_height);
+    let actual_price = gas_price_provider.worst_case_gas_price(next_height).await;
+
+    // then
+    assert_eq!(expected_price, actual_price);
+}

crates/fuel-core/src/service/adapters/fuel_gas_price_provider/tests/producer_gas_price_tests.rs

@@ -0,0 +1,20 @@
+use crate::service::adapters::fuel_gas_price_provider::tests::{
+    build_provider,
+    TestGasPriceAlgorithm,
+};
+use fuel_core_gas_price_service::GasPriceAlgorithm;
+
+#[tokio::test]
+async fn gas_price__if_requested_block_height_is_latest_return_gas_price() {
+    // given
+    let algo = TestGasPriceAlgorithm::default();
+    let gas_price_provider = build_provider(algo);
+    let bytes = 10;
+
+    // when
+    let expected_price = algo.next_gas_price(bytes);
+    let actual_price = gas_price_provider.next_gas_price(bytes).await;
+
+    // then
+    assert_eq!(expected_price, actual_price);
+}

crates/fuel-core/src/service/adapters/fuel_gas_price_provider/tests/tx_pool_gas_price_tests.rs

@@ -0,0 +1,19 @@
+use crate::service::adapters::fuel_gas_price_provider::tests::{
+    build_provider,
+    TestGasPriceAlgorithm,
+};
+use fuel_core_gas_price_service::GasPriceAlgorithm;
+
+#[tokio::test]
+async fn gas_price__if_requested_block_height_is_latest_return_gas_price() {
+    // given
+    let algo = TestGasPriceAlgorithm::default();
+    let gas_price_provider = build_provider(algo);
+
+    // when
+    let expected_price = algo.last_gas_price();
+    let actual_price = gas_price_provider.last_gas_price().await;
+
+    // then
+    assert_eq!(expected_price, actual_price);
+}

crates/fuel-core/src/service/adapters/producer.rs

@@ -17,7 +17,6 @@ use fuel_core_executor::executor::OnceTransactionsSource;
 use fuel_core_producer::{
     block_producer::gas_price::{
         ConsensusParametersProvider as ConsensusParametersProviderTrait,
-        GasPriceParams,
         GasPriceProvider,
     },
     ports::TxPool,
@@ -224,9 +223,10 @@ impl fuel_core_producer::ports::BlockProducerDatabase for Database {
     }
 }
 
+#[async_trait::async_trait]
 impl GasPriceProvider for StaticGasPrice {
-    fn gas_price(&self, _block_height: GasPriceParams) -> Option<u64> {
-        Some(self.gas_price)
+    async fn next_gas_price(&self, _block_bytes: u64) -> anyhow::Result<u64> {
+        Ok(self.gas_price)
     }
 }
 

crates/fuel-core/src/service/adapters/txpool.rs

@@ -38,7 +38,6 @@ use fuel_core_types::{
         UtxoId,
     },
     fuel_types::{
-        BlockHeight,
         ContractId,
         Nonce,
     },
@@ -49,6 +48,7 @@ use fuel_core_types::{
             GossipsubMessageInfo,
             TransactionGossipData,
         },
+        txpool::Result as TxPoolResult,
     },
 };
 use std::sync::Arc;
@@ -141,9 +141,10 @@ impl fuel_core_txpool::ports::TxPoolDb for Database {
     }
 }
 
+#[async_trait::async_trait]
 impl GasPriceProvider for StaticGasPrice {
-    fn gas_price(&self, _block_height: BlockHeight) -> Option<u64> {
-        Some(self.gas_price)
+    async fn last_gas_price(&self) -> TxPoolResult<u64> {
+        Ok(self.gas_price)
     }
 }