debounce gas price rpc requests (#4573)

# Description
When we switched from the old gas price estimation crate to a new one
built on top of alloy we lost a key optimization. The old gas price
estimation updated the gas price in a background task so the total
number of RPC requests was constant while they scale with the number of
connected solvers and such for the new logic.

For example on mainnet this causes the driver to spend a third of its
RPC requests on gas price computation which is obviously insane.
<img width="1187" height="304" alt="Screenshot 2026-06-29 at 09 10 08"
src="https://github.com/user-attachments/assets/087a847b-6cb5-413e-ae94-681e1f1dad57"
/>

# Changes
Implements a background task for the alloy based gas price estimator
which updates the gas price once for every new block.

To break up a circular dependency when creating the `Ethereum` instance
in the driver I needed to move the creation of the gas price estimator
into `Ethereum::new()` which in turn required a few other changes.

## How to test
Added unit test

Also deployed this temporarily to prod BNB and the time to convert the
DTO to the domain types dropped from ~200ms to 3ms because we don't have
any RPC calls on the hot path anymore.
<img width="1599" height="819" alt="Screenshot 2026-06-30 at 08 26 10"
src="https://github.com/user-attachments/assets/c4d00479-5826-45de-87b1-d94ff829baf1"
/>

Author: MartinquaXD

Cargo.lock

@@ -275,8 +275,9 @@ pub async fn run(config: Configuration, shutdown_controller: ShutdownController)
     let gas_price_estimator = Arc::new(
         gas_price_estimation::create_priority_estimator(
             http_factory.create(),
-            &web3,
+            &web3.provider,
             &gas_estimators,
+            eth.current_block(),
         )
         .await
         .expect("failed to create gas price estimator"),

crates/autopilot/src/run.rs

@@ -8,7 +8,7 @@ use {
     alloy::eips::eip1559::Eip1559Estimation,
     anyhow::anyhow,
     eth_domain_types as eth,
-    ethrpc::Web3,
+    ethrpc::{AlloyProvider, block_stream::CurrentBlockWatcher},
     gas_price_estimation::{
         GasPriceEstimating,
         configurable_alloy::ConfigurableGasPriceEstimator,
@@ -17,67 +17,33 @@ use {
     std::sync::Arc,
 };
 
-type MaxAdditionalTip = eth::U256;
-type AdditionalTipPercentage = f64;
-type AdditionalTip = (MaxAdditionalTip, AdditionalTipPercentage);
-
 pub struct GasPriceEstimator {
     pub(super) gas: Arc<dyn GasPriceEstimating>,
-    additional_tip: AdditionalTip,
-    max_fee_per_gas: eth::U256,
-    min_priority_fee: eth::U256,
+    adjustments: GasPriceParameters,
 }
 
 impl GasPriceEstimator {
     pub async fn new(
-        web3: &Web3,
+        provider: &AlloyProvider,
+        current_block: &CurrentBlockWatcher,
         gas_estimator_type: &GasEstimatorType,
-        mempools: &[mempool::Config],
+        adjustments: GasPriceParameters,
     ) -> Result<Self, Error> {
         let gas: Arc<dyn GasPriceEstimating> = match gas_estimator_type {
-            GasEstimatorType::Web3 => Arc::new(NodeGasPriceEstimator::new(web3.provider.clone())),
+            GasEstimatorType::Web3 => Arc::new(NodeGasPriceEstimator::new(provider.clone())),
             GasEstimatorType::Alloy {
                 past_blocks,
                 reward_percentile,
             } => Arc::new(ConfigurableGasPriceEstimator::new(
-                web3.provider.clone(),
+                provider.clone(),
                 configs::gas_price_estimation::EstimatorConfig {
                     past_blocks: *past_blocks,
                     reward_percentile: *reward_percentile,
                 },
+                current_block.clone(),
             )),
         };
-        // TODO: simplify logic by moving gas price adjustments out of the individual
-        // mempool configs
-        let additional_tip = mempools
-            .iter()
-            .map(|mempool| {
-                (
-                    mempool.max_additional_tip,
-                    mempool.additional_tip_percentage,
-                )
-            })
-            .next()
-            .unwrap_or((eth::U256::ZERO, 0.));
-        // Use the lowest max_fee_per_gas of all mempools as the max_fee_per_gas
-        let max_fee_per_gas = mempools
-            .iter()
-            .map(|mempool| mempool.gas_price_cap)
-            .min()
-            .expect("at least one mempool");
-
-        // Use the highest min_priority_fee of all mempools as the min_priority_fee
-        let min_priority_fee = mempools
-            .iter()
-            .map(|mempool| mempool.min_priority_fee)
-            .max()
-            .expect("at least one mempool");
-        Ok(Self {
-            gas,
-            additional_tip,
-            max_fee_per_gas,
-            min_priority_fee,
-        })
+        Ok(Self { gas, adjustments })
     }
 
     /// Estimates the gas price for a transaction.
@@ -88,29 +54,25 @@ impl GasPriceEstimator {
         let estimate = self.gas.estimate().await.map_err(Error::GasPrice)?;
 
         let max_priority_fee_per_gas = {
-            // the driver supports tweaking the tx gas price tip in case the gas
-            // price estimator is systematically too low => compute configured tip bump
-            let (max_additional_tip, tip_percentage_increase) = self.additional_tip;
-
             // Calculate additional tip in integer space to avoid precision loss
             // Convert percentage to basis points (multiply by 10000) to maintain precision
-            // e.g., tip_percentage_increase = 0.125 (12.5%) becomes 1250
+            // e.g., additional_tip_percentage = 0.125 (12.5%) becomes 1250
             let overflow_err = || {
                 Error::GasPrice(anyhow!(
                     "overflow on multiplication (max_priority_fee_per_gas * tip_percentage_as_bps)"
                 ))
             };
-            let tip_percentage_as_bps = tip_percentage_increase * 10000.0;
+            let tip_percentage_as_bps = self.adjustments.additional_tip_factor * 10000.0;
             let calculated_tip = eth::U256::from(estimate.max_priority_fee_per_gas)
                 .checked_mul(eth::U256::from(tip_percentage_as_bps))
                 .ok_or_else(overflow_err)?
                 / eth::U256::from(10000u128);
 
-            let additional_tip = max_additional_tip.min(calculated_tip);
+            let additional_tip = self.adjustments.max_additional_tip.min(calculated_tip);
 
             // make sure we tip at least some configurable minimum amount
             std::cmp::max(
-                self.min_priority_fee,
+                self.adjustments.min_priority_fee,
                 eth::U256::from(estimate.max_priority_fee_per_gas) + additional_tip,
             )
         };
@@ -120,7 +82,7 @@ impl GasPriceEstimator {
         let suggested_max_fee_per_gas = eth::U256::from(estimate.max_fee_per_gas);
         let suggested_max_fee_per_gas =
             std::cmp::max(suggested_max_fee_per_gas, max_priority_fee_per_gas);
-        if suggested_max_fee_per_gas > self.max_fee_per_gas {
+        if suggested_max_fee_per_gas > self.adjustments.max_fee_per_gas {
             return Err(Error::GasPrice(anyhow::anyhow!(
                 "suggested gas price is higher than maximum allowed gas price (network is too \
                  congested)"
@@ -146,3 +108,42 @@ impl GasPriceEstimating for GasPriceEstimator {
         self.gas.base_fee().await
     }
 }
+
+/// Set of tweaks to fine tune the computed gas price.
+pub struct GasPriceParameters {
+    /// Maximum priority_fee_per_gas added on top of the price suggested by the
+    /// estimator.
+    max_additional_tip: eth::U256,
+    /// The max_priority_fee_per_gas suggested by the gas price estimator gets
+    /// multiplied with this factor and get capped at `max_additional_tip`.
+    additional_tip_factor: f64,
+    /// Highest `max_fee_per_gas` at which we still want to submit a tx.
+    max_fee_per_gas: eth::U256,
+    /// We'll always tip at least this value for `max_priority_fee_per_gas`.
+    min_priority_fee: eth::U256,
+}
+
+pub fn adjustments(mempools: &[mempool::Config]) -> GasPriceParameters {
+    // TODO: make configuration of those parameters more obvious by moving them
+    // into a separate config field instead of deriving them from the mempool
+    // configs
+    let mut max_additional_tip = eth::U256::ZERO;
+    let mut additional_tip_percentage = 0.0f64;
+    let mut max_fee_per_gas = eth::U256::MAX;
+    let mut min_priority_fee = eth::U256::ZERO;
+
+    for mempool in mempools {
+        max_additional_tip = max_additional_tip.max(mempool.max_additional_tip);
+        additional_tip_percentage =
+            additional_tip_percentage.max(mempool.additional_tip_percentage);
+        max_fee_per_gas = max_fee_per_gas.min(mempool.gas_price_cap);
+        min_priority_fee = min_priority_fee.max(mempool.min_priority_fee);
+    }
+
+    GasPriceParameters {
+        max_additional_tip,
+        additional_tip_factor: additional_tip_percentage,
+        max_fee_per_gas,
+        min_priority_fee,
+    }
+}

crates/driver/src/infra/blockchain/gas.rs

@@ -1,5 +1,9 @@
 use {
-    crate::{boundary, domain::blockchain::TxStatus},
+    crate::{
+        boundary,
+        domain::blockchain::TxStatus,
+        infra::{blockchain::gas::GasPriceParameters, config::file::GasEstimatorType},
+    },
     account_balances::{BalanceSimulator, SimulationError},
     alloy::{
         eips::eip1559::Eip1559Estimation,
@@ -104,16 +108,28 @@ impl Ethereum {
     pub async fn new(
         rpc: Rpc,
         addresses: contracts::Addresses,
-        gas: Arc<GasPriceEstimator>,
         current_block_args: &shared::current_block::Arguments,
         tx_gas_limit: eth::Gas,
+        gas_estimator_type: &GasEstimatorType,
+        gas_adjustments: GasPriceParameters,
     ) -> Self {
         let Rpc { web3, chain, args } = rpc;
         let current_block_stream = current_block_args
             .stream(args.url.clone(), web3.provider.clone())
             .await
             .expect("couldn't initialize current block stream");
 
+        let gas = Arc::new(
+            GasPriceEstimator::new(
+                &web3.provider,
+                &current_block_stream,
+                gas_estimator_type,
+                gas_adjustments,
+            )
+            .await
+            .expect("initialize gas price estimator"),
+        );
+
         let contracts = Contracts::new(&web3, chain, addresses)
             .await
             .expect("could not initialize important smart contracts");

crates/driver/src/infra/blockchain/mod.rs

@@ -7,7 +7,7 @@ use {
         infra::{
             self,
             Api,
-            blockchain::{self, Ethereum},
+            blockchain::{self, Ethereum, gas},
             cli,
             config,
             liquidity,
@@ -16,12 +16,11 @@ use {
         },
     },
     clap::Parser,
-    eth_domain_types as eth,
     futures::future::join_all,
     http_client::HttpClientFactory,
     shared::arguments::tracing_config,
     simulator::{self, Simulator},
-    std::{net::SocketAddr, sync::Arc, time::Duration},
+    std::{net::SocketAddr, time::Duration},
     tokio::sync::oneshot,
 };
 
@@ -64,7 +63,16 @@ async fn run_with(args: cli::Args, addr_sender: Option<oneshot::Sender<SocketAdd
     tracing::info!(%commit_hash, "running driver with {config:#?}");
 
     let (shutdown_sender, shutdown_receiver) = tokio::sync::oneshot::channel();
-    let eth = ethereum(&config, ethrpc.clone(), &args.current_block).await;
+    let eth = Ethereum::new(
+        ethrpc.clone(),
+        config.contracts.clone(),
+        &args.current_block,
+        config.tx_gas_limit.into(),
+        &config.gas_estimator,
+        gas::adjustments(&config.mempools),
+    )
+    .await;
+
     let simulator_eth = simulator::Ethereum::new(
         ethrpc.web3().clone(),
         ethrpc.chain(),
@@ -186,26 +194,6 @@ async fn ethrpc(args: &cli::Args) -> blockchain::Rpc {
         .expect("connect ethereum RPC")
 }
 
-async fn ethereum(
-    config: &infra::Config,
-    ethrpc: blockchain::Rpc,
-    current_block_args: &shared::current_block::Arguments,
-) -> Ethereum {
-    let gas = Arc::new(
-        blockchain::GasPriceEstimator::new(ethrpc.web3(), &config.gas_estimator, &config.mempools)
-            .await
-            .expect("initialize gas price estimator"),
-    );
-    Ethereum::new(
-        ethrpc,
-        config.contracts.clone(),
-        gas,
-        current_block_args,
-        eth::Gas(config.tx_gas_limit),
-    )
-    .await
-}
-
 async fn solvers(config: &config::Config, eth: &Ethereum) -> Vec<Solver> {
     join_all(
         config

crates/driver/src/run.rs

@@ -9,7 +9,12 @@ use {
             competition::order,
             time::{self},
         },
-        infra::{self, Ethereum, blockchain::contracts::Addresses, config::file::FeeHandler},
+        infra::{
+            self,
+            Ethereum,
+            blockchain::{contracts::Addresses, gas},
+            config::file::FeeHandler,
+        },
         tests::setup::blockchain::Trade,
     },
     alloy::{primitives::Address, signers::local::PrivateKeySigner},
@@ -474,17 +479,6 @@ impl Solver {
         })
         .await
         .unwrap();
-        let gas = Arc::new(
-            infra::blockchain::GasPriceEstimator::new(
-                rpc.web3(),
-                &Default::default(),
-                &[infra::mempool::Config::test_config(
-                    config.blockchain.web3_url.parse().unwrap(),
-                )],
-            )
-            .await
-            .unwrap(),
-        );
         let eth = Ethereum::new(
             rpc,
             Addresses {
@@ -495,12 +489,15 @@ impl Solver {
                 cow_amm_helper_by_factory: Default::default(),
                 flashloan_router: Some((*config.blockchain.flashloan_router.address()).into()),
             },
-            gas,
             &shared::current_block::Arguments {
                 block_stream_poll_interval: None,
                 node_ws_url: Some(config.blockchain.web3_ws_url.parse().unwrap()),
             },
             eth_domain_types::Gas(eth_domain_types::U256::from(45_000_000u64)),
+            &Default::default(),
+            gas::adjustments(&[infra::mempool::Config::test_config(
+                config.blockchain.web3_url.parse().unwrap(),
+            )]),
         )
         .await;
 

crates/driver/src/tests/setup/solver.rs

@@ -23,6 +23,7 @@ url = { workspace = true }
 
 [dev-dependencies]
 mockall = { workspace = true }
+serde_json = { workspace = true }
 
 [lints]
 workspace = true