Relayer fee config (#578)

* relayer and estimated bridge tx fee in config

* main file fixed

* BRIDGE_TRANSACTION_FEE 0.001 ETH

Signed-off-by: Maciej Skrzypkowski <mskr@gmx.com>

---------

Signed-off-by: Maciej Skrzypkowski <mskr@gmx.com>

Author: mskrzypkows

Cargo.lock

@@ -10,7 +10,7 @@ resolver = "2"
 default-members = ["node"]
 
 [workspace.package]
-version = "1.4.2"
+version = "1.5.0"
 edition = "2024"
 repository = "https://github.com/NethermindEth/Catalyst"
 license = "MIT"

Cargo.toml

@@ -15,6 +15,8 @@ pub struct FundsMonitor {
     amount_to_bridge_from_l2_to_l1: u128,
     disable_bridging: bool,
     cancel_token: CancellationToken,
+    bridge_relayer_fee: u64,
+    bridge_transaction_fee: u64,
 }
 
 const MONITOR_INTERVAL_SEC: u64 = 60;
@@ -35,6 +37,8 @@ impl FundsMonitor {
         amount_to_bridge_from_l2_to_l1: u128,
         disable_bridging: bool,
         cancel_token: CancellationToken,
+        bridge_relayer_fee: u64,
+        bridge_transaction_fee: u64,
     ) -> Self {
         Self {
             ethereum_l1,
@@ -47,6 +51,8 @@ impl FundsMonitor {
             amount_to_bridge_from_l2_to_l1,
             disable_bridging,
             cancel_token,
+            bridge_relayer_fee,
+            bridge_transaction_fee,
         }
     }
 
@@ -173,11 +179,18 @@ impl FundsMonitor {
         if !self.disable_bridging
             && let Ok(l2_eth_balance) = l2_eth_balance
             && l2_eth_balance
-                > U256::from(self.amount_to_bridge_from_l2_to_l1 + self.taiko.get_bridging_fee())
+                > U256::from(
+                    self.amount_to_bridge_from_l2_to_l1
+                        + u128::from(self.bridge_relayer_fee)
+                        + u128::from(self.bridge_transaction_fee), // estimated transaction fee
+                )
         {
             match self
                 .taiko
-                .transfer_eth_from_l2_to_l1(self.amount_to_bridge_from_l2_to_l1)
+                .transfer_eth_from_l2_to_l1(
+                    self.amount_to_bridge_from_l2_to_l1,
+                    self.bridge_relayer_fee,
+                )
                 .await
             {
                 Ok(_) => info!(

node/src/funds_monitor/mod.rs

@@ -230,6 +230,8 @@ async fn main() -> Result<(), Error> {
         config.amount_to_bridge_from_l2_to_l1,
         config.disable_bridging,
         cancel_token.clone(),
+        config.bridge_relayer_fee,
+        config.bridge_transaction_fee,
     );
     funds_monitor.run();
 

node/src/main.rs

@@ -24,9 +24,6 @@ use std::time::Duration;
 use tokio::sync::RwLock;
 use tracing::{debug, info, warn};
 
-pub const L2_TO_L1_BRIDGING_FEE: u64 = 10000;
-pub const ESTIMATED_L2_BRIDGING_TRANSACTION_FEE: u128 = 1000000000000;
-
 pub struct L2ExecutionLayer {
     provider: RwLock<DynProvider>,
     taiko_anchor: RwLock<TaikoAnchor::TaikoAnchorInstance<DynProvider>>,
@@ -291,6 +288,7 @@ impl L2ExecutionLayer {
         amount: u128,
         dest_chain_id: u64,
         preconfer_address: Address,
+        bridge_relayer_fee: u64,
     ) -> Result<(), Error> {
         info!(
             "Transfer ETH from L2 to L1: srcChainId: {}, dstChainId: {}",
@@ -309,6 +307,7 @@ impl L2ExecutionLayer {
             amount,
             dest_chain_id,
             preconfer_address,
+            bridge_relayer_fee,
         )
         .await?;
 
@@ -321,6 +320,7 @@ impl L2ExecutionLayer {
         amount: u128,
         dest_chain_id: u64,
         preconfer_address: Address,
+        bridge_relayer_fee: u64,
     ) -> Result<(), Error> {
         let contract = Bridge::new(self.config.taiko_bridge_address, provider.clone());
         let gas_limit = contract
@@ -331,7 +331,7 @@ impl L2ExecutionLayer {
 
         let message = Bridge::Message {
             id: 0,
-            fee: L2_TO_L1_BRIDGING_FEE,
+            fee: bridge_relayer_fee,
             gasLimit: gas_limit + 1,
             from: preconfer_address,
             srcChainId: self.chain_id,
@@ -355,7 +355,7 @@ impl L2ExecutionLayer {
         let tx_send_message = contract
             .sendMessage(message)
             .value(Uint::<256, 4>::from(
-                amount + u128::from(L2_TO_L1_BRIDGING_FEE),
+                amount + u128::from(bridge_relayer_fee),
             ))
             .from(preconfer_address)
             .nonce(nonce)

node/src/taiko/l2_execution_layer.rs

@@ -434,22 +434,22 @@ impl Taiko {
             .await
     }
 
-    pub async fn transfer_eth_from_l2_to_l1(&self, amount: u128) -> Result<(), Error> {
+    pub async fn transfer_eth_from_l2_to_l1(
+        &self,
+        amount: u128,
+        bridge_relayer_fee: u64,
+    ) -> Result<(), Error> {
         self.l2_execution_layer
             .transfer_eth_from_l2_to_l1(
                 amount,
                 self.ethereum_l1.execution_layer.chain_id(),
                 self.ethereum_l1
                     .execution_layer
                     .get_preconfer_alloy_address(),
+                bridge_relayer_fee,
             )
             .await
     }
-
-    pub fn get_bridging_fee(&self) -> u128 {
-        u128::from(l2_execution_layer::L2_TO_L1_BRIDGING_FEE)
-            + l2_execution_layer::ESTIMATED_L2_BRIDGING_TRANSACTION_FEE
-    }
 }
 
 pub trait PreconfDriver {

node/src/taiko/mod.rs

@@ -49,6 +49,8 @@ pub struct Config {
     pub extra_gas_percentage: u64,
     pub preconf_min_txs: u64,
     pub preconf_max_skipped_l2_slots: u64,
+    pub bridge_relayer_fee: u64,
+    pub bridge_transaction_fee: u64,
 }
 
 #[derive(Debug, Clone)]
@@ -367,6 +369,18 @@ impl Config {
             .parse::<u64>()
             .expect("PRECONF_MAX_SKIPPED_L2_SLOTS must be a number");
 
+        // 0.003 eth
+        let bridge_relayer_fee = std::env::var("BRIDGE_RELAYER_FEE")
+            .unwrap_or("3047459064000000".to_string())
+            .parse::<u64>()
+            .expect("BRIDGE_RELAYER_FEE must be a number");
+
+        // 0.001 eth
+        let bridge_transaction_fee = std::env::var("BRIDGE_TRANSACTION_FEE")
+            .unwrap_or("1000000000000000".to_string())
+            .parse::<u64>()
+            .expect("BRIDGE_TRANSACTION_FEE must be a number");
+
         let config = Self {
             preconfer_address,
             taiko_geth_rpc_url: std::env::var("TAIKO_GETH_RPC_URL")
@@ -422,6 +436,8 @@ impl Config {
             extra_gas_percentage,
             preconf_min_txs,
             preconf_max_skipped_l2_slots,
+            bridge_relayer_fee,
+            bridge_transaction_fee,
         };
 
         info!(
@@ -456,7 +472,7 @@ max bytes size of batch: {}
 max blocks per batch value: {}
 max time shift between blocks: {}s
 max anchor height offset reduction value: {}
-min priority fee per gas wei: {}
+min priority fee per gas: {}wei
 tx fees increase percentage: {}
 max attempts to send tx: {}
 max attempts to wait tx: {}
@@ -469,6 +485,8 @@ simulate not submitting at the end of epoch: {}
 propose_forced_inclusion: {}
 min number of transaction to create a L2 block: {}
 max number of skipped L2 slots while creating a L2 block: {}
+bridge relayer fee: {}wei
+bridge transaction fee: {}wei
 "#,
             if let Some(preconfer_address) = &config.preconfer_address {
                 format!("\npreconfer address: {preconfer_address}")
@@ -524,6 +542,8 @@ max number of skipped L2 slots while creating a L2 block: {}
             config.propose_forced_inclusion,
             config.preconf_min_txs,
             config.preconf_max_skipped_l2_slots,
+            config.bridge_relayer_fee,
+            config.bridge_transaction_fee,
         );
 
         config