feat(rpc): add rundler_getUserOperationGasPrice endpoint (#1263)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: dancoombs

bin/rundler/src/cli/rpc.rs

@@ -18,7 +18,7 @@ use clap::Args;
 use rundler_builder::RemoteBuilderClient;
 use rundler_pool::RemotePoolClient;
 use rundler_provider::Providers;
-use rundler_rpc::{EthApiSettings, RpcTask, RpcTaskArgs};
+use rundler_rpc::{EthApiSettings, RpcTask, RpcTaskArgs, RundlerApiSettings};
 use rundler_task::{TaskSpawnerExt, server::connect_with_retries_shutdown};
 use rundler_types::chain::{ChainSpec, TryIntoWithSpec};
 
@@ -98,6 +98,26 @@ pub struct RpcArgs {
         default_value = "false"
     )]
     permissions_enabled: bool,
+
+    /// Priority fee buffer percent for gas price suggestions.
+    /// The suggested priority fee will be this percent above the current required priority fee.
+    #[arg(
+        long = "rpc.priority_fee_suggested_buffer_percent",
+        name = "rpc.priority_fee_suggested_buffer_percent",
+        env = "RPC_PRIORITY_FEE_SUGGESTED_BUFFER_PERCENT",
+        default_value = "30"
+    )]
+    priority_fee_suggested_buffer_percent: u64,
+
+    /// Base fee buffer percent for gas price suggestions.
+    /// The suggested max fee will use a base fee multiplied by (100 + this value) / 100.
+    #[arg(
+        long = "rpc.base_fee_suggested_buffer_percent",
+        name = "rpc.base_fee_suggested_buffer_percent",
+        env = "RPC_BASE_FEE_SUGGESTED_BUFFER_PERCENT",
+        default_value = "50"
+    )]
+    base_fee_suggested_buffer_percent: u64,
 }
 
 impl RpcArgs {
@@ -121,13 +141,19 @@ impl RpcArgs {
                 .user_operation_event_block_distance_fallback,
         };
 
+        let rundler_api_settings = RundlerApiSettings {
+            priority_fee_buffer_percent: self.priority_fee_suggested_buffer_percent,
+            base_fee_buffer_percent: self.base_fee_suggested_buffer_percent,
+        };
+
         Ok(RpcTaskArgs {
             unsafe_mode: common.unsafe_mode,
             port: self.port,
             host: self.host.clone(),
             rpc_url: common.node_http.clone().context("must provide node_http")?,
             api_namespaces: apis,
             eth_api_settings,
+            rundler_api_settings,
             estimation_settings: common.try_into_with_spec(&chain_spec)?,
             rpc_timeout: Duration::from_secs(self.timeout_seconds.parse()?),
             max_connections: self.max_connections,

crates/provider/src/fees/mod.rs

@@ -12,13 +12,14 @@
 // If not, see https://www.gnu.org/licenses/.
 
 use alloy_primitives::B256;
+use alloy_rpc_types_eth::BlockNumberOrTag;
 use anyhow::Context;
 use rundler_types::{GasFees, PriorityFeeMode, chain::ChainSpec};
 use rundler_utils::{cache::LruMap, math};
 use tokio::{sync::Mutex as TokioMutex, try_join};
 use tracing::instrument;
 
-use crate::{EvmProvider, FeeEstimator};
+use crate::{EvmProvider, FeeEstimator, LatestFeeEstimate};
 
 mod oracle;
 use oracle::*;
@@ -83,8 +84,15 @@ impl<P: EvmProvider, O: FeeOracle> FeeEstimatorImpl<P, O> {
     }
 
     #[instrument(skip_all)]
-    async fn get_pending_base_fee(&self) -> anyhow::Result<u128> {
-        Ok(self.provider.get_pending_base_fee().await?)
+    async fn get_pending_base_fee_and_block_number(&self) -> anyhow::Result<(u128, u64)> {
+        let fee_history = self
+            .provider
+            .fee_history(1, BlockNumberOrTag::Latest, &[])
+            .await?;
+        let base_fee = fee_history
+            .next_block_base_fee()
+            .context("should have a next block base fee")?;
+        Ok((base_fee, fee_history.oldest_block))
     }
 
     #[instrument(skip_all)]
@@ -100,10 +108,35 @@ impl<P: EvmProvider, O: FeeOracle> FeeEstimatorImpl<P, O> {
 impl<P: EvmProvider, O: FeeOracle> FeeEstimator for FeeEstimatorImpl<P, O> {
     #[instrument(skip_all)]
     async fn latest_bundle_fees(&self) -> anyhow::Result<(GasFees, u128)> {
-        let (base_fee, priority_fee) =
-            try_join!(self.get_pending_base_fee(), self.get_priority_fee())?;
+        let estimate = self.latest_fee_estimate().await?;
+        let bundle_fees = GasFees {
+            max_fee_per_gas: estimate
+                .required_base_fee
+                .saturating_add(estimate.required_priority_fee),
+            max_priority_fee_per_gas: estimate.required_priority_fee,
+        };
+
+        Ok((bundle_fees, estimate.required_base_fee))
+    }
 
-        Ok(self.calc_bundle_fees(base_fee, priority_fee, None))
+    #[instrument(skip_all)]
+    async fn latest_fee_estimate(&self) -> anyhow::Result<LatestFeeEstimate> {
+        let ((base_fee, block_number), priority_fee) = try_join!(
+            self.get_pending_base_fee_and_block_number(),
+            self.get_priority_fee()
+        )?;
+
+        let required_base_fee =
+            math::increase_by_percent(base_fee, self.bundle_base_fee_overhead_percent);
+        let required_priority_fee =
+            math::increase_by_percent(priority_fee, self.bundle_priority_fee_overhead_percent);
+
+        Ok(LatestFeeEstimate {
+            block_number,
+            base_fee,
+            required_base_fee,
+            required_priority_fee,
+        })
     }
 
     #[instrument(skip_all)]
@@ -116,8 +149,10 @@ impl<P: EvmProvider, O: FeeOracle> FeeEstimator for FeeEstimatorImpl<P, O> {
         let entry = match cache.get(&block_hash) {
             Some(entry) => *entry,
             None => {
-                let (base_fee, priority_fee) =
-                    try_join!(self.get_pending_base_fee(), self.get_priority_fee())?;
+                let ((base_fee, _), priority_fee) = try_join!(
+                    self.get_pending_base_fee_and_block_number(),
+                    self.get_priority_fee()
+                )?;
 
                 let entry = CacheEntry {
                     base_fee,

crates/provider/src/traits/fee_estimator.rs

@@ -14,6 +14,19 @@
 use alloy_primitives::B256;
 use rundler_types::GasFees;
 
+/// Latest fee estimates for bundling.
+#[derive(Debug, Clone, Copy)]
+pub struct LatestFeeEstimate {
+    /// Block number this estimate is based on.
+    pub block_number: u64,
+    /// Current pending base fee (without bundler overhead).
+    pub base_fee: u128,
+    /// Base fee with bundler overhead applied.
+    pub required_base_fee: u128,
+    /// Priority fee with bundler overhead applied.
+    pub required_priority_fee: u128,
+}
+
 /// Trait for a fee estimator.
 #[async_trait::async_trait]
 #[auto_impl::auto_impl(&, &mut, Rc, Arc, Box)]
@@ -34,6 +47,9 @@ pub trait FeeEstimator: Send + Sync {
     /// Returns the latest bundle fees.
     async fn latest_bundle_fees(&self) -> anyhow::Result<(GasFees, u128)>;
 
+    /// Returns the latest fee estimate including base fee, priority fee (with bundler overhead), and block number.
+    async fn latest_fee_estimate(&self) -> anyhow::Result<LatestFeeEstimate>;
+
     /// Returns the required operation fees for the given bundle fees.
     fn required_op_fees(&self, bundle_fees: GasFees) -> GasFees;
 }

crates/provider/src/traits/test_utils.rs

@@ -32,8 +32,9 @@ use super::error::ProviderResult;
 use crate::{
     AggregatorOut, Block, BlockHashOrNumber, BundleHandler, DAGasOracle, DAGasOracleSync,
     DAGasProvider, DepositInfo, EntryPoint, EntryPointProvider, EvmCall,
-    EvmProvider as EvmProviderTrait, ExecutionResult, FeeEstimator, HandleOpsOut, RpcRecv, RpcSend,
-    SignatureAggregator, SimulationProvider, Transaction, TransactionReceipt, TransactionRequest,
+    EvmProvider as EvmProviderTrait, ExecutionResult, FeeEstimator, HandleOpsOut,
+    LatestFeeEstimate, RpcRecv, RpcSend, SignatureAggregator, SimulationProvider, Transaction,
+    TransactionReceipt, TransactionRequest,
 };
 
 mockall::mock! {
@@ -392,6 +393,7 @@ mockall::mock! {
             min_fees: Option<GasFees>,
         ) -> anyhow::Result<(GasFees, u128)>;
         async fn latest_bundle_fees(&self) -> anyhow::Result<(GasFees, u128)>;
+        async fn latest_fee_estimate(&self) -> anyhow::Result<LatestFeeEstimate>;
         fn required_op_fees(&self, bundle_fees: GasFees) -> GasFees;
     }
 }

crates/rpc/src/lib.rs

@@ -33,7 +33,7 @@ pub use eth::{EthApiClient, EthApiSettings};
 mod health;
 
 mod rundler;
-pub use rundler::RundlerApiClient;
+pub use rundler::{RundlerApiClient, RundlerApiSettings};
 
 mod task;
 pub use task::{Args as RpcTaskArgs, RpcTask};

crates/rpc/src/rundler.rs

@@ -11,26 +11,44 @@
 // You should have received a copy of the GNU General Public License along with Rundler.
 // If not, see https://www.gnu.org/licenses/.
 
-use alloy_primitives::{Address, B256, U128, U256};
+use alloy_primitives::{Address, B256, U64, U128, U256};
 use anyhow::Context;
 use async_trait::async_trait;
 use futures_util::future;
 use jsonrpsee::{core::RpcResult, proc_macros::rpc};
 use rundler_provider::{EvmProvider, FeeEstimator};
 use rundler_types::{
-    UserOperation, UserOperationId, UserOperationVariant, chain::ChainSpec, pool::Pool,
+    GasFees, UserOperation, UserOperationId, UserOperationVariant, chain::ChainSpec, pool::Pool,
 };
 use tracing::instrument;
 
 use crate::{
     eth::{EntryPointRouter, EthResult, EthRpcError},
     types::{
-        RpcMinedUserOperation, RpcUserOperation, RpcUserOperationStatus, UOStatusEnum,
-        UserOperationStatusEnum,
+        RpcMinedUserOperation, RpcSuggestedGasFees, RpcUserOperation, RpcUserOperationGasPrice,
+        RpcUserOperationStatus, UOStatusEnum, UserOperationStatusEnum,
     },
     utils::{self, TryIntoRundlerType},
 };
 
+/// Settings for the rundler API
+#[derive(Clone, Copy, Debug)]
+pub struct RundlerApiSettings {
+    /// Priority fee buffer percent for gas price suggestions (e.g., 30 for 30% above current)
+    pub priority_fee_buffer_percent: u64,
+    /// Base fee buffer percent for gas price suggestions (e.g., 50 for 1.5x base fee)
+    pub base_fee_buffer_percent: u64,
+}
+
+impl Default for RundlerApiSettings {
+    fn default() -> Self {
+        Self {
+            priority_fee_buffer_percent: 30,
+            base_fee_buffer_percent: 50,
+        }
+    }
+}
+
 #[rpc(client, server, namespace = "rundler")]
 pub trait RundlerApi {
     /// Returns the maximum priority fee per gas required by Rundler
@@ -72,6 +90,10 @@ pub trait RundlerApi {
         sender: Address,
         nonce: U256,
     ) -> RpcResult<Option<RpcUserOperation>>;
+
+    /// Returns suggested gas prices for user operations
+    #[method(name = "getUserOperationGasPrice")]
+    async fn get_user_operation_gas_price(&self) -> RpcResult<RpcUserOperationGasPrice>;
 }
 
 pub(crate) struct RundlerApi<P, F, E> {
@@ -80,6 +102,7 @@ pub(crate) struct RundlerApi<P, F, E> {
     pool_server: P,
     entry_point_router: EntryPointRouter,
     evm_provider: E,
+    settings: RundlerApiSettings,
 }
 
 #[async_trait]
@@ -149,6 +172,15 @@ where
         )
         .await
     }
+
+    #[instrument(skip_all, fields(rpc_method = "rundler_getUserOperationGasPrice"))]
+    async fn get_user_operation_gas_price(&self) -> RpcResult<RpcUserOperationGasPrice> {
+        utils::safe_call_rpc_handler(
+            "rundler_getUserOperationGasPrice",
+            RundlerApi::get_user_operation_gas_price(self),
+        )
+        .await
+    }
 }
 
 impl<P, F, E> RundlerApi<P, F, E>
@@ -163,22 +195,30 @@ where
         pool_server: P,
         fee_estimator: F,
         evm_provider: E,
+        settings: RundlerApiSettings,
     ) -> Self {
         Self {
             chain_spec: chain_spec.clone(),
             entry_point_router,
             pool_server,
             fee_estimator,
             evm_provider,
+            settings,
         }
     }
     #[instrument(skip_all)]
     async fn max_priority_fee_per_gas(&self) -> EthResult<U128> {
-        let (bundle_fees, _) = self
+        let estimate = self
             .fee_estimator
-            .latest_bundle_fees()
+            .latest_fee_estimate()
             .await
             .context("should get required fees")?;
+        let bundle_fees = GasFees {
+            max_fee_per_gas: estimate
+                .required_base_fee
+                .saturating_add(estimate.required_priority_fee),
+            max_priority_fee_per_gas: estimate.required_priority_fee,
+        };
         Ok(U128::from(
             self.fee_estimator
                 .required_op_fees(bundle_fees)
@@ -344,4 +384,50 @@ where
 
         Ok(uo.map(|uo| uo.uo.into()))
     }
+
+    #[instrument(skip_all)]
+    async fn get_user_operation_gas_price(&self) -> EthResult<RpcUserOperationGasPrice> {
+        // Get base fee, priority fee (with bundler overhead), and block number
+        let estimate = self
+            .fee_estimator
+            .latest_fee_estimate()
+            .await
+            .context("should get fee estimate")?;
+        let bundle_fees = GasFees {
+            max_fee_per_gas: estimate
+                .required_base_fee
+                .saturating_add(estimate.required_priority_fee),
+            max_priority_fee_per_gas: estimate.required_priority_fee,
+        };
+
+        // Convert to user operation fees (current required)
+        let op_fees = self.fee_estimator.required_op_fees(bundle_fees);
+        let priority_fee = op_fees.max_priority_fee_per_gas;
+
+        // Calculate suggested priority fee with configured buffer
+        let priority_multiplier =
+            100u128.saturating_add(u128::from(self.settings.priority_fee_buffer_percent));
+        let suggested_priority_fee = priority_fee
+            .saturating_mul(priority_multiplier)
+            .saturating_div(100);
+
+        // Calculate suggested max fee with configured base fee buffer
+        let base_fee_multiplier =
+            100u128.saturating_add(u128::from(self.settings.base_fee_buffer_percent));
+        let suggested_max_fee = estimate
+            .required_base_fee
+            .saturating_mul(base_fee_multiplier)
+            .saturating_div(100)
+            .saturating_add(suggested_priority_fee);
+
+        Ok(RpcUserOperationGasPrice {
+            priority_fee: U128::from(priority_fee),
+            base_fee: U128::from(estimate.base_fee),
+            block_number: U64::from(estimate.block_number),
+            suggested: RpcSuggestedGasFees {
+                max_priority_fee_per_gas: U128::from(suggested_priority_fee),
+                max_fee_per_gas: U128::from(suggested_max_fee),
+            },
+        })
+    }
 }

crates/rpc/src/task.rs

@@ -41,7 +41,7 @@ use crate::{
     },
     health::{HealthChecker, SystemApiServer},
     rpc_metrics::{HttpMetricMiddlewareLayer, RpcMetricsMiddlewareLayer},
-    rundler::{RundlerApi, RundlerApiServer},
+    rundler::{RundlerApi, RundlerApiServer, RundlerApiSettings},
     types::ApiNamespace,
 };
 
@@ -62,6 +62,8 @@ pub struct Args {
     pub rpc_url: String,
     /// eth_ API settings.
     pub eth_api_settings: EthApiSettings,
+    /// rundler_ API settings.
+    pub rundler_api_settings: RundlerApiSettings,
     /// Estimation settings.
     pub estimation_settings: EstimationSettings,
     /// RPC timeout.
@@ -292,6 +294,7 @@ where
                     self.pool.clone(),
                     fee_estimator,
                     self.providers.evm().clone(),
+                    self.args.rundler_api_settings,
                 )
                 .into_rpc(),
             )?;