fix(sim): use a higher limit for the gas estimation execution gas limit call (#1159)

dancoombs · web-flow · commit 9d59ce9b07f9 · 2025-06-11T17:26:57.000-04:00
diff --git a/bin/rundler/src/cli/mod.rs b/bin/rundler/src/cli/mod.rs
@@ -409,6 +409,15 @@ pub struct CommonArgs {
     )]
     pub call_gas_allowed_error_pct: u128,
 
+    #[arg(
+        long = "max_gas_estimation_gas",
+        name = "max_gas_estimation_gas",
+        env = "MAX_GAS_ESTIMATION_GAS",
+        default_value = "550000000",
+        global = true
+    )]
+    pub max_gas_estimation_gas: u64,
+
     #[arg(
         long = "max_gas_estimation_rounds",
         name = "max_gas_estimation_rounds",
@@ -555,7 +564,7 @@ impl TryFromWithSpec<&CommonArgs> for EstimationSettings {
             > max_bundle_execution_gas.saturating_sub(SIMULATION_GAS_OVERHEAD) as u64
         {
             anyhow::bail!(
-                "max_verification_gas ({}) must be less than max_simulate_handle_ops_gas ({}) by at least {}",
+                "max_verification_gas ({}) must be less than max_bundle_execution_gas ({}) by at least {}",
                 value.max_verification_gas,
                 max_bundle_execution_gas,
                 SIMULATION_GAS_OVERHEAD
@@ -822,6 +831,7 @@ pub fn construct_providers(
             chain_spec.clone(),
             args.max_verification_gas,
             max_bundle_execution_gas,
+            args.max_gas_estimation_gas,
             max_bundle_execution_gas,
             provider.clone(),
             da_gas_oracle.clone(),
@@ -835,6 +845,7 @@ pub fn construct_providers(
             chain_spec.clone(),
             args.max_verification_gas,
             max_bundle_execution_gas,
+            args.max_gas_estimation_gas,
             max_bundle_execution_gas,
             provider.clone(),
             da_gas_oracle.clone(),
diff --git a/crates/provider/src/alloy/entry_point/v0_6.rs b/crates/provider/src/alloy/entry_point/v0_6.rs
@@ -53,6 +53,7 @@ pub struct EntryPointProvider<AP, D> {
     da_gas_oracle: D,
     max_verification_gas: u64,
     max_simulate_handle_op_gas: u64,
+    max_gas_estimation_gas: u64,
     max_aggregation_gas: u64,
     chain_spec: ChainSpec,
 }
@@ -67,6 +68,7 @@ where
         chain_spec: ChainSpec,
         max_verification_gas: u64,
         max_simulate_handle_op_gas: u64,
+        max_gas_estimation_gas: u64,
         max_aggregation_gas: u64,
         provider: AP,
         da_gas_oracle: D,
@@ -79,6 +81,7 @@ where
             da_gas_oracle,
             max_verification_gas,
             max_simulate_handle_op_gas,
+            max_gas_estimation_gas,
             max_aggregation_gas,
             chain_spec,
         }
@@ -455,40 +458,19 @@ where
         target: Address,
         target_call_data: Bytes,
         block_id: BlockId,
-        mut state_override: StateOverride,
+        state_override: StateOverride,
     ) -> ProviderResult<Result<ExecutionResult, ValidationRevert>> {
-        let da_gas: u64 = op
-            .pre_verification_da_gas_limit(&self.chain_spec, Some(1))
-            .try_into()
-            .unwrap_or(u64::MAX);
-
-        if let Some(authorization) = op.authorization_tuple() {
-            authorization_utils::apply_7702_overrides(
-                &mut state_override,
-                op.sender(),
-                authorization.address,
-            );
-        }
-
-        let contract_error = self
-            .i_entry_point
-            .simulateHandleOp(op.into(), target, target_call_data)
-            .block(block_id)
-            .gas(self.max_simulate_handle_op_gas.saturating_add(da_gas))
-            .state(state_override)
-            .call()
-            .await
-            .err()
-            .context("simulateHandleOp succeeded, but should always revert")?;
-        match contract_error {
-            ContractError::TransportError(TransportError::ErrorResp(resp)) => {
-                match resp.as_revert_data() {
-                    Some(err_bytes) => Ok(Self::decode_simulate_handle_ops_revert(&err_bytes)?),
-                    None => Ok(Err(ValidationRevert::Unknown(Bytes::default()))),
-                }
-            }
-            _ => Err(contract_error.into()),
-        }
+        simulate_handle_op_inner::<Self, AP>(
+            &self.chain_spec,
+            self.max_simulate_handle_op_gas,
+            &self.i_entry_point,
+            op,
+            target,
+            target_call_data,
+            block_id,
+            state_override,
+        )
+        .await
     }
 
     #[instrument(skip_all)]
@@ -500,8 +482,17 @@ where
         block_id: BlockId,
         state_override: StateOverride,
     ) -> ProviderResult<Result<ExecutionResult, ValidationRevert>> {
-        self.simulate_handle_op(op, target, target_call_data, block_id, state_override)
-            .await
+        simulate_handle_op_inner::<Self, AP>(
+            &self.chain_spec,
+            self.max_gas_estimation_gas,
+            &self.i_entry_point,
+            op,
+            target,
+            target_call_data,
+            block_id,
+            state_override,
+        )
+        .await
     }
 
     fn decode_simulate_handle_ops_revert(
@@ -660,6 +651,50 @@ pub fn decode_ops_from_calldata(
     }
 }
 
+#[allow(clippy::too_many_arguments)]
+async fn simulate_handle_op_inner<S: SimulationProvider, AP: AlloyProvider>(
+    chain_spec: &ChainSpec,
+    execution_gas_limit: u64,
+    entry_point: &IEntryPointInstance<AP, AnyNetwork>,
+    op: UserOperation,
+    target: Address,
+    target_call_data: Bytes,
+    block_id: BlockId,
+    mut state_override: StateOverride,
+) -> ProviderResult<Result<ExecutionResult, ValidationRevert>> {
+    let da_gas: u64 = op
+        .pre_verification_da_gas_limit(chain_spec, Some(1))
+        .try_into()
+        .unwrap_or(u64::MAX);
+
+    if let Some(authorization) = op.authorization_tuple() {
+        authorization_utils::apply_7702_overrides(
+            &mut state_override,
+            op.sender(),
+            authorization.address,
+        );
+    }
+
+    let contract_error = entry_point
+        .simulateHandleOp(op.into(), target, target_call_data)
+        .block(block_id)
+        .gas(execution_gas_limit.saturating_add(da_gas))
+        .state(state_override)
+        .call()
+        .await
+        .err()
+        .context("simulateHandleOp succeeded, but should always revert")?;
+    match contract_error {
+        ContractError::TransportError(TransportError::ErrorResp(resp)) => {
+            match resp.as_revert_data() {
+                Some(err_bytes) => Ok(S::decode_simulate_handle_ops_revert(&err_bytes)?),
+                None => Err(TransportError::ErrorResp(resp).into()),
+            }
+        }
+        _ => Err(contract_error.into()),
+    }
+}
+
 impl TryFrom<ExecutionResultV0_6> for ExecutionResult {
     type Error = anyhow::Error;
 
diff --git a/crates/provider/src/alloy/entry_point/v0_7.rs b/crates/provider/src/alloy/entry_point/v0_7.rs
@@ -13,7 +13,6 @@
 
 use alloy_contract::Error as ContractError;
 use alloy_eips::eip7702::SignedAuthorization;
-use alloy_json_rpc::ErrorPayload;
 use alloy_primitives::{Address, Bytes, U256};
 use alloy_provider::network::{AnyNetwork, TransactionBuilder7702};
 use alloy_rpc_types_eth::{
@@ -61,6 +60,7 @@ pub struct EntryPointProvider<AP, D> {
     da_gas_oracle: D,
     max_verification_gas: u64,
     max_simulate_handle_ops_gas: u64,
+    max_gas_estimation_gas: u64,
     max_aggregation_gas: u64,
     chain_spec: ChainSpec,
 }
@@ -74,6 +74,7 @@ where
         chain_spec: ChainSpec,
         max_verification_gas: u64,
         max_simulate_handle_ops_gas: u64,
+        max_gas_estimation_gas: u64,
         max_aggregation_gas: u64,
         provider: AP,
         da_gas_oracle: D,
@@ -86,6 +87,7 @@ where
             da_gas_oracle,
             max_verification_gas,
             max_simulate_handle_ops_gas,
+            max_gas_estimation_gas,
             max_aggregation_gas,
             chain_spec,
         }
@@ -500,7 +502,13 @@ where
                     .context("failed to decode validation result")?;
                 Ok(Ok(out.try_into().map_err(anyhow::Error::msg)?))
             }
-            Err(TransportError::ErrorResp(resp)) => Ok(Err(decode_validation_revert_payload(resp))),
+            Err(TransportError::ErrorResp(resp)) => {
+                if let Some(revert) = resp.as_revert_data() {
+                    Ok(Err(decode_validation_revert(&revert)))
+                } else {
+                    Err(TransportError::ErrorResp(resp).into())
+                }
+            }
             Err(error) => Err(error.into()),
         }
     }
@@ -539,7 +547,7 @@ where
     ) -> ProviderResult<Result<ExecutionResult, ValidationRevert>> {
         simulate_handle_op_inner(
             &self.chain_spec,
-            self.max_simulate_handle_ops_gas,
+            self.max_gas_estimation_gas,
             &self.i_entry_point,
             op,
             target,
@@ -643,13 +651,6 @@ fn get_handle_ops_call<AP: AlloyProvider>(
     txn_request
 }
 
-fn decode_validation_revert_payload(err: ErrorPayload) -> ValidationRevert {
-    match err.as_revert_data() {
-        Some(err_bytes) => decode_validation_revert(&err_bytes),
-        None => ValidationRevert::Unknown(Bytes::default()),
-    }
-}
-
 /// Decodes raw validation revert bytes from a v0.7 entry point
 pub fn decode_validation_revert(err_bytes: &Bytes) -> ValidationRevert {
     if let Ok(rev) = SolContractError::<IEntryPointErrors>::abi_decode(err_bytes) {
@@ -724,7 +725,7 @@ pub fn decode_ops_from_calldata(
 #[allow(clippy::too_many_arguments)]
 async fn simulate_handle_op_inner<AP: AlloyProvider>(
     chain_spec: &ChainSpec,
-    max_simulate_handle_ops_gas: u64,
+    execution_gas_limit: u64,
     entry_point: &IEntryPointInstance<AP, AnyNetwork>,
     op: UserOperation,
     target: Address,
@@ -749,24 +750,30 @@ async fn simulate_handle_op_inner<AP: AlloyProvider>(
         ep_simulations
             .simulateHandleOpNoPostOp(op.pack(), target, target_call_data)
             .block(block_id)
-            .gas(max_simulate_handle_ops_gas.saturating_add(da_gas))
+            .gas(execution_gas_limit.saturating_add(da_gas))
             .state(state_override)
             .call()
             .await
     } else {
         ep_simulations
             .simulateHandleOp(op.pack(), target, target_call_data)
             .block(block_id)
-            .gas(max_simulate_handle_ops_gas.saturating_add(da_gas))
+            .gas(execution_gas_limit.saturating_add(da_gas))
             .state(state_override)
             .call()
             .await
     };
 
+    tracing::info!("simulate_handle_op_inner: {:?}", res);
+
     match res {
         Ok(output) => Ok(Ok(output.try_into()?)),
         Err(ContractError::TransportError(TransportError::ErrorResp(resp))) => {
-            Ok(Err(decode_validation_revert_payload(resp)))
+            if let Some(revert) = resp.as_revert_data() {
+                Ok(Err(decode_validation_revert(&revert)))
+            } else {
+                Err(TransportError::ErrorResp(resp).into())
+            }
         }
         Err(error) => Err(error.into()),
     }
