add trace_call support to detect v0.6 reverts

scripts/config.local.json

@@ -12,6 +12,7 @@
     "entrypoints": "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789,0x0000000071727De22E5E9d8BAf0edAc6f37da032",
     "entrypoint-simulation-contract": "0xBbe8A301FbDb2a4CD58c4A37c262ecef8f889c47",
     "enable-debug-endpoints": true,
+    "code-override-support": true,
     "expiration-check": false,
     "safe-mode": false,
     "api-version": "v1,v2",

src/cli/config/bundler.ts

@@ -162,7 +162,8 @@ export const rpcArgsSchema = z.object({
     "send-transaction-rpc-url": z.string().url().optional(),
     "polling-interval": z.number().int().min(0),
     "max-block-range": z.number().int().min(0).optional(),
-    "block-tag-support": z.boolean().optional().default(true)
+    "block-tag-support": z.boolean().optional().default(true),
+    "code-override-support": z.boolean().optional().default(false)
 })
 
 export const bundleCopmressionArgsSchema = z.object({

src/cli/config/options.ts

@@ -326,6 +326,12 @@ export const rpcOptions: CliCommandOptions<IRpcArgsInput> = {
         type: "boolean",
         require: false,
         default: true
+    },
+    "code-override-support": {
+        description: "Does the RPC support code overrides",
+        type: "boolean",
+        require: false,
+        default: false
     }
 }
 

src/cli/setupServer.ts

@@ -91,6 +91,7 @@ const getValidator = ({
             utilityWalletAddress,
             parsedArgs["binary-search-tolerance-delta"],
             parsedArgs["binary-search-gas-allowance"],
+            parsedArgs["code-override-support"],
             parsedArgs["entrypoint-simulation-contract"],
             parsedArgs["fixed-gas-limit-for-estimation"],
             parsedArgs.tenderly,
@@ -110,6 +111,7 @@ const getValidator = ({
         utilityWalletAddress,
         parsedArgs["binary-search-tolerance-delta"],
         parsedArgs["binary-search-gas-allowance"],
+        parsedArgs["code-override-support"],
         parsedArgs["entrypoint-simulation-contract"],
         parsedArgs["fixed-gas-limit-for-estimation"],
         parsedArgs.tenderly,

src/rpc/estimation/gasEstimationsV06.ts

@@ -1,4 +1,5 @@
 import {
+    ENTRYPOINT_V06_SIMULATION_OVERRIDE,
     EntryPointV06Abi,
     EntryPointV06SimulationsAbi,
     RpcError,
@@ -17,23 +18,92 @@ import {
 } from "viem"
 import { z } from "zod"
 import type { SimulateHandleOpResult } from "./types"
+import { deepHexlify } from "../../utils/userop"
 
 export class GasEstimatorV06 {
     publicClient: PublicClient
     blockTagSupport: boolean
     utilityWalletAddress: Address
     fixedGasLimitForEstimation?: bigint
+    codeOverrideSupport: boolean
 
     constructor(
         publicClient: PublicClient,
         blockTagSupport: boolean,
         utilityWalletAddress: Address,
+        codeOverrideSupport: boolean,
         fixedGasLimitForEstimation?: bigint
     ) {
         this.publicClient = publicClient
         this.blockTagSupport = blockTagSupport
         this.utilityWalletAddress = utilityWalletAddress
         this.fixedGasLimitForEstimation = fixedGasLimitForEstimation
+        this.codeOverrideSupport = codeOverrideSupport
+    }
+
+    decodeSimulateHandleOpResult(data: Hex): SimulateHandleOpResult {
+        if (data === "0x") {
+            throw new RpcError(
+                "AA23 reverted: UserOperation called non-existant contract, or reverted with 0x",
+                ValidationErrors.SimulateValidation
+            )
+        }
+
+        const decodedError = decodeErrorResult({
+            abi: [...EntryPointV06Abi, ...EntryPointV06SimulationsAbi],
+            data
+        })
+
+        if (
+            decodedError &&
+            decodedError.errorName === "FailedOp" &&
+            decodedError.args
+        ) {
+            return {
+                result: "failed",
+                data: decodedError.args[1] as string
+            } as const
+        }
+
+        // custom error thrown by entryPoint if code override is used
+        if (
+            decodedError &&
+            decodedError.errorName === "CallPhaseReverted" &&
+            decodedError.args
+        ) {
+            return {
+                result: "failed",
+                data: decodedError.args[0]
+            } as const
+        }
+
+        if (
+            decodedError &&
+            decodedError.errorName === "Error" &&
+            decodedError.args
+        ) {
+            return {
+                result: "failed",
+                data: decodedError.args[0]
+            } as const
+        }
+
+        if (decodedError.errorName === "ExecutionResult") {
+            const parsedExecutionResult = executionResultSchema.parse(
+                decodedError.args
+            )
+
+            return {
+                result: "execution",
+                data: {
+                    executionResult: parsedExecutionResult
+                } as const
+            }
+        }
+
+        throw new Error(
+            "Unexpected error whilst decoding simulateHandleOp result"
+        )
     }
 
     async simulateHandleOpV06({
@@ -49,14 +119,25 @@ export class GasEstimatorV06 {
         entryPoint: Address
         stateOverrides?: StateOverrides | undefined
     }): Promise<SimulateHandleOpResult> {
-        const {
-            publicClient,
-            blockTagSupport,
-            utilityWalletAddress,
-            fixedGasLimitForEstimation
-        } = this
-
         try {
+            const {
+                publicClient,
+                blockTagSupport,
+                utilityWalletAddress,
+                fixedGasLimitForEstimation
+            } = this
+
+            if (this.codeOverrideSupport) {
+                if (stateOverrides === undefined) {
+                    stateOverrides = {}
+                }
+
+                stateOverrides[entryPoint] = {
+                    ...deepHexlify(stateOverrides?.[entryPoint] || {}),
+                    code: ENTRYPOINT_V06_SIMULATION_OVERRIDE
+                }
+            }
+
             await publicClient.request({
                 method: "eth_call",
                 params: [
@@ -126,55 +207,11 @@ export class GasEstimatorV06 {
                 throw new Error(JSON.stringify(err.cause))
             }
 
-            const cause = causeParseResult.data
+            const data = causeParseResult.data.data
 
-            if (cause.data === "0x") {
-                throw new RpcError(
-                    "AA23 reverted: UserOperation called non-existant contract, or reverted with 0x",
-                    ValidationErrors.SimulateValidation
-                )
-            }
-
-            const decodedError = decodeErrorResult({
-                abi: [...EntryPointV06Abi, ...EntryPointV06SimulationsAbi],
-                data: cause.data
-            })
-
-            if (
-                decodedError &&
-                decodedError.errorName === "FailedOp" &&
-                decodedError.args
-            ) {
-                return {
-                    result: "failed",
-                    data: decodedError.args[1] as string
-                } as const
-            }
-
-            if (
-                decodedError &&
-                decodedError.errorName === "Error" &&
-                decodedError.args
-            ) {
-                return {
-                    result: "failed",
-                    data: decodedError.args[0]
-                } as const
-            }
-
-            if (decodedError.errorName === "ExecutionResult") {
-                const parsedExecutionResult = executionResultSchema.parse(
-                    decodedError.args
-                )
-
-                return {
-                    result: "execution",
-                    data: {
-                        executionResult: parsedExecutionResult
-                    } as const
-                }
-            }
+            return this.decodeSimulateHandleOpResult(data)
         }
+
         throw new Error("Unexpected error")
     }
 }

src/rpc/validation/SafeValidator.ts

@@ -73,6 +73,7 @@ export class SafeValidator
         utilityWalletAddress: Address,
         binarySearchToleranceDelta: bigint,
         binarySearchGasAllowance: bigint,
+        codeOverrideSupport: boolean,
         entryPointSimulationsAddress?: Address,
         fixedGasLimitForEstimation?: bigint,
         usingTenderly = false,
@@ -88,6 +89,7 @@ export class SafeValidator
             utilityWalletAddress,
             binarySearchToleranceDelta,
             binarySearchGasAllowance,
+            codeOverrideSupport,
             entryPointSimulationsAddress,
             fixedGasLimitForEstimation,
             usingTenderly,

src/rpc/validation/UnsafeValidator.ts

@@ -73,6 +73,7 @@ export class UnsafeValidator implements InterfaceValidator {
         utilityWalletAddress: Address,
         binarySearchToleranceDelta: bigint,
         binarySearchGasAllowance: bigint,
+        codeOverrideSupport: boolean,
         entryPointSimulationsAddress?: Address,
         fixedGasLimitForEstimation?: bigint,
         usingTenderly = false,
@@ -97,6 +98,7 @@ export class UnsafeValidator implements InterfaceValidator {
             blockTagSupport,
             utilityWalletAddress,
             chainType,
+            codeOverrideSupport,
             entryPointSimulationsAddress,
             fixedGasLimitForEstimation
         )
@@ -194,7 +196,6 @@ export class UnsafeValidator implements InterfaceValidator {
             addSenderBalanceOverride,
             balanceOverrideEnabled: this.balanceOverrideEnabled,
             entryPoint,
-            replacedEntryPoint: false,
             targetAddress: zeroAddress,
             targetCallData: "0x",
             stateOverrides

src/types/contracts/EntryPointSimulations.ts → src/types/contracts/EntryPointSimulations07.ts

@@ -1,16 +1,3 @@
-export const EntryPointV06SimulationsAbi = [
-    {
-        inputs: [
-            {
-                name: "reason",
-                type: "string"
-            }
-        ],
-        name: "Error",
-        type: "error"
-    }
-] as const
-
 export const EntryPointV07SimulationsAbi = [
     {
         type: "constructor",

src/types/contracts/index.ts

@@ -12,5 +12,6 @@ export * from "./TestOpcodesAccountFactory"
 export * from "./TestStorageAccount"
 export * from "./SimpleAccountFactory"
 export * from "./CodeHashGetter"
-export * from "./EntryPointSimulations"
+export * from "./EntryPointSimulations07"
+export * from "./EntryPointSimulations06"
 export * from "./PimlicoEntryPointSimulations"

test/e2e/alto-config.json

@@ -22,5 +22,6 @@
     "mempool-max-parallel-ops": 10,
     "mempool-max-queued-ops": 10,
     "enforce-unique-senders-per-bundle": false,
+    "code-override-support": true,
     "enable-instant-bundling-endpoint": true
 }

test/e2e/tests/eth_estimateUserOperationGas.test.ts

@@ -1,6 +1,11 @@
 import type { EntryPointVersion } from "viem/account-abstraction"
 import { beforeEach, describe, expect, test } from "vitest"
 import { beforeEachCleanUp, getSmartAccountClient } from "../src/utils"
+import {
+    getRevertCall,
+    deployRevertingContract
+} from "../src/revertingContract"
+import { Address, BaseError } from "viem"
 
 describe.each([
     {
@@ -12,7 +17,10 @@ describe.each([
 ])(
     "$entryPointVersion supports eth_estimateUserOperationGas",
     ({ entryPointVersion }) => {
+        let revertingContract: Address
+
         beforeEach(async () => {
+            revertingContract = await deployRevertingContract()
             await beforeEachCleanUp()
         })
 
@@ -113,5 +121,27 @@ describe.each([
             expect(estimation.paymasterPostOpGasLimit).toBe(0n)
             expect(estimation.paymasterVerificationGasLimit).toBe(0n)
         })
+
+        test("Should throw revert reason if simulation reverted during callphase", async () => {
+            const smartAccountClient = await getSmartAccountClient({
+                entryPointVersion
+            })
+
+            try {
+                await smartAccountClient.estimateUserOperationGas({
+                    calls: [
+                        {
+                            to: revertingContract,
+                            data: getRevertCall("foobar"),
+                            value: 0n
+                        }
+                    ]
+                })
+            } catch (e: any) {
+                expect(e).toBeInstanceOf(BaseError)
+                const err = e.walk()
+                expect(err.reason).toEqual("foobar")
+            }
+        })
     }
 )