use code overrides for v0.6 simulations

src/cli/config/bundler.ts

@@ -163,7 +163,7 @@ export const rpcArgsSchema = z.object({
     "polling-interval": z.number().int().min(0),
     "max-block-range": z.number().int().min(0).optional(),
     "block-tag-support": z.boolean().optional().default(true),
-    "trace-call-support": z.boolean().optional().default(false)
+    "code-override-support": z.boolean().optional().default(false)
 })
 
 export const bundleCopmressionArgsSchema = z.object({

src/cli/config/options.ts

@@ -327,9 +327,8 @@ export const rpcOptions: CliCommandOptions<IRpcArgsInput> = {
         require: false,
         default: true
     },
-    "trace-call-support": {
-        description:
-            "Enable trace support when simulating v0.6 user operations",
+    "code-override-support": {
+        description: "Does the RPC support code overrides",
         type: "boolean",
         require: false,
         default: false

src/cli/setupServer.ts

@@ -91,7 +91,7 @@ const getValidator = ({
             utilityWalletAddress,
             parsedArgs["binary-search-tolerance-delta"],
             parsedArgs["binary-search-gas-allowance"],
-            parsedArgs["trace-call-support"],
+            parsedArgs["code-override-support"],
             parsedArgs["entrypoint-simulation-contract"],
             parsedArgs["fixed-gas-limit-for-estimation"],
             parsedArgs.tenderly,
@@ -111,7 +111,7 @@ const getValidator = ({
         utilityWalletAddress,
         parsedArgs["binary-search-tolerance-delta"],
         parsedArgs["binary-search-gas-allowance"],
-        parsedArgs["trace-call-support"],
+        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,
@@ -14,30 +15,31 @@ import {
     decodeErrorResult,
     encodeFunctionData,
     toHex,
-    getAddress
+    slice
 } 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
-    rpcTraceSupport: boolean
+    codeOverrideSupport: boolean
 
     constructor(
         publicClient: PublicClient,
         blockTagSupport: boolean,
         utilityWalletAddress: Address,
-        rpcTraceSupport: boolean,
+        codeOverrideSupport: boolean,
         fixedGasLimitForEstimation?: bigint
     ) {
         this.publicClient = publicClient
         this.blockTagSupport = blockTagSupport
         this.utilityWalletAddress = utilityWalletAddress
         this.fixedGasLimitForEstimation = fixedGasLimitForEstimation
-        this.rpcTraceSupport = rpcTraceSupport
+        this.codeOverrideSupport = codeOverrideSupport
     }
 
     decodeSimulateHandleOpResult(data: Hex): SimulateHandleOpResult {
@@ -64,6 +66,18 @@ export class GasEstimatorV06 {
             } 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" &&
@@ -93,13 +107,19 @@ export class GasEstimatorV06 {
         )
     }
 
-    async ethCall(
-        entryPoint: Address,
-        userOperation: UserOperationV06,
-        targetAddress: Address,
-        targetCallData: Hex,
-        stateOverrides?: StateOverrides
-    ): Promise<SimulateHandleOpResult> {
+    async simulateHandleOpV06({
+        userOperation,
+        targetAddress,
+        targetCallData,
+        entryPoint,
+        stateOverrides = undefined
+    }: {
+        userOperation: UserOperationV06
+        targetAddress: Address
+        targetCallData: Hex
+        entryPoint: Address
+        stateOverrides?: StateOverrides | undefined
+    }): Promise<SimulateHandleOpResult> {
         try {
             const {
                 publicClient,
@@ -108,6 +128,17 @@ export class GasEstimatorV06 {
                 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: [
@@ -177,131 +208,11 @@ export class GasEstimatorV06 {
                 throw new Error(JSON.stringify(err.cause))
             }
 
-            const cause = causeParseResult.data
+            const data = causeParseResult.data.data
 
-            return this.decodeSimulateHandleOpResult(cause.data)
+            return this.decodeSimulateHandleOpResult(data)
         }
 
         throw new Error("Unexpected error")
     }
-
-    async traceCall(
-        entryPoint: Address,
-        userOperation: UserOperationV06,
-        targetAddress: Address,
-        targetCallData: Hex,
-        stateOverrides?: StateOverrides
-    ): Promise<SimulateHandleOpResult> {
-        const {
-            publicClient,
-            blockTagSupport,
-            utilityWalletAddress,
-            fixedGasLimitForEstimation
-        } = this
-
-        const traceResult = await publicClient.request({
-            // @ts-ignore
-            method: "trace_call",
-            params: [
-                {
-                    to: entryPoint,
-                    from: utilityWalletAddress,
-                    data: encodeFunctionData({
-                        abi: EntryPointV06Abi,
-                        functionName: "simulateHandleOp",
-                        args: [userOperation, targetAddress, targetCallData]
-                    }),
-                    ...(fixedGasLimitForEstimation !== undefined && {
-                        gas: `0x${fixedGasLimitForEstimation.toString(16)}`
-                    })
-                },
-                // @ts-ignore
-                ["trace"],
-                // @ts-ignore
-                blockTagSupport
-                    ? "latest"
-                    : toHex(await publicClient.getBlockNumber()),
-                // @ts-ignore
-                ...(stateOverrides ? [stateOverrides] : [])
-            ]
-        })
-
-        const result = z
-            .object({
-                output: hexDataSchema,
-                trace: z.array(
-                    z.object({
-                        action: z.object({
-                            input: hexDataSchema,
-                            from: hexDataSchema,
-                            to: hexDataSchema
-                        }),
-                        error: z.string().optional(),
-                        result: z
-                            .object({
-                                output: hexDataSchema.optional()
-                            })
-                            .optional(),
-                        type: z.string()
-                    })
-                )
-            })
-            .safeParse(traceResult)
-
-        if (!result.success) {
-            throw new Error(JSON.stringify(result.error.cause))
-        }
-
-        // Check if the smartAccount's execution reverted.
-        const smartAccountExecutionResult = result.data.trace.find(
-            (trace) =>
-                getAddress(trace.action.to) === userOperation.sender &&
-                getAddress(trace.action.from) === entryPoint &&
-                trace.action.input === userOperation.callData
-        )
-
-        if (
-            smartAccountExecutionResult &&
-            smartAccountExecutionResult.error?.toLowerCase() === "reverted"
-        ) {
-            return {
-                result: "failed",
-                data: smartAccountExecutionResult.result?.output || "0x"
-            }
-        }
-
-        return this.decodeSimulateHandleOpResult(result.data.output)
-    }
-
-    async simulateHandleOpV06({
-        userOperation,
-        targetAddress,
-        targetCallData,
-        entryPoint,
-        stateOverrides = undefined
-    }: {
-        userOperation: UserOperationV06
-        targetAddress: Address
-        targetCallData: Hex
-        entryPoint: Address
-        stateOverrides?: StateOverrides | undefined
-    }): Promise<SimulateHandleOpResult> {
-        if (this.rpcTraceSupport) {
-            return await this.traceCall(
-                entryPoint,
-                userOperation,
-                targetAddress,
-                targetCallData,
-                stateOverrides
-            )
-        } else {
-            return await this.ethCall(
-                entryPoint,
-                userOperation,
-                targetAddress,
-                targetCallData,
-                stateOverrides
-            )
-        }
-    }
 }

src/rpc/validation/SafeValidator.ts

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

src/rpc/validation/UnsafeValidator.ts

@@ -73,7 +73,7 @@ export class UnsafeValidator implements InterfaceValidator {
         utilityWalletAddress: Address,
         binarySearchToleranceDelta: bigint,
         binarySearchGasAllowance: bigint,
-        rpcTraceSupport: boolean,
+        codeOverrideSupport: boolean,
         entryPointSimulationsAddress?: Address,
         fixedGasLimitForEstimation?: bigint,
         usingTenderly = false,
@@ -98,7 +98,7 @@ export class UnsafeValidator implements InterfaceValidator {
             blockTagSupport,
             utilityWalletAddress,
             chainType,
-            rpcTraceSupport,
+            codeOverrideSupport,
             entryPointSimulationsAddress,
             fixedGasLimitForEstimation
         )
@@ -196,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"