feat: higher priority fee when late (#186)

Co-authored-by: MujkicA <32431923+MujkicA@users.noreply.github.com>
Co-authored-by: hal3e <git@hal3e.io>

Author: 3 people

Cargo.lock

@@ -183,12 +183,24 @@ The Fuel Block Committer is configured primarily through environment variables.
   - **Format:** Human-readable duration
   - **Example:** `300s`
 
-- **`COMMITTER__APP__TX_MAX_FEE`**
+- **`COMMITTER__APP__TX_FEES__MAX`**
 
   - **Description:** Maximum gas fee permitted for a transaction in wei.
   - **Type:** `u64`
   - **Example:** `4000000000000000`
 
+- **`COMMITTER__APP__TX_FEES__MIN_REWARD_PERC`**
+
+  - **Description:** Lowest reward percentage to use when the system is up to date with L2 block posting.
+  - **Type:** `f64`
+  - **Example:** `20.0`
+
+- **`COMMITTER__APP__TX_FEES__MAX_REWARD_PERC`**
+
+  - **Description:** Highest reward percentage to use when the system is very late with L2 block posting.
+  - **Type:** `f64`
+  - **Example:** `30.0`
+
 - **`COMMITTER__APP__SEND_TX_REQUEST_TIMEOUT`**
 
   - **Description:** Duration for timeout when sending transaction requests.

README.md

@@ -133,8 +133,8 @@ pub struct App {
     /// Interval after which to bump a pending tx
     #[serde(deserialize_with = "human_readable_duration")]
     pub gas_bump_timeout: Duration,
-    /// Max gas fee we permit a tx to have in wei
-    pub tx_max_fee: u64,
+    /// Tweak how we pay for a l1 transaction
+    pub tx_fees: TxFeesConfig,
     ///// Contains configs relating to block state posting to l1
     pub bundle: BundleConfig,
     //// Duration for timeout when sending tx requests
@@ -150,6 +150,16 @@ pub struct App {
     pub fee_algo: FeeAlgoConfig,
 }
 
+#[derive(Debug, Clone, Deserialize, Copy)]
+pub struct TxFeesConfig {
+    /// Max gas fee we permit a tx to have in wei
+    pub max: u64,
+    /// lowest reward percentage to use when we're up to date with l2 block posting (e.g. 20.)
+    pub min_reward_perc: f64,
+    /// highest reward percentage to use when we're very late with l2 block posting (e.g. 30.)
+    pub max_reward_perc: f64,
+}
+
 /// Configuration for the fee algorithm used by the StateCommitter
 #[derive(Debug, Clone, Deserialize)]
 pub struct FeeAlgoConfig {

committer/src/config.rs

@@ -1,7 +1,7 @@
 use std::time::Duration;
 
 use clock::SystemClock;
-use eth::{BlobEncoder, Signers};
+use eth::{AcceptablePriorityFeePercentages, BlobEncoder, Signers};
 use fuel_block_committer_encoding::bundle;
 use metrics::{
     prometheus::{IntGauge, Registry},
@@ -230,8 +230,12 @@ pub async fn l1_adapter(
         Signers::for_keys(config.eth.l1_keys.clone()).await?,
         internal_config.eth_errors_before_unhealthy,
         eth::TxConfig {
-            tx_max_fee: config.app.tx_max_fee as u128,
+            tx_max_fee: u128::from(config.app.tx_fees.max),
             send_tx_request_timeout: config.app.send_tx_request_timeout,
+            acceptable_priority_fee_percentage: AcceptablePriorityFeePercentages::new(
+                config.app.tx_fees.min_reward_perc,
+                config.app.tx_fees.max_reward_perc,
+            )?,
         },
     )
     .await?;

committer/src/setup.rs

@@ -76,7 +76,6 @@ impl Committer {
             .env("COMMITTER__APP__L1_FEE_CHECK_INTERVAL", "5s")
             .env("COMMITTER__APP__NUM_BLOCKS_TO_FINALIZE_TX", "3")
             .env("COMMITTER__APP__GAS_BUMP_TIMEOUT", "300s")
-            .env("COMMITTER__APP__TX_MAX_FEE", "4000000000000000")
             .env("COMMITTER__APP__SEND_TX_REQUEST_TIMEOUT", "10s")
             .env(
                 "COMMITTER__APP__BUNDLE__ACCUMULATION_TIMEOUT",
@@ -132,6 +131,9 @@ impl Committer {
                 "COMMITTER__APP__FEE_ALGO__ALWAYS_ACCEPTABLE_FEE",
                 u64::MAX.to_string(),
             )
+            .env("COMMITTER__APP__TX_FEES__MAX", "4000000000000000")
+            .env("COMMITTER__APP__TX_FEES__MIN_REWARD_PERC", "20")
+            .env("COMMITTER__APP__TX_FEES__MAX_REWARD_PERC", "30")
             .current_dir(Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap())
             .kill_on_drop(true);
 

e2e/src/committer.rs

@@ -7,7 +7,9 @@ use alloy::{
     providers::{Provider, ProviderBuilder, WsConnect},
     rpc::types::TransactionRequest,
 };
-use eth::{AwsClient, AwsConfig, Signer, Signers, WebsocketClient};
+use eth::{
+    AcceptablePriorityFeePercentages, AwsClient, AwsConfig, Signer, Signers, WebsocketClient,
+};
 use fs_extra::dir::{copy, CopyOptions};
 use serde::Deserialize;
 use services::types::{fuel::FuelBlock, Address};
@@ -42,6 +44,7 @@ impl DeployedContract {
             eth::TxConfig {
                 tx_max_fee,
                 send_tx_request_timeout,
+                acceptable_priority_fee_percentage: AcceptablePriorityFeePercentages::default(),
             },
         )
         .await?;

e2e/src/eth_node/state_contract.rs

@@ -38,6 +38,7 @@ tracing = { workspace = true }
 url = { workspace = true }
 
 [dev-dependencies]
+eth = { workspace = true, features = ["test-helpers"] }
 alloy = { workspace = true, features = [
   "signer-local",
   "node-bindings",

packages/adapters/eth/Cargo.toml

@@ -12,4 +12,6 @@ pub use alloy::primitives::Address;
 pub use aws::*;
 pub use blob_encoder::BlobEncoder;
 pub use http::Provider as HttpClient;
-pub use websocket::{L1Key, L1Keys, Signer, Signers, TxConfig, WebsocketClient};
+pub use websocket::{
+    AcceptablePriorityFeePercentages, L1Key, L1Keys, Signer, Signers, TxConfig, WebsocketClient,
+};

packages/adapters/eth/src/lib.rs

@@ -11,6 +11,7 @@ use alloy::{
 use delegate::delegate;
 use serde::Deserialize;
 use services::{
+    state_committer::port::l1::Priority,
     types::{
         BlockSubmissionTx, Fragment, FragmentsSubmitted, L1Height, L1Tx, NonEmpty,
         TransactionResponse, U256,
@@ -110,6 +111,7 @@ impl services::state_committer::port::l1::Api for WebsocketClient {
                 &self,
                 fragments: NonEmpty<Fragment>,
                 previous_tx: Option<services::types::L1Tx>,
+                priority: Priority
             ) -> Result<(L1Tx, FragmentsSubmitted)>;
         }
     }
@@ -158,6 +160,58 @@ impl L1Keys {
 pub struct TxConfig {
     pub tx_max_fee: u128,
     pub send_tx_request_timeout: Duration,
+    pub acceptable_priority_fee_percentage: AcceptablePriorityFeePercentages,
+}
+
+#[cfg(feature = "test-helpers")]
+impl Default for TxConfig {
+    fn default() -> Self {
+        Self {
+            tx_max_fee: u128::MAX,
+            send_tx_request_timeout: Duration::from_secs(10),
+            acceptable_priority_fee_percentage: AcceptablePriorityFeePercentages::default(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct AcceptablePriorityFeePercentages {
+    min: f64,
+    max: f64,
+}
+
+#[cfg(feature = "test-helpers")]
+impl Default for AcceptablePriorityFeePercentages {
+    fn default() -> Self {
+        Self::new(20., 20.).expect("valid reward percentile range")
+    }
+}
+
+impl AcceptablePriorityFeePercentages {
+    pub fn new(min: f64, max: f64) -> Result<Self> {
+        if min > max {
+            return Err(services::Error::Other(
+                "min reward percentile must be less than or equal to max reward percentile"
+                    .to_string(),
+            ));
+        }
+
+        if min <= 0.0 || max > 100.0 {
+            return Err(services::Error::Other(
+                "reward percentiles must be > 0 and <= 100".to_string(),
+            ));
+        }
+
+        Ok(Self { min, max })
+    }
+
+    pub fn apply(&self, priority: Priority) -> f64 {
+        let min = self.min;
+
+        let increase = (self.max - min) * priority.get() / 100.;
+
+        (min + increase).min(self.max)
+    }
 }
 
 // This trait is needed because you cannot write `dyn TraitA + TraitB` except when TraitB is an
@@ -268,14 +322,7 @@ impl WebsocketClient {
             .map(|signer| TxSigner::address(&signer));
         let contract_caller_address = TxSigner::address(&signers.main);
 
-        let provider = WsConnection::connect(
-            url,
-            contract_address,
-            signers,
-            tx_config.tx_max_fee,
-            tx_config.send_tx_request_timeout,
-        )
-        .await?;
+        let provider = WsConnection::connect(url, contract_address, signers, tx_config).await?;
 
         Ok(Self {
             inner: HealthTrackingMiddleware::new(provider, unhealthy_after_n_errors),
@@ -327,10 +374,11 @@ impl WebsocketClient {
         &self,
         fragments: NonEmpty<Fragment>,
         previous_tx: Option<services::types::L1Tx>,
+        priority: Priority,
     ) -> Result<(L1Tx, FragmentsSubmitted)> {
         Ok(self
             .inner
-            .submit_state_fragments(fragments, previous_tx)
+            .submit_state_fragments(fragments, previous_tx, priority)
             .await?)
     }
 
@@ -366,6 +414,7 @@ impl RegistersMetrics for WebsocketClient {
 #[cfg(test)]
 mod tests {
     use pretty_assertions::assert_eq;
+    use services::state_committer::port::l1::Priority;
 
     use super::L1Key;
 
@@ -392,4 +441,40 @@ mod tests {
         // then
         assert_eq!(key, L1Key::Kms("0x1234".to_owned()));
     }
+
+    #[test]
+    fn lowest_priority_gives_min_priority_fee_perc() {
+        // given
+        let sut = super::AcceptablePriorityFeePercentages::new(20., 40.).unwrap();
+
+        // when
+        let fee_perc = sut.apply(Priority::MIN);
+
+        // then
+        assert_eq!(fee_perc, 20.);
+    }
+
+    #[test]
+    fn medium_priority_gives_middle_priority_fee_perc() {
+        // given
+        let sut = super::AcceptablePriorityFeePercentages::new(20., 40.).unwrap();
+
+        // when
+        let fee_perc = sut.apply(Priority::new(50.).unwrap());
+
+        // then
+        assert_eq!(fee_perc, 30.);
+    }
+
+    #[test]
+    fn highest_priority_gives_max_priority_fee_perc() {
+        // given
+        let sut = super::AcceptablePriorityFeePercentages::new(20., 40.).unwrap();
+
+        // when
+        let fee_perc = sut.apply(Priority::MAX);
+
+        // then
+        assert_eq!(fee_perc, 40.);
+    }
 }