detect v06 reverts using code overrides

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/rpc/estimation/gasEstimationsV06.ts

@@ -17,6 +17,7 @@ import {
 import { z } from "zod"
 import type { SimulateHandleOpResult } from "./types"
 import type { AltoConfig } from "../../createConfig"
+import { deepHexlify } from "../../utils/userop"
 
 export class GasEstimatorV06 {
     private config: AltoConfig
@@ -25,6 +26,71 @@ export class GasEstimatorV06 {
         this.config = config
     }
 
+    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({
         userOperation,
         targetAddress,
@@ -46,6 +112,17 @@ export class GasEstimatorV06 {
         const fixedGasLimitForEstimation =
             this.config.fixedGasLimitForEstimation
 
+        if (this.config.codeOverrideSupport) {
+            if (stateOverrides === undefined) {
+                stateOverrides = {}
+            }
+
+            stateOverrides[entryPoint] = {
+                ...deepHexlify(stateOverrides?.[entryPoint] || {}),
+                code: ENTRYPOINT_V06_SIMULATION_OVERRIDE
+            }
+        }
+
         try {
             await publicClient.request({
                 method: "eth_call",
@@ -116,54 +193,9 @@ 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/UnsafeValidator.ts

@@ -167,7 +167,6 @@ export class UnsafeValidator implements InterfaceValidator {
             addSenderBalanceOverride,
             balanceOverrideEnabled: this.config.balanceOverride,
             entryPoint,
-            replacedEntryPoint: false,
             targetAddress: zeroAddress,
             targetCallData: "0x",
             stateOverrides

src/types/contracts/EntryPointSimulations.ts → src/types/contracts/EntryPointSimulationsV7.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 "./EntryPointSimulationsV6"
+export * from "./EntryPointSimulationsV7"
 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")
+            }
+        })
     }
 )

test/e2e/tests/eth_getUserOperationReceipt.test.ts

@@ -1,8 +1,17 @@
-import type { Address, Hex } from "viem"
+import {
+    parseGwei,
+    type Address,
+    type Hex,
+    getContract,
+    parseEther,
+    concat
+} from "viem"
 import {
     type EntryPointVersion,
     entryPoint06Address,
-    entryPoint07Address
+    entryPoint07Address,
+    UserOperation,
+    getUserOperationHash
 } from "viem/account-abstraction"
 import { beforeAll, beforeEach, describe, expect, test } from "vitest"
 import {
@@ -12,6 +21,8 @@ import {
 } from "../src/revertingContract"
 import { deployPaymaster } from "../src/testPaymaster"
 import { beforeEachCleanUp, getSmartAccountClient } from "../src/utils"
+import { deepHexlify } from "permissionless"
+import { foundry } from "viem/chains"
 
 describe.each([
     {
@@ -37,28 +48,77 @@ describe.each([
             await beforeEachCleanUp()
         })
 
+        // uses pimlico_sendUserOperationNow to force send a reverting op (because it skips validation)
         test("Returns revert bytes when UserOperation reverts", async () => {
             const smartAccountClient = await getSmartAccountClient({
                 entryPointVersion
             })
 
-            const hash = await smartAccountClient.sendUserOperation({
-                calls: [
-                    {
-                        to: revertingContract,
-                        data: getRevertCall("foobar"),
-                        value: 0n
-                    }
-                ],
-                callGasLimit: 500_000n,
-                verificationGasLimit: 500_000n,
-                preVerificationGas: 500_000n
+            const { factory, factoryData } =
+                await smartAccountClient.account.getFactoryArgs()
+
+            let op: UserOperation<typeof entryPointVersion>
+            if (entryPointVersion === "0.6") {
+                op = {
+                    callData: await smartAccountClient.account.encodeCalls([
+                        {
+                            to: revertingContract,
+                            data: getRevertCall("foobar"),
+                            value: 0n
+                        }
+                    ]),
+                    initCode: concat([factory as Hex, factoryData as Hex]),
+                    paymasterAndData: paymaster,
+                    callGasLimit: 500_000n,
+                    verificationGasLimit: 500_000n,
+                    preVerificationGas: 500_000n,
+                    sender: smartAccountClient.account.address,
+                    nonce: 0n,
+                    maxFeePerGas: parseGwei("10"),
+                    maxPriorityFeePerGas: parseGwei("10")
+                } as UserOperation<typeof entryPointVersion>
+            } else {
+                op = {
+                    sender: smartAccountClient.account.address,
+                    nonce: 0n,
+                    factory,
+                    factoryData,
+                    callData: await smartAccountClient.account.encodeCalls([
+                        {
+                            to: revertingContract,
+                            data: getRevertCall("foobar"),
+                            value: 0n
+                        }
+                    ]),
+                    callGasLimit: 500_000n,
+                    verificationGasLimit: 500_000n,
+                    preVerificationGas: 500_000n,
+                    maxFeePerGas: parseGwei("10"),
+                    maxPriorityFeePerGas: parseGwei("10"),
+                    paymaster,
+                    paymasterVerificationGasLimit: 100_000n,
+                    paymasterPostOpGasLimit: 50_000n
+                } as UserOperation<typeof entryPointVersion>
+            }
+
+            op.signature =
+                await smartAccountClient.account.signUserOperation(op)
+
+            await smartAccountClient.request({
+                // @ts-ignore
+                method: "pimlico_sendUserOperationNow",
+                params: [deepHexlify(op), entryPoint]
             })
 
             await new Promise((resolve) => setTimeout(resolve, 1500))
 
             const receipt = await smartAccountClient.getUserOperationReceipt({
-                hash
+                hash: getUserOperationHash({
+                    userOperation: op,
+                    chainId: foundry.id,
+                    entryPointAddress: entryPoint,
+                    entryPointVersion
+                })
             })
 
             expect(receipt).not.toBeNull()